feat(clusters): org-owned custom regions — picker group and units on the cluster form

src/features/admin/__tests__/adminShellVisibility.test.ts

@@ -21,6 +21,7 @@ describe('admin section visibility', () => {
 			'Regions',
 		]);
 		expect(labels(user('fabric_readonly', ['region:read']))).toEqual(['Regions']);
+		expect(labels(user('fabric_readonly', ['systemStatus:write']))).toEqual(['Notifications']);
 	});
 
 	it('hides the section entirely from customers', () => {

src/features/admin/organizationRegions/OrganizationRegionFormSchema.test.ts

@@ -0,0 +1,94 @@
+import { OrganizationRegion } from '@/integrations/api/api.patch';
+import { describe, expect, it } from 'vitest';
+import {
+	NO_FALLBACK,
+	OrganizationRegionFormSchema,
+	toCreatePayload,
+	toFormValues,
+	toPatch,
+} from './OrganizationRegionFormSchema';
+
+const stored: OrganizationRegion = {
+	id: 'oreg-1',
+	organizationId: 'org-1',
+	name: 'EU edge',
+	placement: { linode: ['fr-par', 'it-mil'], gcp: [] },
+	fallbackGroup: 'europe',
+	active: true,
+};
+
+const valid = {
+	name: 'EU edge',
+	linodeDatacenters: ['fr-par'],
+	gcpDatacenters: [],
+	fallbackGroup: NO_FALLBACK,
+	active: true,
+};
+
+describe('OrganizationRegionFormSchema', () => {
+	it('accepts a region with one provider populated', () => {
+		expect(OrganizationRegionFormSchema.safeParse(valid).success).toBe(true);
+	});
+
+	it('requires at least one datacenter across providers', () => {
+		const result = OrganizationRegionFormSchema.safeParse({ ...valid, linodeDatacenters: [] });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(result.error.issues[0].path).toEqual(['gcpDatacenters']);
+		}
+	});
+
+	it('trims and requires the name', () => {
+		expect(OrganizationRegionFormSchema.safeParse({ ...valid, name: '   ' }).success).toBe(false);
+		const parsed = OrganizationRegionFormSchema.safeParse({ ...valid, name: '  EU  ' });
+		expect(parsed.success && parsed.data.name).toBe('EU');
+	});
+});
+
+describe('toFormValues', () => {
+	it('maps a stored row and defaults a new one', () => {
+		expect(toFormValues(stored)).toEqual({
+			name: 'EU edge',
+			linodeDatacenters: ['fr-par', 'it-mil'],
+			gcpDatacenters: [],
+			fallbackGroup: 'europe',
+			active: true,
+		});
+		expect(toFormValues(null)).toEqual({
+			name: '',
+			linodeDatacenters: [],
+			gcpDatacenters: [],
+			fallbackGroup: NO_FALLBACK,
+			active: true,
+		});
+	});
+});
+
+describe('toCreatePayload', () => {
+	it('stores the no-fallback choice as null', () => {
+		expect(toCreatePayload('org-1', valid)).toEqual({
+			organizationId: 'org-1',
+			name: 'EU edge',
+			placement: { linode: ['fr-par'], gcp: [] },
+			fallbackGroup: null,
+			active: true,
+		});
+	});
+});
+
+describe('toPatch', () => {
+	it('sends only the fields that changed', () => {
+		expect(toPatch(stored, toFormValues(stored))).toEqual({});
+		expect(toPatch(stored, { ...toFormValues(stored), active: false })).toEqual({ active: false });
+	});
+
+	it('sends the whole placement when either provider list changes', () => {
+		expect(toPatch(stored, { ...toFormValues(stored), gcpDatacenters: ['europe-west1'] })).toEqual({
+			placement: { linode: ['fr-par', 'it-mil'], gcp: ['europe-west1'] },
+		});
+	});
+
+	it('clears the fallback pool with null', () => {
+		expect(toPatch(stored, { ...toFormValues(stored), fallbackGroup: NO_FALLBACK })).toEqual({ fallbackGroup: null });
+	});
+});

src/features/admin/organizationRegions/OrganizationRegionFormSchema.ts

@@ -0,0 +1,72 @@
+import { OrganizationRegion, OrganizationRegionPatch, OrganizationRegionPayload } from '@/integrations/api/api.patch';
+import { z } from 'zod';
+
+/** Fields central-manager freezes once a live cluster deploys the region. */
+export const FROZEN_WHILE_REFERENCED = ['name', 'linodeDatacenters', 'gcpDatacenters', 'fallbackGroup'] as const;
+
+/** The form's "no fallback pool" choice; the API stores null for it. */
+export const NO_FALLBACK = '';
+
+// A repeated datacenter asks for another instance there.
+export const OrganizationRegionFormSchema = z.object({
+	name: z.string().trim().min(1, 'Name is required').max(64, 'Keep the name to 64 characters'),
+	linodeDatacenters: z.array(z.string()),
+	gcpDatacenters: z.array(z.string()),
+	fallbackGroup: z.string(),
+	active: z.boolean(),
+}).superRefine((values, ctx) => {
+	if (!values.linodeDatacenters.length && !values.gcpDatacenters.length) {
+		ctx.addIssue({
+			code: 'custom',
+			path: ['gcpDatacenters'],
+			message: 'Add at least one datacenter under Linode or GCP',
+		});
+	}
+});
+
+export type OrganizationRegionFormValues = z.infer<typeof OrganizationRegionFormSchema>;
+
+export function toFormValues(region?: OrganizationRegion | null): OrganizationRegionFormValues {
+	return {
+		name: region?.name ?? '',
+		linodeDatacenters: region?.placement?.linode ?? [],
+		gcpDatacenters: region?.placement?.gcp ?? [],
+		fallbackGroup: region?.fallbackGroup ?? NO_FALLBACK,
+		active: region?.active ?? true,
+	};
+}
+
+export function toCreatePayload(
+	organizationId: string,
+	values: OrganizationRegionFormValues,
+): OrganizationRegionPayload {
+	return {
+		organizationId,
+		name: values.name,
+		placement: { linode: values.linodeDatacenters, gcp: values.gcpDatacenters },
+		fallbackGroup: values.fallbackGroup === NO_FALLBACK ? null : values.fallbackGroup,
+		active: values.active,
+	};
+}
+
+export function toPatch(region: OrganizationRegion, values: OrganizationRegionFormValues): OrganizationRegionPatch {
+	const stored = toFormValues(region);
+	const patch: OrganizationRegionPatch = {};
+	if (values.name !== stored.name) {
+		patch.name = values.name;
+	}
+	const sameList = (a: string[], b: string[]) => a.length === b.length && a.every((v, i) => v === b[i]);
+	if (
+		!sameList(values.linodeDatacenters, stored.linodeDatacenters)
+		|| !sameList(values.gcpDatacenters, stored.gcpDatacenters)
+	) {
+		patch.placement = { linode: values.linodeDatacenters, gcp: values.gcpDatacenters };
+	}
+	if (values.fallbackGroup !== stored.fallbackGroup) {
+		patch.fallbackGroup = values.fallbackGroup === NO_FALLBACK ? null : values.fallbackGroup;
+	}
+	if (values.active !== stored.active) {
+		patch.active = values.active;
+	}
+	return patch;
+}