alchemy 2.0.0-beta.53 → 2.0.0-beta.54

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -1,5 +1,4 @@
 import {
-  layerRuntime,
   Runtime,
   RuntimeError,
   type BindingHook,
@@ -8,6 +7,7 @@ import {
   type Module,
   type Assets as RuntimeAssets,
   type DurableObjectNamespace as RuntimeDurableObjectNamespace,
+  type QueueConsumer as RuntimeQueueConsumer,
   type RuntimeServices,
 } from "@distilled.cloud/cloudflare-runtime";
 import {
@@ -26,6 +26,7 @@ import {
   KvNamespace,
   MtlsCertificate,
   Pipelines,
+  Queue,
   R2Bucket,
   RateLimit,
   SendEmail,
@@ -44,19 +45,21 @@ import * as Equal from "effect/Equal";
 import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
 import * as Hash from "effect/Hash";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Redacted from "effect/Redacted";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
-import { AlchemyContext } from "../../AlchemyContext.ts";
 import type * as Bundle from "../../Bundle/Bundle.ts";
 import { isResolved } from "../../Diff.ts";
 import * as RpcProvider from "../../Local/RpcProvider.ts";
 import type { ResourceBinding } from "../../Resource.ts";
 import { Stack } from "../../Stack.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import { LOCAL_ENTRY_URL, LocalRuntimeState } from "../LocalRuntime.ts";
 import type { WorkerAssetsConfig, WorkerProps } from "../Workers/Worker.ts";
 import { getCompatibility } from "./Compatibility.ts";
 import * as Vite from "./Vite.ts";
@@ -79,41 +82,16 @@ export class WorkerValidationError extends Schema.TaggedErrorClass<WorkerValidat
   },
 ) {}
 
-export const localRuntimeServices = () =>
-  RpcProvider.providerServicesEffect(
-    Effect.gen(function* () {
-      const { accountId } = yield* yield* CloudflareEnvironment;
-      const { dotAlchemy } = yield* AlchemyContext;
-      const path = yield* Path.Path;
-      return layerRuntime({
-        api: {
-          accountId,
-        },
-        storage: {
-          directory: path.join(dotAlchemy, "local"),
-        },
-      });
-    }),
-  );
-
 export const LocalWorkerProvider = () =>
   RpcProvider.effect(
     Worker,
-    import.meta.resolve(
-      // `import.meta.resolve(<string>)` is a runtime API — TypeScript's
-      // `rewriteRelativeImportExtensions` does NOT touch the string literal, so
-      // we have to pick the right extension ourselves. `import.meta.url` reflects
-      // the actual on-disk extension of *this* file (`.ts` when loaded from
-      // `src/` under Bun or vitest, `.js` when loaded from the compiled `lib/`
-      // under Node), which is exactly the signal we need.
-      import.meta.url.endsWith(".ts") ? "../Local.ts" : "../Local.js",
-      import.meta.url,
-    ),
+    LOCAL_ENTRY_URL,
     Effect.gen(function* () {
       const bundler = yield* WorkerBundle;
       const runtime = yield* Runtime;
       const stack = yield* Stack;
       const path = yield* Path.Path;
+      const localRuntimeState = yield* LocalRuntimeState;
       const workerProxy = yield* WorkerProxy.WorkerProxy;
       const proxyInstances = new Map<
         string,
@@ -124,6 +102,32 @@ export const LocalWorkerProvider = () =>
         }
       >();
 
+      const getQueueConsumers = Effect.fnUntraced(function* (
+        scriptName: string,
+      ) {
+        const consumers: RuntimeQueueConsumer[] = [];
+        for (const consumer of MutableHashMap.values(
+          localRuntimeState.queueConsumers,
+        )) {
+          if (consumer.scriptName === scriptName) {
+            const queue = MutableHashMap.get(
+              localRuntimeState.queues,
+              consumer.queueId,
+            ).pipe(Option.getOrUndefined);
+            if (queue) {
+              consumers.push({
+                queueName: queue.queueName,
+                deadLetterQueue: consumer.deadLetterQueue,
+                ...consumer.settings,
+              });
+            } else {
+              return yield* Effect.die(`Queue ${consumer.queueId} not found`);
+            }
+          }
+        }
+        return consumers;
+      });
+
       const startProxy = Effect.fn(function* (
         id: string,
         serverOptions: WorkerConfig["dev"],
@@ -211,6 +215,7 @@ export const LocalWorkerProvider = () =>
             durableObjectNamespaces: toRuntimeDurableObjectNamespaces(
               worker.durableObjectNamespaces,
             ),
+            queueConsumers: yield* getQueueConsumers(worker.name),
             modules: yield* toRuntimeModules(bundle),
             assets: toRuntimeAssets(worker.assets),
           })
@@ -392,6 +397,7 @@ export const LocalWorkerProvider = () =>
                 worker.durableObjectNamespaces,
               ),
               hyperdrives: worker.hyperdrives,
+              queueConsumers: yield* getQueueConsumers(worker.name),
               assets: toRuntimeAssets(worker.assets),
             },
             context,
@@ -586,7 +592,10 @@ const toRuntimeBinding = Effect.fnUntraced(function* (b: WorkerBinding) {
     case "plain_text":
       return Text.local(b.name, b.text);
     case "queue":
-      return yield* unsupported();
+      return Queue.local({
+        binding: b.name,
+        queueName: b.queueName,
+      });
     case "r2_bucket":
       return R2Bucket.remote(b.name, b.bucketName, b.jurisdiction);
     case "ratelimit":

package/src/Cloudflare/Workers/Worker.ts

@@ -6,20 +6,19 @@ import type { ConfigError } from "effect/Config";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 import * as Predicate from "effect/Predicate";
 import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
 import * as crypto from "node:crypto";
 import { Unowned } from "../../AdoptPolicy.ts";
-import { AlchemyContext } from "../../AlchemyContext.ts";
 import * as Artifacts from "../../Artifacts.ts";
 import { hashDirectory, type MemoOptions } from "../../Build/Memo.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
 import { isResolved } from "../../Diff.ts";
 import type { InputProps } from "../../Input.ts";
+import * as ProviderLayer from "../../Local/ProviderLayer.ts";
 import { Platform, type Main, type PlatformProps } from "../../Platform.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource, type ResourceBinding } from "../../Resource.ts";
@@ -36,10 +35,7 @@ import {
 } from "./Assets.ts";
 import { getCompatibility } from "./Compatibility.ts";
 import { isDurableObjectExport } from "./DurableObjectNamespace.ts";
-import {
-  LocalWorkerProvider,
-  localRuntimeServices,
-} from "./LocalWorkerProvider.ts";
+import { LocalWorkerProvider } from "./LocalWorkerProvider.ts";
 import { Request } from "./Request.ts";
 import * as Vite from "./Vite.ts";
 import {
@@ -743,27 +739,10 @@ class MissingDurableObjectNamespaces extends Data.TaggedError(
   expected: string[];
 }> {}
 
-const selectLayer = <
-  LayerLive extends Layer.Layer<any, any, any>,
-  LayerDev extends Layer.Layer<any, any, any>,
->(input: {
-  live: () => LayerLive;
-  dev: () => LayerDev;
-}): Layer.Layer<
-  Layer.Success<LayerLive | LayerDev>,
-  Layer.Error<LayerLive | LayerDev>,
-  Layer.Services<LayerLive | LayerDev> | AlchemyContext
-> =>
-  Layer.unwrap(
-    AlchemyContext.useSync((context) =>
-      context.dev ? input.dev() : input.live(),
-    ),
-  );
-
 export const WorkerProvider = () =>
-  selectLayer({
-    live: LiveWorkerProvider,
-    dev: () => Layer.provide(LocalWorkerProvider(), localRuntimeServices()),
+  ProviderLayer.select({
+    live: () => LiveWorkerProvider(),
+    local: () => LocalWorkerProvider(),
   });
 
 export const LiveWorkerProvider = () =>

package/src/Local/ProviderLayer.ts

@@ -0,0 +1,22 @@
+import * as Layer from "effect/Layer";
+import { AlchemyContext } from "../AlchemyContext.ts";
+
+/**
+ * Returns a layer that selects the live or local provider based on the `AlchemyContext.dev` flag.
+ */
+export const select = <
+  LayerLive extends Layer.Layer<any, any, any>,
+  LayerLocal extends Layer.Layer<any, any, any>,
+>(input: {
+  live: () => LayerLive;
+  local: () => LayerLocal;
+}): Layer.Layer<
+  Layer.Success<LayerLive | LayerLocal>,
+  Layer.Error<LayerLive | LayerLocal>,
+  Layer.Services<LayerLive | LayerLocal> | AlchemyContext
+> =>
+  Layer.unwrap(
+    AlchemyContext.useSync((context) =>
+      context.dev ? input.local() : input.live(),
+    ),
+  );

package/src/Local/RpcProvider.ts

@@ -76,6 +76,7 @@ export const effect = <
     cls,
     Effect.gen(function* () {
       const client = yield* Effect.serviceOption(RpcProviderProxy);
+      const context = yield* Effect.context();
       const stack = yield* Stack;
 
       if (client._tag === "None") {
@@ -87,6 +88,7 @@ export const effect = <
             return (...args: any[]) => {
               const result = value(...args);
               const services = Layer.mergeAll(
+                Layer.succeedContext(context),
                 layerFallback(Stack, stack),
                 layerFallback(Stage, stack.stage),
                 Predicate.hasProperty(args[0], "instanceId") &&

package/src/Local/RpcProviderProxy.ts

@@ -1,4 +1,4 @@
-import { newWebSocketRpcSession, type RpcStub } from "capnweb";
+import { newWebSocketRpcSession } from "capnweb";
 import * as Cache from "effect/Cache";
 import * as Config from "effect/Config";
 import * as Context from "effect/Context";
@@ -42,7 +42,7 @@ const make = Effect.fnUntraced(function* (spawnerUrl: string) {
         body: yield* HttpBody.json(payload),
       });
       const websocketUrl = yield* response.text;
-      return newWebSocketRpcSession(websocketUrl) as RpcStub<RpcProxyApi>;
+      return newWebSocketRpcSession<RpcProxyApi>(websocketUrl);
     },
     (effect, serverEntryUrl) =>
       Effect.catch(effect, (error) =>

package/src/Local/RpcSerialization.ts

@@ -64,7 +64,7 @@ export const wrapRpcHandlers = <T extends Record<string, any>>(
         ? streamKeys?.includes(key)
           ? wrapRpcStreamHandler(value)
           : wrapRpcEffectHandler(value)
-        : typeof value === "object" && value !== null
+        : typeof value === "object" && value !== null && !Array.isArray(value)
           ? wrapRpcHandlers(value)
           : value,
     ]),
@@ -82,7 +82,7 @@ export const unwrapRpcHandlers = <T extends Record<string, any>>(
         ? streamKeys?.includes(key)
           ? unwrapRpcStreamHandler(value)
           : unwrapRpcEffectHandler(value)
-        : typeof value === "object" && value !== null
+        : typeof value === "object" && value !== null && !Array.isArray(value)
           ? unwrapRpcHandlers(value)
           : value,
     ]),

package/src/Planetscale/Branch.ts

@@ -1,6 +1,7 @@
 import * as planetscale from "@distilled.cloud/planetscale";
 import { Credentials } from "@distilled.cloud/planetscale/Credentials";
 import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
 import { Unowned } from "../AdoptPolicy.ts";
 import { isResolved } from "../Diff.ts";
 import { createPhysicalName } from "../PhysicalName.ts";
@@ -157,6 +158,20 @@ export interface BranchMigrationRunners {
 
 const rootDir = Effect.sync(() => process.cwd());
 
+/**
+ * Matches the UnprocessableEntity errors PlanetScale returns when a
+ * branch promotion/demotion races an in-flight cluster resize, e.g.
+ * "Branches with a cluster resize in progress cannot be demoted."
+ */
+const isResizeInProgress = (error: unknown): boolean =>
+  typeof error === "object" &&
+  error !== null &&
+  (error as { readonly _tag?: unknown })._tag === "UnprocessableEntity" &&
+  typeof (error as { readonly message?: unknown }).message === "string" &&
+  (error as { readonly message: string }).message.includes(
+    "cluster resize in progress",
+  );
+
 /**
  * Build a branch provider for a specific PlanetScale engine. The
  * caller supplies the typed `Resource` token and the engine's migration
@@ -369,17 +384,30 @@ export const makeBranchProvider = <R extends ResourceLike>(opts: {
       if (opts.expectedKind === "mysql") {
         const desiredProduction = news.isProduction ?? false;
         if (current.production !== desiredProduction) {
+          // A keyspace can report `resizing: false` while the resize
+          // workflow is still finalizing, during which promote/demote is
+          // rejected with an UnprocessableEntity. Retry until it clears.
+          const retryWhileResizing = Effect.retry({
+            while: isResizeInProgress,
+            schedule: Schedule.spaced("5 seconds").pipe(
+              Schedule.both(Schedule.recurs(120)),
+            ),
+          });
           current = desiredProduction
-            ? yield* planetscale.promoteBranch({
-                organization,
-                database: databaseName,
-                branch: branchName,
-              })
-            : yield* planetscale.demoteBranch({
-                organization,
-                database: databaseName,
-                branch: branchName,
-              });
+            ? yield* planetscale
+                .promoteBranch({
+                  organization,
+                  database: databaseName,
+                  branch: branchName,
+                })
+                .pipe(retryWhileResizing)
+            : yield* planetscale
+                .demoteBranch({
+                  organization,
+                  database: databaseName,
+                  branch: branchName,
+                })
+                .pipe(retryWhileResizing);
         }
       }
 

package/src/Planetscale/Database.ts

@@ -65,7 +65,7 @@ export interface BaseDatabaseProps {
 
   /**
    * Name of the table used to track applied migrations.
-   * @default "planetscale_migrations"
+   * @default "__alchemy_migrations"
    */
   migrationsTable?: string;
 

package/src/Planetscale/Postgres/PostgresClusterSize.ts

@@ -1,6 +1,7 @@
 import * as planetscale from "@distilled.cloud/planetscale";
 import * as Effect from "effect/Effect";
-import { pollUntil } from "../Util.ts";
+import * as Schedule from "effect/Schedule";
+import { pollUntil, waitForBranchReady } from "../Util.ts";
 
 /**
  * Available PlanetScale PostgreSQL cluster sizes.
@@ -54,6 +55,15 @@ export function toPostgresClusterSku(input: {
   return `${size}_${provider}_${arch}`;
 }
 
+/**
+ * Schedule for polling branch change requests. Postgres cluster resizes
+ * routinely take longer than the default 10-minute polling budget, so
+ * give change requests a 60-minute budget (720 × 5s).
+ */
+const changeRequestSchedule = Schedule.spaced("5 seconds").pipe(
+  Schedule.both(Schedule.recurs(720)),
+);
+
 /**
  * Polls branch change requests until all visible changes are in a terminal
  * state (`completed` or `canceled`), or — if `changeId` is provided — until
@@ -85,6 +95,7 @@ export const waitForPendingPostgresChanges = Effect.fn(function* (
 
       return page.data.every((change) => isTerminal(change.state));
     },
+    changeRequestSchedule,
   );
 });
 
@@ -98,7 +109,10 @@ export const ensurePostgresProductionBranchClusterSize = Effect.fn(function* (
   branch: string,
   expectedClusterSize: PostgresClusterSize,
 ) {
-  const data = yield* planetscale.getBranch({ organization, database, branch });
+  // A freshly-forked branch can't accept (or complete) change requests
+  // until it has finished provisioning — queueing a resize against it
+  // just leaves the change pending until the poll budget runs out.
+  const data = yield* waitForBranchReady(organization, database, branch);
 
   const sku = toPostgresClusterSku({
     size: expectedClusterSize,

package/src/Planetscale/Util.ts

@@ -12,7 +12,7 @@ export const DEFAULT_MIGRATIONS_TABLE = "__alchemy_migrations";
  * been reached. Used internally with `Effect.retry` to drive long-running
  * status waits.
  */
-class NotReady extends Data.TaggedError("Planetscale::NotReady")<{
+export class NotReady extends Data.TaggedError("Planetscale::NotReady")<{
   description: string;
 }> {}
 
@@ -29,12 +29,14 @@ export class PlanetscaleConflict extends Data.TaggedError(
 }> {}
 
 /**
- * Default polling schedule: 5s spaced retries with a 10-minute total
- * budget (120 × 5s). Avoids the exponential-blowup trap where later
- * iterations would wait hours, indistinguishable from a hang.
+ * Default polling schedule: 5s spaced retries with a 30-minute total
+ * budget (360 × 5s). Avoids the exponential-blowup trap where later
+ * iterations would wait hours, indistinguishable from a hang. Postgres
+ * database creates routinely run 10-12 minutes, so a 10-minute budget
+ * regularly false-positives as "stuck".
  */
 const defaultSchedule = Schedule.spaced("5 seconds").pipe(
-  Schedule.both(Schedule.recurs(120)),
+  Schedule.both(Schedule.recurs(360)),
 );
 
 /**