alchemy 0.84.0 → 0.85.1

package/src/planetscale/branch.ts

@@ -205,7 +205,7 @@ export const Branch = Resource(
           path: {
             organization,
             database,
-            name: this.output.name,
+            branch: this.output.name,
           },
           throwOnError: false,
         });
@@ -236,7 +236,7 @@ export const Branch = Resource(
       path: {
         organization,
         database,
-        name: branchName,
+        branch: branchName,
       },
       throwOnError: false,
     });
@@ -287,7 +287,7 @@ export const Branch = Resource(
           path: {
             organization,
             database,
-            name: branchName,
+            branch: branchName,
           },
         });
       }
@@ -367,7 +367,7 @@ export const Branch = Resource(
         path: {
           organization,
           database,
-          name: branchName,
+          branch: branchName,
         },
       });
     }

package/src/planetscale/database.ts

@@ -46,63 +46,93 @@ interface BaseDatabaseProps extends PlanetScaleProps {
   };
 
   /**
-   * Whether to require approval for deployments
+   * The number of replicas for the database. 0 for non-HA, 2+ for HA. (create only)
    */
-  requireApprovalForDeploy?: boolean;
+  replicas?: number;
 
   /**
-   * Whether to allow data branching
+   * The database cluster size (required)
    */
-  allowDataBranching?: boolean;
+  clusterSize: PlanetScaleClusterSize;
+
+  /**
+   * The engine kind for the database (create only)
+   * @default "mysql"
+   */
+  kind?: "mysql" | "postgresql";
 
   /**
-   * Whether to enable automatic migrations
+   * Whether or not deploy requests must be approved by a database administrator other than the request creator
    */
-  automaticMigrations?: boolean;
+  requireApprovalForDeploy?: boolean;
 
   /**
-   * Whether to restrict branch creation to the same region as database
+   * Whether or not to limit branch creation to the same region as the one selected during database creation.
    */
   restrictBranchRegion?: boolean;
 
   /**
-   * Whether to collect full queries from the database
+   * Whether or not full queries should be collected from the database
    */
   insightsRawQueries?: boolean;
 
   /**
-   * Whether web console can be used on production branch
+   * Whether or not the web console can be used on the production branch of the database
    */
   productionBranchWebConsole?: boolean;
 
   /**
    * The default branch of the database
+   * @default "main"
    */
   defaultBranch?: string;
+}
+
+/**
+ * Properties for creating or updating a PlanetScale MySQL database
+ */
+interface MySQLDatabaseProps extends BaseDatabaseProps {
+  kind?: "mysql";
 
   /**
-   * Migration framework to use on the database
+   * Whether or not to copy migration data to new branches and in deploy requests. (Vitess only)
+   */
+  automaticMigrations?: boolean;
+
+  /**
+   * A migration framework to use on the database. (Vitess only)
    */
   migrationFramework?: string;
 
   /**
-   * Name of table to use as migration table
+   * Name of table to use as migration table for the database. (Vitess only)
    */
   migrationTableName?: string;
 
   /**
-   * The database cluster size (required)
+   * Whether or not data branching is allowed on the database. (Vitess only)
    */
-  clusterSize: PlanetScaleClusterSize;
+  allowDataBranching?: boolean;
 
   /**
-   * The engine kind for the database
-   * @default "mysql"
+   * Whether or not foreign key constraints are allowed on the database. (Vitess only)
    */
-  kind?: "mysql" | "postgresql";
+  allowForeignKeyConstraints?: boolean;
+}
+
+/**
+ * Properties for creating or updating a PlanetScale PostgreSQL database
+ */
+interface PostgreSQLDatabaseProps extends BaseDatabaseProps {
+  kind: "postgresql";
 
   /**
-   * The CPU architecture for the database. Only available for PostgreSQL databases.
+   * The PostgreSQL major version to use for the database. Defaults to the latest available major version. (PostgreSQL only)
+   */
+  majorVersion?: string;
+
+  /**
+   * The CPU architecture for the database (PostgreSQL only)
    */
   arch?: "x86" | "arm";
 }
@@ -110,17 +140,7 @@ interface BaseDatabaseProps extends PlanetScaleProps {
 /**
  * Properties for creating or updating a PlanetScale Database
  */
-export type DatabaseProps = BaseDatabaseProps &
-  (
-    | {
-        kind?: "mysql";
-        arch?: undefined;
-      }
-    | {
-        kind: "postgresql";
-        arch?: "x86" | "arm";
-      }
-  );
+export type DatabaseProps = MySQLDatabaseProps | PostgreSQLDatabaseProps;
 
 /**
  * Represents a PlanetScale Database
@@ -220,7 +240,11 @@ export const Database = Resource(
     const clusterSize = sanitizeClusterSize({
       size: props.clusterSize,
       kind: props.kind,
-      arch: props.arch,
+      ...(props.kind === "postgresql"
+        ? {
+            arch: props.arch,
+          }
+        : {}),
       region: props.region?.slug,
     });
     const organization =
@@ -234,13 +258,14 @@ export const Database = Resource(
         "PlanetScale organization is required. Please set the `organization` property or the `PLANETSCALE_ORGANIZATION` environment variable.",
       );
     }
+    const adopt = props.adopt ?? this.scope.adopt;
     const shouldDelete = props.delete ?? false;
 
     if (this.phase === "update" && this.output.name !== databaseName) {
       await api.updateDatabaseSettings({
         path: {
           organization,
-          name: this.output.name,
+          database: this.output.name,
         },
         body: { new_name: databaseName },
       });
@@ -251,7 +276,7 @@ export const Database = Resource(
         const response = await api.deleteDatabase({
           path: {
             organization,
-            name: this.output.name,
+            database: this.output.name,
           },
           throwOnError: false,
         });
@@ -269,11 +294,11 @@ export const Database = Resource(
     const getResponse = await api.getDatabase({
       path: {
         organization,
-        name: databaseName,
+        database: databaseName,
       },
       throwOnError: false,
     });
-    if (this.phase === "update" || (props.adopt && getResponse.data)) {
+    if (this.phase === "update" || (adopt && getResponse.data)) {
       if (!getResponse.data) {
         throw new Error(`Database "${databaseName}" not found`, {
           cause: getResponse.error,
@@ -286,7 +311,7 @@ export const Database = Resource(
           path: {
             organization,
             database: databaseName,
-            name: props.defaultBranch,
+            branch: props.defaultBranch,
           },
           throwOnError: false,
         });
@@ -311,15 +336,20 @@ export const Database = Resource(
       const { data } = await api.updateDatabaseSettings({
         path: {
           organization,
-          name: databaseName,
+          database: databaseName,
         },
         body: {
-          automatic_migrations: props.automaticMigrations,
-          migration_framework: props.migrationFramework,
-          migration_table_name: props.migrationTableName,
+          ...(props.kind !== "postgresql"
+            ? {
+                automatic_migrations: props.automaticMigrations,
+                migration_framework: props.migrationFramework,
+                migration_table_name: props.migrationTableName,
+                allow_foreign_key_constraints: props.allowForeignKeyConstraints,
+                allow_data_branching: props.allowDataBranching,
+              }
+            : {}),
           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,
@@ -363,6 +393,12 @@ export const Database = Resource(
         region: props.region?.slug,
         kind: props.kind,
         cluster_size: clusterSize,
+        replicas: props.replicas,
+        ...(props.kind === "postgresql"
+          ? {
+              major_version: props.majorVersion,
+            }
+          : {}),
       },
     });
 
@@ -370,17 +406,22 @@ export const Database = Resource(
     const { data } = await api.updateDatabaseSettings({
       path: {
         organization,
-        name: databaseName,
+        database: databaseName,
       },
       body: {
+        ...(props.kind !== "postgresql"
+          ? {
+              automatic_migrations: props.automaticMigrations,
+              migration_framework: props.migrationFramework,
+              migration_table_name: props.migrationTableName,
+              allow_foreign_key_constraints: props.allowForeignKeyConstraints,
+              allow_data_branching: props.allowDataBranching,
+            }
+          : {}),
         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,
       },
     });
 
@@ -393,7 +434,7 @@ export const Database = Resource(
         path: {
           organization,
           database: databaseName,
-          name: props.defaultBranch,
+          branch: props.defaultBranch,
         },
         throwOnError: false,
       });
@@ -424,7 +465,7 @@ export const Database = Resource(
         const { data: updatedData } = await api.updateDatabaseSettings({
           path: {
             organization,
-            name: databaseName,
+            database: databaseName,
           },
           body: {
             default_branch: props.defaultBranch,

package/src/planetscale/default-role.ts

@@ -0,0 +1,162 @@
+import { alchemy } from "../alchemy.ts";
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import { createPlanetScaleClient, type PlanetScaleProps } from "./api.ts";
+import type { Branch } from "./branch.ts";
+import type { Database } from "./database.ts";
+import type { Role } from "./role.ts";
+import { waitForBranchReady } from "./utils.ts";
+
+export interface DefaultRoleProps extends PlanetScaleProps {
+  /**
+   * The organization where the role will be created
+   * Required when using string database name, optional when using Database resource
+   * @default process.env.PLANETSCALE_ORGANIZATION
+   */
+  organization?: string;
+
+  /**
+   * The database where the role will be created
+   * Can be either a database name (string) or Database resource
+   */
+  database: string | Database;
+
+  /**
+   * The branch where the role will be created
+   * Can be either a branch name (string) or Branch resource
+   * @default "main"
+   */
+  branch?: string | Branch;
+
+  /**
+   * Whether to force reset the default role if it already exists.
+   * This will delete the existing role and create a new one.
+   *
+   * Note: Adopting an existing role is not supported because the password is only returned after create.
+   *
+   * @default false
+   */
+  forceReset?: boolean;
+}
+
+export type DefaultRole = Omit<Role, "successor">;
+
+/**
+ * Create and manage the default role for a PlanetScale PostgreSQL database branch.
+ *
+ * If a default role already exists for this database and branch combination, you may need to use the `forceReset` property to reset the role.
+ *
+ * For MySQL, use [Passwords](./password.ts) instead.
+ *
+ * @example
+ * const database = await Database("my-database", {
+ *   kind: "postgresql",
+ * });
+ * const defaultRole = await DefaultRole("my-default-role", {
+ *   database,
+ * });
+ */
+export const DefaultRole = Resource(
+  "planetscale::DefaultRole",
+  async function (
+    this: Context<DefaultRole, DefaultRoleProps>,
+    _id: string,
+    props: DefaultRoleProps,
+  ): Promise<DefaultRole> {
+    const api = createPlanetScaleClient(props);
+    const organization =
+      props.organization ??
+      (typeof props.database !== "string"
+        ? props.database.organization
+        : (process.env.PLANETSCALE_ORGANIZATION ??
+          process.env.PLANETSCALE_ORG_ID));
+    if (!organization) {
+      throw new Error(
+        "PlanetScale organization is required. Please set the `organization` property or the `PLANETSCALE_ORGANIZATION` environment variable.",
+      );
+    }
+
+    const database =
+      typeof props.database === "string" ? props.database : props.database.name;
+    const branch =
+      typeof props.branch === "string"
+        ? props.branch
+        : (props.branch?.name ?? "main");
+
+    switch (this.phase) {
+      case "create": {
+        if (!props.forceReset) {
+          const existing = await api.getDefaultRole({
+            path: {
+              organization,
+              database,
+              branch,
+            },
+            throwOnError: false,
+          });
+          if (existing.data) {
+            throw new Error(
+              `Default role already exists for database "${database}" branch "${branch}". Use forceReset to reset the role.`,
+            );
+          } else if (existing.error && existing.response.status !== 404) {
+            throw new Error(
+              `Failed to check for default role in database "${database}" branch "${branch}".`,
+              {
+                cause: existing.error,
+              },
+            );
+          }
+        }
+        await waitForBranchReady(api, organization, database, branch);
+        const { data } = await api.resetDefaultRole({
+          path: {
+            organization,
+            database,
+            branch,
+          },
+        });
+        return {
+          id: data.id,
+          name: data.name,
+          expiresAt: data.expires_at,
+          host: data.access_host_url,
+          username: data.username,
+          ttl: data.ttl,
+          password: alchemy.secret(data.password),
+          databaseName: data.database_name,
+          connectionUrl: alchemy.secret(
+            `postgresql://${data.username}:${data.password}@${data.access_host_url}:5432/${data.database_name}?sslmode=verify-full`,
+          ),
+          connectionUrlPooled: alchemy.secret(
+            `postgresql://${data.username}:${data.password}@${data.access_host_url}:6432/${data.database_name}?sslmode=verify-full`,
+          ),
+          inheritedRoles: data.inherited_roles,
+          database,
+          branch,
+          organization,
+        };
+      }
+      case "update": {
+        if (
+          database !== this.output.database ||
+          branch !== this.output.branch
+        ) {
+          return this.replace();
+        }
+        return this.output;
+      }
+      case "delete": {
+        // reset default role - even though we don't need new credentials,
+        // it's best to invalidate existing ones, and there's no delete endpoint
+        await api.resetDefaultRole({
+          path: {
+            organization,
+            database,
+            branch,
+          },
+        });
+        return this.destroy();
+      }
+    }
+  },
+);

package/src/planetscale/index.ts

@@ -1,6 +1,7 @@
 export * from "./api.ts";
 export * from "./branch.ts";
 export * from "./database.ts";
+export * from "./default-role.ts";
 export * from "./organization.ts";
 export * from "./password.ts";
 export * from "./role.ts";

package/src/planetscale/organization.ts

@@ -10,7 +10,7 @@ export async function OrganizationRef(
   const api = createPlanetScaleClient(options);
   const organization = await api.getOrganization({
     path: {
-      name: typeof name === "string" ? name : name.id,
+      organization: typeof name === "string" ? name : name.id,
     },
   });
   return organization.data;

package/src/planetscale/role.ts

@@ -63,7 +63,7 @@ export interface RoleProps extends PlanetScaleProps {
  * Roles that can be inherited from.
  */
 export type InheritedRole =
-  | "postgres"
+  | "pscale_managed"
   | "pg_checkpoint"
   | "pg_create_subscription"
   | "pg_maintain"
@@ -75,6 +75,7 @@ export type InheritedRole =
   | "pg_stat_scan_tables"
   | "pg_use_reserved_connections"
   | "pg_write_all_data"
+  | "postgres"
   | (string & {});
 
 export interface Role extends Omit<RoleProps, "inheritedRoles"> {
@@ -261,7 +262,7 @@ export const Role = Resource(
           path: {
             organization,
             database,
-            name: branch,
+            branch,
           },
         });
         if (kind !== "postgresql") {

package/src/planetscale/utils.ts

@@ -4,6 +4,7 @@ import type { DatabaseBranch } from "./api/types.gen.ts";
 
 export type PlanetScaleClusterSize =
   | "PS_DEV"
+  | "PS_5"
   | "PS_10"
   | "PS_20"
   | "PS_40"
@@ -59,7 +60,7 @@ export async function waitForBranchReady(
     description: `branch "${branch}" ready`,
     fn: () =>
       api.getBranch({
-        path: { organization, database, name: branch },
+        path: { organization, database, branch },
       }),
     predicate: ({ data }) => data.ready,
   });
@@ -78,7 +79,7 @@ export async function waitForDatabaseReady(
     description: `database "${database}" ready`,
     fn: () =>
       api.getDatabase({
-        path: { organization, name: database },
+        path: { organization, database },
       }),
     predicate: ({ data }) => data.ready,
   });
@@ -134,7 +135,7 @@ export async function ensureProductionBranchClusterSize(
       break;
     }
     case "postgresql": {
-      // Postgres databases must be resized first before promoting, otherwise 500 error
+      // Postgres databases do not need to be promoted; PS_DEV is development and all others are production
       await ensurePostgresClusterSize(
         api,
         organization,
@@ -142,7 +143,6 @@ export async function ensureProductionBranchClusterSize(
         branch,
         expectedClusterSize,
       );
-      await ensureProductionBranch(api, organization, database, branch);
       break;
     }
   }
@@ -155,21 +155,21 @@ async function ensureProductionBranch(
   api: PlanetScaleClient,
   organization: string,
   database: string,
-  name: string,
+  branch: string,
 ): Promise<void> {
   const { data } = await api.getBranch({
     path: {
       organization,
       database,
-      name,
+      branch,
     },
   });
   if (!data.production) {
     if (!data.ready) {
-      await waitForBranchReady(api, organization, database, name);
+      await waitForBranchReady(api, organization, database, branch);
     }
     await api.promoteBranch({
-      path: { organization, database, name },
+      path: { organization, database, branch },
     });
   }
 }
@@ -213,7 +213,7 @@ async function ensureMySQLClusterSize(
       path: {
         organization,
         database,
-        name: branch,
+        branch,
       },
       body: { cluster_size: expectedClusterSize },
     });
@@ -243,7 +243,7 @@ async function ensurePostgresClusterSize(
     path: {
       organization,
       database,
-      name: branch,
+      branch,
     },
   });
   if (data.cluster_name === expectedClusterSize) {

package/src/scope.ts

@@ -342,12 +342,21 @@ export class Scope {
     return state !== undefined && (type === undefined || state.kind === type);
   }
 
-  public createPhysicalName(id: string, delimiter = "-"): string {
-    const app = this.appName;
-    const stage = this.stage;
-    return [app, ...this.chain.slice(2), id, stage]
-      .map((s) => s.replaceAll(/[^a-z0-9_-]/gi, delimiter))
+  public createPhysicalName(
+    id: string,
+    delimiter = "-",
+    maxLength?: number,
+  ): string {
+    let name = [this.appName, ...this.chain.slice(2), id, this.stage]
+      .map((part) => part.replaceAll(/[^a-z0-9_-]/gi, delimiter))
       .join(delimiter);
+    while (maxLength && name.length > maxLength) {
+      name = name
+        .split(delimiter)
+        .map((part) => part.slice(0, -1))
+        .join(delimiter);
+    }
+    return name;
   }
 
   public async spawn<

package/src/state/sqlite-state-store.ts

@@ -162,6 +162,7 @@ async function createBunSQLiteDatabase(
     create: true,
     ...bunOptions,
   });
+  client.exec("PRAGMA busy_timeout = 5000;");
   client.exec("PRAGMA journal_mode = WAL;");
   const db = drizzle(client, {
     schema,
@@ -192,6 +193,7 @@ async function createLibSQLDatabase(
   const { migrate } = await import("drizzle-orm/libsql/migrator");
   const schema = await import("./schema.js");
   const client = createClient({ url, ...options });
+  await client.execute("PRAGMA busy_timeout = 5000;");
   await client.execute("PRAGMA journal_mode = WAL;");
   const db = drizzle(client, {
     schema,

package/src/test/bun.ts

@@ -51,6 +51,29 @@ type test = {
    * @param condition If true, test will be skipped
    */
   skipIf(condition: boolean): test;
+  skip: {
+    /**
+     * Create a test with default options
+     * @param name Test name
+     * @param fn Test function
+     * @param timeout Optional timeout in milliseconds
+     */
+    (name: string, fn: (scope: Scope) => Promise<any>, timeout?: number): void;
+
+    /**
+     * Create a test with custom options
+     * @param name Test name
+     * @param options Test configuration options
+     * @param fn Test function
+     * @param timeout Optional timeout in milliseconds
+     */
+    (
+      name: string,
+      options: TestOptions,
+      fn: (scope: Scope) => Promise<any>,
+      timeout?: number,
+    ): void;
+  };
 
   beforeAll(fn: (scope: Scope) => Promise<void>, timeout?: number): void;
 
@@ -95,6 +118,8 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
   // Add skipIf functionality
   test.skipIf = it.skipIf.bind(it);
 
+  test.skip = it.skip.bind(it);
+
   // Create local test scope based on filename
   const scope = new Scope({
     parent: undefined,