alchemy 0.42.1 → 0.43.1

package/src/cloudflare/d1-migrations.ts

@@ -22,6 +22,131 @@ async function readMigrationFile(filePath: string): Promise<string> {
   return fs.readFile(filePath, "utf-8");
 }
 
+/**
+ * Detects the current schema of the migration table.
+ * Returns info about the table structure to determine if migration is needed.
+ */
+async function detectMigrationTableSchema(
+  options: D1MigrationOptions,
+): Promise<{
+  exists: boolean;
+  hasIdColumn: boolean;
+  hasNameColumn: boolean;
+  isLegacySchema: boolean;
+  columns: Array<{ name: string; type: string; pk: number }>;
+}> {
+  try {
+    // Check if the table exists and get its schema
+    const pragmaSQL = `PRAGMA table_info(${options.migrationsTable});`;
+    const result = await executeD1SQL(options, pragmaSQL);
+    const columns = result?.result[0]?.results || [];
+
+    if (columns.length === 0) {
+      return {
+        exists: false,
+        hasIdColumn: false,
+        hasNameColumn: false,
+        isLegacySchema: false,
+        columns: [],
+      };
+    }
+
+    const columnNames = columns.map((col: any) => col.name);
+    const hasIdColumn = columnNames.includes("id");
+    const hasNameColumn = columnNames.includes("name");
+
+    // Legacy schema has only 2 columns and is missing the proper 3-column structure
+    // Wrangler needs (id, name, applied_at) - if we don't have both id and name columns, it's legacy
+    const isLegacySchema =
+      columns.length === 2 && !(hasIdColumn && hasNameColumn);
+
+    return {
+      exists: true,
+      hasIdColumn,
+      hasNameColumn,
+      isLegacySchema,
+      columns: columns.map((col: any) => ({
+        name: col.name,
+        type: col.type,
+        pk: col.pk,
+      })),
+    };
+  } catch (_error) {
+    return {
+      exists: false,
+      hasIdColumn: false,
+      hasNameColumn: false,
+      isLegacySchema: false,
+      columns: [],
+    };
+  }
+}
+
+/**
+ * Migrates a legacy 2-column migration table to the wrangler-compatible 3-column format.
+ * Legacy: (id, applied_at) or (name, applied_at)
+ * New: (id, name, applied_at) where id is primary key and name is migration filename
+ */
+async function migrateLegacySchema(
+  options: D1MigrationOptions,
+  schema: { columns: Array<{ name: string; type: string; pk: number }> },
+): Promise<void> {
+  logger.log(
+    `Migrating legacy migration table ${options.migrationsTable} to wrangler-compatible schema...`,
+  );
+
+  // Determine the current primary column name (could be 'id' or something else)
+  const primaryColumn =
+    schema.columns.find((col) => col.pk === 1)?.name || schema.columns[0]?.name;
+
+  if (!primaryColumn) {
+    throw new Error("Cannot migrate legacy migration table: no columns found");
+  }
+
+  const tempTableName = `${options.migrationsTable}_temp_migration`;
+
+  try {
+    // 1. Create new table with correct schema
+    const createNewTableSQL = `CREATE TABLE ${tempTableName} (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL
+    );`;
+    await executeD1SQL(options, createNewTableSQL);
+
+    // 2. Copy data from old table to new table
+    // Use row_number() to generate sequential IDs, and use the old primary column value as the name
+    const copyDataSQL = `
+      INSERT INTO ${tempTableName} (id, name, applied_at)
+      SELECT 
+        printf('%05d', row_number() OVER (ORDER BY applied_at)) as id,
+        ${primaryColumn} as name,
+        applied_at
+      FROM ${options.migrationsTable}
+      ORDER BY applied_at;
+    `;
+    await executeD1SQL(options, copyDataSQL);
+
+    // 3. Drop old table
+    const dropOldTableSQL = `DROP TABLE ${options.migrationsTable};`;
+    await executeD1SQL(options, dropOldTableSQL);
+
+    // 4. Rename new table
+    const renameTableSQL = `ALTER TABLE ${tempTableName} RENAME TO ${options.migrationsTable};`;
+    await executeD1SQL(options, renameTableSQL);
+
+    logger.log(
+      "Successfully migrated migration table to wrangler-compatible schema",
+    );
+  } catch (error) {
+    // If migration fails, try to clean up temp table
+    try {
+      await executeD1SQL(options, `DROP TABLE IF EXISTS ${tempTableName};`);
+    } catch {}
+    throw new Error(`Failed to migrate legacy migration table: ${error}`);
+  }
+}
+
 /**
  * Reads migration SQL files from the migrationsDir, sorted by filename.
  * @param migrationsDir Directory containing .sql migration files
@@ -54,28 +179,64 @@ export async function listMigrationsFiles(
 }
 
 /**
- * Ensures the migrations table exists in the D1 database.
+ * Ensures the migrations table exists in the D1 database with wrangler-compatible schema.
+ * Handles migration from legacy 2-column schema to 3-column schema if needed.
  */
 export async function ensureMigrationsTable(
   options: D1MigrationOptions,
 ): Promise<void> {
-  const createTableSQL = `CREATE TABLE IF NOT EXISTS ${options.migrationsTable} (id TEXT PRIMARY KEY, applied_at TEXT);`;
+  const schema = await detectMigrationTableSchema(options);
+
+  // If table doesn't exist, create it with the correct 3-column schema
+  if (!schema.exists) {
+    const createTableSQL = `CREATE TABLE ${options.migrationsTable} (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL
+    );`;
+    await executeD1SQL(options, createTableSQL);
+    logger.log(
+      `Created migration table ${options.migrationsTable} with wrangler-compatible schema`,
+    );
+    return;
+  }
 
-  await executeD1SQL(options, createTableSQL);
+  // If table has legacy schema, migrate it
+  if (schema.isLegacySchema) {
+    await migrateLegacySchema(options, schema);
+    return;
+  }
+
+  // If table exists but doesn't have the correct 3-column structure, we need to handle it
+  if (!schema.hasIdColumn || !schema.hasNameColumn) {
+    logger.log(
+      `Migration table ${options.migrationsTable} has incomplete schema - attempting migration...`,
+    );
+    await migrateLegacySchema(options, schema);
+    return;
+  }
+
+  // Table already has correct schema
+  logger.log(
+    `Migration table ${options.migrationsTable} already has correct schema`,
+  );
 }
 
 /**
- * Gets the list of applied migration IDs from the migrations table.
+ * Gets the list of applied migration names from the migrations table.
+ * Uses the 'name' column which contains the migration filename.
  */
 export async function getAppliedMigrations(
   options: D1MigrationOptions,
 ): Promise<Set<string>> {
-  const sql = `SELECT id FROM ${options.migrationsTable};`;
+  const sql = `SELECT name FROM ${options.migrationsTable};`;
 
   const result = await executeD1SQL(options, sql);
 
-  const ids = (result?.result[0]?.results || []).map((row: any) => row.id);
-  return new Set(ids);
+  const migrationNames = (result?.result[0]?.results || []).map(
+    (row: any) => row.name,
+  );
+  return new Set(migrationNames);
 }
 
 /**
@@ -115,6 +276,7 @@ export async function executeD1SQL(
 
 /**
  * Applies all pending migrations from the provided files to the D1 database.
+ * Uses wrangler-compatible 3-column schema (id, name, applied_at).
  */
 export async function applyMigrations(
   options: D1MigrationOptions,
@@ -122,17 +284,65 @@ export async function applyMigrations(
   await ensureMigrationsTable(options);
   const applied = await getAppliedMigrations(options);
 
+  // Determine the starting point for sequential IDs by querying existing IDs from the database
+  const existingIdsResult = await executeD1SQL(
+    options,
+    `SELECT id FROM ${options.migrationsTable} ORDER BY id;`,
+  );
+
+  const existingIds = (existingIdsResult?.result[0]?.results || []).map(
+    (row: any) => row.id,
+  );
+
+  let maxNumeric = 0;
+  for (const id of existingIds) {
+    if (/^\d+$/.test(id)) {
+      const num = Number.parseInt(id, 10);
+      maxNumeric = Math.max(maxNumeric, num);
+    }
+  }
+  let nextSeq = maxNumeric + 1;
+
   for (const migration of options.migrationsFiles) {
-    const migrationId = migration.id;
+    const migrationName = migration.id;
 
-    if (applied.has(migrationId)) continue;
+    if (applied.has(migrationName)) continue;
 
-    // Run the migration
+    // Run the migration SQL
     await executeD1SQL(options, migration.sql);
-    // Record as applied
-    const insertSQL = `INSERT INTO ${options.migrationsTable} (id, applied_at) VALUES ('${migrationId.replace("'", "''")}', datetime('now'));`;
-    await executeD1SQL(options, insertSQL);
 
-    logger.log(`Applied migration: ${migrationId}`);
+    // Generate a migration id: prefer sequential zero-padded numeric ids (e.g. 00014)
+    // to keep consistency with legacy/imported data. If we cannot produce a numeric id
+    // (e.g. existing IDs are not numeric), fall back to a unique timestamp-based ID.
+    let migrationId: string;
+    if (nextSeq > 0) {
+      migrationId = nextSeq.toString().padStart(5, "0");
+      nextSeq += 1;
+    } else {
+      migrationId =
+        Date.now().toString() + Math.random().toString(36).substr(2, 9);
+    }
+
+    const insertSQL = `INSERT INTO ${options.migrationsTable} (id, name, applied_at) VALUES (?, ?, datetime('now'));`;
+
+    // Use parameterised query to record the migration
+    const response = await options.api.post(
+      `/accounts/${options.accountId}/d1/database/${options.databaseId}/query`,
+      {
+        sql: insertSQL,
+        params: [migrationId, migrationName],
+      },
+    );
+
+    if (!response.ok) {
+      await handleApiError(
+        response,
+        "inserting migration record",
+        "D1 database",
+        options.databaseId,
+      );
+    }
+
+    logger.log(`Applied migration: ${migrationName}`);
   }
 }

package/src/cloudflare/website.ts

@@ -123,7 +123,6 @@ export async function Website<B extends Bindings>(
       parent: Scope.current,
     },
     async (scope) => {
-      // directory from which all relative paths are resolved
       const cwd = path.resolve(props.cwd || process.cwd());
 
       function resolveAbsPath<S extends string | undefined>(f: S): S {
@@ -132,7 +131,12 @@ export async function Website<B extends Bindings>(
         ) as S;
       }
 
-      // absolute path to the wrangler.jsonc file
+      const mainPath = resolveAbsPath(props.main);
+      const assetsDirPath = resolveAbsPath(
+        typeof props.assets === "string"
+          ? props.assets
+          : (props.assets?.dist ?? "dist"),
+      );
       const wranglerJsonPath = resolveAbsPath(
         typeof wrangler === "boolean"
           ? "wrangler.jsonc"
@@ -141,23 +145,6 @@ export async function Website<B extends Bindings>(
             : (wrangler?.path ?? "wrangler.jsonc"),
       );
 
-      // absolute path to the worker entrypoint
-      const mainPath = resolveAbsPath(props.main);
-
-      // absolute path to the worker entrypoint (if different in wrangler.jsonc)
-      const wranglerMainPath = resolveAbsPath(
-        typeof wrangler === "object"
-          ? (wrangler.main ?? props.main!)
-          : props.main,
-      );
-
-      // absolute path to the assets directory
-      const assetsDirPath = resolveAbsPath(
-        typeof props.assets === "string"
-          ? props.assets
-          : (props.assets?.dist ?? "dist"),
-      );
-
       const workerName = props.name ?? id;
 
       const workerProps = {
@@ -165,10 +152,8 @@ export async function Website<B extends Bindings>(
         compatibilityDate:
           props.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE,
         name: workerName,
-        entrypoint: mainPath
-          ? // this path should be relative to the process.cwd() because it is used by esbuild
-            path.relative(process.cwd(), mainPath)
-          : undefined,
+        cwd: path.relative(process.cwd(), cwd),
+        entrypoint: mainPath,
         assets: {
           html_handling: "auto-trailing-slash",
           not_found_handling: props.spa ? "single-page-application" : "none",
@@ -189,24 +174,23 @@ export default {
           ? {
               command: props.dev.command,
               url: props.dev.url,
-              cwd,
             }
           : undefined,
       } as WorkerProps<any> & { name: string };
 
       if (wrangler) {
-        // paths in wrangler.jsonc must be relative to it
-        const relativeToWrangler = <S extends string | undefined>(f: S): S =>
-          (f ? path.relative(path.dirname(wranglerJsonPath), f) : f) as S;
+        const wranglerPath = path.relative(cwd, wranglerJsonPath);
+        const wranglerDir = path.dirname(wranglerPath);
+
         await WranglerJson("wrangler.jsonc", {
-          path: wranglerJsonPath,
+          path: wranglerPath,
           worker: workerProps,
-          main: relativeToWrangler(wranglerMainPath),
+          main: mainPath ? path.relative(wranglerDir, mainPath) : undefined,
           // hard-code the assets directory because we haven't yet included the assets binding
           assets: {
             binding: "ASSETS",
             // path must be relative to the wrangler.jsonc file
-            directory: relativeToWrangler(assetsDirPath),
+            directory: path.relative(wranglerDir, assetsDirPath),
           },
         });
       }

package/src/cloudflare/worker/http-server.ts

@@ -1,6 +1,7 @@
 import http from "node:http";
 import type { AddressInfo } from "node:net";
 import { Readable } from "node:stream";
+import { promiseWithResolvers } from "../../util/promise-with-resolvers.ts";
 
 export class HTTPServer {
   server: http.Server;
@@ -10,7 +11,7 @@ export class HTTPServer {
     port?: number;
     fetch: (request: Request) => Promise<Response>;
   }) {
-    const { promise, resolve } = Promise.withResolvers<void>();
+    const { promise, resolve } = promiseWithResolvers<void>();
     this.ready = promise;
     this.server = http
       .createServer(async (req, res) => {

package/src/cloudflare/worker/miniflare.ts

@@ -7,6 +7,10 @@ import type {
 import path from "node:path";
 import { findOpenPort } from "../../util/find-open-port.ts";
 import { logger } from "../../util/logger.ts";
+import {
+  promiseWithResolvers,
+  type PromiseWithResolvers,
+} from "../../util/promise-with-resolvers.ts";
 import { HTTPServer } from "./http-server.ts";
 import {
   buildMiniflareWorkerOptions,
@@ -40,7 +44,7 @@ class MiniflareServer {
   writer = this.stream.getWriter();
 
   async push(worker: MiniflareWorkerOptions) {
-    const promise = Promise.withResolvers<HTTPServer>();
+    const promise = promiseWithResolvers<HTTPServer>();
     const [, server] = await Promise.all([
       this.writer.write({ worker, promise }),
       promise.promise,

package/src/cloudflare/worker.ts

@@ -135,6 +135,12 @@ export interface BaseWorkerProps<
   /**
    * The root directory of the project
    */
+  cwd?: string;
+
+  /**
+   * The root directory of the project
+   * @deprecated Use `cwd` instead
+   */
   projectRoot?: string;
 
   /**
@@ -466,6 +472,12 @@ export type Worker<
      */
     name: string;
 
+    /**
+     * The root directory of the project
+     * @default process.cwd()
+     */
+    cwd: string;
+
     /**
      * Time at which the worker was created
      */
@@ -967,6 +979,15 @@ export const _Worker = Resource(
     // Use the provided name
     const workerName = props.name ?? id;
 
+    if (props.projectRoot) {
+      logger.warn("projectRoot is deprecated, use cwd instead");
+      props.cwd = props.projectRoot;
+    }
+
+    const cwd = props.cwd ? path.resolve(props.cwd) : process.cwd();
+    const relativeCwd =
+      cwd === process.cwd() ? undefined : path.relative(process.cwd(), cwd);
+
     const compatibilityDate =
       props.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE;
     const compatibilityFlags = props.compatibilityFlags ?? [];
@@ -979,7 +1000,7 @@ export const _Worker = Resource(
         upsertDevCommand({
           id,
           command: props.dev.command,
-          cwd: props.dev.cwd ?? process.cwd(),
+          cwd: props.dev.cwd ?? cwd,
           env: props.env ?? {},
         });
         return this({
@@ -987,6 +1008,7 @@ export const _Worker = Resource(
           id,
           entrypoint: props.entrypoint,
           name: workerName,
+          cwd: relativeCwd,
           compatibilityDate,
           compatibilityFlags,
           format: props.format || "esm", // Include format in the output
@@ -1026,6 +1048,7 @@ export const _Worker = Resource(
           {
             ...props,
             entrypoint: props.entrypoint,
+            cwd,
             compatibilityDate,
             compatibilityFlags,
           },
@@ -1124,6 +1147,7 @@ export const _Worker = Resource(
           (await bundleWorkerScript({
             name: workerName,
             ...props,
+            cwd,
             compatibilityDate,
             compatibilityFlags,
           }));
@@ -1142,6 +1166,7 @@ export const _Worker = Resource(
         id,
         entrypoint: props.entrypoint,
         name: workerName,
+        cwd: relativeCwd,
         compatibilityDate,
         compatibilityFlags,
         format: props.format || "esm", // Include format in the output
@@ -1172,6 +1197,7 @@ export const _Worker = Resource(
         (await bundleWorkerScript({
           ...props,
           name: workerName,
+          cwd,
           compatibilityDate,
           compatibilityFlags,
         }));
@@ -1348,31 +1374,34 @@ export const _Worker = Resource(
     };
 
     if (this.phase === "delete") {
-      // Delete any queue consumers attached to this worker first
-      await deleteQueueConsumers(api, workerName);
-
-      await withExponentialBackoff(
-        () =>
-          deleteWorker(api, {
-            workerName,
-            namespace:
-              typeof props.namespace === "string"
-                ? props.namespace
-                : props.namespace?.namespaceId,
-            url: this.output.url,
-          }),
-        (err) =>
-          (err.status === 400 &&
-            err.message.includes(
-              "is still referenced by service bindings in Workers",
-            )) ||
-          err.status === 500 ||
-          err.status === 503,
-        10,
-        100,
-      );
+      // only delete the worker if it's not a version
+      if (!props.version) {
+        // Delete any queue consumers attached to this worker first
+        await deleteQueueConsumers(api, workerName);
+
+        await withExponentialBackoff(
+          () =>
+            deleteWorker(api, {
+              workerName,
+              namespace:
+                typeof props.namespace === "string"
+                  ? props.namespace
+                  : props.namespace?.namespaceId,
+              url: this.output.url,
+            }),
+          (err) =>
+            (err.status === 400 &&
+              err.message.includes(
+                "is still referenced by service bindings in Workers",
+              )) ||
+            err.status === 500 ||
+            err.status === 503,
+          10,
+          100,
+        );
 
-      return this.destroy();
+        return this.destroy();
+      }
     }
 
     if (this.phase === "create") {
@@ -1425,7 +1454,7 @@ export const _Worker = Resource(
                 : customDomain.zoneId,
             adopt:
               typeof customDomain === "string"
-                ? false
+                ? (props.adopt ?? false)
                 : (customDomain.adopt ?? props.adopt),
           });
         }),
@@ -1454,7 +1483,7 @@ export const _Worker = Resource(
               typeof routeConfig === "string" ? undefined : routeConfig.zoneId, // Route resource will handle inference if not provided
             adopt:
               typeof routeConfig === "string"
-                ? false
+                ? (props.adopt ?? false)
                 : (routeConfig.adopt ?? props.adopt),
             accountId: props.accountId,
             apiKey: props.apiKey,
@@ -1497,6 +1526,7 @@ export const _Worker = Resource(
       id,
       entrypoint: props.entrypoint,
       name: workerName,
+      cwd: relativeCwd,
       compatibilityDate,
       compatibilityFlags,
       format: props.format || "esm", // Include format in the output

package/src/cloudflare/wrangler.json.ts

@@ -27,7 +27,7 @@ export interface WranglerJsonProps {
   /**
    * Path to write the wrangler.json file to
    *
-   * @default cwd/wrangler.json
+   * @default worker.cwd/wrangler.json
    */
   path?: string;
 
@@ -89,14 +89,27 @@ export const WranglerJson = Resource(
     _id: string,
     props: WranglerJsonProps,
   ): Promise<WranglerJson> {
-    // Default path is wrangler.json in current directory
-    const filePath = props.path || "wrangler.jsonc";
-
     if (this.phase === "delete") {
       return this.destroy();
     }
 
-    if (props.worker.entrypoint === undefined) {
+    const cwd = props.worker.cwd
+      ? path.resolve(props.worker.cwd)
+      : process.cwd();
+
+    const toAbsolute = <T extends string | undefined>(input: T): T => {
+      return (input ? path.resolve(cwd, input) : undefined) as T;
+    };
+
+    const main = toAbsolute(props.main ?? props.worker.entrypoint);
+    let filePath = toAbsolute(props.path ?? cwd);
+    if (!path.basename(filePath).match(".json")) {
+      filePath = path.join(filePath, props.name ?? "wrangler.jsonc");
+    }
+
+    const dirname = path.dirname(filePath);
+
+    if (!main) {
       throw new Error(
         "Worker must have an entrypoint to generate a wrangler.json",
       );
@@ -107,16 +120,27 @@ export const WranglerJson = Resource(
     const spec: WranglerJsonSpec = {
       name: worker.name,
       // Use entrypoint as main if it exists
-      main: props.main ?? worker.entrypoint,
+      main: path.relative(dirname, main),
       // see: https://developers.cloudflare.com/workers/configuration/compatibility-dates/
       compatibility_date: worker.compatibilityDate,
       compatibility_flags: props.worker.compatibilityFlags,
-      assets: props.assets,
+      assets: props.assets
+        ? {
+            directory: toAbsolute(props.assets.directory),
+            binding: props.assets.binding,
+          }
+        : undefined,
     };
 
     // Process bindings if they exist
     if (worker.bindings) {
-      processBindings(spec, worker.bindings, worker.eventSources, worker.name);
+      processBindings(
+        spec,
+        worker.bindings,
+        worker.eventSources,
+        worker.name,
+        cwd,
+      );
     }
 
     // Add environment variables as vars
@@ -128,13 +152,17 @@ export const WranglerJson = Resource(
       spec.triggers = { crons: worker.crons };
     }
 
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    if (spec.assets) {
+      spec.assets.directory = path.relative(dirname, spec.assets.directory);
+    }
+
+    await fs.mkdir(dirname, { recursive: true });
     await fs.writeFile(filePath, await formatJson(spec));
 
     // Return the resource
     return this({
       ...props,
-      path: filePath,
+      path: path.relative(cwd, filePath),
       spec,
       createdAt: Date.now(),
       updatedAt: Date.now(),
@@ -381,6 +409,7 @@ function processBindings(
   bindings: Bindings,
   eventSources: EventSource[] | undefined,
   workerName: string,
+  workerCwd: string,
 ): void {
   // Arrays to collect different binding types
   const kvNamespaces: { binding: string; id: string; preview_id: string }[] =
@@ -527,7 +556,7 @@ function processBindings(
       secrets.push(bindingName);
     } else if (binding.type === "assets") {
       spec.assets = {
-        directory: binding.path,
+        directory: path.resolve(workerCwd, binding.path),
         binding: bindingName,
       };
     } else if (binding.type === "workflow") {