alchemy 0.70.1 → 0.71.0

package/src/cloudflare/queue-consumer.ts

@@ -318,7 +318,7 @@ export async function createQueueConsumer(
         typeof props.settings.deadLetterQueue === "string"
           ? props.settings.deadLetterQueue
           : props.settings.deadLetterQueue.name;
-      createPayload.settings.dead_letter_queue = dlqName;
+      createPayload.dead_letter_queue = dlqName;
     }
   }
 
@@ -405,7 +405,7 @@ async function updateQueueConsumer(
         typeof props.settings.deadLetterQueue === "string"
           ? props.settings.deadLetterQueue
           : props.settings.deadLetterQueue.name;
-      updatePayload.settings.dead_letter_queue = dlqName;
+      updatePayload.dead_letter_queue = dlqName;
     }
   }
 

package/src/cloudflare/worker-loader.ts

@@ -0,0 +1,12 @@
+/**
+ * A binding for dynamic worker loaders.
+ *
+ */
+export type WorkerLoader = {
+  type: "worker_loader";
+};
+export function WorkerLoader(): WorkerLoader {
+  return {
+    type: "worker_loader",
+  };
+}

package/src/cloudflare/worker-metadata.ts

@@ -1,4 +1,5 @@
 import { assertNever } from "../util/assert-never.ts";
+import { camelToSnakeObjectDeep } from "../util/camel-to-snake.ts";
 import { logger } from "../util/logger.ts";
 import { memoize } from "../util/memoize.ts";
 import { extractCloudflareResult } from "./api-response.ts";
@@ -180,8 +181,20 @@ export interface WorkerMetadata {
   compatibility_date: string;
   compatibility_flags?: string[];
   bindings: WorkerBindingSpec[];
-  observability: {
-    enabled: boolean;
+  observability?: {
+    enabled?: boolean;
+    head_sampling_rate?: number;
+    logs?: {
+      enabled?: boolean;
+      head_sampling_rate?: number;
+      invocation_logs?: boolean;
+    };
+    traces?: {
+      enabled?: boolean;
+      head_sampling_rate?: number;
+      persist?: boolean;
+      destinations?: string[];
+    };
   };
   logpush?: boolean;
   migrations?: SingleStepMigration;
@@ -235,6 +248,7 @@ export async function prepareWorkerMetadata(
       ...(oldSettings?.tags ?? []),
     ]),
   );
+
   const oldBindings = oldSettings?.bindings;
   // we use Cloudflare Worker tags to store a mapping between Alchemy's stable identifier and the binding name
   // e.g.
@@ -315,6 +329,8 @@ export async function prepareWorkerMetadata(
     return [];
   });
 
+  const observability = camelToSnakeObjectDeep(props.observability);
+
   // Prepare metadata with bindings
   const meta: WorkerMetadata = {
     compatibility_date: props.compatibilityDate,
@@ -324,7 +340,8 @@ export async function prepareWorkerMetadata(
     ),
     bindings: [],
     observability: {
-      enabled: props.observability?.enabled !== false,
+      ...observability,
+      enabled: observability?.enabled !== false,
     },
     logpush: props.logpush ?? false,
     // TODO(sam): base64 encode instead? 0 collision risk vs readability.
@@ -551,6 +568,11 @@ export async function prepareWorkerMetadata(
         name: bindingName,
         namespace: binding.namespaceName,
       });
+    } else if (binding.type === "worker_loader") {
+      meta.bindings.push({
+        type: "worker_loader",
+        name: bindingName,
+      });
     } else if (binding.type === "secret_key") {
       meta.bindings.push({
         type: "secret_key",

package/src/cloudflare/worker-stub.ts

@@ -128,7 +128,7 @@ export const WorkerStub = Resource("cloudflare::WorkerStub", async function <
   } as WorkerStub<RPC>;
 });
 
-async function exists(
+export async function exists(
   api: CloudflareApi,
   workerName: string,
 ): Promise<boolean> {
@@ -145,9 +145,10 @@ async function exists(
   }
 }
 
-async function createEmptyWorker(
+export async function createEmptyWorker(
   api: CloudflareApi,
   workerName: string,
+  version?: string,
 ): Promise<void> {
   // Minimal empty worker script
   const emptyScript = `export default { 
@@ -178,6 +179,12 @@ async function createEmptyWorker(
           main_module: "worker.js",
           compatibility_date: "2025-04-20",
           bindings: [],
+          ...(version != null && {
+            annotations: {
+              "workers/tag": version,
+              "workers/message": `Version ${version}`,
+            },
+          }),
         }),
       ],
       {
@@ -189,14 +196,24 @@ async function createEmptyWorker(
   // Upload worker script
   await extractCloudflareResult(
     `create empty worker "${workerName}"`,
-    api.put(
-      `/accounts/${api.accountId}/workers/scripts/${workerName}`,
-      formData,
-      {
-        headers: {
-          "Content-Type": "multipart/form-data",
-        },
-      },
-    ),
+    version != null
+      ? api.post(
+          `/accounts/${api.accountId}/workers/scripts/${workerName}/versions`,
+          formData,
+          {
+            headers: {
+              "Content-Type": "multipart/form-data",
+            },
+          },
+        )
+      : api.put(
+          `/accounts/${api.accountId}/workers/scripts/${workerName}`,
+          formData,
+          {
+            headers: {
+              "Content-Type": "multipart/form-data",
+            },
+          },
+        ),
   );
 }

package/src/cloudflare/worker-subdomain.ts

@@ -111,7 +111,7 @@ export async function enableWorkerSubdomain(
         ),
       ),
     (error) => error instanceof CloudflareApiError && error.status === 404,
-    10,
+    20,
     1000,
   );
 }

package/src/cloudflare/worker.ts

@@ -61,6 +61,7 @@ import { Workflow, isWorkflow, upsertWorkflow } from "./workflow.ts";
 import "../esbuild/bundle.ts";
 import { Scope } from "../scope.ts";
 import type { WorkerRef } from "./worker-ref.ts";
+import { createEmptyWorker, exists } from "./worker-stub.ts";
 
 /**
  * Configuration options for static assets
@@ -166,18 +167,12 @@ export interface BaseWorkerProps<
   url?: boolean;
 
   /**
-   * Observability configuration for the worker
+   * Specify the observability behavior of the Worker.
    *
-   * Controls whether worker logs are enabled
-   * @default { enabled: true }
+   * @see https://developers.cloudflare.com/workers/wrangler/configuration/#observability
+   * @default - `enabled: true`
    */
-  observability?: {
-    /**
-     * Whether to enable worker logs
-     * @default true
-     */
-    enabled?: boolean;
-  };
+  observability?: WorkerObservability;
 
   /**
    * Enable Workers Logpush to export trace events (request/response metadata,
@@ -393,6 +388,85 @@ export interface BaseWorkerProps<
   tailConsumers?: Array<Worker | { service: string }>;
 }
 
+export interface WorkerObservability {
+  /**
+   * If observability is enabled for this Worker
+   *
+   * @default true
+   */
+  enabled?: boolean;
+
+  /**
+   * A number between 0 and 1, where 0 indicates zero out of one hundred requests are logged, and 1 indicates every request is logged.
+   * If head_sampling_rate is unspecified, it is configured to a default value of 1 (100%).
+   * @see https://developers.cloudflare.com/workers/observability/logs/workers-logs/#head-based-sampling
+   * @default 1
+   */
+  headSamplingRate?: number;
+
+  /**
+   * Configuration for worker logs
+   */
+  logs?: {
+    /**
+     * Whether logs are enabled
+     * @default true
+     */
+    enabled?: boolean;
+
+    /**
+     * The sampling rate for logs
+     */
+    headSamplingRate?: number;
+
+    /**
+     * Set to false to disable invocation logs
+     * @default true
+     */
+    invocationLogs?: boolean;
+
+    /**
+     * If logs should be persisted to the Cloudflare observability platform where they can be queried in the dashboard.
+     * @default true
+     */
+    persist?: boolean;
+
+    /**
+     * What destinations logs emitted from the Worker should be sent to.
+     * @default []
+     */
+    destinations?: string[];
+  };
+
+  /**
+   * Configuration for worker traces
+   */
+  traces?: {
+    /**
+     * Whether traces are enabled
+     * @default true
+     */
+    enabled?: boolean;
+
+    /**
+     * The sampling rate for traces
+     */
+    headSamplingRate?: number;
+
+    /**
+     * If traces should be persisted to the Cloudflare observability platform where they can be queried in the dashboard.
+     * @default true
+     */
+    persist?: boolean;
+
+    /**
+     * What destinations traces emitted from the Worker should be sent to.
+     * @default []
+     */
+    destinations?: string[];
+  };
+}
+
 export interface InlineWorkerProps<
   B extends Bindings | undefined = Bindings,
   RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
@@ -863,13 +937,20 @@ const _Worker = Resource(
         durableObjects: options.durableObjects,
         workflows: options.workflows,
       });
-      if (!props.version && this.output?.dev?.hasRemote !== false) {
+      if (this.output?.dev?.hasRemote !== false) {
         const api = await createCloudflareApi(props);
-        await deleteQueueConsumers(api, options.name);
-        await deleteWorker(api, {
-          scriptName: options.name,
-          dispatchNamespace: options.dispatchNamespace,
-        });
+        if (props.version) {
+          //* if the worker exists we deploy an empty version so we can destroy
+          if (await exists(api, options.name)) {
+            await createEmptyWorker(api, options.name, props.version);
+          }
+        } else {
+          await deleteQueueConsumers(api, options.name);
+          await deleteWorker(api, {
+            scriptName: options.name,
+            dispatchNamespace: options.dispatchNamespace,
+          });
+        }
       }
       return this.destroy();
     }
@@ -901,9 +982,11 @@ const _Worker = Resource(
           bundle,
           port: props.dev?.port,
           tunnel: props.dev?.tunnel ?? this.scope.tunnel,
+          cwd: props.cwd ?? process.cwd(),
         });
         this.onCleanup(() => controller.dispose());
       }
+
       await provisionResources(
         {
           ...props,
@@ -1159,12 +1242,18 @@ async function provisionResources<B extends Bindings>(
     containers: options.containers,
     domains: props.domains?.map((domain) => {
       if (typeof domain === "string") {
+        if (domain === "") {
+          throw new Error("Domain names cannot be empty strings");
+        }
         return {
           name: domain,
           zoneId: undefined,
           adopt: props.adopt,
         };
       }
+      if (domain.domainName === "") {
+        throw new Error("Domain names cannot be empty strings");
+      }
       return {
         name: domain.domainName,
         zoneId: domain.zoneId,
@@ -1607,7 +1696,7 @@ async function assertWorkerDoesNotExist(
   );
 }
 
-async function getScriptMetadata(
+export async function getScriptMetadata(
   api: CloudflareApi,
   scriptName: string,
 ): Promise<WorkerScriptMetadata | undefined> {

package/src/cloudflare/wrangler.json.ts

@@ -376,6 +376,10 @@ export interface WranglerJsonSpec {
     entrypoint?: string;
   }[];
 
+  worker_loaders?: {
+    binding: string;
+  }[];
+
   /**
    * Workflow bindings
    */
@@ -627,6 +631,9 @@ function processBindings(
   const containers: {
     class_name: string;
   }[] = [];
+  const workerLoaders: {
+    binding: string;
+  }[] = [];
 
   for (const eventSource of eventSources ?? []) {
     if (isQueueEventSource(eventSource)) {
@@ -850,6 +857,10 @@ function processBindings(
       containers.push({
         class_name: binding.className,
       });
+    } else if (binding.type === "worker_loader") {
+      workerLoaders.push({
+        binding: bindingName,
+      });
     } else {
       console.log("binding", binding);
       // biome-ignore lint/correctness/noVoidTypeReturn: it returns never
@@ -930,4 +941,8 @@ function processBindings(
       bindings: unsafeBindings,
     };
   }
+
+  if (workerLoaders.length > 0) {
+    spec.worker_loaders = workerLoaders;
+  }
 }

package/src/github/comment.ts

@@ -173,17 +173,17 @@ export const GitHubComment = Resource(
     props: GitHubCommentProps,
   ): Promise<GitHubComment> {
     // Create authenticated Octokit client - will automatically handle token resolution
-    const octokit = await createGitHubClient({
-      token: props.token?.unencrypted,
-    });
-
-    // Verify authentication and permissions
-    if (!this.quiet) {
-      await verifyGitHubAuth(octokit, props.owner, props.repository);
-    }
 
     if (this.phase === "delete") {
       if (this.output?.commentId && props.allowDelete) {
+        const octokit = await createGitHubClient({
+          token: props.token?.unencrypted,
+        });
+
+        // Verify authentication and permissions
+        if (!this.quiet) {
+          await verifyGitHubAuth(octokit, props.owner, props.repository);
+        }
         try {
           // Delete the comment
           await octokit.rest.issues.deleteComment({
@@ -209,6 +209,15 @@ export const GitHubComment = Resource(
       return this.destroy();
     }
 
+    const octokit = await createGitHubClient({
+      token: props.token?.unencrypted,
+    });
+
+    // Verify authentication and permissions
+    if (!this.quiet) {
+      await verifyGitHubAuth(octokit, props.owner, props.repository);
+    }
+
     try {
       if (this.phase === "update" && this.output?.commentId) {
         // Update existing comment

package/src/scope.ts

@@ -30,6 +30,7 @@ import { logger } from "./util/logger.ts";
 import { AsyncMutex } from "./util/mutex.ts";
 import { ALCHEMY_ROOT } from "./util/root-dir.ts";
 import { createAndSendEvent } from "./util/telemetry.ts";
+import { validateResourceID } from "./util/validate-resource-id.ts";
 
 export class RootScopeStateAttemptError extends Error {
   constructor() {
@@ -265,21 +266,17 @@ export class Scope {
     // Store provider credentials (TypeScript ensures no conflicts with core options)
     this.providerCredentials = providerCredentials as ProviderCredentials;
 
-    const isChild = this.parent !== undefined;
-    if (this.scopeName?.includes(":") && isChild) {
-      // TODO(sam): relax this constraint once we move to SQLite3 store
-      throw new Error(
-        `Scope name "${this.scopeName}" cannot contain double colons`,
-      );
-    }
-
     this.stage = stage ?? this.parent?.stage ?? DEFAULT_STAGE;
     this.profile = profile ?? this.parent?.profile;
     this.parent?.children.set(this.scopeName!, this);
     this.quiet = quiet ?? this.parent?.quiet ?? false;
-    if (this.parent && !this.scopeName) {
-      throw new Error("Scope name is required when creating a child scope");
+    if (this.parent) {
+      if (!this.scopeName) {
+        throw new Error("Scope name is required when creating a child scope");
+      }
+      validateResourceID(this.scopeName, "Scope");
     }
+
     this.password = password ?? this.parent?.password;
     this.noTrack = noTrack ?? this.parent?.noTrack ?? false;
     const resolvedPhase = phase ?? this.parent?.phase;

package/src/util/camel-to-snake.ts

@@ -0,0 +1,88 @@
+export interface LogPushProps {
+  maxFooBar: string;
+}
+
+export function camelToSnakeObjectDeep<T extends object | undefined>(
+  obj: T,
+): T extends undefined ? undefined : CamelToSnake<T> {
+  return (
+    obj
+      ? Object.fromEntries(
+          Object.entries(obj).map(([key, value]) => [
+            key
+              .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2") // Handle consecutive capitals: "FOOBar" -> "FOO_Bar"
+              .replace(/([a-z])([A-Z])/g, "$1_$2") // Handle normal camelCase: "fooBar" -> "foo_Bar"
+              .toLowerCase(),
+            Array.isArray(value)
+              ? value.map(camelToSnakeObjectDeep)
+              : typeof value === "object" && value !== null
+                ? camelToSnakeObjectDeep(value)
+                : value,
+          ]),
+        )
+      : undefined
+  ) as T extends undefined ? undefined : CamelToSnake<T>;
+}
+
+// Helper to check if a character is uppercase
+type IsUpper<C extends string> = C extends Uppercase<C>
+  ? C extends Lowercase<C>
+    ? false // Not a letter
+    : true // Uppercase letter
+  : false;
+
+// Helper to check if a character is lowercase
+type IsLower<C extends string> = C extends Lowercase<C>
+  ? C extends Uppercase<C>
+    ? false // Not a letter
+    : true // Lowercase letter
+  : false;
+
+// Convert a camelCase string to snake_case at the type level
+type CamelToSnakeString<
+  S extends string,
+  Acc extends string = "",
+> = S extends `${infer First}${infer Second}${infer Rest}`
+  ? IsUpper<First> extends true
+    ? IsUpper<Second> extends true
+      ? // FOO... pattern - check if next char is lowercase
+        Rest extends `${infer Third}${infer _}`
+        ? IsLower<Third> extends true
+          ? // FOOBar -> add First, add _, add Second lowercase, continue with Rest
+            CamelToSnakeString<
+              Rest,
+              `${Acc}${Lowercase<First>}_${Lowercase<Second>}`
+            >
+          : // FOO -> continue
+            CamelToSnakeString<`${Second}${Rest}`, `${Acc}${Lowercase<First>}`>
+        : // Only two chars left, both upper
+          CamelToSnakeString<`${Second}${Rest}`, `${Acc}${Lowercase<First>}`>
+      : // FooBar or Foo - add underscore before uppercase if not at start
+        CamelToSnakeString<
+          `${Second}${Rest}`,
+          Acc extends "" ? `${Lowercase<First>}` : `${Acc}_${Lowercase<First>}`
+        >
+    : IsLower<First> extends true
+      ? IsUpper<Second> extends true
+        ? // fooBar -> just add the lowercase char, underscore will be added when processing uppercase
+          CamelToSnakeString<`${Second}${Rest}`, `${Acc}${First}`>
+        : // foobar -> continue
+          CamelToSnakeString<`${Second}${Rest}`, `${Acc}${First}`>
+      : // Number or special char
+        CamelToSnakeString<`${Second}${Rest}`, `${Acc}${First}`>
+  : S extends `${infer Last}`
+    ? `${Acc}${Lowercase<Last>}`
+    : Acc;
+
+// Deep transformation for objects
+type CamelToSnake<T> = T extends object
+  ? T extends Array<infer U>
+    ? Array<CamelToSnake<U>>
+    : T extends Date | RegExp | Function
+      ? T // Don't transform special object types
+      : {
+          [K in keyof T as K extends string
+            ? CamelToSnakeString<K>
+            : K]: CamelToSnake<T[K]>;
+        }
+  : T;

package/src/util/retry.ts

@@ -14,6 +14,7 @@ export async function withExponentialBackoff<T>(
   isRetryable: (error: any) => any,
   maxAttempts = 5,
   initialDelayMs = 100,
+  maxDelayMs = 10000,
 ): Promise<T> {
   let attempt = 0;
   let delay = initialDelayMs;
@@ -31,7 +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
+      delay = Math.min(delay, maxDelayMs); // Cap at 10 seconds
     }
   }
 }

package/src/util/validate-resource-id.ts

@@ -0,0 +1,10 @@
+export function validateResourceID(id: string, qualifier = "Resource"): void {
+  //todo(sam): during effect rewrite, this should be much more limiting
+  //todo:      its hard to undo the flexibility we've offered to users now
+  if (!id) {
+    throw new Error(`${qualifier} ID cannot be an empty string: "${id}"`);
+  }
+  if (id.includes(":")) {
+    throw new Error(`${qualifier} ID cannot include colons: "${id}"`);
+  }
+}

package/workers/tunnel-proxy.js

@@ -34,7 +34,7 @@ var h={async fetch(e,r){let n=new URL(e.url);n.host=r.TUNNEL_HOST;let l=new Head
             Alchemy</a>.</p>
       </div>
       <div class="bg-slate-200 px-5 py-3 flex flex-col w-full max-w-lg">
-        <p class="text-sm text-slate-500">Alchemy 0.70.1</p>
+        <p class="text-sm text-slate-500">Alchemy 0.71.0</p>
       </div>
     </div>
   </body>