alchemy 0.25.0 → 0.26.1

package/src/cloudflare/worker.ts

@@ -10,6 +10,7 @@ import { Secret, secret } from "../secret.ts";
 import { serializeScope } from "../serde.ts";
 import type { type } from "../type.ts";
 import { getContentType } from "../util/content-type.ts";
+import { logger } from "../util/logger.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
 import { slugify } from "../util/slugify.ts";
 import { CloudflareApiError, handleApiError } from "./api-error.ts";
@@ -33,6 +34,7 @@ import {
   bundleWorkerScript,
 } from "./bundle/bundle-worker.ts";
 import { isD1Database } from "./d1-database.ts";
+import type { DispatchNamespaceResource } from "./dispatch-namespace.ts";
 import {
   DurableObjectNamespace,
   isDurableObjectNamespace,
@@ -50,6 +52,7 @@ import {
   listQueueConsumersForWorker,
 } from "./queue-consumer.ts";
 import { type QueueResource, isQueue } from "./queue.ts";
+import { Route } from "./route.ts";
 import { isVectorizeIndex } from "./vectorize-index.ts";
 import { type AssetUploadResult, uploadAssets } from "./worker-assets.ts";
 import {
@@ -216,12 +219,45 @@ export interface BaseWorkerProps<
    */
   eventSources?: EventSource[];
 
+  /**
+   * Routes to create for this worker.
+   *
+   * Each route maps a URL pattern to this worker script.
+   */
+  routes?: Array<{
+    /**
+     * URL pattern for the route
+     * @example "sub.example.com/*"
+     */
+    pattern: string;
+    /**
+     * Zone ID for the route. If not provided, will be automatically inferred from the route pattern.
+     */
+    zoneId?: string;
+    /**
+     * Whether this is a custom domain route
+     */
+    customDomain?: boolean;
+    /**
+     * Whether to adopt an existing route with the same pattern if it exists
+     * @default false
+     */
+    adopt?: boolean;
+  }>;
+
   /**
    * The RPC class to use for the worker.
    *
    * This is only used when using the rpc property.
    */
   rpc?: (new (...args: any[]) => RPC) | type<RPC>;
+
+  /**
+   * Deploy this worker to a dispatch namespace
+   *
+   * This allows workers to be routed to via dispatch namespace routing rules
+   */
+  dispatchNamespace?: string | DispatchNamespaceResource;
 }
 
 export interface InlineWorkerProps<
@@ -322,7 +358,7 @@ export type Worker<
   B extends Bindings | undefined = Bindings | undefined,
   RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
 > = Resource<"cloudflare::Worker"> &
-  Omit<WorkerProps<B>, "url" | "script"> &
+  Omit<WorkerProps<B>, "url" | "script" | "routes"> &
   globalThis.Service & {
     /** @internal phantom property */
     __rpc__?: RPC;
@@ -367,6 +403,11 @@ export type Worker<
      */
     assets?: AssetsConfig;
 
+    /**
+     * The routes that were created for this worker
+     */
+    routes?: Route[];
+
     // phantom property (for typeof myWorker.Env)
     Env: B extends Bindings
       ? {
@@ -383,6 +424,11 @@ export type Worker<
      * The compatibility flags for the worker
      */
     compatibilityFlags: string[];
+
+    /**
+     * The dispatch namespace this worker is deployed to
+     */
+    dispatchNamespace?: string | DispatchNamespaceResource;
   };
 
 /**
@@ -633,10 +679,9 @@ export function Worker<const B extends Bindings>(
       return _Worker(id, {
         ...(props as any),
         url: true,
-        compatibilityFlags: [
-          "nodejs_compat",
-          ...(props.compatibilityFlags ?? []),
-        ],
+        compatibilityFlags: Array.from(
+          new Set(["nodejs_compat", ...(props.compatibilityFlags ?? [])]),
+        ),
         entrypoint: meta!.filename,
         name: workerName,
         // adopt because the stub guarnatees that the worker exists
@@ -652,9 +697,10 @@ export function Worker<const B extends Bindings>(
             "esbuild",
             // TODO(sam): this is for fetch, why is it a package?
             "undici",
-            // TODO(sam): no idea where this came from, feels dangerous to externalize it
-            "ws",
             "miniflare",
+            "@iarna/toml",
+            "cli-*",
+            "react*",
           ],
           banner: {
             js: "var __ALCHEMY_RUNTIME__ = true;",
@@ -720,7 +766,7 @@ export function Worker<const B extends Bindings>(
           const incoming = request.url.startsWith("/")
             ? new URL(`${worker.url}${request.url}`)
             : new URL(request.url);
-          console.log(incoming);
+          logger.log(incoming);
           const proxyURL = new URL(
             `${incoming.pathname}${incoming.search}${incoming.hash}`,
             origin,
@@ -851,7 +897,20 @@ export const _Worker = Resource(
         assetUploadResult,
       );
 
-      await putWorker(api, workerName, scriptBundle, scriptMetadata);
+      // Get dispatch namespace if specified
+      const dispatchNamespace = props.dispatchNamespace
+        ? typeof props.dispatchNamespace === "string"
+          ? props.dispatchNamespace
+          : props.dispatchNamespace.namespace
+        : undefined;
+
+      await putWorker(
+        api,
+        workerName,
+        scriptBundle,
+        scriptMetadata,
+        dispatchNamespace,
+      );
 
       for (const workflow of workflowsBindings) {
         if (
@@ -935,6 +994,8 @@ export const _Worker = Resource(
         // we are writing a stub worker (to remove binding/event source dependencies)
         // queue consumers will no longer exist by this point
         eventSources: undefined,
+        // stub worker doesn't need dispatch namespace
+        dispatchNamespace: undefined,
       });
 
       await withExponentialBackoff(
@@ -969,6 +1030,38 @@ export const _Worker = Resource(
 
     const { scriptMetadata, workerUrl, now } = await uploadWorkerScript(props);
 
+    // Create routes if provided and capture their outputs
+    let createdRoutes: Route[] = [];
+    if (props.routes && props.routes.length > 0) {
+      // Validate for duplicate patterns
+      const patterns = props.routes.map((route) => route.pattern);
+      const duplicates = patterns.filter(
+        (pattern, index) => patterns.indexOf(pattern) !== index,
+      );
+      if (duplicates.length > 0) {
+        throw new Error(
+          `Duplicate route patterns found: ${duplicates.join(", ")}`,
+        );
+      }
+
+      // Create Route resources for each route and capture their outputs
+      createdRoutes = await Promise.all(
+        props.routes.map(async (routeConfig) => {
+          return await Route(routeConfig.pattern, {
+            pattern: routeConfig.pattern,
+            script: workerName,
+            zoneId: routeConfig.zoneId, // Route resource will handle inference if not provided
+            adopt: routeConfig.adopt ?? false,
+            accountId: props.accountId,
+            apiKey: props.apiKey,
+            apiToken: props.apiToken,
+            baseUrl: props.baseUrl,
+            email: props.email,
+          });
+        }),
+      );
+    }
+
     function exportBindings() {
       return Object.fromEntries(
         Object.entries(props.bindings ?? ({} as B)).map(
@@ -1014,6 +1107,10 @@ export const _Worker = Resource(
       assets: props.assets,
       // Include cron triggers in the output
       crons: props.crons,
+      // Include the created routes in the output
+      routes: createdRoutes.length > 0 ? createdRoutes : undefined,
+      // Include the dispatch namespace in the output
+      dispatchNamespace: props.dispatchNamespace,
       // phantom property
       Env: undefined!,
     } as unknown as Worker<B>);
@@ -1048,7 +1145,7 @@ export async function deleteWorker<B extends Bindings>(
         },
       );
     } catch (error) {
-      console.warn("Failed to disable worker URL during deletion:", error);
+      logger.warn("Failed to disable worker URL during deletion:", error);
     }
   }
 
@@ -1061,6 +1158,7 @@ export async function putWorker(
   workerName: string,
   scriptBundle: string | NoBundleResult,
   scriptMetadata: WorkerMetadata,
+  dispatchNamespace?: string,
 ) {
   return withExponentialBackoff(
     async () => {
@@ -1103,15 +1201,15 @@ export async function putWorker(
       );
 
       // Upload worker script with bindings
-      const uploadResponse = await api.put(
-        `/accounts/${api.accountId}/workers/scripts/${workerName}`,
-        formData,
-        {
-          headers: {
-            "Content-Type": "multipart/form-data",
-          },
+      const endpoint = dispatchNamespace
+        ? `/accounts/${api.accountId}/workers/dispatch/namespaces/${dispatchNamespace}/scripts/${workerName}`
+        : `/accounts/${api.accountId}/workers/scripts/${workerName}`;
+
+      const uploadResponse = await api.put(endpoint, formData, {
+        headers: {
+          "Content-Type": "multipart/form-data",
         },
-      );
+      });
 
       // Check if the upload was successful
       if (!uploadResponse.ok) {

package/src/cloudflare/wrangler.json.ts

@@ -197,6 +197,13 @@ export interface WranglerJsonSpec {
     binding: string;
   };
 
+  /**
+   * Images bindings
+   */
+  images?: {
+    binding: string;
+  };
+
   /**
    * KV Namespace bindings
    */
@@ -341,12 +348,29 @@ export interface WranglerJsonSpec {
    */
   pipelines?: { binding: string; pipeline: string }[];
 
+  /**
+   * Secrets Store bindings
+   */
+  secrets_store_secrets?: {
+    binding: string;
+    store_id: string;
+    secret_name: string;
+  }[];
+
   /**
    * Version metadata bindings
    */
   version_metadata?: {
     binding: string;
   };
+
+  /**
+   * Dispatch namespace bindings
+   */
+  dispatch_namespaces?: {
+    binding: string;
+    namespace: string;
+  }[];
 }
 
 /**
@@ -408,6 +432,15 @@ function processBindings(
     localConnectionString: string;
   }[] = [];
   const pipelines: { binding: string; pipeline: string }[] = [];
+  const secretsStoreSecrets: {
+    binding: string;
+    store_id: string;
+    secret_name: string;
+  }[] = [];
+  const dispatchNamespaces: {
+    binding: string;
+    namespace: string;
+  }[] = [];
 
   for (const eventSource of eventSources ?? []) {
     if (isQueueEventSource(eventSource)) {
@@ -523,6 +556,13 @@ function processBindings(
       spec.ai = {
         binding: bindingName,
       };
+    } else if (binding.type === "images") {
+      if (spec.images) {
+        throw new Error(`Images already bound to ${spec.images.binding}`);
+      }
+      spec.images = {
+        binding: bindingName,
+      };
     } else if (binding.type === "analytics_engine") {
       analyticsEngineDatasets.push({
         binding: bindingName,
@@ -556,6 +596,21 @@ function processBindings(
       });
     } else if (binding.type === "json") {
       // TODO(sam): anything to do here? not sure wrangler.json supports this
+    } else if (binding.type === "secrets_store") {
+      if (binding.secrets) {
+        for (const [secretName, _secret] of Object.entries(binding.secrets)) {
+          secretsStoreSecrets.push({
+            binding: bindingName,
+            store_id: binding.id,
+            secret_name: secretName,
+          });
+        }
+      }
+    } else if (binding.type === "dispatch_namespace") {
+      dispatchNamespaces.push({
+        binding: bindingName,
+        namespace: binding.namespaceName,
+      });
     } else {
       // biome-ignore lint/correctness/noVoidTypeReturn: it returns never
       return assertNever(binding);
@@ -618,4 +673,12 @@ function processBindings(
   if (pipelines.length > 0) {
     spec.pipelines = pipelines;
   }
+
+  if (secretsStoreSecrets.length > 0) {
+    spec.secrets_store_secrets = secretsStoreSecrets;
+  }
+
+  if (dispatchNamespaces.length > 0) {
+    spec.dispatch_namespaces = dispatchNamespaces;
+  }
 }

package/src/cloudflare/zone.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import { logger } from "../util/logger.ts";
 import { handleApiError } from "./api-error.ts";
 import { createCloudflareApi, type CloudflareApiOptions } from "./api.ts";
 import type {
@@ -329,7 +330,7 @@ export const Zone = Resource(
           );
         }
       } else {
-        console.warn(`Zone '${props.name}' not found, skipping delete`);
+        logger.warn(`Zone '${props.name}' not found, skipping delete`);
       }
       return this.destroy();
     }
@@ -387,7 +388,7 @@ export const Zone = Resource(
     if (!response.ok) {
       if (response.status === 400 && body.includes("already exists")) {
         // Zone already exists, fetch it instead
-        console.warn(
+        logger.warn(
           `Zone '${props.name}' already exists during Zone create, adopting it...`,
         );
         const getResponse = await api.get(`/zones?name=${props.name}`);
@@ -488,7 +489,7 @@ async function updateZoneSettings(
         if (!response.ok) {
           const data = await response.text();
           if (response.status === 400 && data.includes("already enabled")) {
-            console.warn(`Warning: Setting '${key}' already enabled`);
+            logger.warn(`Warning: Setting '${key}' already enabled`);
             return;
           }
           throw new Error(

package/src/destroy.ts

@@ -10,6 +10,8 @@ import {
   ResourceSeq,
 } from "./resource.ts";
 import { Scope } from "./scope.ts";
+import { formatFQN } from "./util/cli.tsx";
+import { logger } from "./util/logger.ts";
 
 export class DestroyedSignal extends Error {}
 
@@ -37,18 +39,21 @@ export async function destroy<Type extends string>(
       ...(args[1] ?? {}),
     } satisfies DestroyOptions;
 
-    // destroy all active resources
-    await destroyAll(Array.from(scope.resources.values()), options);
-
-    // then detect orphans and destroy them
-    const orphans = await scope.state.all();
-    await destroyAll(
-      Object.values(orphans).map((orphan) => ({
-        ...orphan.output,
-        Scope: scope,
-      })),
-      options,
-    );
+    await scope.run(async () => {
+      // destroy all active resources
+      await destroyAll(Array.from(scope.resources.values()), options);
+
+      // then detect orphans and destroy them
+      const orphans = await scope.state.all();
+      await destroyAll(
+        Object.values(orphans).map((orphan) => ({
+          ...orphan.output,
+          Scope: scope,
+        })),
+        options,
+      );
+    });
+
     // finally, destroy the scope container
     await scope.deinit();
     return;
@@ -65,7 +70,7 @@ export async function destroy<Type extends string>(
       parent: instance[ResourceScope],
       scopeName: instance[ResourceID],
     });
-    console.log("Destroying scope", scope.chain.join("/"));
+    logger.log("Destroying scope", scope.chain.join("/"));
     return await destroy(scope, options);
   }
 
@@ -78,13 +83,19 @@ export async function destroy<Type extends string>(
 
   const scope = instance[ResourceScope];
   if (!scope) {
-    console.warn(`Resource "${instance[ResourceFQN]}" has no scope`);
+    logger.warn(`Resource "${instance[ResourceFQN]}" has no scope`);
   }
   const quiet = options?.quiet ?? scope.quiet;
 
   try {
     if (!quiet) {
-      console.log(`Delete:  "${instance[ResourceFQN]}"`);
+      logger.task(instance[ResourceFQN], {
+        prefix: "DELETING",
+        prefixColor: "magenta",
+        resource: formatFQN(instance[ResourceFQN]),
+        message: "Deleting Resource...",
+      });
+      logger.log(`Delete:  "${instance[ResourceFQN]}"`);
     }
 
     const state = await scope.state.get(instance[ResourceID]);
@@ -140,10 +151,17 @@ export async function destroy<Type extends string>(
     await scope.delete(instance[ResourceID]);
 
     if (!quiet) {
-      console.log(`Deleted: "${instance[ResourceFQN]}"`);
+      logger.task(instance[ResourceFQN], {
+        prefix: "DELETED",
+        prefixColor: "greenBright",
+        resource: formatFQN(instance[ResourceFQN]),
+        message: "Deleted Resource",
+        status: "success",
+      });
+      logger.log(`Deleted: "${instance[ResourceFQN]}"`);
     }
   } catch (error) {
-    console.error(error);
+    logger.error(error);
     throw error;
   }
 }

package/src/dns/godaddy.ts

@@ -1,3 +1,4 @@
+import { logger } from "../util/logger.ts";
 import { safeFetch } from "../util/safe-fetch.ts";
 
 export type UpdateNameserversOptions = {
@@ -23,9 +24,9 @@ export async function updateNameservers(options: UpdateNameserversOptions) {
   });
 
   if (response.ok) {
-    console.log(`✅ Nameservers updated for ${options.domain}`);
+    logger.log(`✅ Nameservers updated for ${options.domain}`);
   } else {
     const error = await response.json();
-    console.error("❌ Failed to update nameservers:", error);
+    logger.error("❌ Failed to update nameservers:", error);
   }
 }

package/src/dns/import-dns.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import { logger } from "../util/logger.ts";
 import { DEFAULT_RECORD_TYPES, type DnsRecordType } from "./record.ts";
 
 /**
@@ -195,7 +196,7 @@ export const ImportDnsRecords = Resource(
           allRecords.push(...compatRecords);
         }
       } catch (error) {
-        console.warn(
+        logger.warn(
           `Failed to fetch ${type} records for ${props.domain}:`,
           error,
         );

package/src/esbuild/bundle.ts

@@ -4,6 +4,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import { logger } from "../util/logger.ts";
 
 /**
  * Properties for creating or updating an esbuild bundle
@@ -199,7 +200,7 @@ export async function bundle(props: BundleProps) {
     metafile: true,
   };
   if (process.env.DEBUG) {
-    console.log(options);
+    logger.log(options);
   }
   const esbuild = await import("esbuild");
   return await esbuild.build(options);

package/src/fs/copy-file.ts

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import { ignore } from "../util/ignore.ts";
+import { logger } from "../util/logger.ts";
 
 /**
  * Properties for creating a CopyFile resource
@@ -107,7 +108,7 @@ export const CopyFile = Resource(
         createdAt: Date.now(),
       });
     } catch (error) {
-      console.error(`Error copying file from ${src} to ${dest}:`, error);
+      logger.error("Error copying file:", error);
       throw error;
     }
   },

package/src/fs/file.ts

@@ -3,6 +3,7 @@ import path from "node:path";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import { ignore } from "../util/ignore.ts";
+import { logger } from "../util/logger.ts";
 
 import { alchemy } from "../alchemy.ts";
 import type { FileCollection } from "./file-collection.ts";
@@ -176,7 +177,7 @@ export const File = Resource(
       this.output.path !== filePath
     ) {
       // If path has changed, delete the old file
-      console.log(
+      logger.log(
         `File: Path changed from ${this.output.path} to ${filePath}, removing old file`,
       );
       await ignore("ENOENT", async () => fs.promises.unlink(this.output.path));
@@ -186,6 +187,7 @@ export const File = Resource(
     await fs.promises.mkdir(path.dirname(filePath), {
       recursive: true,
     });
+
     await fs.promises.writeFile(filePath, props.content);
 
     return this({

package/src/github/client.ts

@@ -1,6 +1,7 @@
 import { Octokit } from "@octokit/rest";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import { logger } from "../util/logger.ts";
 
 // Convert exec to promise-based
 const execAsync = promisify(exec);
@@ -77,36 +78,36 @@ export async function verifyGitHubAuth(
     });
   } catch (error: any) {
     if (error.status === 401) {
-      console.error(
+      logger.error(
         "\n⚠️ GitHub authentication failed. Please try one of the following:",
       );
-      console.error(
+      logger.error(
         "1. Run 'gh auth login' to authenticate with the GitHub CLI",
       );
-      console.error(
+      logger.error(
         "2. Set the GITHUB_TOKEN environment variable with a personal access token",
       );
-      console.error("3. Pass a token directly to the constructor");
-      console.error(
+      logger.error("3. Pass a token directly to the constructor");
+      logger.error(
         "\nTo create a token, visit: https://github.com/settings/tokens",
       );
-      console.error(
+      logger.error(
         "Required scopes: 'repo' for private repos or 'public_repo' for public repos\n",
       );
       throw new Error("GitHub authentication failed");
     }
     if (error.status === 403) {
-      console.error(
+      logger.error(
         "\n⚠️ Insufficient permissions. You need admin access to the repository.",
       );
-      console.error(
+      logger.error(
         "Make sure your token has the 'repo' scope for private repos or 'public_repo' for public repos\n",
       );
       throw new Error("Insufficient GitHub permissions");
     }
     if (error.status === 404) {
-      console.error(`\n⚠️ Repository not found: ${owner}/${repo}`);
-      console.error(
+      logger.error(`\n⚠️ Repository not found: ${owner}/${repo}`);
+      logger.error(
         "Make sure the repository exists and you have access to it\n",
       );
       throw new Error("GitHub repository not found");

package/src/github/repository-environment.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import { logger } from "../util/logger.ts";
 import { createGitHubClient, verifyGitHubAuth } from "./client.ts";
 
 /**
@@ -198,7 +199,7 @@ export const RepositoryEnvironment = Resource(
         } catch (error: any) {
           // Ignore 404 errors (environment already deleted)
           if (error.status === 404) {
-            console.log("Environment doesn't exist, ignoring");
+            logger.log("Environment doesn't exist, ignoring");
           } else {
             throw error;
           }
@@ -447,14 +448,14 @@ export const RepositoryEnvironment = Resource(
         error.status === 403 &&
         error.message?.includes("Must have admin rights")
       ) {
-        console.error(
+        logger.error(
           "\n⚠️ Error creating/updating GitHub environment: You must have admin rights to the repository.",
         );
-        console.error(
+        logger.error(
           "Make sure your GitHub token has the required permissions (repo scope for private repos).\n",
         );
       } else {
-        console.error(
+        logger.error(
           "Error creating/updating GitHub environment:",
           error.message,
         );