alchemy-effect 0.6.3 → 0.7.0

package/src/Cloudflare/Workers/Worker.ts

@@ -1,5 +1,6 @@
 import type * as cf from "@cloudflare/workers-types";
-import cloudflare from "@distilled.cloud/cloudflare-rolldown-plugin";
+import cloudflareRolldown from "@distilled.cloud/cloudflare-rolldown-plugin";
+import cloudflareVite from "@distilled.cloud/cloudflare-vite-plugin";
 import * as workers from "@distilled.cloud/cloudflare/workers";
 import type * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
@@ -8,12 +9,16 @@ import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Queue from "effect/Queue";
+import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
 import * as ServiceMap from "effect/ServiceMap";
 import * as Stream from "effect/Stream";
 import * as Socket from "effect/unstable/socket/Socket";
 import type * as rolldown from "rolldown";
+import type * as vite from "vite";
+import * as Artifacts from "../../Artifacts.ts";
 import * as Binding from "../../Binding.ts";
+import { hashDirectory, type MemoOptions } from "../../Build/Memo.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
 import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
@@ -33,7 +38,6 @@ import { Resource, type ResourceBinding } from "../../Resource.ts";
 import { Self } from "../../Self.ts";
 import * as Serverless from "../../Serverless/index.ts";
 import { Stack } from "../../Stack.ts";
-import { sha256 } from "../../Util/index.ts";
 import { Account } from "../Account.ts";
 import { CloudflareLogs } from "../Logs.ts";
 import type { AssetsConfig, AssetsProps } from "./Assets.ts";
@@ -42,6 +46,7 @@ import cloudflare_workers from "./cloudflare_workers.ts";
 import { isDurableObjectExport } from "./DurableObject.ts";
 import { fromCloudflareFetcher } from "./Fetcher.ts";
 import { workersHttpHandler } from "./HttpServer.ts";
+import { Request } from "./Request.ts";
 import { makeRpcStub } from "./Rpc.ts";
 import { isWorkflowExport } from "./Workflow.ts";
 
@@ -163,6 +168,11 @@ export interface WorkerProps extends PlatformProps {
     enabled?: boolean;
     previewsEnabled?: boolean;
   };
+  /** @internal used by Cloudflare.Vite resource */
+  vite?: {
+    rootDir?: string;
+    memo?: MemoOptions;
+  };
   logpush?: boolean;
   observability?: WorkerObservability;
   tags?: string[];
@@ -181,7 +191,7 @@ export interface WorkerExecutionContext extends Serverless.FunctionContext {
   export(name: string, value: any): Effect.Effect<void>;
 }
 
-export type WorkerServices = Worker | WorkerEnvironment;
+export type WorkerServices = Worker | WorkerEnvironment | Request;
 
 export type WorkerShape = Main<WorkerServices>;
 
@@ -197,7 +207,8 @@ export interface Worker extends Resource<
     accountId: string;
     hash?: {
       assets: string | undefined;
-      bundle: string;
+      bundle: string | undefined;
+      input: string | undefined;
     };
   },
   {
@@ -249,11 +260,31 @@ export const Worker: Platform<
             ? Effect.succeed(value)
             : Effect.die(`Environment variable '${key}' not found`),
         ),
+        Effect.map((json) => {
+          try {
+            const value = JSON.parse(json);
+            if (!Redacted.isRedacted(value)) {
+              return Redacted.make(value.value);
+            }
+            return value;
+          } catch {
+            return json;
+          }
+        }),
       ) as any,
     set: (id: string, output: Output.Output) =>
       Effect.sync(() => {
         const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
-        env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
+        env[key] = output.pipe(
+          Output.map((value) =>
+            Redacted.isRedacted(value)
+              ? JSON.stringify({
+                  _tag: "Redacted",
+                  value: Redacted.value(value),
+                })
+              : JSON.stringify(value),
+          ),
+        );
         return key;
       }),
     serve: <Req = never>(handler: HttpEffect<Req>) =>
@@ -389,6 +420,10 @@ export const WorkerProvider = () =>
       const listScripts = yield* workers.listScripts;
       const putScript = yield* workers.putScript;
       const telemetry = yield* CloudflareLogs;
+      const defaultCompatibilityDate = yield* Effect.promise(() =>
+        // @ts-expect-error no types for workerd
+        import("workerd").then((m) => m.compatibilityDate as string),
+      );
 
       const getAccountSubdomain = (accountId: string) =>
         getSubdomain({
@@ -436,44 +471,34 @@ export const WorkerProvider = () =>
           "path" in assets &&
           "hash" in assets
         ) {
-          const path = assets.path as string;
-          const hash = assets.hash as string;
           const result = yield* read({
-            directory: path,
+            directory: assets.path as string,
             config: assets.config,
           });
           return {
             ...result,
-            hash,
+            hash: assets.hash as string,
           };
         }
 
         // Handle string path or AssetsProps
-        const result = yield* read(
+        return yield* read(
           typeof assets === "string" ? { directory: assets } : assets,
         );
-        return {
-          ...result,
-          hash: yield* sha256(JSON.stringify(result)),
-        };
       });
 
-      const prepareBundle = Effect.fnUntraced(function* (
-        id: string,
-        props: WorkerProps,
-      ) {
-        const realMain = yield* fs.realPath(props.main);
-        const buildBundle = Effect.fnUntraced(function* (
-          entry: string,
-          plugins?: rolldown.RolldownPluginOption,
-        ) {
-          const { files, hash } = yield* Bundle.build(
+      const prepareBundle = Effect.fnUntraced(function* (props: WorkerProps) {
+        const main = yield* fs.realPath(props.main);
+        const cwd = yield* findCwdForBundle(main);
+        const buildBundle = (plugins?: rolldown.RolldownPluginOption) =>
+          Bundle.build(
             {
-              input: entry,
-              cwd: yield* findCwdForBundle(entry),
+              input: main,
+              cwd,
               plugins: [
-                cloudflare({
-                  compatibilityDate: props.compatibility?.date ?? "2026-03-10",
+                cloudflareRolldown({
+                  compatibilityDate:
+                    props.compatibility?.date ?? defaultCompatibilityDate,
                   compatibilityFlags: props.compatibility?.flags,
                 }),
                 plugins,
@@ -490,20 +515,10 @@ export const WorkerProvider = () =>
               keepNames: true,
             },
           );
-          return {
-            files: files.map(
-              (file) =>
-                new File([file.content as BlobPart], file.path, {
-                  type: contentTypeFromExtension(path.extname(file.path)),
-                }),
-            ),
-            mainModule: files[0].path,
-            hash,
-          };
-        });
 
         if (props.isExternal) {
-          return yield* buildBundle(realMain);
+          const bundle = yield* buildBundle();
+          return bundle;
         }
 
         const exportMap = (props.exports ?? {}) as Record<string, unknown>;
@@ -574,7 +589,10 @@ const exportsEffect = tag.asEffect().pipe(
       Layer.provideMerge(
         Layer.succeed(
           ConfigProvider.ConfigProvider,
-          ConfigProvider.fromUnknown(env),
+          ConfigProvider.orElse(
+            ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
+            ConfigProvider.fromUnknown(env),
+          ),
         )
       ),
       Layer.provideMerge(
@@ -631,9 +649,111 @@ ${[
 ].join("\n")}
 `;
 
-        return yield* buildBundle(realMain, virtualEntryPlugin(script));
+        return yield* buildBundle(virtualEntryPlugin(script));
       });
 
+      const viteBuild = Effect.fnUntraced(function* (props: WorkerProps) {
+        const vite = yield* Effect.promise(() => import("vite"));
+        let assetsDirectory: string | undefined;
+        let serverBundle: vite.Rolldown.OutputBundle | undefined;
+
+        yield* Effect.promise(async () => {
+          const builder = await vite.createBuilder(
+            {
+              root: props.vite?.rootDir,
+              plugins: [
+                cloudflareVite({
+                  compatibilityDate:
+                    props.compatibility?.date ?? defaultCompatibilityDate,
+                  compatibilityFlags: props.compatibility?.flags,
+                }),
+                {
+                  name: "output:ssr",
+                  applyToEnvironment(environment) {
+                    return environment.name === "ssr";
+                  },
+                  generateBundle(_outputOptions, bundle) {
+                    serverBundle = bundle;
+                  },
+                },
+                {
+                  name: "output:client",
+                  applyToEnvironment(environment) {
+                    return environment.name === "client";
+                  },
+                  generateBundle(outputOptions) {
+                    assetsDirectory = outputOptions.dir;
+                  },
+                },
+              ],
+            },
+            // This is the `useLegacyBuilder` option. The Vite CLI implementation uses `null` here.
+            // Originally we used `undefined` here, but this caused the static site build to fail.
+            // https://github.com/vitejs/vite/blob/a07a4bd052ac75f916391c999c408ad5f2867e61/packages/vite/src/node/cli.ts#L367
+            null,
+          );
+          await builder.buildApp();
+        });
+        if (!assetsDirectory && !serverBundle) {
+          return yield* Effect.die(
+            new Error("Vite build produced neither server nor client output"),
+          );
+        }
+        const [assets, bundle] = yield* Effect.all(
+          [
+            assetsDirectory
+              ? read({
+                  directory: assetsDirectory,
+                  config:
+                    typeof props.assets === "object" && "config" in props.assets
+                      ? props.assets.config
+                      : undefined,
+                })
+              : Effect.succeed(undefined),
+            serverBundle
+              ? Bundle.bundleOutputFromRolldownOutputBundle(serverBundle)
+              : Effect.succeed(undefined),
+          ],
+          { concurrency: "unbounded" },
+        );
+        return { assets, bundle };
+      });
+
+      const prepareAssetsAndBundle = (props: WorkerProps) =>
+        Effect.gen(function* () {
+          if (props.vite) {
+            const [{ assets, bundle }, input] = yield* Effect.all(
+              [viteBuild(props), hashDirectory(props.vite)],
+              { concurrency: "unbounded" },
+            );
+            return { assets, bundle, input };
+          }
+          const [assets, bundle] = yield* Effect.all(
+            [prepareAssets(props.assets), prepareBundle(props)],
+            { concurrency: "unbounded" },
+          );
+          return { assets, bundle };
+        }).pipe(
+          Effect.map(({ assets, bundle, input }) => ({
+            assets,
+            bundle: {
+              main: bundle?.files[0].path,
+              files: bundle?.files.map(
+                (file) =>
+                  new File([file.content as BlobPart], file.path, {
+                    type: contentTypeFromExtension(path.extname(file.path)),
+                  }),
+              ),
+            },
+            hash: {
+              assets: assets?.hash,
+              bundle: bundle?.hash,
+              input,
+            } satisfies Worker["Attributes"]["hash"],
+          })),
+          Artifacts.cached("build"),
+        );
+
       const putWorker = Effect.fnUntraced(function* (
         id: string,
         news: WorkerProps,
@@ -647,10 +767,7 @@ ${[
         yield* Effect.logInfo(
           `Cloudflare Worker ${olds ? "update" : "create"}: preparing bundle for ${name}`,
         );
-        const [assets, bundle] = yield* Effect.all([
-          prepareAssets(news.assets),
-          prepareBundle(id, news),
-        ]);
+        const { assets, bundle, hash } = yield* prepareAssetsAndBundle(news);
         const metadataBindings = bindings.flatMap((b) => b.data.bindings);
         let metadataAssets:
           | workers.PutScriptRequest["metadata"]["assets"]
@@ -867,7 +984,7 @@ ${[
           keepBindings: undefined,
           limits: news.limits,
           logpush: news.logpush,
-          mainModule: bundle.mainModule,
+          mainModule: bundle.main,
           migrations,
           observability: news.observability ?? {
             enabled: true,
@@ -936,13 +1053,33 @@ ${[
               : undefined,
           tags: metadata.tags,
           accountId,
-          hash: {
-            assets: assets?.hash,
-            bundle: bundle.hash,
-          },
+          hash,
         } satisfies Worker["Attributes"];
       });
 
+      const hasChanged = Effect.fnUntraced(function* (
+        props: WorkerProps,
+        output: Worker["Attributes"],
+      ) {
+        if (props.vite) {
+          const input = yield* hashDirectory(props.vite);
+          return input !== output.hash?.input;
+        }
+        const [assetsHash, bundleHash] = yield* Effect.all(
+          [
+            "assets" in output && output.hash?.assets
+              ? Effect.succeed(output.hash.assets)
+              : prepareAssets(props.assets).pipe(Effect.map((a) => a?.hash)),
+            prepareBundle(props).pipe(Effect.map((b) => b.hash)),
+          ],
+          { concurrency: "unbounded" },
+        );
+        return (
+          assetsHash !== output.hash?.assets ||
+          bundleHash !== output.hash?.bundle
+        );
+      });
+
       return Worker.provider.of({
         stables: ["workerId", "workerName"],
         diff: Effect.fnUntraced(function* ({ id, news, olds, output }) {
@@ -960,14 +1097,7 @@ ${[
           if (!output) {
             return;
           }
-          const [assets, bundle] = yield* Effect.all([
-            prepareAssets(news.assets),
-            prepareBundle(id, news),
-          ]);
-          if (
-            assets?.hash !== output.hash?.assets ||
-            bundle.hash !== output.hash?.bundle
-          ) {
+          if (yield* hasChanged(news, output)) {
             return {
               action: "update",
               stables:

package/src/Destroy.ts

@@ -1,5 +1,6 @@
 import * as Effect from "effect/Effect";
 import { apply } from "./Apply.ts";
+import { provideFreshArtifactStore } from "./Artifacts.ts";
 import * as Plan from "./Plan.ts";
 import { Stack } from "./Stack.ts";
 
@@ -11,5 +12,5 @@ export const destroy = () =>
       resources: {},
       bindings: {},
       output: {},
-    }),
-  ).pipe(Effect.flatMap(apply));
+    }).pipe(Effect.flatMap(apply), provideFreshArtifactStore),
+  );

package/src/Output.ts

@@ -53,6 +53,7 @@ export interface Output<A = any, Req = any> extends Pipeable {
   >;
   bind(id: string): Effect.Effect<Effect.Effect<A>, never, ExecutionContext>;
   asEffect(): Effect.Effect<Accessor<A>, never, Req>;
+  as<T>(): Output<T, Req>;
 }
 
 export interface Accessor<A> extends Effect.Effect<A> {}
@@ -91,6 +92,9 @@ export abstract class BaseExpr<A = any, Req = any> implements Output<A, Req> {
   declare readonly req: Req;
   // we use a kind tag instead of instanceof to protect ourselves from duplicate alchemy-effect module imports
   constructor() {}
+  as<T>(): Output<T, Req> {
+    return this as any;
+  }
 
   [Symbol.iterator](): Iterator<
     Yieldable<any, void, never, Req>,