alchemy 0.44.4 → 0.45.1

package/src/cloudflare/d1-state-store.ts

@@ -0,0 +1,105 @@
+import type { RemoteCallback } from "drizzle-orm/sqlite-proxy";
+import { drizzle } from "drizzle-orm/sqlite-proxy";
+import assert from "node:assert";
+import type { Scope } from "../scope.ts";
+import {
+  BaseSQLiteStateStore,
+  resolveMigrationsPath,
+} from "../sqlite/base-sqlite-state-store.ts";
+import * as schema from "../sqlite/schema.ts";
+import { memoize } from "../util/memoize.ts";
+import type { CloudflareApi, CloudflareApiOptions } from "./api.ts";
+
+export interface D1StateStoreOptions extends CloudflareApiOptions {
+  databaseName?: string;
+}
+
+type D1Response =
+  | {
+      success: true;
+      result: {
+        results: { columns: string[]; rows: any[][] };
+      }[];
+    }
+  | {
+      success: false;
+      errors: { code: number; message: string }[];
+    };
+
+export class D1StateStore extends BaseSQLiteStateStore {
+  constructor(scope: Scope, options: D1StateStoreOptions = {}) {
+    super(scope, {
+      create: async () => createDatabaseClient(options),
+    });
+  }
+}
+
+const createDatabaseClient = memoize(async (options: D1StateStoreOptions) => {
+  const { createCloudflareApi } = await import("./api.ts");
+  const api = await createCloudflareApi(options);
+  const database = await upsertDatabase(
+    api,
+    options.databaseName ?? "alchemy-state",
+  );
+  const remoteCallback: RemoteCallback = async (sql, params) => {
+    const res = await api.post(
+      `/accounts/${api.accountId}/d1/database/${database.id}/raw`,
+      { sql, params },
+      {
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
+    );
+    const data = (await res.json()) as D1Response;
+    if (!data.success) {
+      throw new Error(
+        data.errors.map((it) => `${it.code}: ${it.message}`).join("\n"),
+      );
+    }
+    const [result] = data.result;
+    assert(result, "Missing result");
+    return {
+      rows: Object.values(result.results.rows),
+    };
+  };
+  return drizzle(remoteCallback, {
+    schema,
+  });
+});
+
+const upsertDatabase = async (api: CloudflareApi, databaseName: string) => {
+  const { listDatabases, createDatabase } = await import("./d1-database.ts");
+  const { applyMigrations, listMigrationsFiles } = await import(
+    "./d1-migrations.ts"
+  );
+  const databases = await listDatabases(api, databaseName);
+  if (databases[0]) {
+    await applyMigrations({
+      migrationsFiles: await listMigrationsFiles(resolveMigrationsPath()),
+      migrationsTable: "migrations",
+      accountId: api.accountId,
+      databaseId: databases[0].id,
+      api,
+      quiet: true,
+    });
+    return {
+      id: databases[0].id,
+    };
+  }
+  const res = await createDatabase(api, databaseName, {
+    readReplication: { mode: "disabled" },
+  });
+  assert(res.result.uuid, "Missing UUID for database");
+  await applyMigrations({
+    migrationsFiles: await listMigrationsFiles(resolveMigrationsPath()),
+    migrationsTable: "migrations",
+    accountId: api.accountId,
+    databaseId: res.result.uuid,
+    api,
+    quiet: true,
+  });
+  return {
+    id: res.result.uuid,
+  };
+};

package/src/cloudflare/do-state-store/internal.ts

@@ -3,7 +3,7 @@ import { withExponentialBackoff } from "../../util/retry.ts";
 import { handleApiError } from "../api-error.ts";
 import type { CloudflareApi } from "../api.ts";
 import type { WorkerMetadata } from "../worker-metadata.ts";
-import { getWorkerTemplate } from "../worker/get-worker-template.ts";
+import { getWorkerTemplate } from "../worker/shared.ts";
 import type { DOStateStoreAPI } from "./types.ts";
 
 interface DOStateStoreClientOptions {

package/src/cloudflare/do-state-store/store.ts

@@ -5,7 +5,7 @@ import { serialize } from "../../serde.ts";
 import type { State, StateStore } from "../../state.ts";
 import { deserialize } from "../../serde.ts";
 import { createCloudflareApi, type CloudflareApiOptions } from "../api.ts";
-import { getAccountSubdomain } from "../worker/subdomain.ts";
+import { getAccountSubdomain } from "../worker/shared.ts";
 import { DOStateStoreClient, upsertStateStoreWorker } from "./internal.ts";
 
 export interface DOStateStoreOptions extends CloudflareApiOptions {

package/src/cloudflare/index.ts

@@ -11,8 +11,6 @@ export * from "./bindings.ts";
 export * from "./bound.ts";
 export * from "./browser-rendering.ts";
 export * from "./bucket.ts";
-export * from "./bundle/external.ts";
-export * from "./bundle/local-dev-cloudflare-shim.ts";
 export * from "./certificate-pack.ts";
 export * from "./container.ts";
 export * from "./custom-domain.ts";
@@ -20,6 +18,7 @@ export * from "./d1-clone.ts";
 export * from "./d1-database.ts";
 export * from "./d1-export.ts";
 export * from "./d1-import.ts";
+export * from "./d1-state-store.ts";
 export * from "./dispatch-namespace.ts";
 export * from "./dns-records.ts";
 export * from "./do-state-store/index.ts";
@@ -31,6 +30,7 @@ export * from "./email-rule.ts";
 export * from "./hyperdrive.ts";
 export * from "./images.ts";
 export * from "./kv-namespace.ts";
+export * from "./local-dev-cloudflare-shim.ts";
 export * from "./nuxt.ts";
 export * from "./orange.ts";
 export * from "./permission-groups.ts";
@@ -53,6 +53,7 @@ export * from "./version-metadata.ts";
 export * from "./vite.ts";
 export * from "./website.ts";
 export * from "./worker-stub.ts";
+export * from "./worker-subdomain.ts";
 export * from "./worker.ts";
 export { Workflow } from "./workflow.ts";
 export * from "./wrangler.json.ts";

package/src/cloudflare/{bundle/local-dev-cloudflare-shim.ts → local-dev-cloudflare-shim.ts}

@@ -1,4 +1,4 @@
-import { dedent } from "../../util/dedent.ts";
+import { dedent } from "../util/dedent.ts";
 
 /**
  * TanStackStart server functions and middleware run in Node.js intead of Miniflare when using `vite dev`.

package/src/cloudflare/{worker → miniflare}/miniflare-worker-options.ts

@@ -7,6 +7,7 @@ import assert from "node:assert";
 import { assertNever } from "../../util/assert-never.ts";
 import { logger } from "../../util/logger.ts";
 import { Self, type Binding, type WorkerBindingSpec } from "../bindings.ts";
+import type { WorkerBundle } from "../bundle/index.ts";
 import type { WorkerProps } from "../worker.ts";
 
 export type MiniflareWorkerOptions = Pick<
@@ -18,7 +19,7 @@ export type MiniflareWorkerOptions = Pick<
   | "format"
 > & {
   name: string;
-  script: string;
+  bundle: WorkerBundle;
   port?: number;
 };
 
@@ -206,9 +207,9 @@ function buildRemoteBinding(
   }
 }
 
-export function buildMiniflareWorkerOptions({
+export async function buildMiniflareWorkerOptions({
   name: workerName,
-  script,
+  bundle,
   bindings,
   format,
   eventSources,
@@ -217,11 +218,18 @@ export function buildMiniflareWorkerOptions({
   remoteProxyConnectionString,
 }: MiniflareWorkerOptions & {
   remoteProxyConnectionString: RemoteProxyConnectionString | undefined;
-}): WorkerOptions {
+}): Promise<WorkerOptions> {
   const options: WorkerOptions = {
     name: workerName,
-    script,
-    modules: format !== "cjs",
+    modules: await Promise.all(
+      bundle.files.map(async (file) => ({
+        type: (format === "cjs" ? "CommonJS" : "ESModule") as
+          | "CommonJS"
+          | "ESModule",
+        path: file.name,
+        contents: await file.text(),
+      })),
+    ),
     compatibilityDate,
     compatibilityFlags,
     unsafeDirectSockets: [{ entrypoint: undefined, proxy: true }],

package/src/cloudflare/{worker → miniflare}/miniflare.ts

@@ -60,7 +60,7 @@ class MiniflareServer {
   private async set(worker: MiniflareWorkerOptions) {
     this.workers.set(
       worker.name as string,
-      buildMiniflareWorkerOptions({
+      await buildMiniflareWorkerOptions({
         ...worker,
         remoteProxyConnectionString:
           await this.maybeCreateMixedModeProxy(worker),

package/src/cloudflare/{worker → miniflare}/mixed-mode.ts

@@ -3,9 +3,8 @@ import { createCloudflareApi, type CloudflareApi } from "../api.ts";
 import type { WorkerBindingSpec } from "../bindings.ts";
 import type { CloudflareApiResponse } from "../types.ts";
 import type { WorkerMetadata } from "../worker-metadata.ts";
-import { getWorkerTemplate } from "./get-worker-template.ts";
+import { getAccountSubdomain, getWorkerTemplate } from "../worker/shared.ts";
 import { HTTPServer } from "./http-server.ts";
-import { getAccountSubdomain } from "./subdomain.ts";
 
 type WranglerSessionConfig =
   | {

package/src/cloudflare/user.ts

@@ -81,7 +81,7 @@ export async function getCloudflareAccounts(
     return (accountCache[cacheKey] ??= ((await accounts.json()) as any).result);
   } else {
     throw new CloudflareApiError(
-      `Failed to get accounts for authorized user, please make sure you're authenticated (see: https://alchemy.run/docs/guides/cloudflare-auth.html) or explicitly set the Cloudflare Account ID (see: https://alchemy.run/docs/guides/cloudflare-auth.html#account-id)`,
+      `Failed to get accounts for authorized user, please make sure you're authenticated (see: https://alchemy.run/guides/cloudflare/) or explicitly set the Cloudflare Account ID (see: https://alchemy.run/guides/cloudflare/#account-id)`,
       accounts,
     );
   }

package/src/cloudflare/worker/{subdomain.ts → shared.ts}

@@ -1,3 +1,6 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { memoize } from "../../util/memoize.ts";
 import type { CloudflareApi } from "../api.ts";
 
@@ -14,3 +17,14 @@ export const getAccountSubdomain = memoize(
   },
   (api) => api.accountId,
 );
+
+export async function getWorkerTemplate(
+  name: "do-state-store" | "mixed-mode-proxy-worker",
+) {
+  const dir = dirname(fileURLToPath(import.meta.url));
+  const path = join(dir, "..", "..", "..", "workers", `${name}.js`);
+  const template = await readFile(path, "utf8");
+  return new File([template], `${name}.js`, {
+    type: "application/javascript+module",
+  });
+}

package/src/cloudflare/worker/tail.ts

@@ -0,0 +1,287 @@
+import kleur from "kleur";
+import { WebSocket } from "ws";
+import { logger } from "../../util/logger.ts";
+import type { CloudflareApi } from "../api.ts";
+import type { CloudflareApiResponse } from "../types.ts";
+
+export const createTail = async (
+  api: CloudflareApi,
+  id: string,
+  scriptName: string,
+) => {
+  const tail = new TailClient(api, id, scriptName);
+  await tail.connect();
+  return tail;
+};
+
+interface Tail {
+  id: string;
+  url: string;
+  expires_at: Date;
+}
+
+const DEBUG = !!process.env.DEBUG;
+
+class TailClient {
+  private api: CloudflareApi;
+  private id: string;
+  private scriptName: string;
+
+  private tail?: Tail;
+  private ws?: WebSocket;
+  private pingInterval?: NodeJS.Timeout;
+  private clean = false;
+
+  constructor(api: CloudflareApi, id: string, scriptName: string) {
+    this.api = api;
+    this.id = id;
+    this.scriptName = scriptName;
+  }
+
+  private async create() {
+    if (
+      this.tail &&
+      this.tail.expires_at > new Date(Date.now() + 1000 * 60 * 5)
+    ) {
+      return this.tail;
+    }
+    const res = await this.api.post(
+      `/accounts/${this.api.accountId}/workers/scripts/${this.scriptName}/tails`,
+      {},
+    );
+    const json = (await res.json()) as CloudflareApiResponse<Tail>;
+    if (!json.success) {
+      throw new Error(
+        `Failed to create tail for ${this.scriptName} (${res.status}): ${json.errors.map((e) => `${e.code} - ${e.message}`).join("\n")}`,
+      );
+    }
+    this.tail = {
+      id: json.result.id,
+      url: json.result.url,
+      expires_at: new Date(json.result.expires_at),
+    };
+    return this.tail;
+  }
+
+  async connect(attempt = 0) {
+    if (this.ws) {
+      throw new Error(`Tail already connected for ${this.scriptName}`);
+    }
+    if (attempt > 3) {
+      await this.close();
+      throw new Error(`Failed to connect to tail for ${this.scriptName}`);
+    }
+    const tail = await this.create();
+    const ws = new WebSocket(tail.url, {
+      headers: {
+        "Sec-WebSocket-Protocol": "trace-v1",
+      },
+    });
+    ws.on("open", () => {
+      this.ping(ws);
+      if (DEBUG) {
+        logger.log(`connected to tail for "${this.scriptName}"`);
+      }
+    });
+    ws.on("close", () => {
+      this.ws = undefined;
+      if (DEBUG) {
+        logger.log(`closed tail for "${this.scriptName}"`);
+      }
+      if (this.clean) {
+        return;
+      }
+      logger.log(`reconnecting to tail for "${this.scriptName}"`);
+      this.connect(attempt + 1);
+    });
+    ws.on("error", (event) => {
+      logger.error(`error on tail for "${this.scriptName}": ${event}`);
+    });
+    ws.on("message", (message) => {
+      const data: TailEventMessage = JSON.parse(message.toString());
+      const prefix = kleur.blue(`[${this.id}]`);
+      if (data.event && "request" in data.event) {
+        // TODO: handle other event types
+        const event = data.event;
+        const url = new URL(event.request.url);
+        const status = event.response?.status ?? 500;
+        // TODO: make this look nicer
+        logger.log(
+          `${prefix} ${kleur.gray(event.request.method)} ${url.pathname} ${kleur.dim(">")} ${status >= 200 && status < 300 ? kleur.green(status) : kleur.red(status)} ${kleur.gray(`(cpu: ${Math.round(data.cpuTime)}ms, wall: ${Math.round(data.wallTime)}ms)`)}`,
+        );
+      }
+      for (const log of data.logs) {
+        logger.log(
+          `${prefix} ${kleur.gray(log.level)} ${log.message.join(" ")}`,
+        );
+      }
+      for (const exception of data.exceptions) {
+        const start = `${prefix} ${kleur.red(exception.name)}`;
+        logger.log(
+          `${start} ${exception.message}\n${kleur.gray(exception.stack)}`,
+        );
+      }
+    });
+  }
+
+  private async ping(ws: WebSocket) {
+    let waitingForPong = false;
+
+    const cleanup = () => {
+      if (!this.pingInterval) {
+        return;
+      }
+      clearInterval(this.pingInterval);
+      this.pingInterval = undefined;
+    };
+
+    this.pingInterval = setInterval(() => {
+      if (ws.readyState !== WebSocket.OPEN) {
+        cleanup();
+        return;
+      }
+      if (waitingForPong) {
+        ws.close();
+      }
+      waitingForPong = true;
+      ws.ping();
+    }, 10_000);
+
+    ws.on("pong", () => {
+      waitingForPong = false;
+    });
+  }
+
+  async close() {
+    this.clean = true;
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = undefined;
+    }
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.close();
+      this.ws = undefined;
+    }
+    if (this.tail) {
+      const res = await this.api.delete(
+        `/accounts/${this.api.accountId}/workers/scripts/${this.scriptName}/tails/${this.tail.id}`,
+      );
+      if (!res.ok) {
+        throw new Error(
+          `Failed to close tail for ${this.scriptName} (${res.status}): ${res.statusText}`,
+        );
+      }
+      this.tail = undefined;
+      if (DEBUG) {
+        logger.log(`closed tail for "${this.scriptName}": ${res.status}`);
+      }
+    }
+  }
+}
+interface TailEventMessage {
+  wallTime: number;
+  cpuTime: number;
+  truncated: boolean;
+  executionModel: "stateless" | "durableObject";
+  outcome:
+    | "ok"
+    | "canceled"
+    | "exception"
+    | "exceededCpu"
+    | "exceededMemory"
+    | "unknown";
+  scriptTags: string[];
+  scriptVersion: { id: string };
+  scriptName: string;
+  diagnosticsChannelEvents: unknown[];
+  exceptions: {
+    name: string;
+    message: string;
+    stack: string;
+    timestamp: string;
+  }[];
+  logs: {
+    message: string[];
+    level: string;
+    timestamp: string;
+  }[];
+  event: TailEventMessage.Event;
+}
+
+namespace TailEventMessage {
+  export type Event =
+    | RequestEvent
+    | ScheduledEvent
+    | EmailEvent
+    | QueueEvent
+    | RpcEvent
+    | TailEvent
+    | TailInfoEvent
+    | null
+    | undefined;
+
+  export interface RequestEvent {
+    request: {
+      method: string;
+      url: string;
+      headers: Record<string, string>;
+      body: string;
+    };
+    response?: { status: number };
+  }
+
+  export interface ScheduledEvent {
+    cron: string;
+    scheduledTime: string;
+  }
+
+  export interface EmailEvent {
+    /**
+     * Who sent the email
+     */
+    mailFrom: string;
+
+    /**
+     * Who was the email sent to
+     */
+    rcptTo: string;
+
+    /**
+     * Size of the email in bytes
+     */
+    rawSize: number;
+  }
+
+  /**
+   * An event that was triggered for a tail receiving TailEventMessages
+   * Only seen when tailing a tail worker
+   */
+  export interface TailEvent {
+    /**
+     * A minimal representation of the TailEventMessages that were delivered to the tail handler
+     */
+    consumedEvents: {
+      /**
+       * The name of script being tailed
+       */
+      scriptName?: string;
+    }[];
+  }
+
+  /**
+   * Message from tail with information about the tail itself
+   */
+  export interface TailInfoEvent {
+    message: string;
+    type: string;
+  }
+
+  export interface QueueEvent {
+    queue: string;
+    batchSize: number;
+  }
+
+  export interface RpcEvent {
+    rpcMethod: string;
+  }
+}

package/src/cloudflare/worker-metadata.ts

@@ -1,6 +1,6 @@
-import path from "node:path";
 import { assertNever } from "../util/assert-never.ts";
 import { logger } from "../util/logger.ts";
+import { memoize } from "../util/memoize.ts";
 import type { CloudflareApi } from "./api.ts";
 import {
   Self,
@@ -13,7 +13,7 @@ import {
   isDurableObjectNamespace,
   type DurableObjectNamespace,
 } from "./durable-object-namespace.ts";
-import { createAssetConfig, type AssetUploadResult } from "./worker-assets.ts";
+import { createAssetConfig } from "./worker-assets.ts";
 import type {
   MultiStepMigration,
   SingleStepMigration,
@@ -205,10 +205,17 @@ export async function prepareWorkerMetadata(
     compatibilityFlags: string[];
     workerName: string;
     migrationTag?: string;
-    assetUploadResult?: AssetUploadResult;
+    assetUploadResult?: {
+      completionToken?: string;
+      keepAssets?: boolean;
+      assetConfig?: AssetsConfig;
+    };
+    unstable_cacheWorkerSettings?: boolean;
   },
 ): Promise<WorkerMetadata> {
-  const oldSettings = await getWorkerSettings(api, props.workerName);
+  const oldSettings = await (props.unstable_cacheWorkerSettings
+    ? getWorkerSettingsWithCache
+    : getWorkerSettings)(api, props.workerName);
   const oldTags: string[] | undefined = Array.from(
     new Set([
       ...(oldSettings?.default_environment?.script?.tags ?? []),
@@ -333,15 +340,10 @@ export async function prepareWorkerMetadata(
   if (assetUploadResult) {
     meta.assets = {
       jwt: assetUploadResult.completionToken,
+      keep_assets: assetUploadResult.keepAssets,
+      config: assetUploadResult.assetConfig,
     };
 
-    // Initialize config from assetUploadResult if it exists
-    if (assetUploadResult.assetConfig) {
-      meta.assets.config = {
-        ...assetUploadResult.assetConfig,
-      };
-    }
-
     // If there's no config from assetUploadResult but we have props.assets,
     // we need to create the config ourselves (this handles the case when no assets were uploaded)
     if (!meta.assets.config && props.assets) {
@@ -617,21 +619,6 @@ export async function prepareWorkerMetadata(
     }
   }
 
-  // Determine if we're using ESM or service worker format
-  const isEsModule = props.format !== "cjs"; // Default to ESM unless CJS is specified
-  const scriptName = props.noBundle
-    ? path.basename(props.entrypoint!)
-    : isEsModule
-      ? "worker.js"
-      : "script";
-
-  if (isEsModule) {
-    // For ES modules format
-    meta.main_module = scriptName;
-  } else {
-    // For service worker format (CJS)
-    meta.body_part = scriptName;
-  }
   if (process.env.DEBUG) {
     logger.log(meta);
   }
@@ -656,6 +643,11 @@ interface WorkerSettings {
   [key: string]: any;
 }
 
+const getWorkerSettingsWithCache = memoize(
+  getWorkerSettings,
+  (api, workerName) => `${api.accountId}:${workerName}`,
+);
+
 async function getWorkerSettings(
   api: CloudflareApi,
   workerName: string,

package/src/cloudflare/worker-stub.ts

@@ -7,7 +7,7 @@ import {
   type CloudflareApi,
   type CloudflareApiOptions,
 } from "./api.ts";
-import { configureURL } from "./worker.ts";
+import { WorkerSubdomain } from "./worker-subdomain.ts";
 
 /**
  * Properties for creating a Worker stub
@@ -109,18 +109,20 @@ export const WorkerStub = Resource("cloudflare::WorkerStub", async function <
   }
 
   // Configure URL if requested (defaults to true)
-  const workerUrl = await configureURL(this, api, {
-    ...props,
-    workerName: props.name!,
-    url: props.url ?? true,
-  });
+  const subdomain =
+    props.url !== false
+      ? await WorkerSubdomain("url", {
+          ...props,
+          scriptName: props.name,
+        })
+      : undefined;
 
   // Return the worker stub info
   return this({
     type: "service",
     __rpc__: props.rpc as unknown as RPC,
     ...props,
-    url: workerUrl,
+    url: subdomain?.url,
   }) as WorkerStub<RPC>;
 });