alchemy 0.22.4 → 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/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);

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

@@ -264,6 +264,7 @@ export interface WranglerJsonSpec {
     name: string;
     binding: string;
     class_name: string;
+    script_name?: string;
   }[];
 
   /**
@@ -369,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;
@@ -484,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({

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/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",
     });
 

package/src/test/vitest.ts

@@ -0,0 +1,209 @@
+import path from "node:path";
+import { afterAll, beforeAll, it } from "vitest";
+import { alchemy } from "../alchemy.ts";
+import { R2RestStateStore } from "../cloudflare/r2-rest-state-store.ts";
+import { Scope } from "../scope.ts";
+import type { StateStoreType } from "../state.ts";
+
+/**
+ * Extend the Alchemy interface to include test functionality
+ */
+declare module "../alchemy.ts" {
+  interface Alchemy {
+    test: typeof test;
+  }
+}
+
+/**
+ * Add test functionality to alchemy instance
+ */
+alchemy.test = test;
+
+/**
+ * Options for configuring test behavior
+ */
+export interface TestOptions {
+  /**
+   * Whether to suppress logging output.
+   * @default false.
+   */
+  quiet?: boolean;
+
+  /**
+   * Password to use for test resources.
+   * @default "test-password".
+   */
+  password?: string;
+
+  /**
+   * Override the default state store for the test.
+   */
+  stateStore?: StateStoreType;
+
+  /**
+   * Prefix to use for the scope to isolate tests and environments.
+   */
+  prefix?: string;
+}
+
+/**
+ * Test function type definition with overloads
+ */
+type test = {
+  /**
+   * Create a test with default options
+   * @param name Test name
+   * @param fn Test function
+   * @param timeout Optional timeout in milliseconds
+   */
+  (name: string, fn: (scope: Scope) => Promise<any>, timeout?: number): void;
+
+  /**
+   * Create a test with custom options
+   * @param name Test name
+   * @param options Test configuration options
+   * @param fn Test function
+   * @param timeout Optional timeout in milliseconds
+   */
+  (
+    name: string,
+    options: TestOptions,
+    fn: (scope: Scope) => Promise<any>,
+    timeout?: number,
+  ): void;
+
+  /**
+   * Skip test conditionally
+   * @param condition If true, test will be skipped
+   */
+  skipIf(condition: boolean): test;
+
+  beforeAll(fn: (scope: Scope) => Promise<void>): void;
+
+  afterAll(fn: (scope: Scope) => Promise<void>): void;
+
+  /**
+   * Current test scope
+   */
+  scope: Scope;
+};
+
+/**
+ * Creates a test helper function that provides scoped resource management
+ *
+ * @param meta Import meta object from the test file
+ * @param defaultOptions Default options to apply to all tests
+ * @returns Test function with scope management
+ *
+ * @example
+ * ```typescript
+ * const test = alchemy.test(import.meta, {
+  prefix: BRANCH_PREFIX
+});
+ *
+ * describe("My Resource", () => {
+ *   test("create and delete", async (scope) => {
+ *     try {
+ *       const resource = await MyResource("test", { ... });
+ *       expect(resource.id).toBeTruthy();
+ *     } finally {
+ *       await alchemy.destroy(scope);
+ *     }
+ *   });
+ * });
+ * ```
+ */
+export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
+  defaultOptions = defaultOptions ?? {};
+  if (
+    defaultOptions.stateStore === undefined &&
+    process.env.ALCHEMY_STATE_STORE === "cloudflare"
+  ) {
+    defaultOptions.stateStore = (scope) =>
+      new R2RestStateStore(scope, {
+        apiKey: alchemy.secret(process.env.CLOUDFLARE_API_KEY),
+        email: process.env.CLOUDFLARE_EMAIL,
+        bucketName: process.env.CLOUDFLARE_BUCKET_NAME!,
+      });
+  }
+
+  test.skipIf = (condition: boolean) => {
+    if (condition) {
+      return (..._args: any[]) => {};
+    }
+    return test;
+  };
+
+  const scope = new Scope({
+    scopeName: `${defaultOptions.prefix ? `${defaultOptions.prefix}-` : ""}${path.basename(meta.filename)}`,
+    stateStore: defaultOptions?.stateStore,
+    phase: "up",
+  });
+
+  test.beforeAll = (fn: (scope: Scope) => Promise<void>) => {
+    return beforeAll(() => scope.run(() => fn(scope)));
+  };
+
+  test.afterAll = (fn: (scope: Scope) => Promise<void>) => {
+    return afterAll(() => scope.run(() => fn(scope)));
+  };
+
+  return test as test;
+
+  function test(
+    ...args:
+      | [
+          name: string,
+          options: TestOptions,
+          fn: (scope: Scope) => Promise<void>,
+        ]
+      | [name: string, fn: (scope: Scope) => Promise<void>]
+  ) {
+    const testName = args[0];
+    const _options = typeof args[1] === "object" ? args[1] : undefined;
+    const timeout =
+      typeof args[args.length - 1] === "number"
+        ? (args[args.length - 1] as number)
+        : 120000;
+    const spread = (obj: any) =>
+      obj && typeof obj === "object"
+        ? Object.fromEntries(
+            Object.entries(obj).flatMap(([k, v]) =>
+              v !== undefined ? [[k, v]] : [],
+            ),
+          )
+        : {};
+
+    const options: TestOptions = {
+      quiet: false,
+      password: "test-password",
+      ...spread(defaultOptions),
+      ...spread(_options),
+    };
+
+    const fn = typeof args[1] === "function" ? args[1] : args[2]!;
+
+    return it(
+      testName,
+      (ctx) => {
+        // Get the current describe block name from the test context
+        let describeBlockName = "";
+        if (ctx.task.suite?.name) {
+          describeBlockName = `${ctx.task.suite.name}/`;
+        }
+
+        return alchemy.run(
+          `${describeBlockName}${testName}`,
+          {
+            ...options,
+            parent: scope,
+          },
+          async (scope) => {
+            await scope.run(() => fn(scope));
+          },
+        );
+      },
+      timeout,
+    );
+  }
+}

package/src/upstash/api.ts

@@ -1,4 +1,5 @@
 import type { Secret } from "../secret.ts";
+import { safeFetch } from "../util/safe-fetch.ts";
 
 /**
  * Options for Upstash API requests
@@ -68,7 +69,7 @@ export class UpstashApi {
       });
     }
 
-    return fetch(`${this.baseUrl}${path}`, {
+    return safeFetch(`${this.baseUrl}${path}`, {
       ...init,
       headers,
     });

package/src/util/retry.ts

@@ -21,11 +21,10 @@ export async function withExponentialBackoff<T>(
   while (true) {
     try {
       return await operation();
-    } catch (error) {
-      console.log("error", error);
+    } catch (error: any) {
+      console.log(error.message);
       attempt++;
       if (attempt >= maxAttempts || !isRetryable(error)) {
-        console.warn("Failed after ", attempt, " attempts");
         throw error;
       }
 
@@ -33,6 +32,7 @@ export async function withExponentialBackoff<T>(
       const jitter = Math.random() * 0.1 * delay;
       await new Promise((resolve) => setTimeout(resolve, delay + jitter));
       delay *= 2; // Double the delay for next attempt
+      delay = Math.min(delay, 10000); // Cap at 10 seconds
     }
   }
 }