validate kind, arch, branch region on adopt too

Author: mmkal

alchemy/src/planetscale/branch.ts

@@ -83,6 +83,18 @@ export interface BranchProps extends PlanetScaleProps {
    * Enable or disable safe migrations on this branch
    */
   safeMigrations?: boolean;
+
+  /**
+   * The region to create the branch in.
+   * If not provided, the branch will be created in the default region for its database.
+   * On adopt/update, if specified, the actual branch region is validated against this value.
+   */
+  region?: {
+    /**
+     * The slug identifier of the region (e.g. "us-east", "eu-west")
+     */
+    slug: string;
+  };
 }
 
 /**
@@ -113,6 +125,20 @@ export interface Branch extends BranchProps {
    * HTML URL to access the branch
    */
   htmlUrl: string;
+
+  /**
+   * The actual region of the branch as reported by PlanetScale
+   */
+  actualRegion: {
+    /**
+     * The slug identifier of the region (e.g. "us-east", "eu-west")
+     */
+    slug: string;
+    /**
+     * Display name of the region (e.g. "US East", "EU West")
+     */
+    displayName: string;
+  };
 }
 
 /**
@@ -259,6 +285,18 @@ export const Branch = Resource(
       const data = getResponse.data;
       const currentParentBranch = data.parent_branch || "main";
 
+      // Validate region matches if specified
+      if (props.region) {
+        const actualSlug = data.region.slug;
+        if (actualSlug !== props.region.slug) {
+          throw new Error(
+            `Branch "${branchName}" is in region "${actualSlug}" but expected "${props.region.slug}". ` +
+              `PlanetScale branch regions cannot be changed after creation. ` +
+              `Either update the region in your configuration to match, or create a new branch in the correct region.`,
+          );
+        }
+      }
+
       // Check immutable properties
       if (props.parentBranch && parentBranchName !== currentParentBranch) {
         throw new Error(
@@ -323,6 +361,10 @@ export const Branch = Resource(
         createdAt: data.created_at,
         updatedAt: data.updated_at,
         htmlUrl: data.html_url,
+        actualRegion: {
+          slug: data.region.slug,
+          displayName: data.region.display_name,
+        },
       };
     }
     let clusterSize: string | undefined;
@@ -352,6 +394,7 @@ export const Branch = Resource(
         parent_branch: parentBranchName,
         backup_id: props.backupId,
         seed_data: props.seedData,
+        region: props.region?.slug,
         // This is ignored unless props.backupId is provided
         cluster_size: clusterSize,
       },
@@ -391,6 +434,10 @@ export const Branch = Resource(
       createdAt: data.created_at,
       updatedAt: data.updated_at,
       htmlUrl: data.html_url,
+      actualRegion: {
+        slug: data.region.slug,
+        displayName: data.region.display_name,
+      },
     };
   },
 );

alchemy/src/planetscale/database.ts

@@ -346,7 +346,15 @@ export const Database = Resource(
         });
       }
 
-      // Validate region matches if specified
+      // Validate immutable properties match if specified
+      const actualKind = getResponse.data.kind;
+      if (props.kind && actualKind !== props.kind) {
+        throw new Error(
+          `Database "${databaseName}" has kind "${actualKind}" but expected "${props.kind}". ` +
+            `Database kind cannot be changed after creation.`,
+        );
+      }
+
       if (props.region) {
         const actualSlug = getResponse.data.region.slug;
         if (actualSlug !== props.region.slug) {
@@ -358,6 +366,28 @@ export const Database = Resource(
         }
       }
 
+      if (props.kind === "postgresql" && props.arch) {
+        const defaultBranch = props.defaultBranch || "main";
+        const branchInfo = await api.getBranch({
+          path: {
+            organization,
+            database: databaseName,
+            branch: defaultBranch,
+          },
+          throwOnError: false,
+        });
+        if (branchInfo.data?.cluster_architecture) {
+          const actualArch =
+            branchInfo.data.cluster_architecture === "aarch64" ? "arm" : "x86";
+          if (actualArch !== props.arch) {
+            throw new Error(
+              `Database "${databaseName}" has architecture "${actualArch}" but expected "${props.arch}". ` +
+                `Database architecture cannot be changed after creation.`,
+            );
+          }
+        }
+      }
+
       // Update database settings
       // If updating to a non-'main' default branch, create it first
       if (props.defaultBranch && props.defaultBranch !== "main") {

alchemy/test/planetscale/database.test.ts

@@ -348,6 +348,96 @@ describe.skipIf(!process.env.PLANETSCALE_TEST).concurrent.each(kinds)(
       }
     }, 5_000_000);
 
+    test(`adopt with wrong kind should throw (${kind})`, async (scope) => {
+      const name = `${BRANCH_PREFIX}-${kind}-kind`;
+      const wrongKind = kind === "mysql" ? "postgresql" : "mysql";
+
+      try {
+        await Database("kind-check", {
+          name,
+          clusterSize: "PS_10",
+          kind,
+          delete: true,
+        });
+
+        await waitForDatabaseReady(api, organization, name);
+
+        // Try to adopt with the wrong kind — should throw
+        await expect(
+          Database("kind-check", {
+            name,
+            adopt: true,
+            clusterSize: "PS_10",
+            kind: wrongKind,
+            delete: true,
+          }),
+        ).rejects.toThrow(
+          new RegExp(`has kind "${kind}" but expected "${wrongKind}"`),
+        );
+
+        // Adopting with the correct kind should succeed
+        const adopted = await Database("kind-check", {
+          name,
+          adopt: true,
+          clusterSize: "PS_10",
+          kind,
+          delete: true,
+        });
+
+        expect(adopted.name).toBe(name);
+      } finally {
+        await destroy(scope);
+        await assertDatabaseDeleted(api, organization, name);
+      }
+    }, 5_000_000);
+
+    test.skipIf(kind !== "postgresql")(
+      `adopt with wrong arch should throw (${kind})`,
+      async (scope) => {
+        const name = `${BRANCH_PREFIX}-${kind}-arch-check`;
+
+        try {
+          await Database("arch-check", {
+            name,
+            clusterSize: "PS_10",
+            kind: "postgresql",
+            arch: "x86",
+            delete: true,
+          });
+
+          await waitForDatabaseReady(api, organization, name);
+
+          // Try to adopt with the wrong arch — should throw
+          await expect(
+            Database("arch-check", {
+              name,
+              adopt: true,
+              clusterSize: "PS_10",
+              kind: "postgresql",
+              arch: "arm",
+              delete: true,
+            }),
+          ).rejects.toThrow(/has architecture "x86" but expected "arm"/);
+
+          // Adopting with the correct arch should succeed
+          const adopted = await Database("arch-check", {
+            name,
+            adopt: true,
+            clusterSize: "PS_10",
+            kind: "postgresql",
+            arch: "x86",
+            delete: true,
+          });
+
+          expect(adopted.name).toBe(name);
+        } finally {
+          await destroy(scope);
+          await assertDatabaseDeleted(api, organization, name);
+        }
+      },
+      5_000_000,
+    );
+
     test(`database with delete=false should not be deleted via API (${kind})`, async (scope) => {
       const name = `${BRANCH_PREFIX}-${kind}-nodelete`;