alchemy 0.70.2 → 0.71.0

package/src/cloudflare/miniflare/build-worker-options.ts

@@ -1,4 +1,5 @@
 import * as miniflare from "miniflare";
+import path from "pathe";
 import { assertNever } from "../../util/assert-never.ts";
 import type { HTTPServer } from "../../util/http.ts";
 import { logger } from "../../util/logger.ts";
@@ -26,6 +27,7 @@ export interface MiniflareWorkerInput {
   bundle: WorkerBundleSource;
   port: number | undefined;
   tunnel: boolean | undefined;
+  cwd: string;
 }
 
 type RemoteOnlyBindingType =
@@ -78,11 +80,6 @@ export const buildWorkerOptions = async (
         proxy: true,
       },
     ],
-    containerEngine: {
-      localDocker: {
-        socketPath: await getDockerSocketPath(),
-      },
-    },
     // This exposes the worker as a route that can be accessed by setting the MF-Route-Override header.
     routes: [input.name],
   };
@@ -119,7 +116,7 @@ export const buildWorkerOptions = async (
       case "assets": {
         options.assets = {
           binding: key,
-          directory: binding.path,
+          directory: path.resolve(input.cwd, binding.path),
           assetConfig: {
             html_handling: input.assets?.html_handling,
             not_found_handling: input.assets?.not_found_handling,
@@ -144,6 +141,11 @@ export const buildWorkerOptions = async (
             imageName: binding.image.imageRef,
           },
         };
+        options.containerEngine = {
+          localDocker: {
+            socketPath: await getDockerSocketPath(),
+          },
+        };
         break;
       }
       case "d1": {
@@ -268,6 +270,10 @@ export const buildWorkerOptions = async (
             type: "r2_bucket",
             name: key,
             bucket_name: binding.name,
+            jurisdiction:
+              binding.jurisdiction === "default"
+                ? undefined
+                : binding.jurisdiction,
             raw: true,
           });
         } else {
@@ -308,6 +314,10 @@ export const buildWorkerOptions = async (
         };
         break;
       }
+      case "worker_loader": {
+        (options.workerLoaders ??= {})[key] = {};
+        break;
+      }
       case "workflow": {
         (options.workflows ??= {})[key] = {
           name: binding.workflowName,
@@ -329,11 +339,13 @@ export const buildWorkerOptions = async (
       );
     }
     if (isQueueEventSource(eventSource)) {
+      const dlq = eventSource.settings?.deadLetterQueue;
       (options.queueConsumers ??= {})[queue.name] = {
         maxBatchSize: eventSource.settings?.batchSize,
         maxBatchTimeout: eventSource.settings?.maxWaitTimeMs,
         maxRetries: eventSource.settings?.maxRetries,
         retryDelay: eventSource.settings?.retryDelay,
+        deadLetterQueue: typeof dlq === "string" ? dlq : dlq?.name,
       };
     } else {
       (options.queueConsumers ??= {})[eventSource.name] = {};

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

@@ -82,6 +82,8 @@ export async function createRemoteProxyWorker(input: {
         headers,
         body: req.body,
         redirect: "manual",
+        // @ts-expect-error - caused by @cloudflare/workers-types
+        duplex: req.body ? "half" : undefined,
       });
 
       const responseHeaders = new Headers(res.headers);

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

@@ -568,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-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

@@ -982,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,
@@ -1240,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,

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/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.2</p>
+        <p class="text-sm text-slate-500">Alchemy 0.71.0</p>
       </div>
     </div>
   </body>