alchemy 2.0.0-beta.30 → 2.0.0-beta.32

package/src/Cloudflare/Workers/WorkerBundle.ts

@@ -106,129 +106,121 @@ export const WorkerBundle = Effect.gen(function* () {
   };
 });
 
-const makeEffectVirtualEntry = (
+export const makeEffectVirtualEntry = (
   exports: Record<string, DurableObjectExport | WorkflowExport>,
   stack: { name: string; stage: string },
 ) => {
-  const durableObjectClasses: string[] = [];
-  const workflowClasses: string[] = [];
+  const doClasses: string[] = [];
+  const wfClasses: string[] = [];
   for (const [className, entry] of Object.entries(exports)) {
     if (isDurableObjectExport(entry)) {
-      durableObjectClasses.push(className);
+      doClasses.push(className);
     } else if (isWorkflowExport(entry)) {
-      workflowClasses.push(className);
+      wfClasses.push(className);
     }
   }
-  return (importPath: string) => `import * as Config from "effect/Config";
-  import * as ConfigProvider from "effect/ConfigProvider";
-  import * as Console from "effect/Console";
-  import * as Effect from "effect/Effect";
-  import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
-  import * as Layer from "effect/Layer";
-  import * as Logger from "effect/Logger";
-  import * as Context from "effect/Context";
-  import * as Stream from "effect/Stream";
-  
-  import { env, DurableObject${workflowClasses.length > 0 ? ", WorkflowEntrypoint" : ""} } from "cloudflare:workers";
-  import { MinimumLogLevel } from "effect/References";
-  import { NodeServices } from "@effect/platform-node";
-  import { Stack } from "alchemy/Stack";
-  import { WorkerEnvironment, makeDurableObjectBridge${workflowClasses.length > 0 ? ", makeWorkflowBridge" : ""}, ExportedHandlerMethods } from "alchemy/Cloudflare";
-  
-  import entry from "${importPath}";
-  
-  const tag = Context.Service("${Self.key}")
-  const layer =
+  const hasDoClasses = doClasses.length > 0;
+  const hasWfClasses = wfClasses.length > 0;
+  return (importPath: string) => `
+import * as Config from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Context from "effect/Context";
+import * as Stream from "effect/Stream";
+
+import { env, DurableObject${hasWfClasses ? ", WorkflowEntrypoint" : ""} } from "cloudflare:workers";
+import { MinimumLogLevel } from "effect/References";
+import { NodeServices } from "@effect/platform-node";
+import { Stack } from "alchemy/Stack";
+import { WorkerEnvironment, makeDurableObjectBridge${hasWfClasses ? ", makeWorkflowBridge" : ""}, ExportedHandlerMethods } from "alchemy/Cloudflare";
+
+import entry from "${importPath}";
+
+const tag = Context.Service("${Self.key}")
+const layer =
   typeof entry?.build === "function"
-  ? entry
-  : Layer.effect(tag, typeof entry?.asEffect === "function" ? entry.asEffect() : entry);
-  
-  const platform = Layer.mergeAll(
+    ? entry
+    : Layer.effect(tag, typeof entry?.asEffect === "function" ? entry.asEffect() : entry);
+
+const platform = Layer.mergeAll(
   NodeServices.layer,
   FetchHttpClient.layer,
   // TODO(sam): wire this up to telemetry more directly
   Logger.layer([Logger.consolePretty()]),
-  );
-  
-  const stack = Layer.succeed(
+);
+
+const stack = Layer.succeed(
   Stack,
   {
-  name: "${stack.name}",
-  stage: "${stack.stage}",
-  bindings: {},
-  resources: {}
+    name: "${stack.name}",
+    stage: "${stack.stage}",
+    bindings: {},
+    resources: {}
   }
-  );
-  
-  const exportsEffect = tag.asEffect().pipe(
-  Effect.flatMap(func => func.ExecutionContext.exports),
-  Effect.map(exports => exports),
+);
+
+const exportsEffect = tag.asEffect().pipe(
+  Effect.flatMap(func => func.RuntimeContext.exports),
   Effect.provide(
-  layer.pipe(
-  Layer.provideMerge(stack),
-  // TODO(sam): additional credentials?
-  Layer.provideMerge(platform),
-  Layer.provideMerge(
-  Layer.succeed(
-    ConfigProvider.ConfigProvider,
-    ConfigProvider.orElse(
-      ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
-      ConfigProvider.fromUnknown(env),
+    layer.pipe(
+      Layer.provideMerge(stack),
+      Layer.provideMerge(platform),
+      Layer.provideMerge(
+        Layer.succeed(
+          ConfigProvider.ConfigProvider,
+          ConfigProvider.orElse(
+            ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
+            ConfigProvider.fromUnknown(env),
+          ),
+        ),
+      ),
+      Layer.provideMerge(Layer.succeed(WorkerEnvironment, env)),
+      Layer.provideMerge(
+        Layer.succeed(MinimumLogLevel, env.DEBUG ? "Debug" : "Info"),
+      ),
     ),
-  )
   ),
-  Layer.provideMerge(
-  Layer.succeed(
-    WorkerEnvironment,
-    env,
-  )
-  ),
-  Layer.provideMerge(
-  Layer.succeed(
-    MinimumLogLevel,
-    env.DEBUG ? "Debug" : "Info",
-  )
-  ),
-  )
-  ),
-  Effect.scoped
-  );
-  
-  // TODO(sam): we could kick this off during module init, but any I/O will break deploy
-  // let exportsPromise = Effect.runPromise(exportsEffect);
-  
-  // for now, we delay initializing the worker until the first request
-  let exportsPromise;
-  
-  // don't initialize the workerEffect during module init because Cloudflare does not allow I/O during module init
-  // we cache it synchronously (??=) to guarnatee only one initialization ever happens
-  const getExports = () => (exportsPromise ??= Effect.runPromise(exportsEffect))
-  const getExport = (name) => getExports().then(exports => exports[name]?.make)
-  const worker = () => getExports().then(exports => exports.default)
-  
-  export default Object.fromEntries(ExportedHandlerMethods.map(
+  Effect.scoped,
+);
+
+// TODO(sam): we could kick this off during module init, but any I/O will break deploy
+// let exportsPromise = Effect.runPromise(exportsEffect);
+
+// for now, we delay initializing the worker until the first request
+let exportsPromise;
+
+// don't initialize the workerEffect during module init because Cloudflare does not allow I/O during module init
+// we cache it synchronously (??=) to guarnatee only one initialization ever happens
+const getExports = () => (exportsPromise ??= Effect.runPromise(exportsEffect))
+const getExport = (name) => getExports().then(exports => exports[name]?.make)
+const worker = () => getExports().then(exports => exports.default)
+
+export default Object.fromEntries(ExportedHandlerMethods.map(
   method => [method, async (...args) => (await worker())[method](...args)])
-  ) satisfies Required<cf.ExportedHandler>;
-  
-  // export class proxy stubs for Durable Objects and Workflows
-  ${[
-    ...(durableObjectClasses.length > 0
-      ? [
-          "const DurableObjectBridge = makeDurableObjectBridge(DurableObject, getExport);",
-          ...durableObjectClasses.map(
-            (id) =>
-              `export class ${id} extends DurableObjectBridge("${id}") {}`,
-          ),
-        ]
-      : []),
-    ...(workflowClasses.length > 0
-      ? [
-          "const WorkflowBridgeFn = makeWorkflowBridge(WorkflowEntrypoint, getExport);",
-          ...workflowClasses.map(
-            (id) => `export class ${id} extends WorkflowBridgeFn("${id}") {}`,
-          ),
-        ]
-      : []),
-  ].join("\n")}
-  `;
+);
+
+// export class proxy stubs for Durable Objects and Workflows
+${[
+  ...(hasDoClasses
+    ? [
+        "const DurableObjectBridge = makeDurableObjectBridge(DurableObject, getExport);",
+        ...doClasses.map(
+          (id) => `export class ${id} extends DurableObjectBridge("${id}") {}`,
+        ),
+      ]
+    : []),
+  ...(hasWfClasses
+    ? [
+        "const WorkflowBridgeFn = makeWorkflowBridge(WorkflowEntrypoint, getExport);",
+        ...wfClasses.map(
+          (id) => `export class ${id} extends WorkflowBridgeFn("${id}") {}`,
+        ),
+      ]
+    : []),
+].join("\n")}
+`;
 };

package/src/Cloudflare/Workers/Workflow.ts

@@ -480,12 +480,17 @@ export const WorkflowProvider = () =>
 
       return WorkflowResource.Provider.of({
         stables: ["workflowId", "accountId"],
-        create: Effect.fnUntraced(function* ({ news }) {
+        reconcile: Effect.fnUntraced(function* ({ news, output }) {
+          const acct = output?.accountId ?? accountId;
           yield* Effect.logInfo(
-            `Cloudflare Workflow create: ${news.workflowName}`,
+            `Cloudflare Workflow reconcile: ${news.workflowName}`,
           );
+          // Cloudflare's `putWorkflow` is a true PUT-as-upsert: identical
+          // payloads converge to the same state and a missing workflow is
+          // created on the spot. There is no separate observe step needed
+          // — the API is naturally reconciler-shaped.
           const result = yield* putWorkflow({
-            accountId,
+            accountId: acct,
             workflowName: news.workflowName,
             className: news.className,
             scriptName: news.scriptName,
@@ -495,25 +500,7 @@ export const WorkflowProvider = () =>
             workflowName: result.name,
             className: result.className,
             scriptName: result.scriptName,
-            accountId,
-          };
-        }),
-        update: Effect.fnUntraced(function* ({ news, output }) {
-          yield* Effect.logInfo(
-            `Cloudflare Workflow update: ${news.workflowName}`,
-          );
-          const result = yield* putWorkflow({
-            accountId: output.accountId,
-            workflowName: news.workflowName,
-            className: news.className,
-            scriptName: news.scriptName,
-          });
-          return {
-            workflowId: result.id,
-            workflowName: result.name,
-            className: result.className,
-            scriptName: result.scriptName,
-            accountId: output.accountId,
+            accountId: acct,
           };
         }),
         delete: Effect.fnUntraced(function* ({ output }) {

package/src/Cloudflare/index.ts

@@ -5,11 +5,14 @@ export * from "./CloudflareEnvironment.ts";
 export * from "./Container/index.ts";
 export * from "./D1/index.ts";
 export * from "./EdgeSession.ts";
+export * from "./Hyperdrive/index.ts";
 export * from "./KV/index.ts";
 export * from "./Providers.ts";
 export * from "./Queue/index.ts";
 export * from "./R2/index.ts";
 export * from "./SecretsStore/index.ts";
 export * from "./StateStore/index.ts";
+export * from "./Tunnel/index.ts";
+export * from "./VpcService/index.ts";
 export * from "./Website/index.ts";
 export * from "./Workers/index.ts";

package/src/Deploy.ts

@@ -9,9 +9,11 @@ import { Stage } from "./Stage.ts";
 export const deploy = <A>({
   stack,
   stage,
+  dev,
 }: {
   stack: StackEffect<CompiledStack<A>, Stage | AlchemyContext>;
   stage: string;
+  dev?: boolean;
 }) =>
   evalStack(
     stack,
@@ -21,5 +23,5 @@ export const deploy = <A>({
         const output = yield* Apply.apply(plan);
         return output as Input.Resolve<A>;
       }),
-    { stage },
+    { stage, dev },
   );

package/src/Destroy.ts

@@ -9,9 +9,11 @@ import type { Stage } from "./Stage.ts";
 export const destroy = ({
   stack,
   stage,
+  dev,
 }: {
   stack: StackEffect<CompiledStack, Stage | AlchemyContext>;
   stage: string;
+  dev?: boolean;
 }) =>
   evalStack(
     stack,
@@ -24,5 +26,5 @@ export const destroy = ({
         bindings: {},
         output: {},
       }).pipe(Effect.flatMap(Apply.apply)),
-    { stage },
+    { stage, dev },
   );

package/src/Drizzle/Postgres.ts

@@ -0,0 +1,78 @@
+import * as PgClient from "@effect/sql-pg/PgClient";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm";
+import type { EffectPgDatabase } from "drizzle-orm/effect-postgres";
+import * as PgDrizzle from "drizzle-orm/effect-postgres";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { ExecutionContext } from "../ExecutionContext.ts";
+import { proxyChain } from "../Util/proxy-chain.ts";
+
+/**
+ * Open a Drizzle/Postgres database from a connection URL using the
+ * `drizzle-orm/effect-postgres` integration.
+ *
+ * Returns a chainable Proxy over `EffectPgDatabase` (via `proxyChain`) —
+ * every property read records a step, every call records args, and the
+ * chain is replayed against the resolved drizzle db when it's finally
+ * yielded as an Effect. Callers don't need a separate `yield* conn` step:
+ *
+ * ```typescript
+ * const db = yield* Drizzle.postgres(hd.connectionString);
+ *
+ * fetch: Effect.gen(function* () {
+ *   const rows = yield* db.select().from(users);
+ * });
+ * ```
+ *
+ * Behind the scenes the actual connect work is wrapped in `Effect.cached`,
+ * so the pool is built at most once per JS realm. Yielding the
+ * connection string is also deferred until first query, so deploy /
+ * plan-time invocations (where `WorkerEnvironment` isn't provided)
+ * never trigger a real connection attempt.
+ *
+ * The PgClient pool is built against an isolated, never-closing `Scope`
+ * so it outlives whatever scope this helper is yielded under. In a
+ * Cloudflare Worker the surrounding `Cloudflare.Worker` runs init
+ * inside `Effect.scoped`, which closes after returning the exports
+ * object — without an isolated scope, the pool's `end` finalizer
+ * would fire there and every subsequent request would see "Cannot
+ * use a pool after end".
+ *
+ * @binding
+ */
+
+export const postgres = <
+  TRelations extends AnyRelations = EmptyRelations,
+  E = never,
+  R = never,
+>(
+  connectionString: Effect.Effect<Redacted.Redacted<string>, E, R>,
+  config?: PgDrizzle.EffectDrizzlePgConfig<TRelations>,
+) =>
+  Effect.sync(function () {
+    const symbol = Symbol();
+
+    return proxyChain<
+      EffectPgDatabase<TRelations> & {
+        $client: PgClient.PgClient;
+      }
+    >(
+      Effect.gen(function* () {
+        const ctx = yield* ExecutionContext;
+        return yield* (ctx.cache[symbol] ??= yield* Effect.gen(function* () {
+          const pgCtx = yield* Layer.buildWithScope(
+            PgClient.layer({ url: yield* connectionString }),
+            ctx.scope,
+          );
+          return yield* PgDrizzle.makeWithDefaults(config).pipe(
+            Effect.provideContext(pgCtx),
+          );
+        }).pipe(Effect.cached));
+      }) as Effect.Effect<
+        EffectPgDatabase<TRelations> & {
+          $client: PgClient.PgClient;
+        }
+      >,
+    );
+  });

package/src/Drizzle/Providers.ts

@@ -0,0 +1,53 @@
+import * as Layer from "effect/Layer";
+import * as Provider from "../Provider.ts";
+import { Schema, SchemaProvider } from "./Schema.ts";
+
+export class Providers extends Provider.ProviderCollection<Providers>()(
+  "Drizzle",
+) {}
+
+export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
+
+/**
+ * Build-time providers for managing Drizzle schemas as Alchemy resources.
+ * Drizzle.Schema regenerates migration SQL via drizzle-kit's programmatic
+ * API on every deploy when the source schema changes.
+ *
+ * @example
+ * ```typescript
+ * import * as Alchemy from "alchemy";
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Drizzle from "alchemy/Drizzle";
+ * import * as Neon from "alchemy/Neon";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ *
+ * export default Alchemy.Stack(
+ *   "MyStack",
+ *   {
+ *     providers: Layer.mergeAll(
+ *       Cloudflare.providers(),
+ *       Drizzle.providers(),
+ *       Neon.providers(),
+ *     ),
+ *     state: Alchemy.localState(),
+ *   },
+ *   Effect.gen(function* () {
+ *     const schema = yield* Drizzle.Schema("app-schema", {
+ *       schema: "./src/schema.ts",
+ *     });
+ *     const project = yield* Neon.Project("app-db");
+ *     const branch = yield* Neon.Branch("app-branch", {
+ *       project,
+ *       migrationsDir: schema.out,
+ *     });
+ *     return { branchId: branch.branchId };
+ *   }),
+ * );
+ * ```
+ */
+export const providers = () =>
+  Layer.effect(Providers, Provider.collection([Schema])).pipe(
+    Layer.provide(SchemaProvider()),
+    Layer.orDie,
+  );