alchemy 2.0.0-beta.51 → 2.0.0-beta.53

package/src/Cloudflare/VpcService/VpcService.ts

@@ -120,143 +120,144 @@ export type VpcService = Resource<
  */
 export const VpcService = Resource<VpcService>("Cloudflare.VpcService");
 
-export const VpcServiceProvider = () =>
-  Provider.effect(
-    VpcService,
-    Effect.gen(function* () {
-      const { accountId } = yield* CloudflareEnvironment;
-      const createService = yield* connectivity.createDirectoryService;
-      const getService = yield* connectivity.getDirectoryService;
-      const updateService = yield* connectivity.updateDirectoryService;
-      const deleteService = yield* connectivity.deleteDirectoryService;
-      const listServices = connectivity.listDirectoryServices;
-
-      const createServiceName = (id: string, name: string | undefined) =>
-        Effect.gen(function* () {
-          if (name) return name;
-          return yield* createPhysicalName({
-            id,
-            lowercase: true,
-            maxLength: 63,
-          });
-        });
-
-      const findServiceByName = (name: string) =>
-        listServices.items({ accountId }).pipe(
-          Stream.filter((s) => s.name === name),
-          Stream.runHead,
-          Effect.map(Option.getOrUndefined),
-        );
+const createServiceName = (id: string, name: string | undefined) =>
+  Effect.gen(function* () {
+    if (name) return name;
+    return yield* createPhysicalName({
+      id,
+      lowercase: true,
+      maxLength: 63,
+    });
+  });
 
-      return {
-        stables: ["serviceId", "accountId"],
-        diff: Effect.fn(function* ({ id, olds, news, output }) {
-          if (!isResolved(news)) return undefined;
-          if ((output?.accountId ?? accountId) !== accountId) {
-            return { action: "replace" } as const;
-          }
-          const name = yield* createServiceName(id, news.name);
-          const oldName = output?.serviceName
-            ? output.serviceName
-            : yield* createServiceName(id, olds?.name);
-          if (name !== oldName) {
-            return { action: "update" } as const;
-          }
-        }),
-        reconcile: Effect.fn(function* ({ id, news, output }) {
-          const name = yield* createServiceName(id, news.name);
-          const acct = output?.accountId ?? accountId;
+const findServiceByName = Effect.fnUntraced(function* (name: string) {
+  const { accountId } = yield* yield* CloudflareEnvironment;
+  return yield* connectivity.listDirectoryServices.items({ accountId }).pipe(
+    Stream.filter((s) => s.name === name),
+    Stream.runHead,
+    Effect.map(Option.getOrUndefined),
+  );
+});
 
-          // Observe — re-fetch the cached service; fall back to a name
-          // scan so we recover from out-of-band deletes or partial state
-          // persistence failures.
-          let observed: connectivity.GetDirectoryServiceResponse | undefined;
-          if (output?.serviceId) {
-            observed = yield* getService({
-              accountId: acct,
-              serviceId: output.serviceId,
-            }).pipe(Effect.catch(() => Effect.succeed(undefined)));
-          }
-          if (!observed) {
-            const match = yield* findServiceByName(name);
-            observed = match as
-              | connectivity.GetDirectoryServiceResponse
-              | undefined;
-          }
+export const VpcServiceProvider = () =>
+  Provider.succeed(VpcService, {
+    stables: ["serviceId", "accountId"],
+    diff: Effect.fn(function* ({ id, olds, news, output }) {
+      const { accountId } = yield* yield* CloudflareEnvironment;
+      if (!isResolved(news)) return undefined;
+      if ((output?.accountId ?? accountId) !== accountId) {
+        return { action: "replace" } as const;
+      }
+      const name = yield* createServiceName(id, news.name);
+      const oldName = output?.serviceName
+        ? output.serviceName
+        : yield* createServiceName(id, olds?.name);
+      if (name !== oldName) {
+        return { action: "update" } as const;
+      }
+    }),
+    reconcile: Effect.fn(function* ({ id, news, output }) {
+      const { accountId } = yield* yield* CloudflareEnvironment;
+      const name = yield* createServiceName(id, news.name);
+      const acct = output?.accountId ?? accountId;
 
-          // Ensure — create if missing. Cloudflare rejects a duplicate
-          // name with a generic error; tolerate by adopting the existing
-          // service (when the caller opted in) and re-applying the
-          // desired configuration.
-          if (!observed || !observed.serviceId) {
-            const result = yield* createService({
-              accountId: acct,
-              name,
-              type: news.serviceType ?? "http",
-              httpPort: news.httpPort,
-              httpsPort: news.httpsPort,
-              host: news.host,
-            }).pipe(
-              Effect.catch((err: unknown) =>
-                Effect.gen(function* () {
-                  if (!news.adopt) return yield* Effect.fail(err as never);
-                  const existing = yield* findServiceByName(name);
-                  if (!existing || !existing.serviceId) {
-                    return yield* Effect.fail(err as never);
-                  }
-                  return yield* updateService({
-                    accountId: acct,
-                    serviceId: existing.serviceId,
-                    name,
-                    type: news.serviceType ?? "http",
-                    httpPort: news.httpPort,
-                    httpsPort: news.httpsPort,
-                    host: news.host,
-                  });
-                }),
-              ),
-            );
-            return formatVpcService(result, acct);
-          }
+      // Observe — re-fetch the cached service; fall back to a name
+      // scan so we recover from out-of-band deletes or partial state
+      // persistence failures.
+      let observed: connectivity.GetDirectoryServiceResponse | undefined;
+      if (output?.serviceId) {
+        observed = yield* connectivity
+          .getDirectoryService({
+            accountId: acct,
+            serviceId: output.serviceId,
+          })
+          .pipe(Effect.catch(() => Effect.succeed(undefined)));
+      }
+      if (!observed) {
+        const match = yield* findServiceByName(name);
+        observed = match as
+          | connectivity.GetDirectoryServiceResponse
+          | undefined;
+      }
 
-          // Sync — the Cloudflare update API replaces all mutable fields
-          // (name, ports, host) atomically, so always issue it so
-          // adoption and routine updates converge.
-          const result = yield* updateService({
+      // Ensure — create if missing. Cloudflare rejects a duplicate
+      // name with a generic error; tolerate by adopting the existing
+      // service (when the caller opted in) and re-applying the
+      // desired configuration.
+      if (!observed || !observed.serviceId) {
+        const result = yield* connectivity
+          .createDirectoryService({
             accountId: acct,
-            serviceId: observed.serviceId,
             name,
-            type: news.serviceType ?? observed.type ?? "http",
+            type: news.serviceType ?? "http",
             httpPort: news.httpPort,
             httpsPort: news.httpsPort,
             host: news.host,
-          });
-          return formatVpcService(result, acct);
-        }),
-        delete: Effect.fn(function* ({ output }) {
-          yield* deleteService({
+          })
+          .pipe(
+            Effect.catch((err: unknown) =>
+              Effect.gen(function* () {
+                if (!news.adopt) return yield* Effect.fail(err as never);
+                const existing = yield* findServiceByName(name);
+                if (!existing || !existing.serviceId) {
+                  return yield* Effect.fail(err as never);
+                }
+                return yield* connectivity.updateDirectoryService({
+                  accountId: acct,
+                  serviceId: existing.serviceId,
+                  name,
+                  type: news.serviceType ?? "http",
+                  httpPort: news.httpPort,
+                  httpsPort: news.httpsPort,
+                  host: news.host,
+                });
+              }),
+            ),
+          );
+        return formatVpcService(result, acct);
+      }
+
+      // Sync — the Cloudflare update API replaces all mutable fields
+      // (name, ports, host) atomically, so always issue it so
+      // adoption and routine updates converge.
+      const result = yield* connectivity.updateDirectoryService({
+        accountId: acct,
+        serviceId: observed.serviceId,
+        name,
+        type: news.serviceType ?? observed.type ?? "http",
+        httpPort: news.httpPort,
+        httpsPort: news.httpsPort,
+        host: news.host,
+      });
+      return formatVpcService(result, acct);
+    }),
+    delete: Effect.fn(function* ({ output }) {
+      yield* connectivity
+        .deleteDirectoryService({
+          accountId: output.accountId,
+          serviceId: output.serviceId,
+        })
+        .pipe(Effect.catch(() => Effect.void));
+    }),
+    read: Effect.fn(function* ({ id, output, olds }) {
+      const { accountId } = yield* yield* CloudflareEnvironment;
+      if (output?.serviceId) {
+        return yield* connectivity
+          .getDirectoryService({
             accountId: output.accountId,
             serviceId: output.serviceId,
-          }).pipe(Effect.catch(() => Effect.void));
-        }),
-        read: Effect.fn(function* ({ id, output, olds }) {
-          if (output?.serviceId) {
-            return yield* getService({
-              accountId: output.accountId,
-              serviceId: output.serviceId,
-            }).pipe(
-              Effect.map((s) => formatVpcService(s, output.accountId)),
-              Effect.catch(() => Effect.succeed(undefined)),
-            );
-          }
-          const name = yield* createServiceName(id, olds?.name);
-          const existing = yield* findServiceByName(name);
-          if (!existing || !existing.serviceId) return undefined;
-          return formatVpcService(existing, accountId);
-        }),
-      };
+          })
+          .pipe(
+            Effect.map((s) => formatVpcService(s, output.accountId)),
+            Effect.catch(() => Effect.succeed(undefined)),
+          );
+      }
+      const name = yield* createServiceName(id, olds?.name);
+      const existing = yield* findServiceByName(name);
+      if (!existing || !existing.serviceId) return undefined;
+      return formatVpcService(existing, accountId);
     }),
-  );
+  });
 
 export const formatVpcService = (
   service: {

package/src/Cloudflare/VpcService/VpcServiceRef.ts

@@ -44,7 +44,7 @@ export type VpcServiceRef = VpcServiceAttributes;
  */
 export const VpcServiceRef = (props: VpcServiceRefProps) =>
   Effect.gen(function* () {
-    const { accountId } = yield* CloudflareEnvironment;
+    const { accountId } = yield* yield* CloudflareEnvironment;
     if ("name" in props) {
       const match = yield* connectivity.listDirectoryServices
         .items({ accountId })

package/src/Cloudflare/Website/StaticSite.ts

@@ -1,11 +1,17 @@
+import * as Output from "alchemy/Output";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
+import { AlchemyContext } from "../../AlchemyContext.ts";
 import { Command, type CommandProps } from "../../Build/Command.ts";
+import { DevServer } from "../../Build/DevServer.ts";
 import type { InputProps } from "../../Input.ts";
 import * as Namespace from "../../Namespace.ts";
+import { effectClass } from "../../Util/effect.ts";
+import type { Providers } from "../Providers.ts";
 import type { AssetsConfig } from "../Workers/Assets.ts";
 import {
   Worker,
+  type NormalizedBindings,
   type WorkerAssetsConfig,
   type WorkerBindingProps,
   type WorkerProps,
@@ -19,13 +25,48 @@ export interface StaticSiteProps<Bindings extends WorkerBindingProps = {}>
    * Optional configuration for static asset routing behavior.
    * Supports `runWorkerFirst`, `htmlHandling`, `notFoundHandling`, etc.
    */
-  assetsConfig?: AssetsConfig;
+
+  assets?: AssetsConfig;
+  /**
+   * Local dev configuration. When `alchemy dev` runs, the build command is
+   * skipped and `command` is spawned as a long-lived child process tied to
+   * the stack's scope. Alchemy does not proxy or interpret the process —
+   * the dev server's own URL (e.g. `http://localhost:5173`) is what you
+   * open in the browser.
+   *
+   * @example
+   * ```typescript
+   * Cloudflare.StaticSite("App", {
+   *   command: "npm run build",
+   *   outdir: "dist",
+   *   main: "./src/worker.ts",
+   *   dev: { command: "npm run dev" },
+   * });
+   * ```
+   */
   dev?: {
+    /**
+     * Shell command to run as the local dev server (e.g. `npm run dev`).
+     */
     command: string;
+    /**
+     * Working directory for {@link command}. Defaults to {@link CommandProps.cwd}
+     * (the build command's `cwd`), or `process.cwd()` if neither is set.
+     */
+    cwd?: string;
+    /**
+     * Override for the `url` output if alchemy fails to detect it from the stdout of the dev command
+     */
+    url?: string;
   };
 }
 
-export type StaticSite = ReturnType<typeof StaticSite>;
+type StaticSiteWorker<Bindings extends WorkerBindingProps> = Worker<{
+  [binding in keyof NormalizedBindings<
+    Bindings,
+    WorkerAssetsConfig
+  >]: NormalizedBindings<Bindings, WorkerAssetsConfig>[binding];
+}>;
 
 /**
  * A Cloudflare Worker that serves static assets built by a shell command.
@@ -68,7 +109,7 @@ export type StaticSite = ReturnType<typeof StaticSite>;
  * ```
  *
  * @section Asset Configuration
- * Use `assetsConfig` to control how Cloudflare handles routing for
+ * Use `assets` to control how Cloudflare handles routing for
  * your static files — HTML handling, not-found behavior, etc.
  *
  * @example SPA-style routing
@@ -77,7 +118,7 @@ export type StaticSite = ReturnType<typeof StaticSite>;
  *   command: "npm run build",
  *   outdir: "dist",
  *   main: "./src/worker.ts",
- *   assetsConfig: {
+ *   assets: {
  *     htmlHandling: "auto-trailing-slash",
  *     notFoundHandling: "single-page-application",
  *   },
@@ -113,54 +154,126 @@ export type StaticSite = ReturnType<typeof StaticSite>;
  *   },
  * });
  * ```
+ *
+ * @section Class Form
+ * Calling `StaticSite` with no arguments returns a constructor you can
+ * `extend` to declare the Worker as a named class. The class is both
+ * an `Effect` you can `yield*` to deploy and a type you can reference
+ * elsewhere — useful when other resources need to bind to this Worker.
+ *
+ * @example Declaring a Worker class
+ * ```typescript
+ * class Blog extends Cloudflare.StaticSite<Blog>()("Blog", {
+ *   command: "hugo --minify",
+ *   outdir: "public",
+ *   main: "./src/worker.ts",
+ * }) {}
+ *
+ * const site = yield* Blog;
+ * ```
  */
-export const StaticSite = <
+export const StaticSite: {
+  <Self>(): {
+    <const Bindings extends WorkerBindingProps = {}, Req = never>(
+      id: string,
+      propsEff:
+        | InputProps<StaticSiteProps<Bindings>, "dev">
+        | Effect.Effect<
+            InputProps<StaticSiteProps<Bindings>, "dev">,
+            never,
+            Req
+          >,
+    ): Effect.Effect<Self, never, Req | Providers> & {
+      new (): StaticSiteWorker<Bindings>;
+    };
+  };
+  <const Bindings extends WorkerBindingProps = {}, Req = never>(
+    id: string,
+    propsEff:
+      | InputProps<StaticSiteProps<Bindings>, "dev">
+      | Effect.Effect<InputProps<StaticSiteProps<Bindings>, "dev">, never, Req>,
+  ): Effect.Effect<StaticSiteWorker<Bindings>, never, Req | Providers>;
+} = ((id?: any, propsEff?: any) =>
+  id === undefined
+    ? (id: string, propsEff: any) => effectClass(makeStaticSite(id, propsEff))
+    : makeStaticSite(id, propsEff)) as any;
+
+const makeStaticSite = <
   const Bindings extends WorkerBindingProps = {},
   Req = never,
 >(
   id: string,
   propsEff:
-    | InputProps<StaticSiteProps<Bindings>>
-    | Effect.Effect<InputProps<StaticSiteProps<Bindings>>, never, Req>,
+    | InputProps<StaticSiteProps<Bindings>, "dev">
+    | Effect.Effect<InputProps<StaticSiteProps<Bindings>, "dev">, never, Req>,
 ) =>
   Effect.gen(function* () {
     const props = Effect.isEffect(propsEff)
       ? propsEff
       : Effect.succeed(propsEff);
+    const { dev: isDevPhase } = yield* AlchemyContext;
 
-    // TODO(sam): local dev/hmr support?
-    const build = yield* Command(
-      "Build",
-      Effect.map(props, (props) => ({
-        command: props.command,
-        cwd: props.cwd,
-        memo: props.memo,
-        outdir: props.outdir,
-        env: props.env
-          ? Object.fromEntries(
-              Object.entries(props.env).flatMap(([k, v]) => {
-                if (v === undefined) return [];
-                if (typeof v === "string" || Redacted.isRedacted(v))
-                  return [[k, v]];
-                return [[k, JSON.stringify(v)]];
-              }),
-            )
-          : undefined,
-      })),
-    );
+    return yield* Effect.gen(function* () {
+      const resolved = yield* props;
+      const useDevServer = isDevPhase && resolved.dev !== undefined;
 
-    return yield* Worker<Bindings, WorkerAssetsConfig, Req>(
-      "Worker",
-      Effect.map(props, (props) => ({
-        ...props,
-        assets: {
-          path: build.outdir,
-          hash: build.hash,
-          config: props.assetsConfig,
-        },
-        // Omit the dev command from WorkerProps since it's different from WorkerProps["dev"].
-        // TODO: we'll need to update this when we add local dev support for StaticSite.
-        dev: undefined,
-      })),
-    );
+      // In dev mode with a dev.command, declare a DevCommand resource so
+      // the sidecar owns the process lifecycle (survives user-code HMR),
+      // skip the build, and tell Worker not to start a local instance.
+      let devUrl = yield* useDevServer
+        ? DevServer("Dev", {
+            command: resolved.dev!.command,
+            cwd:
+              resolved.dev!.cwd ??
+              (typeof resolved.cwd === "string" ? resolved.cwd : undefined),
+          }).pipe(
+            Effect.map((d) =>
+              Output.map(d.url, (url) => url ?? resolved.dev?.url ?? false),
+            ),
+          )
+        : Effect.succeed(false as const);
+
+      const build = useDevServer
+        ? undefined
+        : yield* Command("Build", {
+            command: resolved.command,
+            cwd: resolved.cwd,
+            memo: resolved.memo,
+            outdir: resolved.outdir,
+            env: resolved.env
+              ? Object.fromEntries(
+                  Object.entries(resolved.env).flatMap(([k, v]) => {
+                    if (v === undefined) return [];
+                    if (typeof v === "string" || Redacted.isRedacted(v))
+                      return [[k, v]];
+                    return [[k, JSON.stringify(v)]];
+                  }),
+                )
+              : undefined,
+          });
+
+      // Pure-static sites don't need a custom Worker entrypoint —
+      // delegate every request straight to the ASSETS binding. Only
+      // injected when the user provided neither `main` nor `script`.
+      const fallbackScript =
+        resolved.main == null && resolved.script == null
+          ? `export default { fetch: (request, env) => env.ASSETS.fetch(request) };`
+          : undefined;
+
+      return yield* Worker<Bindings, WorkerAssetsConfig, Req>("Worker", {
+        ...resolved,
+        assets: build
+          ? {
+              directory: build.outdir,
+              hash: build.hash,
+              ...resolved.assets,
+            }
+          : undefined,
+        // Opt out of the local Worker in dev when the external DevCommand
+        // is serving the content. The Worker resource still exists in
+        // state with a stub Attributes shape.
+        dev: useDevServer ? devUrl : undefined,
+        script: fallbackScript ?? resolved.script,
+      });
+    });
   }).pipe(Namespace.push(id));

package/src/Cloudflare/Website/Vite.ts

@@ -1,16 +1,19 @@
 import * as Effect from "effect/Effect";
 import type { MemoOptions } from "../../Build/Memo.ts";
 import type { InputProps } from "../../Input.ts";
+import { effectClass } from "../../Util/effect.ts";
+import type { Providers } from "../Providers.ts";
+import type { AssetsConfig } from "../Workers/Assets.ts";
 import {
   Worker,
+  type NormalizedBindings,
   type WorkerAssetsConfig,
   type WorkerBindingProps,
   type WorkerProps,
 } from "../Workers/Worker.ts";
-
 export interface ViteProps<
   Bindings extends WorkerBindingProps = {},
-> extends Omit<WorkerProps<Bindings>, "vite" | "main"> {
+> extends Omit<WorkerProps<Bindings>, "vite" | "main" | "assets"> {
   /**
    * Root directory passed to Vite's `root` option.
    * Defaults to the current working directory (`process.cwd()`).
@@ -24,6 +27,11 @@ export interface ViteProps<
    * @see {@link MemoOptions}
    */
   memo?: MemoOptions;
+  /**
+   * Optional configuration for static asset routing behavior.
+   * Supports `runWorkerFirst`, `htmlHandling`, `notFoundHandling`, etc.
+   */
+  assets?: AssetsConfig;
 }
 
 /**
@@ -106,27 +114,67 @@ export interface ViteProps<
  *   },
  * });
  * ```
+ *
+ * @section Class Form
+ * Calling `Vite` with no arguments returns a constructor you can
+ * `extend` to declare the Worker as a named class. The class is both
+ * an `Effect` you can `yield*` to deploy and a type you can reference
+ * elsewhere — useful when other resources need to bind to this Worker.
+ *
+ * @example Declaring a Worker class
+ * ```typescript
+ * class Website extends Cloudflare.Vite<Website>()("Website", {
+ *   compatibility: { flags: ["nodejs_compat"] },
+ * }) {}
+ *
+ * const site = yield* Website;
+ * ```
  */
-export const Vite = <
-  const Bindings extends WorkerBindingProps = {},
-  Req = never,
->(
-  id: string,
-  propsEff?:
-    | InputProps<ViteProps<Bindings>>
-    | Effect.Effect<InputProps<ViteProps<Bindings>>, never, Req>,
-) =>
-  Worker<Bindings, WorkerAssetsConfig, Req>(
-    id,
-    Effect.map(
-      Effect.isEffect(propsEff) ? propsEff : Effect.succeed(propsEff),
-      (props) => ({
-        ...props,
-        main: undefined!,
-        vite: {
-          rootDir: props?.rootDir,
-          memo: props?.memo,
-        },
-      }),
-    ),
-  );
+export const Vite: {
+  <Self>(): {
+    <const Bindings extends WorkerBindingProps = {}, Req = never>(
+      id: string,
+      propsEff?:
+        | InputProps<ViteProps<Bindings>>
+        | Effect.Effect<InputProps<ViteProps<Bindings>>, never, Req>,
+    ): Effect.Effect<Self, never, Req | Providers> & {
+      new (): Worker<{
+        [binding in keyof NormalizedBindings<
+          Bindings,
+          WorkerAssetsConfig
+        >]: NormalizedBindings<Bindings, WorkerAssetsConfig>[binding];
+      }>;
+    };
+  };
+  <const Bindings extends WorkerBindingProps = {}, Req = never>(
+    id: string,
+    propsEff?:
+      | InputProps<ViteProps<Bindings>>
+      | Effect.Effect<InputProps<ViteProps<Bindings>>, never, Req>,
+  ): Effect.Effect<
+    Worker<{
+      [binding in keyof NormalizedBindings<
+        Bindings,
+        WorkerAssetsConfig
+      >]: NormalizedBindings<Bindings, WorkerAssetsConfig>[binding];
+    }>,
+    never,
+    Req | Providers
+  >;
+} = ((id?: any, propsEff?: any) =>
+  id === undefined
+    ? (id: string, propsEff: any) => effectClass(Vite(id, propsEff))
+    : Worker(
+        id,
+        Effect.map(
+          Effect.isEffect(propsEff) ? propsEff : Effect.succeed(propsEff),
+          (props) => ({
+            ...props,
+            main: undefined!,
+            vite: {
+              rootDir: props?.rootDir,
+              memo: props?.memo,
+            },
+          }),
+        ),
+      )) as any;