alchemy 2.0.0-beta.25 → 2.0.0-beta.27

package/src/Cloudflare/Workers/Worker.ts

@@ -1010,7 +1010,6 @@ export const LiveWorkerProvider = () =>
       const getScriptSubdomain = yield* workers.getScriptSubdomain;
       const getScriptSettings = yield* workers.getScriptScriptAndVersionSetting;
       const getSubdomain = yield* workers.getSubdomain;
-      const listScripts = yield* workers.listScripts;
       const putScript = yield* workers.putScript;
       const putDomain = yield* workers.putDomain;
       const listDomains = yield* workers.listDomains;
@@ -1139,9 +1138,7 @@ export const LiveWorkerProvider = () =>
 
           // Detach what's no longer wanted. Use the live list so we
           // don't try to delete domains we no longer track.
-          const toRemove = liveAll.filter(
-            (d) => !desiredSet.has(d.hostname),
-          );
+          const toRemove = liveAll.filter((d) => !desiredSet.has(d.hostname));
           yield* Effect.all(
             toRemove.map((d) =>
               deleteDomain({ accountId, domainId: d.id }).pipe(
@@ -1208,10 +1205,9 @@ export const LiveWorkerProvider = () =>
             };
           });
 
-          const applied = yield* Effect.all(
-            desired.map(attachDomain),
-            { concurrency: "unbounded" },
-          );
+          const applied = yield* Effect.all(desired.map(attachDomain), {
+            concurrency: "unbounded",
+          });
           return applied;
         });
 
@@ -1650,12 +1646,7 @@ ${[
           yield* Effect.logInfo(
             `Cloudflare Worker ${olds ? "update" : "create"}: uploading assets for ${name}`,
           );
-          const { jwt } = yield* uploadAssets(
-            accountId,
-            name,
-            assets,
-            session,
-          );
+          const { jwt } = yield* uploadAssets(accountId, name, assets, session);
           metadataAssets = {
             jwt,
             config: assets.config,
@@ -2140,42 +2131,36 @@ ${[
             yield* Effect.logInfo(
               `Cloudflare Worker read: checking ${workerName}`,
             );
-            const [worker, subdomain, settings, domainsList] =
-              yield* Effect.all([
-                listScripts({
-                  accountId,
-                }).pipe(
-                  Effect.map((workers) =>
-                    workers.result.find((worker) => worker.id === workerName),
-                  ),
-                ),
-                getScriptSubdomain({
-                  accountId,
-                  scriptName: workerName,
-                }),
-                getScriptSettings({
-                  accountId,
-                  scriptName: workerName,
-                }),
-                listDomains({
-                  accountId,
-                  service: workerName,
-                }).pipe(Effect.map((r) => r.result ?? [])),
-              ]);
-            if (!worker) {
-              yield* Effect.logInfo(
-                `Cloudflare Worker read: ${workerName} not found in script list`,
-              );
-              return undefined;
-            }
+            // We deliberately don't call `listScripts({ accountId })` here:
+            // it pulls every Worker on the account back through a strict
+            // schema decode, and a single existing Worker the schema doesn't
+            // know about (e.g. `placement_mode: "targeted"`) breaks the
+            // entire read. `getScriptSettings` already fails with
+            // `WorkerNotFound` if the script doesn't exist, which the
+            // surrounding `Effect.catchTag` turns into `undefined` — that's
+            // all the existence check we need.
+            const [subdomain, settings, domainsList] = yield* Effect.all([
+              getScriptSubdomain({
+                accountId,
+                scriptName: workerName,
+              }),
+              getScriptSettings({
+                accountId,
+                scriptName: workerName,
+              }),
+              listDomains({
+                accountId,
+                service: workerName,
+              }).pipe(Effect.map((r) => r.result ?? [])),
+            ]);
             yield* Effect.logInfo(
               `Cloudflare Worker read: found ${workerName}`,
             );
             return {
               accountId,
-              workerId: worker.id ?? workerName,
+              workerId: workerName,
               workerName,
-              logpush: worker.logpush ?? undefined,
+              logpush: settings.logpush ?? undefined,
               url: subdomain.enabled
                 ? `https://${workerName}.${yield* getAccountSubdomain(accountId)}.workers.dev`
                 : undefined,

package/src/Output.ts

@@ -499,7 +499,9 @@ export const upstreamAny = (
 ): {
   [ID in string]: Resource;
 } => {
-  if (isExpr(value)) {
+  if (isResource(value)) {
+    return { [value.FQN]: value as Resource };
+  } else if (isExpr(value)) {
     return upstream(value);
   } else if (Array.isArray(value)) {
     return Object.assign({}, ...value.map(resolveUpstream));
@@ -517,7 +519,11 @@ export const upstreamAny = (
 
 // TODO(sam): add a type
 export const upstream = <E extends Output<any, any>>(expr: E): any => {
-  if (isResourceExpr(expr)) {
+  if (isResource(expr)) {
+    return {
+      [(expr as unknown as Resource).FQN]: expr,
+    };
+  } else if (isResourceExpr(expr)) {
     return {
       [expr.src.FQN]: expr.src,
     };
@@ -541,6 +547,8 @@ export const upstream = <E extends Output<any, any>>(expr: E): any => {
 export const resolveUpstream = <const A>(value: A): any => {
   if (isPrimitive(value)) {
     return {} as any;
+  } else if (isResource(value)) {
+    return { [(value as unknown as Resource).FQN]: value } as any;
   } else if (isOutput(value)) {
     return upstream(value) as any;
   } else if (Array.isArray(value)) {

package/src/Provider.ts

@@ -5,7 +5,7 @@ import * as Option from "effect/Option";
 import type * as Stream from "effect/Stream";
 import type { Artifacts } from "./Artifacts.ts";
 import type { Policy } from "./Binding.ts";
-import type { ScopedPlanStatusSession } from "./Cli/index.ts";
+import type { ScopedPlanStatusSession } from "./Cli/Cli.ts";
 import type { Diff } from "./Diff.ts";
 import type { Input } from "./Input.ts";
 import type { InstanceId } from "./InstanceId.ts";

package/src/Stack.ts

@@ -184,7 +184,7 @@ export const make =
                 `    providers: Cloudflare.providers(),\n` +
                 `    state: Cloudflare.state(), // <-- required\n` +
                 `  }, ...)\n` +
-                `See https://alchemy.run/concepts/state-store for available state stores.`,
+                `See https://v2.alchemy.run/concepts/state-store for available state stores.`,
             ),
           );
         }
@@ -249,7 +249,7 @@ export const CurrentStack = Effect.serviceOption(Stack)
 const platform = Layer.mergeAll(
   PlatformServices,
   FetchHttpClient.layer,
-  Logger.layer([fileLogger("out")]),
+  Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
 );
 // override alchemy state store, CLI/reporting, state, and Config
 const alchemy = Layer.mergeAll(

package/src/Telemetry/Layer.ts

@@ -1,6 +1,7 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as OtlpLogger from "effect/unstable/observability/OtlpLogger";
 import * as OtlpMetrics from "effect/unstable/observability/OtlpMetrics";
 import * as OtlpSerialization from "effect/unstable/observability/OtlpSerialization";
 import * as OtlpTracer from "effect/unstable/observability/OtlpTracer";
@@ -11,6 +12,7 @@ import { collectAttributes, isTelemetryDisabled } from "./Attributes.ts";
 
 const TRACES_URL = "https://otel.alchemy.run/v1/traces";
 const METRICS_URL = "https://otel.alchemy.run/v1/metrics";
+const LOGS_URL = "https://otel.alchemy.run/v1/logs";
 
 const SERVICE_NAME = "alchemy-cli";
 
@@ -35,8 +37,18 @@ const buildOtlpLayer = (
     resource,
     exportInterval: "1 second",
   });
+  // Replace (don't merge with) the default stdout logger here; downstream
+  // commands re-add their own `fileLogger`/`consolePretty` via
+  // `Logger.layer([...], { mergeWithExisting: true })`, which stacks on top
+  // of this OtlpLogger without resurrecting Effect's default stdout logger.
+  const logger = OtlpLogger.layer({
+    url: LOGS_URL,
+    resource,
+    exportInterval: "1 second",
+    mergeWithExisting: false,
+  });
 
-  return Layer.mergeAll(tracer, metrics).pipe(
+  return Layer.mergeAll(tracer, metrics, logger).pipe(
     Layer.provide(OtlpSerialization.layerJson),
     Layer.provide(FetchHttpClient.layer),
   );

package/src/Test/Bun.ts

@@ -1,163 +1,187 @@
 import bun from "bun:test";
-import { ConfigProvider } from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Logger from "effect/Logger";
-import * as Option from "effect/Option";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import type { HookOptions } from "node:test";
-import { AlchemyContext, AlchemyContextLive } from "../AlchemyContext.ts";
-import { provideFreshArtifactStore } from "../Artifacts.ts";
-import { AuthProviders } from "../Auth/AuthProvider.ts";
-import { inkCLI } from "../Cli/InkCLI.tsx";
-import { deploy as _deploy } from "../Deploy.ts";
-import { destroy as _destroy } from "../Destroy.ts";
-import {
-  type CompiledStack,
-  type StackEffect,
-  type StackServices,
-} from "../Stack.ts";
-import * as State from "../State/index.ts";
-import { loadConfigProvider } from "../Util/ConfigProvider.ts";
-import { PlatformServices } from "../Util/PlatformServices.ts";
-
-export type ProvidedServices = StackServices;
-
-type TestEffect<A, Req = never> = StackEffect<A, any, Req>;
-
-const platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer);
-
-// override alchemy state store, CLI/reporting, state, and dotAlchemy
-const alchemy = Layer.mergeAll(
-  inkCLI(),
-  Logger.layer([Logger.consolePretty()]),
-  AlchemyContextLive,
-);
-
-const run = <A>(effect: TestEffect<A>) =>
-  Effect.gen(function* () {
-    const configProvider = yield* loadConfigProvider(Option.none());
-
-    return yield* effect.pipe(
-      provideFreshArtifactStore,
-      Effect.provide(Layer.succeed(ConfigProvider, configProvider)),
-    );
-  }).pipe(
-    Effect.provideService(AuthProviders, {}),
-    Effect.provide(State.localState()),
-    Effect.provide(Layer.provideMerge(alchemy, platform)),
-    Effect.scoped,
-    Effect.runPromise,
-  );
-
-export const it = test;
-
-export const expect = bun.expect;
-
-export function test(
-  name: string,
-  test: TestEffect<void>,
-  options?: bun.TestOptions,
-) {
-  bun.test(name, () => run(test), options);
+
+import type { AlchemyContext } from "../AlchemyContext.ts";
+import type { CompiledStack } from "../Stack.ts";
+import type { Stage } from "../Stage.ts";
+import * as Core from "./Core.ts";
+
+export type MakeOptions<ROut = any> = Core.MakeOptions<ROut>;
+export type ScratchStack = Core.ScratchStack;
+export type TestEffect<A, R = never> = Core.TestEffect<A, R>;
+
+export interface TestApi {
+  test: TestFn;
+  beforeAll: BeforeAllFn;
+  beforeEach: BeforeEachFn;
+  afterAll: AfterAllFn;
+  afterEach: AfterEachFn;
+  deploy: <A>(
+    stack: TestEffect<CompiledStack<A>, Stage | AlchemyContext>,
+    options?: { stage?: string },
+  ) => ReturnType<typeof Core.deploy<A>>;
+  destroy: (
+    stack: TestEffect<CompiledStack, Stage | AlchemyContext>,
+    options?: { stage?: string },
+  ) => ReturnType<typeof Core.destroy>;
 }
 
-export namespace test {
-  export function skipIf(condition: boolean) {
-    return (
-      name: string,
-      test: TestEffect<void>,
-      options?: bun.TestOptions,
-    ) => {
-      bun.test.skipIf(condition)(name, () => run(test), options);
-    };
-  }
-
-  export function skip(
+interface TestFn {
+  (name: string, eff: TestEffect<void>, options?: bun.TestOptions): void;
+  skip: (
     name: string,
-    test: TestEffect<void>,
+    eff: TestEffect<void>,
     options?: bun.TestOptions,
-  ) {
-    bun.test.skip(name, () => run(test), options);
-  }
-
-  export function only(
+  ) => void;
+  skipIf: (
+    condition: boolean,
+  ) => (name: string, eff: TestEffect<void>, options?: bun.TestOptions) => void;
+  only: (
     name: string,
-    test: TestEffect<void>,
+    eff: TestEffect<void>,
     options?: bun.TestOptions,
-  ) {
-    bun.test.only(name, () => run(test), options);
-  }
-
-  export function todo(
+  ) => void;
+  todo: (
     name: string,
-    test: TestEffect<void>,
+    eff: TestEffect<void>,
     options?: bun.TestOptions,
-  ) {
-    bun.test.todo(name, () => run(test), options);
-  }
+  ) => void;
+  provider: ProviderFn;
 }
 
-export const describe = bun.describe;
-
-export function beforeAll<A>(eff: TestEffect<A>, options?: HookOptions) {
-  let a: A;
-  bun.beforeAll(
-    () => run(eff).then((v) => (a = v)),
-    options ?? {
-      timeout: 120_000,
-    },
-  );
-  return Effect.sync(() => a);
+interface ProviderFn {
+  (
+    name: string,
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+    options?: bun.TestOptions,
+  ): void;
+  skip: (
+    name: string,
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+    options?: bun.TestOptions,
+  ) => void;
+  skipIf: (
+    condition: boolean,
+  ) => (
+    name: string,
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+    options?: bun.TestOptions,
+  ) => void;
 }
 
-export function beforeEach(eff: TestEffect<void>, options?: HookOptions) {
-  bun.beforeEach(() => run(eff), options);
+interface BeforeAllFn {
+  <A>(eff: TestEffect<A>, options?: HookOptions): Effect.Effect<A>;
 }
 
-export function afterAll(eff: TestEffect<any>, options?: HookOptions) {
-  bun.afterAll(() => run(eff), options);
+interface BeforeEachFn {
+  (eff: TestEffect<void>, options?: HookOptions): void;
 }
 
-export namespace afterAll {
-  export const skipIf =
-    (predicate: boolean) => (test: TestEffect<void>, options?: HookOptions) => {
-      if (predicate) {
-      } else {
-        bun.afterAll(
-          () => run(test),
-          options ?? {
-            timeout: 120_000,
-          },
-        );
-      }
-    };
+interface AfterAllFn {
+  (eff: TestEffect<any>, options?: HookOptions): void;
+  skipIf: (
+    predicate: boolean,
+  ) => (eff: TestEffect<any>, options?: HookOptions) => void;
 }
 
-export function afterEach(eff: TestEffect<void>, options?: HookOptions) {
-  bun.afterEach(() => run(eff), options);
+interface AfterEachFn {
+  (eff: TestEffect<void>, options?: HookOptions): void;
 }
 
-export const deploy = <A>(
-  stack: TestEffect<CompiledStack<A>, AlchemyContext>,
-  options?: {
-    /** @default test */
-    stage?: string;
-  },
-) =>
-  _deploy({
-    stack: stack,
-    stage: options?.stage ?? "test",
-  });
-
-export const destroy = (
-  stack: TestEffect<CompiledStack, AlchemyContext>,
-  options?: {
-    /** @default test */
-    stage?: string;
-  },
-) =>
-  _destroy({
-    stack,
-    stage: options?.stage ?? "test",
-  });
+const DEFAULT_HOOK_TIMEOUT: HookOptions = { timeout: 120_000 };
+
+/**
+ * Build the per-file test API. Configure providers / state once at the top of
+ * the test file:
+ *
+ * ```ts
+ * import * as Test from "alchemy/Test/Bun";
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ *
+ * const { test, deploy, destroy, beforeAll, afterAll } = Test.make({
+ *   providers: Cloudflare.providers(),
+ *   state: Cloudflare.state(),
+ * });
+ * ```
+ */
+export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
+  const runEff = <A>(eff: TestEffect<A>) => Core.run(eff, options);
+
+  const test = ((name, eff, opts) => {
+    bun.test(name, () => runEff(eff), opts);
+  }) as TestFn;
+
+  test.skip = (name, eff, opts) => {
+    bun.test.skip(name, () => runEff(eff), opts);
+  };
+  test.skipIf = (condition) => (name, eff, opts) => {
+    bun.test.skipIf(condition)(name, () => runEff(eff), opts);
+  };
+  test.only = (name, eff, opts) => {
+    bun.test.only(name, () => runEff(eff), opts);
+  };
+  test.todo = (name, eff, opts) => {
+    bun.test.todo(name, () => runEff(eff), opts);
+  };
+
+  const runProvider = (
+    name: string,
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+  ) => {
+    const scratch = Core.scratchStack(options, name);
+    return Core.run(Core.withProviders(fn(scratch), options, scratch.name), {
+      ...options,
+      state: scratch.state,
+    });
+  };
+
+  const provider = ((name, fn, opts) => {
+    bun.test(name, () => runProvider(name, fn), opts);
+  }) as ProviderFn;
+  provider.skip = (name, fn, opts) => {
+    bun.test.skip(name, () => runProvider(name, fn), opts);
+  };
+  provider.skipIf = (condition) => (name, fn, opts) => {
+    bun.test.skipIf(condition)(name, () => runProvider(name, fn), opts);
+  };
+  test.provider = provider;
+
+  const beforeAll: BeforeAllFn = <A>(
+    eff: TestEffect<A>,
+    hookOptions?: HookOptions,
+  ) => {
+    let result: A;
+    bun.beforeAll(
+      () => runEff(eff).then((v) => (result = v)),
+      hookOptions ?? DEFAULT_HOOK_TIMEOUT,
+    );
+    return Effect.sync(() => result);
+  };
+
+  const beforeEach: BeforeEachFn = (eff, hookOptions) => {
+    bun.beforeEach(() => runEff(eff), hookOptions);
+  };
+
+  const afterAll = ((eff, hookOptions) => {
+    bun.afterAll(() => runEff(eff), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
+  }) as AfterAllFn;
+  afterAll.skipIf = (predicate) => (eff, hookOptions) => {
+    if (predicate) return;
+    bun.afterAll(() => runEff(eff), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
+  };
+
+  const afterEach: AfterEachFn = (eff, hookOptions) => {
+    bun.afterEach(() => runEff(eff), hookOptions);
+  };
+
+  return {
+    test,
+    beforeAll,
+    beforeEach,
+    afterAll,
+    afterEach,
+    deploy: (stack, callOpts) => Core.deploy(options, stack, callOpts),
+    destroy: (stack, callOpts) => Core.destroy(options, stack, callOpts),
+  };
+};