alchemy 0.58.0 → 0.59.1

package/src/cloudflare/miniflare/delete.ts

@@ -0,0 +1,136 @@
+import crypto from "node:crypto";
+import type { RmDirOptions } from "node:fs";
+import fs from "node:fs/promises";
+import path from "pathe";
+import type { DurableObjectNamespace } from "../durable-object-namespace.ts";
+import type { Workflow } from "../workflow.ts";
+import { DEFAULT_PERSIST_PATH } from "./paths.ts";
+
+const PERSIST_ROOT = path.resolve(DEFAULT_PERSIST_PATH);
+const BINDING_TYPE_KEY = {
+  d1: "miniflare-D1DatabaseObject",
+  kv: "miniflare-KVNamespaceObject",
+  r2: "miniflare-R2BucketObject",
+} as const;
+
+type BindingType = keyof typeof BINDING_TYPE_KEY;
+
+/**
+ * Delete a binding from the miniflare directory.
+ */
+export async function deleteMiniflareBinding(type: BindingType, id: string) {
+  const bindingPath = path.join(PERSIST_ROOT, type, BINDING_TYPE_KEY[type]);
+
+  // delete durable object/sqlite files
+  const namespaceId = durableObjectNamespaceIdFromName(
+    BINDING_TYPE_KEY[type],
+    id,
+  );
+  const files = await fs
+    .readdir(bindingPath)
+    .then((files) => files.filter((file) => file.startsWith(namespaceId)))
+    .catch(() => []);
+  await Promise.all(files.map((file) => fs.rm(path.join(bindingPath, file))));
+
+  // delete data directory, if present
+  await removeDirectory(path.join(PERSIST_ROOT, type, id), {
+    recursive: true,
+  });
+
+  // delete the miniflare directory if it is empty
+  await cleanMiniflareDirectory();
+}
+
+/**
+ * Delete local durable object and workflow data for a given Worker script.
+ */
+export async function deleteMiniflareWorkerData(
+  scriptName: string,
+  input: {
+    durableObjects: DurableObjectNamespace[];
+    workflows: Workflow[];
+  },
+) {
+  await Promise.all(
+    input.durableObjects.map((durableObject) =>
+      removeDirectory(
+        path.join(
+          PERSIST_ROOT,
+          "do",
+          `${scriptName}-${durableObject.className}`,
+        ),
+        {
+          recursive: true,
+        },
+      ),
+    ),
+  );
+  await Promise.all(
+    input.workflows.map((workflow) =>
+      removeDirectory(
+        path.join(
+          PERSIST_ROOT,
+          "workflows",
+          `miniflare-workflows-${workflow.workflowName}`,
+        ),
+        {
+          recursive: true,
+        },
+      ),
+    ),
+  );
+  await cleanMiniflareDirectory();
+}
+
+/**
+ * Delete the miniflare directory iff it is empty.
+ */
+async function cleanMiniflareDirectory() {
+  const directory = path.resolve(".alchemy/miniflare");
+  const files = await fs
+    .readdir(directory, {
+      recursive: true,
+      withFileTypes: true,
+    })
+    .catch((error) => {
+      if (!isENOENT(error)) {
+        throw error;
+      }
+      return [];
+    });
+  if (!files.some((file) => !file.isDirectory())) {
+    await removeDirectory(directory, { recursive: true });
+  }
+}
+
+const removeDirectory = async (path: string, options?: RmDirOptions) => {
+  try {
+    await fs.rmdir(path, options);
+  } catch (error) {
+    if (!isENOENT(error)) {
+      throw error;
+    }
+  }
+};
+
+const isENOENT = (error: unknown): error is { code: "ENOENT" } =>
+  !!error &&
+  typeof error === "object" &&
+  "code" in error &&
+  error.code === "ENOENT";
+
+// copied from https://github.com/cloudflare/workers-sdk/blob/a5892915e173ca8666c04fb394e70711e87b46d8/packages/miniflare/src/plugins/shared/index.ts#L236
+const durableObjectNamespaceIdFromName = (uniqueKey: string, name: string) => {
+  const key = crypto.createHash("sha256").update(uniqueKey).digest();
+  const nameHmac = crypto
+    .createHmac("sha256", key)
+    .update(name)
+    .digest()
+    .subarray(0, 16);
+  const hmac = crypto
+    .createHmac("sha256", key)
+    .update(nameHmac)
+    .digest()
+    .subarray(0, 16);
+  return Buffer.concat([nameHmac, hmac]).toString("hex");
+};

package/src/cloudflare/miniflare/miniflare-controller.ts

@@ -76,21 +76,38 @@ export class MiniflareController {
   private async update() {
     return await this.mutex.lock(async () => {
       const options: miniflare.MiniflareOptions = {
-        workers: Array.from(this.options.values()),
+        workers: [],
         defaultPersistRoot: path.resolve(DEFAULT_PERSIST_PATH),
         unsafeDevRegistryPath: miniflare.getDefaultDevRegistryPath(),
-        analyticsEngineDatasetsPersist: true,
-        cachePersist: true,
-        d1Persist: true,
-        durableObjectsPersist: true,
-        kvPersist: true,
-        r2Persist: true,
-        secretsStorePersist: true,
-        workflowsPersist: true,
         log: process.env.DEBUG
           ? new miniflare.Log(miniflare.LogLevel.DEBUG)
           : undefined,
       };
+      for (const worker of this.options.values()) {
+        options.workers.push(worker);
+        // avoid creating unnecessary directories
+        if (worker.analyticsEngineDatasets) {
+          options.analyticsEngineDatasetsPersist = true;
+        }
+        if (worker.d1Databases) {
+          options.d1Persist = true;
+        }
+        if (worker.durableObjects) {
+          options.durableObjectsPersist = true;
+        }
+        if (worker.kvNamespaces) {
+          options.kvPersist = true;
+        }
+        if (worker.r2Buckets) {
+          options.r2Persist = true;
+        }
+        if (worker.secretsStoreSecrets) {
+          options.secretsStorePersist = true;
+        }
+        if (worker.workflows) {
+          options.workflowsPersist = true;
+        }
+      }
       return await this.setMiniflareOptions(options);
     });
   }

package/src/cloudflare/miniflare/remote-binding-proxy.ts

@@ -1,11 +1,12 @@
 import type { RemoteProxyConnectionString } from "miniflare";
 import { HTTPServer } from "../../util/http.ts";
 import { extractCloudflareResult } from "../api-response.ts";
-import { createCloudflareApi, type CloudflareApi } from "../api.ts";
+import type { CloudflareApi } from "../api.ts";
 import type { WorkerBindingSpec } from "../bindings.ts";
 import { getInternalWorkerBundle } from "../bundle/internal-worker-bundle.ts";
 import { WorkerBundle } from "../worker-bundle.ts";
 import type { WorkerMetadata } from "../worker-metadata.ts";
+import { getAccountSubdomain } from "../worker-subdomain.ts";
 
 type WranglerSessionConfig =
   | {
@@ -30,13 +31,13 @@ export interface RemoteBindingProxy {
 }
 
 export async function createRemoteProxyWorker(input: {
+  api: CloudflareApi;
   name: string;
   bindings: WorkerBindingSpec[];
 }): Promise<RemoteBindingProxy> {
-  const api = await createCloudflareApi();
   const script = await getInternalWorkerBundle("remote-binding-proxy");
   const [token, subdomain] = await Promise.all([
-    createWorkersPreviewToken(api, {
+    createWorkersPreviewToken(input.api, {
       name: input.name,
       metadata: {
         main_module: script.bundle.entrypoint,
@@ -50,7 +51,7 @@ export async function createRemoteProxyWorker(input: {
         minimal_mode: true,
       },
     }),
-    import("../worker-subdomain.ts").then((m) => m.getAccountSubdomain(api)),
+    getAccountSubdomain(input.api),
   ]);
 
   const proxyURL = `https://${input.name}.${subdomain}.workers.dev`;

package/src/cloudflare/pipeline.ts

@@ -218,6 +218,8 @@ export interface PipelineProps extends CloudflareApiOptions {
    * @default false
    */
   adopt?: boolean;
+
+  dev?: { remote?: boolean };
 }
 
 /**
@@ -337,6 +339,20 @@ export const Pipeline = Resource("cloudflare::Pipeline", async function <
   const api = await createCloudflareApi(props);
   const pipelineName = props.name ?? id;
 
+  if (this.scope.local && !props.dev?.remote) {
+    return this({
+      type: "pipeline",
+      id: this.output?.id ?? "",
+      name: this.output?.name ?? pipelineName,
+      endpoint: this.output?.endpoint ?? "",
+      version: this.output?.version ?? 0,
+      source: this.output?.source ?? [],
+      destination: props.destination,
+      compression: props.compression,
+      accountId: this.output?.accountId ?? "",
+    });
+  }
+
   if (this.phase === "delete") {
     if (props.delete !== false) {
       // Delete Pipeline
@@ -348,7 +364,7 @@ export const Pipeline = Resource("cloudflare::Pipeline", async function <
   }
   let pipelineData: CloudflarePipelineResponse;
 
-  if (this.phase === "create") {
+  if (this.phase === "create" || !this.output?.id) {
     // Check if we should adopt an existing pipeline
     try {
       // Try to create pipeline first

package/src/cloudflare/queue-consumer.ts

@@ -82,6 +82,15 @@ export interface QueueConsumerProps extends CloudflareApiOptions {
    * @default false
    */
   adopt?: boolean;
+
+  /**
+   * If true, the queue consumer will not be created, but will be retained if it already exists.
+   * This is used for local development.
+   *
+   * @default `false`
+   * @internal
+   */
+  dev?: boolean;
 }
 
 /**
@@ -148,16 +157,24 @@ export const QueueConsumer = Resource(
     _id: string,
     props: QueueConsumerProps,
   ): Promise<QueueConsumer> {
-    const api = await createCloudflareApi(props);
-
     // Get queueId from either props.queue or props.queueId
     const queueId =
       typeof props.queue === "string" ? props.queue : props.queue.id;
 
-    if (!queueId) {
-      throw new Error("Either queue or queueId must be provided");
+    if (this.scope.local && props.dev) {
+      return this({
+        id: this.output?.id ?? "",
+        queueId,
+        queue: props.queue,
+        type: "worker",
+        scriptName: props.scriptName,
+        settings: props.settings,
+        accountId: this.output?.accountId ?? "",
+      });
     }
 
+    const api = await createCloudflareApi(props);
+
     if (this.phase === "delete") {
       logger.log(`Deleting Queue Consumer for queue ${queueId}`);
       if (props.delete !== false && this.output?.id) {
@@ -168,9 +185,14 @@ export const QueueConsumer = Resource(
       // Return void (a deleted consumer has no content)
       return this.destroy();
     }
+
+    if (!queueId) {
+      throw new Error("Either queue or queueId must be provided");
+    }
+
     let consumerData: CloudflareQueueConsumerResponse;
 
-    if (this.phase === "create" || this.output?.id === undefined) {
+    if (this.phase === "create" || !this.output?.id) {
       try {
         consumerData = await createQueueConsumer(api, queueId, props);
       } catch (err) {

package/src/cloudflare/queue.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import { Resource, ResourceKind } from "../resource.ts";
+import { Scope } from "../scope.ts";
 import { CloudflareApiError, handleApiError } from "./api-error.ts";
 import {
   createCloudflareApi,
@@ -80,6 +81,12 @@ export interface QueueProps extends CloudflareApiOptions {
      * @default false
      */
     remote?: boolean;
+
+    /**
+     * Set when `Scope.local` is true to force update to the queue even if it was already deployed live.
+     * @internal
+     */
+    force?: boolean;
   };
 }
 
@@ -95,7 +102,7 @@ export function isQueue(eventSource: any): eventSource is Queue {
  */
 export interface Queue<Body = unknown>
   extends Resource<"cloudflare::Queue">,
-    QueueProps {
+    Omit<QueueProps, "dev"> {
   /**
    * Type identifier for Cloudflare Queue
    */
@@ -127,6 +134,22 @@ export interface Queue<Body = unknown>
   Body: Body;
 
   Batch: MessageBatch<Body>;
+
+  /**
+   * Development mode properties
+   * @internal
+   */
+  dev: {
+    /**
+     * The ID of the queue in development mode
+     */
+    id: string;
+
+    /**
+     * Whether the queue is running remotely
+     */
+    remote: boolean;
+  };
 }
 
 /**
@@ -208,26 +231,57 @@ export interface Queue<Body = unknown>
  *
  * @see https://developers.cloudflare.com/queues/
  */
-export const Queue = Resource("cloudflare::Queue", async function <
+export async function Queue<T = unknown>(
+  id: string,
+  props: QueueProps = {},
+): Promise<Queue<T>> {
+  return await _Queue(id, {
+    ...props,
+    dev: {
+      ...(props.dev ?? {}),
+      force: Scope.current.local,
+    },
+  });
+}
+
+const _Queue = Resource("cloudflare::Queue", async function <
   T = unknown,
 >(this: Context<Queue<T>>, id: string, props: QueueProps = {}): Promise<
   Queue<T>
 > {
-  const api = await createCloudflareApi(props);
   const queueName = props.name ?? id;
+  const dev = {
+    id: this.output?.dev?.id ?? this.output?.id ?? id,
+    remote: props.dev?.remote ?? false,
+  };
+  if (this.scope.local && !props.dev?.remote) {
+    return this({
+      type: "queue",
+      id: this.output?.id ?? "",
+      name: queueName,
+      dev,
+      createdOn: this.output?.createdOn ?? new Date().toISOString(),
+      modifiedOn: this.output?.modifiedOn ?? new Date().toISOString(),
+      Body: undefined as T,
+      Batch: undefined! as MessageBatch<T>,
+    });
+  }
+
+  const api = await createCloudflareApi(props);
 
   if (this.phase === "delete") {
-    if (props.delete !== false) {
+    if (props.delete !== false && this.output?.id) {
       // Delete Queue
-      await deleteQueue(api, this.output?.id);
+      await deleteQueue(api, this.output.id);
     }
 
     // Return void (a deleted queue has no content)
     return this.destroy();
   }
+
   let queueData: CloudflareQueueResponse;
 
-  if (this.phase === "create") {
+  if (this.phase === "create" || !this.output?.id) {
     try {
       queueData = await createQueue(api, queueName, props);
     } catch (error) {
@@ -282,7 +336,7 @@ export const Queue = Resource("cloudflare::Queue", async function <
     createdOn: queueData.result.created_on || new Date().toISOString(),
     modifiedOn: queueData.result.modified_on || new Date().toISOString(),
     accountId: api.accountId,
-    dev: props.dev,
+    dev,
     // phantom properties
     Body: undefined as T,
     Batch: undefined! as MessageBatch<T>,
@@ -372,12 +426,8 @@ export async function getQueue(
  */
 export async function deleteQueue(
   api: CloudflareApi,
-  queueId?: string,
+  queueId: string,
 ): Promise<void> {
-  if (!queueId) {
-    return;
-  }
-
   // Delete Queue
   const deleteResponse = await api.delete(
     `/accounts/${api.accountId}/queues/${queueId}`,

package/src/cloudflare/route.ts

@@ -48,6 +48,15 @@ export interface RouteProps extends CloudflareApiOptions {
    * @default false
    */
   adopt?: boolean;
+
+  /**
+   * If true, the route will not be created, but will be retained if it already exists.
+   * This is used for local development.
+   *
+   * @default `false`
+   * @internal
+   */
+  dev?: boolean;
 }
 
 /**
@@ -150,6 +159,21 @@ export const Route = Resource(
       return this.destroy();
     }
 
+    if (this.scope.local && props.dev) {
+      // Get or infer zone ID for noop mode too
+      let zoneId = props.zoneId;
+      if (!zoneId) {
+        zoneId = this.output?.zoneId ?? "noop-zone";
+      }
+
+      return this({
+        id: this.output?.id ?? "noop-route",
+        pattern: props.pattern,
+        script: scriptName,
+        zoneId: zoneId,
+      });
+    }
+
     // Get or infer zone ID (only needed for create/update phases)
     let zoneId = props.zoneId;
     if (!zoneId) {

package/src/cloudflare/worker-subdomain.ts

@@ -1,6 +1,8 @@
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import { memoize } from "../util/memoize.ts";
+import { withExponentialBackoff } from "../util/retry.ts";
+import { CloudflareApiError } from "./api-error.ts";
 import { extractCloudflareResult } from "./api-response.ts";
 import {
   createCloudflareApi,
@@ -25,6 +27,14 @@ interface WorkerSubdomainProps extends CloudflareApiOptions {
    * @default false
    */
   retain?: boolean;
+  /**
+   * If true, the subdomain will not be created, but will be retained if it already exists.
+   * This is used for local development.
+   *
+   * @default `false`
+   * @internal
+   */
+  dev?: boolean;
 }
 
 export interface WorkerSubdomain
@@ -42,6 +52,12 @@ export const WorkerSubdomain = Resource(
     id: string,
     props: WorkerSubdomainProps,
   ) {
+    if (this.scope.local && props.dev) {
+      return this({
+        url: this.output?.url ?? "https://unavailable.alchemy.run",
+      });
+    }
+
     const api = await createCloudflareApi(props);
     if (this.phase === "delete") {
       if (!props.retain) {
@@ -86,12 +102,18 @@ export async function enableWorkerSubdomain(
   api: CloudflareApi,
   scriptName: string,
 ) {
-  await extractCloudflareResult<SubdomainResponse>(
-    `enable subdomain for "${scriptName}"`,
-    api.post(
-      `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
-      { enabled: true, previews_enabled: true },
-    ),
+  await withExponentialBackoff(
+    () =>
+      extractCloudflareResult<SubdomainResponse>(
+        `enable subdomain for "${scriptName}"`,
+        api.post(
+          `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
+          { enabled: true, previews_enabled: true },
+        ),
+      ),
+    (error) => error instanceof CloudflareApiError && error.status === 404,
+    10,
+    1000,
   );
 }
 
@@ -105,6 +127,7 @@ export async function getWorkerSubdomain(
       `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
     ),
   ).catch((error): SubdomainResponse => {
+    console.log("error", error);
     if (error.status === 404) {
       return { enabled: false, previews_enabled: false };
     }