alchemy 0.63.0 → 0.64.0

package/src/planetscale/database.ts

@@ -1,9 +1,9 @@
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
-import type { Secret } from "../secret.ts";
-import { PlanetScaleApi } from "./api.ts";
+import type { PlanetScaleProps } from "./api/client.gen.ts";
+import { PlanetScaleClient } from "./api/client.gen.ts";
 import {
-  fixClusterSize,
+  ensureProductionBranchClusterSize,
   type PlanetScaleClusterSize,
   waitForDatabaseReady,
 } from "./utils.ts";
@@ -11,7 +11,7 @@ import {
 /**
  * Properties for creating or updating a PlanetScale Database
  */
-export interface DatabaseProps {
+export interface DatabaseProps extends PlanetScaleProps {
   /**
    * The name of the database
    *
@@ -24,11 +24,6 @@ export interface DatabaseProps {
    */
   organizationId: string;
 
-  /**
-   * PlanetScale API token (overrides environment variable)
-   */
-  apiKey?: Secret;
-
   /**
    * Whether to adopt the database if it already exists in Planetscale
    */
@@ -183,233 +178,229 @@ export const Database = Resource(
     id: string,
     props: DatabaseProps,
   ): Promise<Database> {
-    const adopt = props.adopt ?? this.scope.adopt;
-    const apiKey =
-      props.apiKey?.unencrypted || process.env.PLANETSCALE_API_TOKEN;
-    if (!apiKey) {
-      throw new Error("PLANETSCALE_API_TOKEN environment variable is required");
-    }
-
-    const api = new PlanetScaleApi({ apiKey });
+    const api = new PlanetScaleClient(props);
 
     const databaseName =
       props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
 
     if (this.phase === "update" && this.output.name !== databaseName) {
-      await api.patch(
-        `/organizations/${props.organizationId}/databases/${this.output.name}`,
-        { new_name: databaseName },
-      );
+      await api.organizations.databases.patch({
+        path: {
+          organization: props.organizationId,
+          name: this.output.name,
+        },
+        body: { new_name: databaseName },
+      });
     }
 
     if (this.phase === "delete") {
-      try {
-        if (this.output?.name) {
-          const response = await api.delete(
-            `/organizations/${props.organizationId}/databases/${this.output.name}`,
-          );
-
-          if (!response.ok && response.status !== 404) {
-            throw new Error(
-              `Failed to delete database: ${response.statusText} ${await response.text()}`,
-            );
-          }
+      if (this.output?.name) {
+        const response = await api.organizations.databases.delete({
+          path: {
+            organization: props.organizationId,
+            name: this.output.name,
+          },
+          result: "full",
+        });
+
+        if (response.error && response.error.status !== 404) {
+          throw new Error(`Failed to delete database "${this.output.name}"`, {
+            cause: response.error,
+          });
         }
-      } catch (error) {
-        console.error("Error deleting database:", error);
-        throw error;
       }
       return this.destroy();
     }
 
-    try {
-      // Check if database exists
-      const getResponse = await api.get(
-        `/organizations/${props.organizationId}/databases/${databaseName}`,
-      );
-      const getData = await getResponse.json<any>();
-      if (this.phase === "update" || (adopt && getResponse.ok)) {
-        if (!getResponse.ok) {
-          throw new Error(`Database ${databaseName} not found`);
-        }
-        // Update database settings
-        // If updating to a non-'main' default branch, create it first
-        if (props.defaultBranch && props.defaultBranch !== "main") {
-          const branchResponse = await api.get(
-            `/organizations/${props.organizationId}/databases/${databaseName}/branches/${props.defaultBranch}`,
-          );
-          if (!getData.ready) {
-            await waitForDatabaseReady(api, props.organizationId, databaseName);
-          }
-          if (!branchResponse.ok && branchResponse.status === 404) {
-            // Create the branch
-            const createBranchResponse = await api.post(
-              `/organizations/${props.organizationId}/databases/${databaseName}/branches`,
-              {
-                name: props.defaultBranch,
-                parent_branch: "main",
-              },
-            );
-
-            if (!createBranchResponse.ok) {
-              throw new Error(
-                `Failed to create default branch: ${createBranchResponse.statusText} ${await createBranchResponse.text()}`,
-              );
-            }
-          }
-        }
-
-        const updateResponse = await api.patch(
-          `/organizations/${props.organizationId}/databases/${databaseName}`,
-          {
-            automatic_migrations: props.automaticMigrations,
-            migration_framework: props.migrationFramework,
-            migration_table_name: props.migrationTableName,
-            require_approval_for_deploy: props.requireApprovalForDeploy,
-            restrict_branch_region: props.restrictBranchRegion,
-            allow_data_branching: props.allowDataBranching,
-            insights_raw_queries: props.insightsRawQueries,
-            production_branch_web_console: props.productionBranchWebConsole,
-            default_branch: props.defaultBranch,
-          },
-        );
-
-        if (!updateResponse.ok) {
-          throw new Error(
-            `Failed to update database: ${updateResponse.statusText} ${await updateResponse.text()}`,
-          );
-        }
-
-        await fixClusterSize(
-          api,
-          props.organizationId,
-          databaseName,
-          props.defaultBranch || "main",
-          props.clusterSize,
-          getData.ready,
-        );
-
-        const data = await updateResponse.json<any>();
-        return this({
-          ...props,
-          id: data.id,
-          name: databaseName,
-          state: data.state,
-          defaultBranch: data.default_branch,
-          plan: data.plan,
-          createdAt: data.created_at,
-          updatedAt: data.updated_at,
-          htmlUrl: data.html_url,
+    // Check if database exists
+    const getResponse = await api.organizations.databases.get({
+      path: {
+        organization: props.organizationId,
+        name: databaseName,
+      },
+      result: "full",
+    });
+    if (this.phase === "update" || (props.adopt && getResponse.data)) {
+      if (!getResponse.data) {
+        throw new Error(`Database "${databaseName}" not found`, {
+          cause: getResponse.error,
         });
       }
-
-      if (getResponse.ok) {
-        throw new Error(`Database with name ${databaseName} already exists`);
+      // Update database settings
+      // If updating to a non-'main' default branch, create it first
+      if (props.defaultBranch && props.defaultBranch !== "main") {
+        const branchResponse = await api.organizations.databases.branches.get({
+          path: {
+            organization: props.organizationId,
+            database: databaseName,
+            name: props.defaultBranch,
+          },
+          result: "full",
+        });
+        if (!branchResponse.data) {
+          await waitForDatabaseReady(api, props.organizationId, databaseName);
+        }
+        if (branchResponse.error && branchResponse.error.status === 404) {
+          // Create the branch
+          await api.organizations.databases.branches.post({
+            path: {
+              organization: props.organizationId,
+              database: databaseName,
+            },
+            body: {
+              name: props.defaultBranch,
+              parent_branch: "main",
+            },
+          });
+        }
       }
 
-      // Create new database
-      const createResponse = await api.post(
-        `/organizations/${props.organizationId}/databases`,
-        {
+      const updateResponse = await api.organizations.databases.patch({
+        path: {
+          organization: props.organizationId,
           name: databaseName,
-          region_slug: props.region?.slug,
-          require_approval_for_deploy: props.requireApprovalForDeploy,
-          allow_data_branching: props.allowDataBranching,
+        },
+        body: {
           automatic_migrations: props.automaticMigrations,
+          migration_framework: props.migrationFramework,
+          migration_table_name: props.migrationTableName,
+          require_approval_for_deploy: props.requireApprovalForDeploy,
           restrict_branch_region: props.restrictBranchRegion,
+          allow_data_branching: props.allowDataBranching,
           insights_raw_queries: props.insightsRawQueries,
           production_branch_web_console: props.productionBranchWebConsole,
-          migration_framework: props.migrationFramework,
-          migration_table_name: props.migrationTableName,
-          cluster_size: props.clusterSize,
+          default_branch: props.defaultBranch,
         },
+      });
+
+      await ensureProductionBranchClusterSize(
+        api,
+        props.organizationId,
+        databaseName,
+        props.defaultBranch || "main",
+        props.clusterSize,
+        updateResponse.ready,
       );
 
-      if (!createResponse.ok) {
-        throw new Error(
-          `Failed to create database: ${createResponse.statusText} ${await createResponse.text()}`,
-        );
-      }
+      return this({
+        ...props,
+        id: updateResponse.id,
+        name: databaseName,
+        state: updateResponse.state,
+        defaultBranch: updateResponse.default_branch,
+        plan: updateResponse.plan,
+        createdAt: updateResponse.created_at,
+        updatedAt: updateResponse.updated_at,
+        htmlUrl: updateResponse.html_url,
+      });
+    }
 
-      const data = await createResponse.json<any>();
+    if (getResponse.data) {
+      throw new Error(`Database with name "${databaseName}" already exists`);
+    }
 
-      // If a non-'main' default branch is specified, create it
-      if (props.defaultBranch && props.defaultBranch !== "main") {
-        await waitForDatabaseReady(api, props.organizationId, databaseName);
+    // Create new database
+    let data = await api.organizations.databases.post({
+      path: {
+        organization: props.organizationId,
+      },
+      body: {
+        name: databaseName,
+        region: props.region?.slug,
+        kind: "mysql",
+        cluster_size: props.clusterSize,
+      },
+    });
+
+    // These settings can't be set on creation, so we need to patch them after creation.
+    data = await api.organizations.databases.patch({
+      path: {
+        organization: props.organizationId,
+        name: databaseName,
+      },
+      body: {
+        require_approval_for_deploy: props.requireApprovalForDeploy,
+        allow_data_branching: props.allowDataBranching,
+        automatic_migrations: props.automaticMigrations,
+        restrict_branch_region: props.restrictBranchRegion,
+        insights_raw_queries: props.insightsRawQueries,
+        production_branch_web_console: props.productionBranchWebConsole,
+        migration_framework: props.migrationFramework,
+        migration_table_name: props.migrationTableName,
+      },
+    });
+
+    // If a non-'main' default branch is specified, create it
+    if (props.defaultBranch && props.defaultBranch !== "main") {
+      await waitForDatabaseReady(api, props.organizationId, databaseName);
+
+      // Check if branch exists
+      const branchResponse = await api.organizations.databases.branches.get({
+        path: {
+          organization: props.organizationId,
+          database: databaseName,
+          name: props.defaultBranch,
+        },
+        result: "full",
+      });
 
-        // Check if branch exists
-        const branchResponse = await api.get(
-          `/organizations/${props.organizationId}/databases/${databaseName}/branches/${props.defaultBranch}`,
+      if (branchResponse.error && branchResponse.error.status === 404) {
+        // Create the branch
+        await api.organizations.databases.branches.post({
+          path: {
+            organization: props.organizationId,
+            database: databaseName,
+          },
+          body: {
+            name: props.defaultBranch,
+            parent_branch: "main",
+          },
+        });
+
+        await ensureProductionBranchClusterSize(
+          api,
+          props.organizationId,
+          databaseName,
+          props.defaultBranch || "main",
+          props.clusterSize,
+          false,
         );
 
-        if (!branchResponse.ok && branchResponse.status === 404) {
-          // Create the branch
-          const createBranchResponse = await api.post(
-            `/organizations/${props.organizationId}/databases/${databaseName}/branches`,
-            {
-              name: props.defaultBranch,
-              parent_branch: "main",
-            },
-          );
-
-          if (!createBranchResponse.ok) {
-            throw new Error(
-              `Failed to create default branch: ${createBranchResponse.statusText} ${await createBranchResponse.text()}`,
-            );
-          }
-
-          await fixClusterSize(
-            api,
-            props.organizationId,
-            databaseName,
-            props.defaultBranch || "main",
-            props.clusterSize,
-            false,
-          );
-
-          // Update database to use new branch as default
-          const updateResponse = await api.patch(
-            `/organizations/${props.organizationId}/databases/${databaseName}`,
-            {
-              default_branch: props.defaultBranch,
-            },
-          );
-
-          if (!updateResponse.ok) {
-            throw new Error(
-              `Failed to set default branch: ${updateResponse.statusText} ${await updateResponse.text()}`,
-            );
-          }
-
-          const updatedData = await updateResponse.json<any>();
-          return this({
-            ...props,
-            id: data.id,
+        // Update database to use new branch as default
+        const updatedData = await api.organizations.databases.patch({
+          path: {
+            organization: props.organizationId,
             name: databaseName,
-            state: updatedData.state,
-            defaultBranch: updatedData.default_branch,
-            plan: updatedData.plan,
-            createdAt: updatedData.created_at,
-            updatedAt: updatedData.updated_at,
-            htmlUrl: updatedData.html_url,
-          });
-        }
-      }
+          },
+          body: {
+            default_branch: props.defaultBranch,
+          },
+        });
 
-      return this({
-        ...props,
-        id: data.id,
-        name: databaseName,
-        state: data.state,
-        defaultBranch: data.default_branch || "main",
-        plan: data.plan,
-        createdAt: data.created_at,
-        updatedAt: data.updated_at,
-        htmlUrl: data.html_url,
-      });
-    } catch (error) {
-      console.error("Error managing database:", error);
-      throw error;
+        return this({
+          ...props,
+          id: data.id,
+          name: databaseName,
+          state: updatedData.state,
+          defaultBranch: updatedData.default_branch,
+          plan: updatedData.plan,
+          createdAt: updatedData.created_at,
+          updatedAt: updatedData.updated_at,
+          htmlUrl: updatedData.html_url,
+        });
+      }
     }
+
+    return this({
+      ...props,
+      id: data.id,
+      name: databaseName,
+      state: data.state,
+      defaultBranch: data.default_branch || "main",
+      plan: data.plan,
+      createdAt: data.created_at,
+      updatedAt: data.updated_at,
+      htmlUrl: data.html_url,
+    });
   },
 );

package/src/planetscale/index.ts

@@ -1,4 +1,4 @@
-export * from "./api.ts";
+export * from "./api/client.gen.ts";
 export * from "./branch.ts";
 export * from "./database.ts";
 export * from "./password.ts";