alchemy 0.22.3 → 0.23.0

package/src/cloudflare/route.ts

@@ -28,6 +28,14 @@ export interface RouteProps extends CloudflareApiOptions {
    * Zone ID for the route
    */
   zoneId: string;
+
+  /**
+   * Whether to adopt an existing route with the same pattern if it exists
+   * If true and a route with the same pattern exists, it will be adopted rather than creating a new one
+   *
+   * @default false
+   */
+  adopt?: boolean;
 }
 
 /**
@@ -133,8 +141,44 @@ export const Route = Resource(
     } else {
       console.log("Creating Route:", props.pattern);
 
-      // Create new route
-      routeData = await createRoute(api, zoneId, props.pattern, scriptName);
+      try {
+        // Create new route
+        routeData = await createRoute(api, zoneId, props.pattern, scriptName);
+      } catch (error) {
+        // Check if this is a "route already exists" error and adopt is enabled
+        if (
+          props.adopt &&
+          error instanceof CloudflareApiError &&
+          error.status === 409
+        ) {
+          console.log(
+            `Route with pattern '${props.pattern}' already exists, adopting it`,
+          );
+          // Find the existing route by pattern
+          const existingRoute = await findRouteByPattern(
+            api,
+            zoneId,
+            props.pattern,
+          );
+
+          if (!existingRoute) {
+            throw new Error(
+              `Failed to find existing route with pattern '${props.pattern}' for adoption`,
+            );
+          }
+
+          // Use the existing route data
+          routeData = {
+            result: existingRoute,
+            success: true,
+            errors: [],
+            messages: [],
+          };
+        } else {
+          // Re-throw the error if adopt is false or it's not a 409 error
+          throw error;
+        }
+      }
     }
 
     // Return the route resource
@@ -266,3 +310,43 @@ export async function listRoutes(
 
   return (await response.json()) as CloudflareRouteResponse;
 }
+
+/**
+ * Find a route by pattern
+ */
+async function findRouteByPattern(
+  api: CloudflareApi,
+  zoneId: string,
+  pattern: string,
+): Promise<{ id: string; pattern: string; script: string } | null> {
+  const response = await api.get(`/zones/${zoneId}/workers/routes`);
+
+  if (!response.ok) {
+    throw new CloudflareApiError(
+      `Failed to list routes: ${response.statusText}`,
+      response,
+    );
+  }
+
+  const data = (await response.json()) as {
+    result: Array<{
+      id: string;
+      pattern: string;
+      script: string;
+    }>;
+    success: boolean;
+    errors: Array<{ code: number; message: string }>;
+    messages: string[];
+  };
+
+  if (!data.success) {
+    throw new CloudflareApiError(
+      `Failed to list routes: ${data.errors?.[0]?.message || "Unknown error"}`,
+      response,
+    );
+  }
+
+  // Look for a route with matching pattern
+  const match = data.result.find((route) => route.pattern === pattern);
+  return match || null;
+}

package/src/cloudflare/version-metadata.ts

@@ -0,0 +1,6 @@
+/**
+ * @see https://developers.cloudflare.com/workers/runtime-apis/bindings/version-metadata/
+ */
+export class VersionMetadata {
+  public readonly type = "version_metadata";
+}

package/src/cloudflare/worker-metadata.ts

@@ -403,8 +403,7 @@ export async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         workflow_name: binding.workflowName,
         class_name: binding.className,
-        // this should be set if the Workflow is in another script ...
-        // script_name: ??,
+        script_name: binding.scriptName,
       });
       // it's unclear whether this is needed, but it works both ways
       // configureClassMigration(binding, binding.id, binding.className);
@@ -461,6 +460,11 @@ export async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         dataset: binding.dataset,
       });
+    } else if (binding.type === "version_metadata") {
+      meta.bindings.push({
+        type: "version_metadata",
+        name: bindingName,
+      });
     } else {
       // @ts-expect-error - we should never reach here
       throw new Error(`Unsupported binding type: ${binding.type}`);

package/src/cloudflare/worker.ts

@@ -58,7 +58,7 @@ import {
 } from "./worker-metadata.ts";
 import type { SingleStepMigration } from "./worker-migration.ts";
 import { WorkerStub, isWorkerStub } from "./worker-stub.ts";
-import { type Workflow, upsertWorkflow } from "./workflow.ts";
+import { Workflow, isWorkflow, upsertWorkflow } from "./workflow.ts";
 
 /**
  * Configuration options for static assets
@@ -351,6 +351,8 @@ export type Worker<
     /**
      * The worker's URL if enabled
      * Format: {name}.{subdomain}.workers.dev
+     *
+     * @default true
      */
     url?: string;
 
@@ -391,7 +393,6 @@ export type Worker<
  * const api = await Worker("api", {
  *   name: "api-worker",
  *   entrypoint: "./src/api.ts",
- *   routes: ["api.example.com/*"],
  *   url: true
  * });
  *
@@ -802,11 +803,16 @@ export const _Worker = Resource(
       await putWorker(api, workerName, scriptBundle, scriptMetadata);
 
       for (const workflow of workflowsBindings) {
-        await upsertWorkflow(api, {
-          workflowName: workflow.workflowName,
-          className: workflow.className,
-          scriptName: workerName,
-        });
+        if (
+          workflow.scriptName === undefined ||
+          workflow.scriptName === workerName
+        ) {
+          await upsertWorkflow(api, {
+            workflowName: workflow.workflowName,
+            className: workflow.className,
+            scriptName: workflow.scriptName ?? workerName,
+          });
+        }
       }
 
       await Promise.all(
@@ -833,7 +839,7 @@ export const _Worker = Resource(
         this,
         api,
         workerName,
-        props.url ?? false,
+        props.url ?? true,
       );
 
       // Get current timestamp
@@ -922,7 +928,13 @@ export const _Worker = Resource(
                   // re-export this binding mapping to the host worker (this worker)
                   scriptName: workerName,
                 })
-              : binding,
+              : isWorkflow(binding) && binding.scriptName === undefined
+                ? new Workflow(binding.id, {
+                    ...binding,
+                    // re-export this binding mapping to the host worker (this worker)
+                    scriptName: workerName,
+                  })
+                : binding,
           ],
         ),
       );

package/src/cloudflare/workflow.ts

@@ -19,6 +19,12 @@ export interface WorkflowProps {
    * @default - workflowName if provided, otherwise id
    */
   className?: string;
+  /**
+   * Name of the script containing the workflow implementation
+   *
+   * @default - bound worker script
+   */
+  scriptName?: string;
 }
 
 export function isWorkflow(binding: Binding): binding is Workflow {
@@ -36,6 +42,7 @@ export class Workflow<PARAMS = unknown> {
 
   public readonly workflowName: string;
   public readonly className: string;
+  public readonly scriptName?: string;
 
   constructor(
     public readonly id: string,
@@ -43,6 +50,7 @@ export class Workflow<PARAMS = unknown> {
   ) {
     this.workflowName = props.workflowName ?? props.className ?? id;
     this.className = props.className ?? this.workflowName;
+    this.scriptName = props.scriptName;
   }
 }
 

package/src/cloudflare/wrangler.json.ts

@@ -1,5 +1,7 @@
+import fs from "node:fs/promises";
+import path from "node:path";
 import type { Context } from "../context.ts";
-import { StaticJsonFile } from "../fs/static-json-file.ts";
+import { formatJson } from "../fs/static-json-file.ts";
 import { Resource } from "../resource.ts";
 import { assertNever } from "../util/assert-never.ts";
 import { Self, type Bindings } from "./bindings.ts";
@@ -126,7 +128,8 @@ export const WranglerJson = Resource(
       spec.triggers = { crons: worker.crons };
     }
 
-    await StaticJsonFile(filePath, spec);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, await formatJson(spec));
 
     // Return the resource
     return this({
@@ -261,6 +264,7 @@ export interface WranglerJsonSpec {
     name: string;
     binding: string;
     class_name: string;
+    script_name?: string;
   }[];
 
   /**
@@ -336,6 +340,13 @@ export interface WranglerJsonSpec {
    * Pipelines
    */
   pipelines?: { binding: string; pipeline: string }[];
+
+  /**
+   * Version metadata bindings
+   */
+  version_metadata?: {
+    binding: string;
+  };
 }
 
 /**
@@ -359,7 +370,12 @@ function processBindings(
   const services: { binding: string; service: string; environment?: string }[] =
     [];
   const secrets: string[] = [];
-  const workflows: { name: string; binding: string; class_name: string }[] = [];
+  const workflows: {
+    name: string;
+    binding: string;
+    class_name: string;
+    script_name?: string;
+  }[] = [];
   const d1Databases: {
     binding: string;
     database_id: string;
@@ -474,6 +490,7 @@ function processBindings(
         name: binding.workflowName,
         binding: bindingName,
         class_name: binding.className,
+        script_name: binding.scriptName,
       });
     } else if (binding.type === "d1") {
       d1Databases.push({
@@ -513,6 +530,15 @@ function processBindings(
       });
     } else if (binding.type === "ai_gateway") {
       // no-op
+    } else if (binding.type === "version_metadata") {
+      if (spec.version_metadata) {
+        throw new Error(
+          `Version metadata already bound to ${spec.version_metadata.binding}`,
+        );
+      }
+      spec.version_metadata = {
+        binding: bindingName,
+      };
     } else if (binding.type === "hyperdrive") {
       const password =
         "password" in binding.origin

package/src/destroy.ts

@@ -72,7 +72,7 @@ export async function destroy<Type extends string>(
   const Provider = resolveDeletionHandler(instance[ResourceKind]);
   if (!Provider) {
     throw new Error(
-      `Cannot destroy resource "${instance[ResourceFQN]}" type ${instance[ResourceKind]} - no provider found. You may need to import the provider in your alchemy.config.ts.`,
+      `Cannot destroy resource "${instance[ResourceFQN]}" type ${instance[ResourceKind]} - no provider found. You may need to import the provider in your alchemy.run.ts.`,
     );
   }
 

package/src/dns/godaddy.ts

@@ -1,3 +1,5 @@
+import { safeFetch } from "../util/safe-fetch.ts";
+
 export type UpdateNameserversOptions = {
   domain: string;
   apiKey: string;
@@ -8,7 +10,7 @@ export type UpdateNameserversOptions = {
 export async function updateNameservers(options: UpdateNameserversOptions) {
   const url = `https://api.godaddy.com/v1/domains/${options.domain}/nameservers`;
 
-  const response = await fetch(url, {
+  const response = await safeFetch(url, {
     method: "PUT",
     headers: {
       Authorization: `sso-key ${options.apiKey}:${options.apiSecret}`,

package/src/fs/file-system-state-store.ts

@@ -24,7 +24,19 @@ export class FileSystemStateStore implements StateStore {
   }
 
   async deinit(): Promise<void> {
-    await ignore("ENOENT", () => fs.promises.rmdir(this.dir));
+    await ignore("ENOENT", async () => {
+      const entries = await fs.promises.readdir(this.dir, {
+        withFileTypes: true,
+      });
+      const files = entries.filter((entry) => entry.isFile());
+      if (files.length > 0) {
+        throw new Error(
+          `Cannot deinit: directory "${this.dir}" contains files and cannot be deleted.`,
+        );
+      }
+      // Only folders (or empty), delete recursively
+      await fs.promises.rm(this.dir, { recursive: true, force: true });
+    });
   }
 
   async count(): Promise<number> {
@@ -67,8 +79,10 @@ export class FileSystemStateStore implements StateStore {
 
   async set(key: string, value: State): Promise<void> {
     await this.init();
+    const file = this.getPath(key);
+    await fs.promises.mkdir(path.dirname(file), { recursive: true });
     await fs.promises.writeFile(
-      this.getPath(key),
+      file,
       JSON.stringify(await serialize(this.scope, value), null, 2),
     );
   }

package/src/fs/static-json-file.ts

@@ -20,15 +20,19 @@ export async function StaticJsonFile(
   ...args: [content: any] | [path: string, content: any]
 ): Promise<StaticJsonFile> {
   const [path, content] = args.length === 1 ? [id, args[0]] : args;
-  const prettier = await import("prettier");
   return File(id, {
     path,
-    content: await prettier.format(JSON.stringify(content), {
-      parser: "json",
-      editor: {
-        tabWidth: 2,
-        indentWidth: 2,
-      },
-    }),
+    content: await formatJson(content),
+  });
+}
+
+export async function formatJson(content: any) {
+  const prettier = await import("prettier");
+  return prettier.format(JSON.stringify(content), {
+    parser: "json",
+    editor: {
+      tabWidth: 2,
+      indentWidth: 2,
+    },
   });
 }

package/src/github/secret.ts

@@ -224,6 +224,8 @@ export const GitHubSecret = Resource(
         }
       }
 
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
       let publicKey;
 
       // Get the appropriate public key for encrypting secrets

package/src/neon/api.ts

@@ -1,5 +1,6 @@
 import type { Secret } from "../secret.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
+import { safeFetch } from "../util/safe-fetch.ts";
 
 /**
  * Options for Neon API requests
@@ -98,7 +99,7 @@ export class NeonApi {
     // Use withExponentialBackoff for automatic retry on network errors
     return withExponentialBackoff(
       () =>
-        fetch(`${this.baseUrl}${path}`, {
+        safeFetch(`${this.baseUrl}${path}`, {
           ...init,
           headers,
         }),

package/src/sentry/api.ts

@@ -1,5 +1,6 @@
 import { alchemy } from "../alchemy.ts";
 import type { Secret } from "../secret.ts";
+import { safeFetch } from "../util/safe-fetch.ts";
 
 /**
  * Options for Sentry API requests
@@ -60,7 +61,7 @@ export class SentryApi {
       delete headers["Content-Type"];
     }
 
-    return fetch(`${this.baseUrl}${path}`, {
+    return safeFetch(`${this.baseUrl}${path}`, {
       ...init,
       headers,
     });

package/src/test/bun.ts

@@ -131,13 +131,7 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
   }
 
   // Add skipIf functionality
-  test.skipIf = (condition: boolean) => {
-    if (condition) {
-      // TODO: proxy through to bun:test.skipIf
-      return (..._args: any[]) => {};
-    }
-    return test;
-  };
+  test.skipIf = it.skipIf.bind(it);
 
   // Create local test scope based on filename
   const scope = new Scope({

package/src/test/prune.ts

@@ -10,23 +10,50 @@ const execAsync = promisify(exec);
  * Runs only tests that have changed dependencies
  * @param directory Directory to scan for test files
  * @param baseCommit Optional base commit to compare against
+ * @param useVitest Whether to use vitest instead of bun test
  */
 export async function runChangedTests(
   directory: string,
   baseCommit?: string,
+  useVitest?: boolean,
 ): Promise<void> {
   const changedTests = await findChangedTestFiles(directory, baseCommit);
 
+  // Always include smoke test
+  const smokeTestPath = "alchemy/test/smoke.test.ts";
+  if (!changedTests.includes(smokeTestPath)) {
+    changedTests.unshift(smokeTestPath); // Add at the beginning
+  }
+
+  if (process.env.CI) {
+    // these tests are being really weird in GitHub CI.
+    // not the priority to test in CI
+    const testsToRemove = [
+      "alchemy/test/cloudflare/dns-records.test.ts",
+      "alchemy/test/cloudflare/route.test.ts",
+    ];
+    for (const test of testsToRemove) {
+      const idx = changedTests.indexOf(test);
+      if (idx !== -1) {
+        changedTests.splice(idx, 1);
+      }
+    }
+  }
+
   if (changedTests.length === 0) {
     console.log("No tests affected by recent changes.");
     return;
   }
 
-  // Run the tests with bun using spawn for stdio inheritance
+  // Run the tests using spawn for stdio inheritance
   return new Promise<void>((resolve, reject) => {
-    console.log(`bun test ${changedTests.join(" ")}`);
+    const command = useVitest ? "vitest" : "bun";
+    const args = useVitest
+      ? ["run", ...changedTests]
+      : ["test", ...changedTests];
+    console.log(`${command} ${args.join(" ")}`);
     // resolve();
-    const child = spawn("bun", ["test", ...changedTests], { stdio: "inherit" });
+    const child = spawn(command, args, { stdio: "inherit" });
 
     child.on("close", (code) => {
       if (code === 0) resolve();
@@ -129,7 +156,7 @@ async function getDependencies(testFile: string): Promise<Set<string>> {
       format: "esm",
       bundle: true,
       metafile: true,
-      external: ["@cloudflare/workers-types", "bun:test", "@swc/*"],
+      external: ["@cloudflare/workers-types", "bun:test", "vitest", "@swc/*"],
       logLevel: "error",
     });