alchemy 2.0.0-beta.test-export-fix-4 → 2.0.0-cli-bundle-fix.1

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

@@ -208,8 +208,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>,

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> = {
@@ -159,7 +165,7 @@ export interface Platform<
   ): Effect.Effect<
     Resource & Rpc<Shape>,
     never,
-    | Provider<Resource>
+    | Resource["Providers"]
     | PropsReq
     | Exclude<InitReq, Services | PlatformServices>
   >;
@@ -220,10 +226,15 @@ export const Platform = <
             //     return new Response("Hello, world!");
             //   }
             // }
-            resource(id, {
-              ...props,
-              isExternal: true,
-            })
+            resource(
+              id,
+              Effect.isEffect(props)
+                ? Effect.map(props, (p: any) => ({ ...p, isExternal: true }))
+                : {
+                    ...props,
+                    isExternal: true,
+                  },
+            )
           : Effect.flatMap(
               // this is a tagged resource
               Effect.serviceOption(cls.Self),

package/src/Provider.ts

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

package/src/Resource.ts

@@ -31,10 +31,10 @@ export type ResourceConstructor<R extends ResourceLike, Req = never> = {
           },
         ]
   ): Effect.Effect<R, never, Req>;
-  // <PropsReq = never>(
-  //   id: string,
-  //   props: Effect.Effect<Input<R["Props"]>, never, PropsReq>,
-  // ): Effect.Effect<R, never, PropsReq | Req>;
+  <PropsReq = never>(
+    id: string,
+    props: Effect.Effect<Input<R["Props"]>, never, PropsReq>,
+  ): Effect.Effect<R, never, PropsReq | Req>;
 };
 
 export type ResourceClassWithMethods<

package/src/Stack.ts

@@ -1,19 +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 { 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
@@ -21,15 +31,35 @@ export type StackServices =
   | Scope
   | FileSystem
   | Path
-  | DotAlchemy
+  | AlchemyContext
   | HttpClient
-  | ChildProcessSpawner;
+  | ChildProcessSpawner
+  | 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",
@@ -48,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 : {};
@@ -73,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(
@@ -85,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;
@@ -128,46 +160,84 @@ 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.all([
-      effect,
-      Stack.asEffect(),
-      Effect.context<ROut | StackServices>(),
-    ]).pipe(
-      Effect.map(
-        ([output, stack, services]) =>
-          ({
-            ...stack,
-            output,
-            services,
-          }) satisfies CompiledStack<A, ROut | StackServices> as CompiledStack<
-            A,
-            ROut | StackServices
-          >,
-      ),
-      Effect.provide(providers),
-      Effect.provideServiceEffect(
-        Stack,
-        Stage.asEffect().pipe(
+    Effect.scope.pipe(
+      Effect.flatMap((scope) => {
+        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: {},
+                    },
+                ),
+              ),
+            ),
+          ),
+          Layer.buildWithScope(scope),
+        );
+      }),
+      Effect.flatMap((context) =>
+        Effect.all([
+          effect,
+          Stack.asEffect(),
+          Effect.context<ROut | StackServices>(),
+        ]).pipe(
           Effect.map(
-            (stage) =>
-              (stack ?? {
-                name,
-                stage,
-                resources: {},
-                bindings: {},
-              }) satisfies Stack["Service"],
+            ([output, stack, services]): CompiledStack<
+              A,
+              ROut | StackServices
+            > => ({
+              ...stack,
+              output,
+              services: Context.merge(services, context),
+            }),
           ),
-          Effect.tap(Effect.logInfo),
+          Effect.provideContext(context),
         ),
       ),
     );
@@ -175,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,
+  );

package/src/State/HttpStateApi.ts

@@ -0,0 +1,155 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiError from "effect/unstable/httpapi/HttpApiError";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiMiddleware from "effect/unstable/httpapi/HttpApiMiddleware";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
+import * as HttpApiSecurity from "effect/unstable/httpapi/HttpApiSecurity";
+
+export const ResourceStateSchema = Schema.Any;
+
+export class BearerTokenValidator extends Context.Service<
+  BearerTokenValidator,
+  {
+    readonly validate: (
+      token: string,
+    ) => Effect.Effect<void, HttpApiError.Unauthorized>;
+  }
+>()("alchemy/State/BearerTokenValidator") {}
+
+export class StateAuth extends HttpApiMiddleware.Service<
+  StateAuth,
+  { requires: BearerTokenValidator }
+>()("alchemy/State/StateAuth", {
+  security: {
+    bearer: HttpApiSecurity.bearer,
+  },
+  error: HttpApiError.UnauthorizedNoContent,
+}) {}
+
+export const StateAuthLive: Layer.Layer<
+  StateAuth,
+  never,
+  BearerTokenValidator
+> = Layer.effect(
+  StateAuth,
+  Effect.gen(function* () {
+    const validator = yield* BearerTokenValidator;
+    return {
+      bearer: (httpEffect, { credential }) =>
+        validator
+          .validate(Redacted.value(credential))
+          .pipe(Effect.flatMap(() => httpEffect)),
+    };
+  }),
+);
+
+/** `stack` path segment for nested REST resources. */
+const StackParams = Schema.Struct({
+  stack: Schema.String,
+});
+
+/** Optional stage selector for stack deletion. */
+const OptionalStageQuery = Schema.Struct({
+  stage: Schema.optional(Schema.String),
+});
+
+/** `(stack, stage)` path segments shared by stage-scoped endpoints. */
+const StackStage = Schema.Struct({
+  stack: Schema.String,
+  stage: Schema.String,
+});
+
+/** `(stack, stage, fqn)` path segments for a single resource. */
+const ResourceKey = Schema.Struct({
+  stack: Schema.String,
+  stage: Schema.String,
+  fqn: Schema.String,
+});
+
+export const ListStacks = HttpApiEndpoint.get("listStacks", "/state/stacks", {
+  success: Schema.Array(Schema.String),
+});
+
+export const ListStages = HttpApiEndpoint.get(
+  "listStages",
+  "/state/stacks/:stack/stages",
+  {
+    params: StackParams,
+    success: Schema.Array(Schema.String),
+  },
+);
+
+export const ListResources = HttpApiEndpoint.get(
+  "listResources",
+  "/state/stacks/:stack/stages/:stage/resources",
+  {
+    params: StackStage,
+    success: Schema.Array(Schema.String),
+  },
+);
+
+export const GetState = HttpApiEndpoint.get(
+  "getState",
+  "/state/stacks/:stack/stages/:stage/resources/:fqn",
+  {
+    params: ResourceKey,
+    success: Schema.UndefinedOr(ResourceStateSchema),
+  },
+);
+
+export const SetState = HttpApiEndpoint.put(
+  "setState",
+  "/state/stacks/:stack/stages/:stage/resources/:fqn",
+  {
+    params: ResourceKey,
+    payload: ResourceStateSchema,
+    success: ResourceStateSchema,
+  },
+);
+
+export const DeleteState = HttpApiEndpoint.delete(
+  "deleteState",
+  "/state/stacks/:stack/stages/:stage/resources/:fqn",
+  {
+    params: ResourceKey,
+    success: HttpApiSchema.NoContent,
+  },
+);
+
+export const DeleteStack = HttpApiEndpoint.delete(
+  "deleteStack",
+  "/state/stacks/:stack",
+  {
+    params: StackParams,
+    query: OptionalStageQuery,
+    success: HttpApiSchema.NoContent,
+  },
+);
+
+export const GetReplacedResources = HttpApiEndpoint.get(
+  "getReplacedResources",
+  "/state/stacks/:stack/stages/:stage/replaced-resources",
+  {
+    params: StackStage,
+    success: Schema.Array(ResourceStateSchema),
+  },
+);
+
+export class StateGroup extends HttpApiGroup.make("state")
+  .add(ListStacks)
+  .add(ListStages)
+  .add(ListResources)
+  .add(GetState)
+  .add(SetState)
+  .add(DeleteState)
+  .add(GetReplacedResources)
+  .add(DeleteStack)
+  .middleware(StateAuth) {}
+
+export class StateApi extends HttpApi.make("alchemy-state").add(StateGroup) {}