alchemy 2.0.0-beta.36 → 2.0.0-beta.37

package/src/Test/Core.ts

@@ -2,6 +2,7 @@ import { ConfigProvider } from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Scope from "effect/Scope";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 
 import { AdoptPolicy } from "../AdoptPolicy.ts";
@@ -90,14 +91,22 @@ const alchemyLayer = Layer.mergeAll(LoggingCli, AlchemyContextLive);
  * registry that the user's `providers` layer populates, the platform layers,
  * and the configured state store. Adapters wrap this into runner-specific
  * thunks (`bun.test` -> `runPromise`, `it.live` -> as-is).
+ *
+ * When `scope` is provided, scoped resources (like the Cloudflare dev
+ * sidecar) survive past this effect and are tied to the lifetime of the
+ * provided scope instead. The runner is responsible for closing it.
+ *
+ * When `scope` is omitted, the effect runs with `Effect.scoped` and any
+ * scoped resources are torn down as soon as it resolves.
  */
 export const toEffect = <A>(
   effect: TestEffect<A>,
   options: MakeOptions,
-): Effect.Effect<A, any, never> =>
-  Effect.gen(function* () {
-    const base = yield* loadConfigProvider(Option.none());
-    const configProvider = withProfileOverride(base, options.profile);
+  scope?: Scope.Scope,
+): Effect.Effect<A, any, never> => {
+  const base = Effect.gen(function* () {
+    const cfg = yield* loadConfigProvider(Option.none());
+    const configProvider = withProfileOverride(cfg, options.profile);
     return yield* effect.pipe(
       provideFreshArtifactStore,
       Effect.provide(Layer.succeed(ConfigProvider, configProvider)),
@@ -112,14 +121,19 @@ export const toEffect = <A>(
     Effect.provide(options.state ?? State.localState()),
     Effect.provideService(AuthProviders, {}),
     Effect.provide(Layer.provideMerge(alchemyLayer, platformLayer)),
-    Effect.scoped,
+  );
+
+  return (
+    scope === undefined ? Effect.scoped(base) : Scope.provide(base, scope)
   ) as Effect.Effect<A, any, never>;
+};
 
 /** Promise wrapper around {@link toEffect} for `bun.test`-style runners. */
 export const run = <A>(
   effect: TestEffect<A>,
   options: MakeOptions,
-): Promise<A> => Effect.runPromise(toEffect(effect, options));
+  scope?: Scope.Scope,
+): Promise<A> => Effect.runPromise(toEffect(effect, options, scope));
 
 /**
  * Wrap an effect so it runs with `options.providers` + a placeholder Stack +
@@ -148,27 +162,34 @@ export const withProviders = <A, E, R, ROut>(
  * Curried `deploy` for the test factory: bakes in the configured stage and
  * adds the telemetry layer the CLI uses, so `beforeAll(deploy(Stack))` works
  * the same way as `alchemy deploy`.
+ *
+ * `scope`, when supplied, is forwarded down so the dev sidecar (and other
+ * scoped resources) lives until the caller closes it instead of dying as
+ * soon as `deploy` resolves. The test harness uses this to keep workerd
+ * alive across `beforeAll` → tests → `afterAll`.
  */
 export const deploy = <A>(
   options: MakeOptions,
   stack: TestEffect<CompiledStack<A>, Stage | AlchemyContext>,
-  callOptions?: { stage?: string },
+  callOptions?: { stage?: string; scope?: Scope.Scope },
 ) =>
   _deploy({
     stack: stack as Effect.Effect<CompiledStack<A>, never, any>,
     stage: callOptions?.stage ?? options.stage ?? "test",
     dev: resolveDev(options),
+    scope: callOptions?.scope,
   }).pipe(Effect.provide(TelemetryLive));
 
 export const destroy = (
   options: MakeOptions,
   stack: TestEffect<CompiledStack, Stage | AlchemyContext>,
-  callOptions?: { stage?: string },
+  callOptions?: { stage?: string; scope?: Scope.Scope },
 ) =>
   _destroy({
     stack: stack as Effect.Effect<CompiledStack, never, any>,
     stage: callOptions?.stage ?? options.stage ?? "test",
     dev: resolveDev(options),
+    scope: callOptions?.scope,
   }).pipe(Effect.provide(TelemetryLive));
 
 /**

package/src/Test/Vitest.ts

@@ -1,5 +1,7 @@
 import { it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Scope from "effect/Scope";
 import {
   afterAll as vitestAfterAll,
   afterEach as vitestAfterEach,
@@ -98,8 +100,13 @@ const DEFAULT_TIMEOUT = 120_000;
  * Effect-aware tests stay first-class.
  */
 export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
-  const wrap = <A>(eff: TestEffect<A>) => Core.toEffect(eff, options);
-  const runEff = <A>(eff: TestEffect<A>) => Core.run(eff, options);
+  // See `Test/Bun.ts` for the rationale: the dev sidecar must outlive a
+  // single `runPromise` boundary, so all hooks share one scope that's only
+  // closed after `destroy(...)` runs.
+  const sharedScope = Scope.makeUnsafe("sequential");
+  const wrap = <A>(eff: TestEffect<A>) =>
+    Core.toEffect(eff, options, sharedScope);
+  const runEff = <A>(eff: TestEffect<A>) => Core.run(eff, options, sharedScope);
 
   const test = ((name, eff, opts) => {
     it.live(name, () => wrap(eff), timeoutOf(opts));
@@ -130,6 +137,7 @@ export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
     return Core.toEffect(
       Core.withProviders(fn(scratch), options, scratch.name),
       { ...options, state: scratch.state },
+      sharedScope,
     );
   };
 
@@ -182,13 +190,34 @@ export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
     vitestAfterEach(() => runEff(eff), timeoutOf(hookOptions));
   };
 
+  // `destroy(Stack)` needs the dev sidecar alive so it can call `sidecar.stop`.
+  // `Scope.close` on an already-closed scope is a no-op, so the destroy
+  // wrapper AND the fallback cleanup hook below can both call it safely.
+  const closeScope = Effect.suspend(() =>
+    Scope.close(sharedScope, Exit.void),
+  ).pipe(Effect.ignore);
+
+  // Fallback cleanup: if the user never calls `destroy(Stack)` (e.g.
+  // `NO_DESTROY=1`), nothing else closes the shared scope and the sidecar
+  // child process leaks past the test process. Register an `afterAll` that
+  // closes it. We defer registration to a microtask so it runs AFTER any
+  // user-registered `afterAll` (including `destroy(Stack)`); vitest runs
+  // afterAll hooks in registration order.
+  queueMicrotask(() => {
+    vitestAfterAll(() => Effect.runPromise(closeScope), DEFAULT_TIMEOUT);
+  });
+
   return {
     test,
     beforeAll,
     beforeEach,
     afterAll,
     afterEach,
-    deploy: (stack, callOpts) => Core.deploy(options, stack, callOpts),
-    destroy: (stack, callOpts) => Core.destroy(options, stack, callOpts),
+    deploy: (stack, callOpts) =>
+      Core.deploy(options, stack, { ...callOpts, scope: sharedScope }),
+    destroy: (stack, callOpts) =>
+      Core.destroy(options, stack, { ...callOpts, scope: sharedScope }).pipe(
+        Effect.ensuring(closeScope),
+      ),
   };
 };

package/src/Util/LocalhostDns.ts

@@ -1,22 +1,27 @@
 /**
- * Process-level DNS shim that makes `*.localhost` resolve to 127.0.0.1.
+ * Process-level DNS shim that makes `*.localhost` resolve to 127.0.0.1
+ * for any HTTP client that goes through undici (Node's global `fetch`,
+ * undici-based clients, etc.).
  *
  * Background: macOS's `getaddrinfo` does not honor RFC 6761 for arbitrary
- * `*.localhost` names; only the bare `localhost` is mapped to loopback.
- * workerd and browsers handle it themselves, but Node's undici-based fetch
- * (and Bun's libcurl-based fetch on some platforms) fails with `ENOTFOUND`
- * when calling URLs returned by the local Cloudflare worker proxy
- * (e.g. `http://my-worker.localhost:1337`).
+ * `*.localhost` names — only the bare `localhost` is mapped to loopback.
+ * The Cloudflare local proxy returns URLs like
+ * `http://my-worker.localhost:1337` and dispatches by the URL hostname,
+ * so we cannot rewrite the URL client-side to `127.0.0.1` (and `Host` is
+ * a forbidden fetch header). The fix is to make the host resolvable at
+ * the network layer.
  *
- * The proxy in `@distilled.cloud/cloudflare-runtime` dispatches by the
- * URL hostname, so we cannot rewrite the URL client-side to `127.0.0.1`
- * (and `Host` is a forbidden fetch header). The fix is to make the host
- * resolvable at the network layer.
+ * On Bun, `globalThis.fetch` is the native (Zig) implementation and does
+ * not consult undici's global dispatcher; Bun resolves `*.localhost`
+ * itself on Darwin/Linux, so this shim is effectively a no-op there for
+ * the global `fetch` and only matters if user code reaches for `undici`
+ * directly.
  *
  * Calling `installLocalhostDns()` is idempotent.
  */
 
-import { createRequire } from "node:module";
+import * as dns from "node:dns";
+import * as undici from "undici";
 
 let installed = false;
 
@@ -28,31 +33,20 @@ const isLocalhost = (hostname: string): boolean =>
 export const installLocalhostDns = (): void => {
   if (installed) return;
   installed = true;
-  // Bun resolves `*.localhost` natively via its libcurl-based fetch on
-  // Darwin and Linux, so the shim is a no-op there. If a future Bun
-  // release changes this, install via Bun's undici-compatible global
-  // dispatcher here.
-  if (typeof (globalThis as { Bun?: unknown }).Bun !== "undefined") return;
-  try {
-    const require = createRequire(import.meta.url);
-    const undici: typeof import("undici") = require("undici");
-    const dns: typeof import("node:dns") = require("node:dns");
-    undici.setGlobalDispatcher(
-      new undici.Agent({
-        connect: {
-          lookup: (hostname, options, cb: any) => {
-            if (isLocalhost(hostname)) {
-              if (options && (options as { all?: boolean }).all) {
-                return cb(null, [{ address: "127.0.0.1", family: 4 }]);
-              }
-              return cb(null, "127.0.0.1", 4);
+
+  undici.setGlobalDispatcher(
+    new undici.Agent({
+      connect: {
+        lookup: (hostname, options, cb) => {
+          if (isLocalhost(hostname)) {
+            if (options && (options as { all?: boolean }).all) {
+              return cb(null, [{ address: "127.0.0.1", family: 4 }]);
             }
-            return dns.lookup(hostname, options, cb);
-          },
+            return cb(null, "127.0.0.1", 4);
+          }
+          return dns.lookup(hostname, options, cb);
         },
-      }),
-    );
-  } catch {
-    // undici not available; nothing to do.
-  }
+      },
+    }),
+  );
 };

package/src/Util/effect.ts

@@ -64,6 +64,31 @@ export const taggedFunction = <
   }) as Tag & Fn;
 };
 
+export const isYieldableEffect = (
+  value: unknown,
+): value is Effect.Effect<unknown, unknown, unknown> =>
+  Effect.isEffect(value) &&
+  typeof (value as { [Symbol.iterator]?: unknown })[Symbol.iterator] ===
+    "function";
+
+export type YieldableEffectLike<A = unknown, E = unknown, R = unknown> =
+  | Effect.Effect<A, E, R>
+  | {
+      asEffect: () => Effect.Effect<A, E, R>;
+      [Symbol.iterator]: () => Iterator<unknown>;
+    };
+
+export const isEffectClassLike = (
+  value: unknown,
+): value is YieldableEffectLike =>
+  typeof value === "function" &&
+  typeof (value as { asEffect?: unknown }).asEffect === "function";
+
+export const isYieldableEffectLike = (
+  value: unknown,
+): value is YieldableEffectLike =>
+  isYieldableEffect(value) || isEffectClassLike(value);
+
 export type UnwrapEffect<T> =
   T extends Effect.Effect<infer A, any, any> ? A : T;
 

package/src/Variable.ts

@@ -0,0 +1,44 @@
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as Output from "./Output.ts";
+import { toOutput } from "./Secret.ts";
+
+/**
+ * The shapes a {@link variable} can be derived from.
+ */
+export type VariableInput<T, R = never> =
+  | T
+  | Effect.Effect<T, any, R>
+  | Config.Config<T>;
+
+/**
+ * Bind a non-secret value into the active {@link RuntimeContext} (e.g. a
+ * Cloudflare Worker's `env`) under the given `name`. Counterpart to
+ * {@link Secret} for plain (non-redacted) values — the resource provider
+ * deploys it as `plain_text` / `json` rather than `secret_text`.
+ *
+ * The result is an `Output<T>` — `yield*`-ing it returns an `Accessor<T>`
+ * that resolves the value at runtime.
+ *
+ * @example One-arg shortcut — reads `Config.string("DATABASE_URL")`
+ * ```ts
+ * const url = yield* Alchemy.Variable("DATABASE_URL");
+ * ```
+ *
+ * @example From a literal
+ * ```ts
+ * const port = yield* Alchemy.Variable("PORT", 3000);
+ * ```
+ */
+export function Variable(name: string): Output.Output<string, never>;
+export function Variable<T, R = never>(
+  name: string,
+  value: VariableInput<T, R>,
+): Output.Output<T, R>;
+export function Variable<T = string, R = never>(
+  name: string,
+  value?: VariableInput<T, R>,
+): Output.Output<T, R> {
+  const source: any = value ?? Config.string(name);
+  return Output.named(toOutput<T, R>(source), name);
+}

package/src/index.ts

@@ -14,6 +14,7 @@ export * from "./Diff.ts";
 export * from "./Input.ts";
 export * from "./InstanceId.ts";
 export * from "./Namespace.ts";
+export { stackRef } from "./Output.ts";
 export type { Output } from "./Output.ts";
 export * from "./PhysicalName.ts";
 export * as Plan from "./Plan.ts";
@@ -23,12 +24,14 @@ export * from "./Ref.ts";
 export * as RemovalPolicy from "./RemovalPolicy.ts";
 export * from "./Resource.ts";
 export * as Schema from "./Schema.ts";
+export { Secret } from "./Secret.ts";
 export * as Server from "./Server/index.ts";
 export * as Serverless from "./Serverless/index.ts";
 export { Stack } from "./Stack.ts";
 export * from "./Stage.ts";
 export { inMemoryState, localState } from "./State/index.ts";
 export * from "./Trait.ts";
+export { Variable } from "./Variable.ts";
 
 export * as Construct from "./Construct.ts";