@alchemy.run/planetscale 2.0.0-beta.84 → 2.0.0-beta.85

package/src/MySQL/MySQLMigrations.ts

@@ -1,34 +1,18 @@
 import {
-  makeMySQLMigrationExecutor,
   runMigrations,
+  withMySqlExecutor,
   type NormalizedMigrationsInput,
+  type SqlExecutor,
   type StampedMigrationsState,
 } from "@alchemy.run/sql/Migrations";
-import { readSqlFile, splitSqlStatements } from "@alchemy.run/sql/SqlFile";
+import { applySqlImports, splitSqlStatements } from "@alchemy.run/sql/SqlFile";
 import * as ps from "@distilled.cloud/planetscale";
-import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
-import type { Connection } from "mysql2/promise";
 
 const MIGRATION_PASSWORD_TTL_SECONDS = 600;
 
-// `mysql2` is an optional peer dependency — loaded lazily so importing the
-// Planetscale provider never requires the driver unless migrations run.
-const importMysql = () =>
-  import("mysql2/promise").catch((cause) => {
-    throw new Error(
-      "Failed to load the 'mysql2' driver. Install the optional peer dependency 'mysql2' to run Planetscale MySQL migrations.",
-      { cause },
-    );
-  });
-
-export class MySQLMigrationError extends Data.TaggedError("Planetscale::MySQLMigrationError")<{
-  message: string;
-  cause?: unknown;
-}> {}
-
 export interface MySQLMigrationTarget {
   organization: string;
   database: string;
@@ -47,69 +31,48 @@ export const runMySQLMigrations = (
   runMigrations({
     input,
     stamped,
-    withExecutor: (apply) =>
-      withMySQLConnection(target, (connection) => apply(makeMySQLMigrationExecutor(connection))),
+    withExecutor: (apply) => withMySQLExecutor(target, apply),
   });
 
+/**
+ * Apply `importFiles`, each once and again only when it changes. Vitess
+ * rejects drizzle-kit's `--> statement-breakpoint` markers, so statements
+ * run one at a time.
+ */
 export const runMySQLImports = (
   target: MySQLMigrationTarget,
   importFiles: ReadonlyArray<string>,
   rootDir: string,
   previous: Record<string, string>,
 ) =>
-  Effect.gen(function* () {
-    const hashes: Record<string, string> = { ...previous };
-    for (const filePath of importFiles) {
-      const file = yield* readSqlFile(rootDir, filePath);
-      if (previous[filePath] === file.hash) {
-        hashes[filePath] = file.hash;
-        continue;
-      }
-      yield* runMySQLSql(target, file.sql);
-      hashes[filePath] = file.hash;
-    }
-    const tracked = new Set(importFiles);
-    for (const key of Object.keys(hashes)) {
-      if (!tracked.has(key)) delete hashes[key];
-    }
-    return hashes;
+  applySqlImports({
+    importFiles,
+    rootDir,
+    previous,
+    apply: (file) =>
+      withMySQLExecutor(target, (executor) =>
+        Effect.forEach(splitSqlStatements(file.sql), (statement) => executor.query(statement), {
+          discard: true,
+        }),
+      ),
   });
 
-const runMySQLSql = (target: MySQLMigrationTarget, sql: string) =>
-  withMySQLConnection(target, (connection) =>
-    Effect.gen(function* () {
-      for (const statement of splitSqlStatements(sql)) {
-        yield* mysqlQuery(connection, statement);
-      }
-    }),
-  );
-
-const withMySQLConnection = <A, E, R>(
+/** A verified-TLS `mysql2` session as a short-lived admin password. */
+const withMySQLExecutor = <A, E, R>(
   target: MySQLMigrationTarget,
-  use: (connection: Connection) => Effect.Effect<A, E, R>,
+  use: (executor: SqlExecutor) => Effect.Effect<A, E, R>,
 ) =>
   withTemporaryMySQLPassword(target, (password) =>
-    Effect.acquireUseRelease(
-      Effect.tryPromise({
-        try: async () => {
-          const { createConnection } = await importMysql();
-          return createConnection({
-            host: password.host,
-            user: password.username,
-            password: Redacted.value(password.password),
-            database: target.database,
-            multipleStatements: true,
-            ssl: { rejectUnauthorized: true },
-          });
-        },
-        catch: toMigrationError,
-      }),
+    withMySqlExecutor(
+      {
+        host: password.host,
+        user: password.username,
+        password: Redacted.value(password.password),
+        database: target.database,
+        multipleStatements: true,
+        ssl: { rejectUnauthorized: true },
+      },
       use,
-      (connection) =>
-        Effect.tryPromise({
-          try: () => connection.end(),
-          catch: toMigrationError,
-        }).pipe(Effect.ignore),
     ),
   );
 
@@ -168,15 +131,3 @@ const withTemporaryMySQLPassword = <A, E, R>(
           ),
         ),
   );
-
-const mysqlQuery = (connection: Connection, sql: string) =>
-  Effect.tryPromise({
-    try: () => connection.query(sql).then(() => undefined),
-    catch: toMigrationError,
-  });
-
-const toMigrationError = (cause: unknown) =>
-  new MySQLMigrationError({
-    message: cause instanceof Error ? cause.message : String(cause),
-    cause,
-  });

package/src/MySQL/MySQLPassword.ts

@@ -189,7 +189,7 @@ export const MySQLPasswordProvider = () =>
               branch: output.branch,
             }),
           ),
-          Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          Effect.catchTag("NotFound", () => Effect.undefined),
         );
     }),
 
@@ -217,7 +217,7 @@ export const MySQLPasswordProvider = () =>
               branch: branchName,
               id: output.id,
             })
-            .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)))
+            .pipe(Effect.catchTag("NotFound", () => Effect.undefined))
         : undefined;
 
       // 2. Ensure — create the password if it doesn't exist live.

package/src/Postgres/PostgresDatabase.ts

@@ -200,7 +200,7 @@ export const PostgresDatabaseProvider = () =>
           organization,
           database: databaseName,
         })
-        .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
+        .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
 
       if (!data) return undefined;
 
@@ -223,7 +223,7 @@ export const PostgresDatabaseProvider = () =>
           database: data.name,
           branch: defaultBranch,
         })
-        .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
+        .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
 
       const arch = toPostgresClusterArch(branch!.cluster_architecture);
       const clusterSize = branch!.cluster_name;
@@ -276,7 +276,7 @@ export const PostgresDatabaseProvider = () =>
           organization,
           database: observedName,
         })
-        .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
+        .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
 
       // Ensure — if missing, create.
       if (!observed) {
@@ -425,7 +425,7 @@ export const PostgresDatabaseProvider = () =>
                 database: data.name,
                 branch: defaultBranch,
               })
-              .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
+              .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
 
             const arch = toPostgresClusterArch(branch?.cluster_architecture);
             const clusterSize = branch?.cluster_name ?? "";

package/src/Postgres/PostgresDefaultRole.ts

@@ -153,7 +153,7 @@ export const PostgresDefaultRoleProvider = () =>
             privateHost: role.private_access_host_url,
             privateConnectionServiceName: role.private_connection_service_name,
           })),
-          Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          Effect.catchTag("NotFound", () => Effect.undefined),
         );
     }),
 
@@ -175,7 +175,7 @@ export const PostgresDefaultRoleProvider = () =>
           database: databaseName,
           branch: branchName,
         })
-        .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
+        .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
 
       // 2. Sync (no-op) — we own the role and it still exists in the
       //    cloud. Default roles have nothing mutable in place: their

package/src/Postgres/PostgresMigrations.ts

@@ -1,36 +1,19 @@
 import {
-  makePgMigrationExecutor,
   runMigrations,
+  withPgExecutor,
   type NormalizedMigrationsInput,
+  type SqlExecutor,
   type StampedMigrationsState,
 } from "@alchemy.run/sql/Migrations";
-import { readSqlFile } from "@alchemy.run/sql/SqlFile";
+import { stripSslQueryParams } from "@alchemy.run/sql/PostgresDriver";
+import { applySqlImports } from "@alchemy.run/sql/SqlFile";
 import * as ps from "@distilled.cloud/planetscale";
-import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
-import type { Client } from "pg";
-
-// `pg` is an optional peer dependency — loaded lazily so importing the
-// Planetscale provider never requires the driver unless migrations run.
-const importPg = () =>
-  import("pg").catch((cause) => {
-    throw new Error(
-      "Failed to load the 'pg' driver. Install the optional peer dependency 'pg' to run Planetscale Postgres migrations.",
-      { cause },
-    );
-  });
 
 const MIGRATION_ROLE_TTL_SECONDS = 600;
 
-export class PostgresMigrationError extends Data.TaggedError(
-  "Planetscale::PostgresMigrationError",
-)<{
-  message: string;
-  cause?: unknown;
-}> {}
-
 export interface PostgresMigrationTarget {
   organization: string;
   database: string;
@@ -49,67 +32,36 @@ export const runPostgresMigrations = (
   runMigrations({
     input,
     stamped,
-    withExecutor: (apply) =>
-      withPostgresClient(target, (client) => apply(makePgMigrationExecutor(client))),
+    withExecutor: (apply) => withPostgresExecutor(target, apply),
   });
 
+/** Apply `importFiles`, each once and again only when it changes. */
 export const runPostgresImports = (
   target: PostgresMigrationTarget,
   importFiles: ReadonlyArray<string>,
   rootDir: string,
   previous: Record<string, string>,
 ) =>
-  Effect.gen(function* () {
-    const hashes: Record<string, string> = { ...previous };
-    for (const filePath of importFiles) {
-      const file = yield* readSqlFile(rootDir, filePath);
-      if (previous[filePath] === file.hash) {
-        hashes[filePath] = file.hash;
-        continue;
-      }
-      yield* runPostgresSql(target, file.sql);
-      hashes[filePath] = file.hash;
-    }
-    const tracked = new Set(importFiles);
-    for (const key of Object.keys(hashes)) {
-      if (!tracked.has(key)) delete hashes[key];
-    }
-    return hashes;
+  applySqlImports({
+    importFiles,
+    rootDir,
+    previous,
+    apply: (file) =>
+      withPostgresExecutor(target, (executor) => executor.query(file.sql)).pipe(Effect.asVoid),
   });
 
-const runPostgresSql = (target: PostgresMigrationTarget, sql: string) =>
-  withPostgresClient(target, (client) => pgExec(client, sql));
-
-const withPostgresClient = <A, E, R>(
+/** A verified-TLS `pg` session as a short-lived migration role. */
+const withPostgresExecutor = <A, E, R>(
   target: PostgresMigrationTarget,
-  use: (client: Client) => Effect.Effect<A, E, R>,
+  use: (executor: SqlExecutor) => Effect.Effect<A, E, R>,
 ) =>
   withTemporaryPostgresRole(target, (role) =>
-    Effect.acquireUseRelease(
-      Effect.gen(function* () {
-        const { Client } = yield* Effect.tryPromise({
-          try: importPg,
-          catch: toMigrationError,
-        });
-        const client = yield* Effect.sync(
-          () =>
-            new Client({
-              connectionString: role.connectionUrl.pipe(Redacted.value, stripPgSslQueryParams),
-              ssl: { rejectUnauthorized: true },
-            }),
-        );
-        yield* Effect.tryPromise({
-          try: () => client.connect(),
-          catch: toMigrationError,
-        });
-        return client;
-      }),
+    withPgExecutor(
+      {
+        connectionString: role.connectionUrl.pipe(Redacted.value, stripSslQueryParams),
+        ssl: { rejectUnauthorized: true },
+      },
       use,
-      (client) =>
-        Effect.tryPromise({
-          try: () => client.end(),
-          catch: toMigrationError,
-        }).pipe(Effect.ignore),
     ),
   );
 
@@ -168,26 +120,3 @@ const withTemporaryPostgresRole = <A, E, R>(
           ),
         ),
   );
-
-const pgExec = (client: Client, sql: string, values?: ReadonlyArray<unknown>) =>
-  Effect.tryPromise({
-    try: () => client.query(sql, values as Array<unknown>).then(() => undefined),
-    catch: toMigrationError,
-  });
-
-const toMigrationError = (cause: unknown) =>
-  new PostgresMigrationError({
-    message: cause instanceof Error ? cause.message : String(cause),
-    cause,
-  });
-
-const stripPgSslQueryParams = (uri: string): string => {
-  try {
-    const url = new URL(uri);
-    url.searchParams.delete("sslmode");
-    url.searchParams.delete("channel_binding");
-    return url.toString();
-  } catch {
-    return uri;
-  }
-};

package/src/Postgres/PostgresRole.ts

@@ -251,8 +251,8 @@ export const PostgresRoleProvider = () =>
             }),
           ),
           Effect.catchTags({
-            Forbidden: () => Effect.succeed(undefined),
-            NotFound: () => Effect.succeed(undefined),
+            Forbidden: () => Effect.undefined,
+            NotFound: () => Effect.undefined,
           }),
         );
     }),
@@ -277,7 +277,7 @@ export const PostgresRoleProvider = () =>
               organization,
               database: databaseName,
             })
-            .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)))
+            .pipe(Effect.catchTag("NotFound", () => Effect.undefined))
         : undefined;
 
       // 2. Ensure — create if missing. Single branch covers both
@@ -292,7 +292,7 @@ export const PostgresRoleProvider = () =>
       //    once on create; on an observe-hit we re-use the cached
       //    plaintext from output (which is why adoption requires
       //    pre-existing state — see `read`).
-      let live: planetscale.GetRoleOutput | planetscale.CreateRoleOutput;
+      let live: planetscale.GetRoleOutput;
       let plaintext: Redacted.Redacted<string>;
       if (observed) {
         live = observed;

package/src/Util.ts

@@ -48,7 +48,7 @@ export const deleteUnprotectedDatabase = Effect.fn(function* (
 ) {
   const live = yield* ps
     .getDatabase({ organization, database })
-    .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
+    .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
   if (!live) return;
   if (live.deletion_protected) {
     return yield* new PlanetscaleDeletionProtected({