alchemy 2.0.0-beta.13 → 2.0.0-beta.15

package/src/Cloudflare/Workers/HttpServer.ts

@@ -14,7 +14,7 @@ import { isWorkerEvent, type WorkerServices } from "./Worker.ts";
 export type HttpEffect = Http.HttpEffect<WorkerServices>;
 
 export const workersHttpHandler = <Req = never>(
-  handler: Http.HttpEffect<Req>,
+  handler: Http.HttpEffect<Req> | Effect.Effect<Http.HttpEffect<Req>>,
 ) => {
   const safeHandler = Http.safeHttpEffect(handler);
   return (event: any) => {

package/src/Cloudflare/Workers/Worker.ts

@@ -48,11 +48,11 @@ import { Stack } from "../../Stack.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import { D1Database } from "../D1/D1Database.ts";
 import { fromCloudflareFetcher } from "../Fetcher.ts";
+import type { KVNamespace } from "../KV/KVNamespace.ts";
 import { CloudflareLogs } from "../Logs.ts";
 import type { Providers } from "../Providers.ts";
-import type { R2Bucket } from "../R2/R2Bucket.ts";
-import type { KVNamespace } from "../KV/KVNamespace.ts";
 import type { Queue as CloudflareQueue } from "../Queue/Queue.ts";
+import type { R2Bucket } from "../R2/R2Bucket.ts";
 import {
   isAssets,
   readAssets,
@@ -173,9 +173,9 @@ export interface WorkerExecutionContext extends Serverless.FunctionContext {
   export(name: string, value: any): Effect.Effect<void>;
 }
 
-export type WorkerServices = Worker | WorkerEnvironment | Request;
+export type WorkerServices = Worker | Request;
 
-export type WorkerShape = Main<WorkerServices>;
+export type WorkerShape = Main<WorkerServices | WorkerEnvironment>;
 
 export type WorkerBindingResource =
   | Assets
@@ -764,8 +764,9 @@ export const Worker: Platform<
           );
           return key;
         }),
-      serve: <Req = never>(handler: HttpEffect<Req>) =>
-        ctx.listen(workersHttpHandler(handler)),
+      serve: <Req = never>(
+        handler: HttpEffect<Req> | Effect.Effect<HttpEffect<Req>>,
+      ) => ctx.listen(workersHttpHandler(handler)),
       listen: ((
         handler:
           | Serverless.FunctionListener
@@ -1280,7 +1281,6 @@ const stack = Layer.succeed(
 
 const exportsEffect = tag.asEffect().pipe(
   Effect.flatMap(func => func.ExecutionContext.exports),
-  Effect.map(exports => exports),
   Effect.provide(
     layer.pipe(
       Layer.provideMerge(stack),

package/src/Cloudflare/index.ts

@@ -1,10 +1,13 @@
+export * from "./ApiToken/index.ts";
 export * from "./CloudflareEnvironment.ts";
 export * from "./Container/index.ts";
 export * from "./D1/index.ts";
+export * from "./EdgeSession.ts";
 export * from "./KV/index.ts";
-export * from "./Queue/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 "./Website/index.ts";
 export * from "./Workers/index.ts";

package/src/Deploy.ts

@@ -0,0 +1,25 @@
+import * as Effect from "effect/Effect";
+import { AlchemyContext } from "./AlchemyContext.ts";
+import * as Apply from "./Apply.ts";
+import type { Input } from "./Input.ts";
+import * as Plan from "./Plan.ts";
+import { evalStack, type CompiledStack, type StackEffect } from "./Stack.ts";
+import { Stage } from "./Stage.ts";
+
+export const deploy = <A>({
+  stack,
+  stage,
+}: {
+  stack: StackEffect<CompiledStack<A>, Stage | AlchemyContext>;
+  stage: string;
+}) =>
+  evalStack(
+    stack,
+    (stack) =>
+      Effect.gen(function* () {
+        const plan = yield* Plan.make(stack);
+        const output = yield* Apply.apply(plan);
+        return output as Input.Resolve<A>;
+      }),
+    { stage },
+  );

package/src/Destroy.ts

@@ -1,16 +1,28 @@
-import * as Effect from "effect/Effect";
-import { apply } from "./Apply.ts";
-import { provideFreshArtifactStore } from "./Artifacts.ts";
+import { Effect } from "effect";
+import type { AlchemyContext } from "./AlchemyContext.ts";
+import * as Apply from "./Apply.ts";
 import * as Plan from "./Plan.ts";
-import { Stack } from "./Stack.ts";
+import type { CompiledStack, StackEffect } from "./Stack.ts";
+import { evalStack } from "./Stack.ts";
+import type { Stage } from "./Stage.ts";
 
-export const destroy = () =>
-  Stack.use((stack) =>
-    Plan.make({
-      name: stack.name,
-      stage: stack.stage,
-      resources: {},
-      bindings: {},
-      output: {},
-    }).pipe(Effect.flatMap(apply), provideFreshArtifactStore),
+export const destroy = ({
+  stack,
+  stage,
+}: {
+  stack: StackEffect<CompiledStack, Stage | AlchemyContext>;
+  stage: string;
+}) =>
+  evalStack(
+    stack,
+    (stack) =>
+      Plan.make({
+        ...stack,
+        // zero these out (destroy will treat all as orphans)
+        // TODO(sam): probably better to have Plan.destroy and Plan.update
+        resources: {},
+        bindings: {},
+        output: {},
+      }).pipe(Effect.flatMap(Apply.apply)),
+    { stage },
   );

package/src/GitHub/Providers.ts

@@ -0,0 +1,6 @@
+import * as Layer from "effect/Layer";
+import { SecretProvider } from "./Secret.ts";
+import { VariableProvider } from "./Variable.ts";
+
+export const providers = () =>
+  Layer.mergeAll(SecretProvider(), VariableProvider());

package/src/GitHub/index.ts

@@ -1,3 +1,4 @@
 export * from "./Comment.ts";
+export * from "./Providers.ts";
 export * from "./Secret.ts";
 export * from "./Variable.ts";

package/src/Http.ts

@@ -25,7 +25,6 @@ export const serve = <Req = never>(
 ) =>
   Effect.serviceOption(HttpServer).pipe(
     Effect.map(Option.getOrUndefined),
-    Effect.tap((http) => Effect.logInfo("http", http)),
     Effect.flatMap((http) => (http ? http.serve(handler) : Effect.void)),
   );
 
@@ -45,22 +44,38 @@ export class HttpServer extends Context.Service<
   }
 >()("HttpServer") {}
 
-export const safeHttpEffect = <Req = never>(handler: HttpEffect<Req>) =>
-  Effect.catchCause(handler, (cause) => {
-    const message = Option.match(Cause.findErrorOption(cause), {
-      onNone: () => "Internal Server Error",
-      onSome: (error) => error.message ?? "Internal Server Error",
-    });
+export const safeHttpEffect = <Req = never>(
+  handler: HttpEffect<Req> | Effect.Effect<HttpEffect<Req>>,
+): Effect.Effect<
+  HttpServerResponse.HttpServerResponse,
+  never,
+  Req | HttpServerRequest | Scope
+> =>
+  Effect.catchCause(
+    handler.pipe(
+      // @ts-expect-error
+      Effect.flatMap((response) =>
+        HttpServerResponse.isHttpServerResponse(response)
+          ? Effect.succeed(response)
+          : response,
+      ),
+    ) as any as HttpEffect<Req>,
+    (cause) => {
+      const message = Option.match(Cause.findErrorOption(cause), {
+        onNone: () => "Internal Server Error",
+        onSome: (error) => error.message ?? "Internal Server Error",
+      });
 
-    return Effect.map(
-      Effect.all([Effect.logInfo(message), Effect.logInfo(cause)]),
-      () =>
-        HttpServerResponse.text(message, {
-          status: 500,
-          statusText: message,
-        }),
-    );
-  });
+      return Effect.map(
+        Effect.all([Effect.logError(message), Effect.logError(cause)]),
+        () =>
+          HttpServerResponse.text(message, {
+            status: 500,
+            statusText: message,
+          }),
+      );
+    },
+  );
 
 export const resolvePort = (options: { port?: number } | undefined) =>
   options?.port !== undefined

package/src/Output.ts

@@ -3,6 +3,7 @@ import type { Yieldable } from "effect/Effect";
 import * as Effect from "effect/Effect";
 import { pipe } from "effect/Function";
 import type { Pipeable } from "effect/Pipeable";
+import * as Redacted from "effect/Redacted";
 import { SingleShotGen } from "effect/Utils";
 import { ExecutionContext } from "./ExecutionContext.ts";
 import { getRefMetadata, isRef, ref as stageRef, type Ref } from "./Ref.ts";
@@ -208,8 +209,6 @@ export const map: {
         new ApplyExpr(output as Expr<A, Req>, args[0]) as any
     : new ApplyExpr(args[0] as any, args[1])) as any;
 
-type _ = Parameters<typeof map>;
-
 //Output.ApplyExpr<any, any, ResourceLike, any>
 export const isApplyExpr = <In = any, Out = any, Req = any>(
   node: Output<Out, Req>,
@@ -470,6 +469,8 @@ export const evaluate: <A, Req = never>(
     }
     if (Array.isArray(expr)) {
       return yield* Effect.all(expr.map((item) => evaluate(item, upstream)));
+    } else if (Redacted.isRedacted(expr)) {
+      return expr;
     } else if (typeof expr === "object" && expr !== null) {
       return Object.fromEntries(
         yield* Effect.all(

package/src/Plan.ts

@@ -1,6 +1,7 @@
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
+import * as Redacted from "effect/Redacted";
 import { asEffect } from ".//Util/types.ts";
 import {
   Artifacts,
@@ -271,6 +272,8 @@ export const make = <A>(
           return input;
         } else if (Output.isExpr(input)) {
           return yield* resolveOutput(input);
+        } else if (Redacted.isRedacted(input)) {
+          return input;
         } else if (Array.isArray(input)) {
           return yield* Effect.all(input.map(resolveInput), {
             concurrency: "unbounded",

package/src/Platform.ts

@@ -28,8 +28,14 @@ export interface PlatformProps {
   isExternal?: boolean;
 }
 
-export type Main<Services = never> = void | {
-  fetch: HttpEffect<Services | PlatformServices>;
+export type Main<InitServices = never> = void | {
+  fetch:
+    | HttpEffect<InitServices | PlatformServices>
+    | Effect.Effect<
+        HttpEffect<InitServices | PlatformServices>,
+        never,
+        InitServices | PlatformServices
+      >;
 };
 
 export type Rpc<Shape> = {

package/src/Provider.ts

@@ -381,7 +381,5 @@ export const tryFindProviderByType: {
       }
     }
   }
-
-  console.log(context.mapUnsafe.keys());
   return Option.none();
 }) as any;

package/src/Stack.ts

@@ -1,20 +1,29 @@
+import { ConfigProvider } from "effect/ConfigProvider";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import { FileSystem } from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
 import * as Option from "effect/Option";
 import { Path } from "effect/Path";
 import type { Scope } from "effect/Scope";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
-import type { AuthProviders } from "./Auth/AuthProvider.ts";
-import { DotAlchemy } from "./Config.ts";
+import { AlchemyContext, AlchemyContextLive } from "./AlchemyContext.ts";
+import { provideFreshArtifactStore } from "./Artifacts.ts";
+import { AuthProviders } from "./Auth/AuthProvider.ts";
+import { Cli } from "./Cli/Cli.ts";
 import type { Input, InputProps } from "./Input.ts";
 import * as Output from "./Output.ts";
 import { ref } from "./Ref.ts";
 import type { ResourceBinding, ResourceLike } from "./Resource.ts";
 import { Stage } from "./Stage.ts";
+import type { State } from "./State/State.ts";
+import { loadConfigProvider } from "./Util/ConfigProvider.ts";
 import { taggedFunction } from "./Util/effect.ts";
+import { fileLogger } from "./Util/FileLogger.ts";
+import { PlatformServices } from "./Util/PlatformServices.ts";
 
 export type StackServices =
   | Stack
@@ -22,16 +31,35 @@ export type StackServices =
   | Scope
   | FileSystem
   | Path
-  | DotAlchemy
+  | AlchemyContext
   | HttpClient
   | ChildProcessSpawner
-  | AuthProviders;
+  | AuthProviders
+  | Cli;
+
+export type StackEffect<A, Err = never, Req = never> = Effect.Effect<
+  A,
+  Err,
+  | PlatformServices
+  | HttpClient
+  | Scope
+  | AuthProviders
+  | AlchemyContext
+  | Cli
+  | State
+  | Req
+>;
 
 export type Stack = Context.ServiceClass.Shape<
   "Stack",
   Omit<StackSpec, "output">
 >;
 
+export interface StackProps<Req> {
+  providers: Layer.Layer<NoInfer<Req>, never, StackServices>;
+  state: Layer.Layer<State, never, StackServices>;
+}
+
 export const Stack: Context.ServiceClass<
   Stack,
   "Stack",
@@ -50,9 +78,7 @@ export const Stack: Context.ServiceClass<
   <Self>(): {
     <A, Req>(
       stackName: string,
-      options: {
-        providers: Layer.Layer<NoInfer<Req>, never, StackServices>;
-      },
+      options: StackProps<NoInfer<Req>>,
       eff: Effect.Effect<A, never, Req>,
     ): Effect.Effect<Self> & {
       new (_: never): A extends object ? A : {};
@@ -75,9 +101,7 @@ export const Stack: Context.ServiceClass<
   };
   <A, Req>(
     stackName: string,
-    options: {
-      providers: Layer.Layer<NoInfer<Req>, never, StackServices>;
-    },
+    options: StackProps<NoInfer<Req>>,
     eff: Effect.Effect<A, never, Req | StackServices>,
   ): Effect.Effect<CompiledStack<A>>;
 } = Object.assign(
@@ -87,23 +111,29 @@ export const Stack: Context.ServiceClass<
       stackName: string,
       options: {
         providers: Layer.Layer<NoInfer<Req>, never, StackServices>;
+        state: Layer.Layer<State, never, StackServices>;
       },
       eff: Effect.Effect<A, never, Req>,
     ) =>
-      eff.pipe(make(stackName, options.providers), (eff) =>
-        Object.assign(eff, {
-          stage: new Proxy(
-            {},
-            {
-              get: (_, stage: string) =>
-                ref({
-                  stack: stackName,
-                  stage,
-                  id: stackName,
-                }),
-            },
-          ),
+      eff.pipe(
+        make({
+          name: stackName,
+          ...options,
         }),
+        (eff) =>
+          Object.assign(eff, {
+            stage: new Proxy(
+              {},
+              {
+                get: (_, stage: string) =>
+                  ref({
+                    stack: stackName,
+                    stage,
+                    id: stackName,
+                  }),
+              },
+            ),
+          }),
       ),
   ),
 ) as any;
@@ -130,35 +160,64 @@ export interface CompiledStack<
 
 export const StackName = Stack.use((stack) => Effect.succeed(stack.name));
 
+export interface MakeStackProps<ROut = never> {
+  name: string;
+  providers: Layer.Layer<ROut, never, StackServices>;
+  state: Layer.Layer<State, never, StackServices>;
+  /** @internal */
+  stack?: StackSpec;
+}
+
 export const make =
-  <ROut = never>(
-    name: string,
-    providers: Layer.Layer<ROut, never, StackServices>,
-    /** @internal */
-    stack?: StackSpec,
-  ) =>
+  <ROut = never>(options: MakeStackProps<ROut>) =>
   <A, Err = never, Req extends ROut | StackServices = never>(
     effect: Effect.Effect<A, Err, Req>,
   ) =>
     Effect.scope.pipe(
       Effect.flatMap((scope) => {
-        const stackLayer = Layer.effect(
-          Stack,
-          Stage.asEffect().pipe(
-            Effect.map(
-              (stage) =>
-                stack ?? {
-                  name,
-                  stage,
-                  resources: {},
-                  bindings: {},
-                },
+        if (options.state == null) {
+          return Effect.die(
+            new Error(
+              `Stack "${options.name}" is missing a state store. ` +
+                `Add a \`state\` layer to the stack options, e.g.:\n` +
+                `  Alchemy.Stack("${options.name}", {\n` +
+                `    providers: Cloudflare.providers(),\n` +
+                `    state: Cloudflare.state(), // <-- required\n` +
+                `  }, ...)\n` +
+                `See https://alchemy.run/concepts/state-store for available state stores.`,
+            ),
+          );
+        }
+        if (options.providers == null) {
+          return Effect.die(
+            new Error(
+              `Stack "${options.name}" is missing a providers layer. ` +
+                `Add a \`providers\` layer to the stack options, e.g.:\n` +
+                `  Alchemy.Stack("${options.name}", {\n` +
+                `    providers: Cloudflare.providers(), // <-- required\n` +
+                `    state: Cloudflare.state(),\n` +
+                `  }, ...)`,
+            ),
+          );
+        }
+        return options.providers.pipe(
+          Layer.provideMerge(options.state),
+          Layer.provideMerge(
+            Layer.effect(
+              Stack,
+              Stage.asEffect().pipe(
+                Effect.map(
+                  (stage) =>
+                    options.stack ?? {
+                      name: options.name,
+                      stage,
+                      resources: {},
+                      bindings: {},
+                    },
+                ),
+              ),
             ),
-            Effect.tap(Effect.logInfo),
           ),
-        );
-        return providers.pipe(
-          Layer.provideMerge(stackLayer),
           Layer.buildWithScope(scope),
         );
       }),
@@ -175,7 +234,7 @@ export const make =
             > => ({
               ...stack,
               output,
-              services,
+              services: Context.merge(services, context),
             }),
           ),
           Effect.provideContext(context),
@@ -186,3 +245,45 @@ export const make =
 export const CurrentStack = Effect.serviceOption(Stack)
   .asEffect()
   .pipe(Effect.map(Option.getOrUndefined));
+
+const platform = Layer.mergeAll(
+  PlatformServices,
+  FetchHttpClient.layer,
+  Logger.layer([fileLogger("out")]),
+);
+// override alchemy state store, CLI/reporting, state, and Config
+const alchemy = Layer.mergeAll(
+  // CLI.inkCLI(),
+  // optional
+  AlchemyContextLive,
+);
+
+export const evalStack = <A, B, Err, Req>(
+  effect: StackEffect<CompiledStack<A>, Stage | AlchemyContext>,
+  fn: (stack: CompiledStack<A>) => Effect.Effect<B, Err, Req>,
+  options: {
+    stage: string;
+  },
+) =>
+  Effect.gen(function* () {
+    const stack = yield* effect;
+    const configProvider = yield* loadConfigProvider(Option.none());
+
+    return yield* fn(stack).pipe(
+      provideFreshArtifactStore,
+      Effect.provide(stack.services),
+      Effect.provide(Layer.succeed(ConfigProvider, configProvider)),
+    );
+  }).pipe(
+    Effect.provide(
+      Layer.effect(
+        AuthProviders,
+        Effect.serviceOption(AuthProviders).pipe(
+          Effect.map(Option.getOrElse(() => ({}))),
+        ),
+      ),
+    ),
+    Effect.provide(Layer.succeed(Stage, options.stage)),
+    Effect.provide(Layer.provideMerge(alchemy, platform)),
+    Effect.scoped,
+  );