alchemy 2.0.0-beta.39 → 2.0.0-beta.40

package/src/Cloudflare/Local/SidecarHandlers.ts

@@ -1,79 +1,221 @@
-import * as Server from "@distilled.cloud/cloudflare-runtime/Server";
-import type { WorkerModule } from "@distilled.cloud/cloudflare-runtime/WorkerModule";
+import {
+  Runtime,
+  type BindingHook,
+  type BindingServices,
+  type HyperdriveOrigin,
+  type Module,
+  type Assets as RuntimeAssets,
+  type DurableObjectNamespace as RuntimeDurableObjectNamespace,
+  type RuntimeServices,
+} from "@distilled.cloud/cloudflare-runtime";
+import {
+  Ai,
+  Assets,
+  Browser,
+  D1,
+  Data,
+  DurableObjectNamespace,
+  Hyperdrive,
+  Images,
+  Json,
+  KvNamespace,
+  R2Bucket,
+  Service,
+  Text,
+  VersionMetadata,
+  WasmModule,
+  WorkerLoader,
+} from "@distilled.cloud/cloudflare-runtime/bindings";
+import * as LocalProxy from "@distilled.cloud/cloudflare-runtime/proxy/LocalProxy";
 import * as Cause from "effect/Cause";
-import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
 import * as Hash from "effect/Hash";
 import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Redacted from "effect/Redacted";
 import * as Result from "effect/Result";
 import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
-import * as Bundle from "../../Bundle/Bundle.ts";
-import { WorkerBundle } from "../Workers/WorkerBundle.ts";
+import type * as Bundle from "../../Bundle/Bundle.ts";
+import { InstanceId } from "../../InstanceId.ts";
+import { Stack } from "../../Stack.ts";
+import { Stage } from "../../Stage.ts";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import { getCompatibility } from "../Workers/Compatibility.ts";
+import { getCronBindings } from "../Workers/index.ts";
+import * as Vite from "../Workers/Vite.ts";
+import type {
+  Worker,
+  WorkerAssetsConfig,
+  WorkerBinding,
+} from "../Workers/Worker.ts";
 import {
+  WorkerBundle,
+  type WorkerBundleOptions,
+} from "../Workers/WorkerBundle.ts";
+import { createWorkerName } from "../Workers/WorkerName.ts";
+import {
+  ServeError,
+  ServeResult,
   Sidecar,
-  type ServeError,
-  type ServeOptions,
-  type ServeResult,
+  ValidationError,
+  type ReconcileOptions,
 } from "./Sidecar.ts";
 
 export const SidecarHandlers = Layer.effect(
   Sidecar,
   Effect.gen(function* () {
-    const bundle = yield* WorkerBundle;
-    const server = yield* Server.Server;
+    const { accountId } = yield* CloudflareEnvironment;
+    const bundler = yield* WorkerBundle;
+    const runtime = yield* Runtime;
+    const path = yield* Path.Path;
+    const localProxy = yield* LocalProxy.LocalProxy;
 
-    const rootScope = yield* Effect.scope;
-    const serverScopes = new Map<string, Scope.Closeable>();
+    const toRuntimeModules = Effect.fn(function* (bundle: Bundle.BundleOutput) {
+      const modules: Module[] = [];
+      for (const file of bundle.files) {
+        const ext = path.extname(file.path);
+        const type = moduleTypeFromExtension(ext);
+        if (type === "SourceMap") continue;
+        if (type === "Data" || type === "Wasm") {
+          if (!(file.content instanceof Uint8Array)) {
+            return yield* new ValidationError({
+              message: `Expected Uint8Array for ${file.path} (${type})`,
+              value: file.content,
+            });
+          }
+          modules.push({
+            name: file.path,
+            type,
+            content: file.content,
+          });
+        } else {
+          if (typeof file.content !== "string") {
+            return yield* new ValidationError({
+              message: `Expected string for ${file.path} (${type})`,
+              value: file.content,
+            });
+          }
+          modules.push({
+            name: file.path,
+            type,
+            content: file.content,
+          });
+        }
+      }
+      return modules;
+    });
 
     const serveScoped = Effect.fnUntraced(function* (
-      worker: ServeOptions,
-      modules: WorkerModule[],
+      worker: WorkerConfig,
+      bundle: Bundle.BundleOutput,
     ) {
       const scope = yield* Effect.flatMap(Effect.scope, Scope.fork);
-      const result = yield* server
-        .serve({
-          name: worker.id.toLowerCase(),
+      const address = yield* runtime
+        .start({
+          name: worker.name,
           compatibilityDate: worker.compatibility.date,
           compatibilityFlags: worker.compatibility.flags,
-          bindings: worker.bindings,
+          bindings: worker.workerBindings as never,
           hyperdrives: worker.hyperdrives,
-          durableObjectNamespaces: worker.durableObjectNamespaces,
-          modules,
+          durableObjectNamespaces: toRuntimeDurableObjectNamespaces(
+            worker.durableObjectNamespaces,
+          ),
+          modules: yield* toRuntimeModules(bundle),
+          assets: toRuntimeAssets(worker.assets),
         })
         .pipe(Scope.provide(scope));
-      const previous = serverScopes.get(worker.name);
+      const previous = workerdScopes.get(worker.id);
       if (previous) {
         yield* Effect.forkDetach(Scope.close(previous, Exit.void));
       }
-      serverScopes.set(worker.name, scope);
-      return result;
+      workerdScopes.set(worker.id, scope);
+      yield* localProxy.setLocalAddress(worker.id, address);
+      return address;
     });
 
-    const watchers = new Map<
-      string,
-      {
-        hash: number;
-        fiber: Fiber.Fiber<ServeResult, ServeError>;
-        scope: Scope.Closeable;
+    const buildConfig = Effect.fn(function* ({
+      id,
+      props,
+      bindings,
+      stack,
+      instanceId,
+    }: ReconcileOptions) {
+      const name = yield* createWorkerName(id, props.name).pipe(
+        Effect.provideService(Stack, stack),
+        Effect.provideService(Stage, stack.stage),
+        Effect.provideService(InstanceId, instanceId),
+      );
+      const compatibility = getCompatibility(props);
+      const workerBindings: BindingHook<BindingServices>[] = [];
+      const durableObjectNamespaces: Record<string, string> = {};
+      const hyperdrives: Record<string, Required<HyperdriveOrigin>> = {};
+      for (const { data } of bindings) {
+        for (const binding of data.bindings ?? []) {
+          if (binding.type === "durable_object_namespace") {
+            durableObjectNamespaces[binding.name] = binding.className!;
+          }
+          workerBindings.push(yield* toRuntimeBinding(binding));
+        }
+        if (data.hyperdrives) {
+          for (const [id, origin] of Object.entries(data.hyperdrives)) {
+            hyperdrives[id] = {
+              scheme: origin.scheme,
+              host: origin.host,
+              port: origin.port,
+              user: origin.user,
+              database: origin.database,
+              password: Redacted.isRedacted(origin.password)
+                ? Redacted.value(origin.password)
+                : origin.password,
+              sslmode: origin.sslmode,
+            };
+          }
+        }
       }
-    >();
+      for (const [key, value] of Object.entries(props.env ?? {})) {
+        if (value === undefined) continue;
+        if (Redacted.isRedacted(value)) {
+          workerBindings.push(Text.binding(key, Redacted.value(value)));
+        } else if (typeof value === "string") {
+          workerBindings.push(Text.binding(key, value));
+        } else {
+          workerBindings.push(Json.binding(key, value));
+        }
+      }
+      return {
+        id,
+        name,
+        compatibility,
+        workerBindings,
+        durableObjectNamespaces,
+        hyperdrives,
+        bundleOptions: {
+          id,
+          main: props.main,
+          compatibility,
+          entry: props.isExternal
+            ? { kind: "external" }
+            : { kind: "effect", exports: (props.exports ?? {}) as any },
+          stack: { name: stack.name, stage: stack.stage },
+          userOptions: props.build,
+        } satisfies WorkerBundleOptions,
+        assets: props.assets,
+      };
+    });
 
-    const serveFiber = Effect.fnUntraced(function* (worker: ServeOptions) {
-      const result = yield* Deferred.make<ServeResult, ServeError>();
+    type WorkerConfig = Effect.Success<ReturnType<typeof buildConfig>>;
+
+    const runServer = Effect.fnUntraced(function* (worker: WorkerConfig) {
       let start = Date.now();
-      yield* bundle.watch(worker).pipe(
-        Stream.mapEffect((event) =>
-          event._tag === "Error" && !Deferred.isDoneUnsafe(result)
-            ? Effect.fail(event.error)
-            : Effect.succeed(event),
-        ),
+      let status: "start" | "update" = "start";
+      yield* bundler.watch(worker.bundleOptions).pipe(
         Stream.tap((event) => {
           if (event._tag === "Start") {
             start = Date.now();
-            if (Deferred.isDoneUnsafe(result)) {
+            if (status === "update") {
               return Effect.log(`[${worker.id}] Rebuilding`);
             }
           } else if (event._tag === "Error") {
@@ -86,105 +228,267 @@ export const SidecarHandlers = Layer.effect(
             ? Result.succeed(event.output)
             : Result.failVoid,
         ),
-        Stream.map(bundleOutputToWorkerModules),
-        Stream.mapEffect((modules) =>
-          serveScoped(worker, modules).pipe(
+        Stream.mapEffect((bundle) =>
+          serveScoped(worker, bundle).pipe(
             Effect.exit,
             Effect.tap((exit) => {
-              const isDone = Deferred.isDoneUnsafe(result);
               if (exit._tag === "Success") {
-                return Effect.log(
-                  `[${worker.id}] ${isDone ? "Updated" : "Started"} in ${Math.round(Date.now() - start)}ms`,
+                const message = Effect.log(
+                  `[${worker.id}] ${status === "update" ? "Updated" : "Started"} in ${Math.round(Date.now() - start)}ms`,
                 );
-              } else if (isDone) {
+                status = "update";
+                return message;
+              } else {
                 return Effect.logError(
                   `[${worker.id}] Error`,
                   Cause.squash(exit.cause),
                 );
               }
-              return Effect.void;
             }),
-            Effect.tap((exit) => Deferred.complete(result, exit)),
           ),
         ),
-        Stream.onExit((exit) =>
-          exit._tag === "Failure" && !Deferred.isDoneUnsafe(result)
-            ? Deferred.failCause(result, exit.cause)
-            : Effect.void,
-        ),
         Stream.runDrain,
         Effect.forkScoped,
       );
-      return yield* Deferred.await(result);
+    });
+
+    const rootScope = yield* Effect.scope;
+    const workerdScopes = new Map<string, Scope.Closeable>();
+
+    const context = yield* Effect.context<RuntimeServices>();
+    const instances = new Map<
+      string,
+      {
+        hash: number;
+        fiber: Fiber.Fiber<ServeResult, ServeError>;
+        scope: Scope.Closeable;
+      }
+    >();
+
+    const runInstance = Effect.fn(function* (options: ReconcileOptions) {
+      const { id, props, bindings } = options;
+      const config = yield* buildConfig(options);
+      const url = yield* localProxy.registerWorker(id);
+      if (props.vite) {
+        console.log("starting vite dev server", id);
+        const devServer = yield* Vite.viteDev(
+          props.vite.rootDir,
+          props.env ?? {},
+          {
+            compatibilityDate: config.compatibility.date,
+            compatibilityFlags: config.compatibility.flags,
+            worker: {
+              name: config.name,
+              bindings: config.workerBindings,
+              durableObjectNamespaces: toRuntimeDurableObjectNamespaces(
+                config.durableObjectNamespaces,
+              ),
+              hyperdrives: config.hyperdrives,
+              assets: toRuntimeAssets(config.assets),
+            },
+            context,
+          },
+        );
+        console.log("vite dev server started", id);
+        const localAddress = devServer.resolvedUrls!.local[0].slice(0, -1);
+        yield* localProxy.setLocalAddress(id, localAddress);
+      } else {
+        yield* runServer(config);
+      }
+      return {
+        workerId: config.name,
+        workerName: config.name,
+        logpush: undefined,
+        url,
+        tags: [],
+        durableObjectNamespaces: config.durableObjectNamespaces,
+        domains: [],
+        crons: Array.from(
+          new Set([...getCronBindings(bindings), ...(props.crons ?? [])]),
+        ),
+        accountId,
+      } satisfies Worker["Attributes"];
     });
 
     return Sidecar.of({
-      serve: Effect.fn(function* (worker: ServeOptions) {
-        const hash = Hash.structure(worker);
-        const existing = watchers.get(worker.name);
+      diff: Effect.fn(function* (options) {
+        const hash = Hash.structure(options);
+        return {
+          action: instances.get(options.id)?.hash === hash ? "noop" : "update",
+        };
+      }),
+      reconcile: Effect.fn(function* (options) {
+        const hash = Hash.structure(options);
+        const existing = instances.get(options.id);
         if (existing) {
           if (existing.hash === hash) {
             yield* Effect.log(
-              `[${worker.id}] No changes, using existing watcher`,
+              `[${options.id}] No changes, using existing instance`,
             );
             return yield* Fiber.join(existing.fiber);
           }
           yield* Effect.log(
-            `[${worker.id}] Changes detected, interrupting existing watcher`,
+            `[${options.id}] Changes detected, interrupting existing instance`,
           );
           yield* Fiber.interrupt(existing.fiber);
           yield* Scope.close(existing.scope, Exit.void);
-          watchers.delete(worker.name);
+          instances.delete(options.id);
         }
         const scope = yield* Scope.fork(rootScope);
-        const fiber = yield* serveFiber(worker).pipe(
+        const fiber = yield* runInstance(options).pipe(
           Effect.forkDetach,
           Scope.provide(scope),
         );
-        watchers.set(worker.name, { hash, fiber, scope });
+        instances.set(options.id, { hash, fiber, scope });
         return yield* Fiber.join(fiber).pipe(
           Effect.onExit((exit) =>
             Effect.sync(() => {
               if (exit._tag === "Failure") {
-                watchers.delete(worker.name);
+                instances.delete(options.id);
               }
             }),
           ),
         );
       }),
-      stop: Effect.fn(function* (name: string) {
-        const watcher = watchers.get(name);
-        if (watcher) {
-          yield* Fiber.interrupt(watcher.fiber);
-          yield* Scope.close(watcher.scope, Exit.void);
-          watchers.delete(name);
+      delete: Effect.fn(function* (id) {
+        const existing = instances.get(id);
+        if (existing) {
+          yield* Fiber.interrupt(existing.fiber);
+          yield* Scope.close(existing.scope, Exit.void);
+          instances.delete(id);
         }
       }),
     });
   }),
 );
 
-function bundleOutputToWorkerModules(
-  bundle: Bundle.BundleOutput,
-): WorkerModule[] {
-  const modules: WorkerModule[] = [];
-  for (const file of bundle.files) {
-    if (file.path.endsWith(".map")) {
-      continue;
-    }
-    if (file.content instanceof Uint8Array) {
-      modules.push({
-        name: file.path,
-        type: file.path.endsWith(".wasm") ? "Wasm" : "Data",
-        content: file.content,
-      });
-      continue;
-    }
-    modules.push({
-      name: file.path,
-      type: "ESModule",
-      content: file.content,
+const toRuntimeBinding = Effect.fnUntraced(function* (b: WorkerBinding) {
+  const unsupported = () =>
+    new ValidationError({
+      message: `${b.type} bindings are not supported in local mode`,
+      value: b,
     });
+  switch (b.type) {
+    case "ai":
+      return Ai.remote(b.name);
+    case "analytics_engine":
+      return yield* unsupported();
+    case "artifacts":
+      return yield* unsupported();
+    case "assets":
+      return Assets.binding(b.name);
+    case "browser":
+      return Browser.binding(b.name);
+    case "d1":
+      return D1.remote(b.name, b.id);
+    case "data_blob":
+      return Data.binding(b.name, Buffer.from(b.part));
+    case "dispatch_namespace":
+      return yield* unsupported();
+    case "durable_object_namespace":
+      return DurableObjectNamespace.local({
+        name: b.name,
+        className: b.className!,
+        scriptName: b.scriptName,
+      });
+    case "hyperdrive":
+      return Hyperdrive.binding(b.name, b.id);
+    case "images":
+      return Images.remote(b.name);
+    case "inherit":
+      return yield* unsupported();
+    case "json":
+      return Json.binding(b.name, b.json);
+    case "kv_namespace":
+      return KvNamespace.remote(b.name, b.namespaceId);
+    case "mtls_certificate":
+      return yield* unsupported();
+    case "pipelines":
+      return yield* unsupported();
+    case "plain_text":
+      return Text.binding(b.name, b.text);
+    case "queue":
+      return yield* unsupported();
+    case "r2_bucket":
+      return R2Bucket.remote(b.name, b.bucketName, b.jurisdiction);
+    case "ratelimit":
+      return yield* unsupported();
+    case "secret_key":
+      return yield* unsupported();
+    case "secret_text":
+      return Text.binding(b.name, b.text);
+    case "secrets_store_secret":
+      return yield* unsupported();
+    case "send_email":
+      return yield* unsupported();
+    case "service":
+      return Service.local({ name: b.name, scriptName: b.service });
+    case "text_blob":
+      return Data.binding(b.name, Buffer.from(b.part));
+    case "vectorize":
+      return yield* unsupported();
+    case "version_metadata":
+      return VersionMetadata.binding(b.name);
+    case "wasm_module":
+      return WasmModule.binding(b.name, Buffer.from(b.part));
+    case "worker_loader":
+      return WorkerLoader.binding(b.name);
+    case "workflow":
+      return yield* unsupported();
+    default:
+      return yield* unsupported();
+  }
+});
+
+const toRuntimeAssets = (
+  assets: WorkerAssetsConfig | undefined,
+): RuntimeAssets | undefined => {
+  if (!assets) return undefined;
+  if (typeof assets === "string") {
+    return {
+      directory: assets,
+    };
+  }
+  return {
+    directory: "directory" in assets ? assets.directory : assets.path,
+    headers: assets.config?.headers,
+    redirects: assets.config?.redirects,
+    htmlHandling: assets.config?.htmlHandling,
+    notFoundHandling: assets.config?.notFoundHandling,
+    runWorkerFirst: assets.config?.runWorkerFirst,
+    serveDirectly: assets.config?.serveDirectly,
+  };
+};
+
+const toRuntimeDurableObjectNamespaces = (
+  namespaces: Record<string, string>,
+): RuntimeDurableObjectNamespace[] => {
+  return Object.entries(namespaces).map(([className, namespaceId]) => ({
+    className,
+    uniqueKey: namespaceId,
+    sql: true,
+  }));
+};
+
+const moduleTypeFromExtension = (ext: string): Module["type"] | "SourceMap" => {
+  switch (ext) {
+    case ".wasm":
+      return "Wasm";
+    case ".txt":
+    case ".html":
+    case ".sql":
+    case ".custom":
+      return "Text";
+    case ".bin":
+      return "Data";
+    case ".mjs":
+    case ".js":
+      return "ESModule";
+    case ".cjs":
+      return "CommonJsModule";
+    case ".map":
+      return "SourceMap";
+    default:
+      return "Text";
   }
-  return modules;
-}
+};

package/src/Cloudflare/Local/SidecarServer.ts

@@ -1,4 +1,7 @@
-import * as RuntimeServices from "@distilled.cloud/cloudflare-runtime/RuntimeServices";
+import {
+  layerLocalProxy,
+  layerRuntime,
+} from "@distilled.cloud/cloudflare-runtime/RuntimeServices";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
@@ -31,6 +34,7 @@ const apiServices = Layer.merge(
 );
 
 const runtimeServices = SidecarHandlers.pipe(
+  Layer.provide(layerLocalProxy(1337)),
   Layer.provide(
     Layer.unwrap(
       Effect.gen(function* () {
@@ -38,9 +42,13 @@ const runtimeServices = SidecarHandlers.pipe(
           yield* CloudflareEnvironment.CloudflareEnvironment;
         const { dotAlchemy } = yield* AlchemyContext.AlchemyContext;
         const path = yield* Path.Path;
-        return RuntimeServices.layer({
-          accountId,
-          storage: path.join(dotAlchemy, "local"),
+        return layerRuntime({
+          api: {
+            accountId,
+          },
+          storage: {
+            directory: path.join(dotAlchemy, "local"),
+          },
         });
       }),
     ),

package/src/Cloudflare/StateStore/Api.ts

@@ -29,7 +29,7 @@ export const STATE_STORE_SCRIPT_NAME = "alchemy-state-store" as const;
  * compare against this constant; a mismatch (or 404) triggers a
  * forced redeploy via the bootstrap flow.
  */
-export const STATE_STORE_VERSION = 4 as const;
+export const STATE_STORE_VERSION = 5 as const;
 
 /**
  * Hard-coded OTLP/HTTP endpoints. Point at the public ingest relay