alchemy 2.0.0-beta.3 → 2.0.0-beta.31

package/src/Sidecar/RpcHandler.ts

@@ -0,0 +1,169 @@
+import type { RpcCompatible } from "capnweb";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Schema from "effect/Schema";
+
+type RpcHandler<Args extends Array<any>, Success, Error> = (
+  ...args: Args
+) => Effect.Effect<Success, Error>;
+
+type SerializedRpcHandler<Args extends Array<any>, Success, Error> = (
+  ...args: Args
+) => Promise<SerializedExit<RpcCompatible<Success>, RpcCompatible<Error>>>;
+
+type SerializedCause<Error> =
+  | { _tag: "Fail"; error: Error }
+  | { _tag: "Die"; defect: unknown }
+  | { _tag: "Interrupt"; fiberId: number | undefined };
+
+type SerializedExit<Success, Error> =
+  | { _tag: "Success"; value: Success }
+  | {
+      _tag: "Failure";
+      cause: Array<SerializedCause<Error>>;
+    };
+
+export type RpcHandlers = Record<string, RpcHandler<any, any, any>>;
+
+export type SerializedRpcHandlers<T extends RpcHandlers> = {
+  [K in keyof T]: T[K] extends RpcHandler<
+    infer Args,
+    infer Success,
+    infer Error
+  >
+    ? SerializedRpcHandler<Args, Success, Error>
+    : never;
+} extends infer O extends object & RpcCompatible<O>
+  ? O
+  : never;
+
+type RpcHandlerEncoder<Success, Error> = {
+  success: Schema.Encoder<Success>;
+  error: Schema.Encoder<Error>;
+};
+
+export type RpcHandlerEncoders<T extends RpcHandlers> = {
+  [K in keyof T]: T[K] extends RpcHandler<any, infer Success, infer Error>
+    ? RpcHandlerEncoder<Success, Error>
+    : never;
+};
+
+type RpcHandlerDecoder<Success, Error> = {
+  success: Schema.Decoder<Success>;
+  error: Schema.Decoder<Error>;
+};
+
+export type RpcHandlerDecoders<T extends RpcHandlers> = {
+  [K in keyof T]: T[K] extends RpcHandler<any, infer Success, infer Error>
+    ? RpcHandlerDecoder<Success, Error>
+    : never;
+};
+
+const serializeRpcHandler =
+  <Args extends Array<any>, Success, Error>(
+    handler: RpcHandler<Args, Success, Error>,
+    schema: RpcHandlerEncoder<Success, Error>,
+  ): SerializedRpcHandler<Args, Success, Error> =>
+  (...args) =>
+    handler(...args).pipe(
+      Effect.exit,
+      Effect.map((exit): SerializedExit<Success, Error> => {
+        if (exit._tag === "Success") {
+          return {
+            _tag: "Success",
+            value: Schema.encodeSync(schema.success)(exit.value),
+          } as const;
+        }
+        return {
+          _tag: "Failure",
+          cause: exit.cause.reasons.map((reason): SerializedCause<Error> => {
+            switch (reason._tag) {
+              case "Fail":
+                return {
+                  _tag: "Fail",
+                  error: Schema.encodeSync(schema.error)(reason.error),
+                };
+              case "Die":
+                return {
+                  _tag: "Die",
+                  defect: Schema.encodeSync(Schema.DefectWithStack)(
+                    reason.defect,
+                  ),
+                };
+              case "Interrupt":
+                return { _tag: "Interrupt", fiberId: reason.fiberId };
+            }
+          }),
+        } as const;
+      }),
+      Effect.runPromise,
+    );
+
+export const serializeRpcHandlers = <T extends RpcHandlers>(
+  handlers: T,
+  schema: RpcHandlerEncoders<T>,
+): SerializedRpcHandlers<T> =>
+  Object.fromEntries(
+    Object.entries(schema).map(([key, schema]) => [
+      key,
+      serializeRpcHandler(handlers[key], schema),
+    ]),
+  ) as SerializedRpcHandlers<T>;
+
+const deserializeRpcHandler =
+  <Args extends Array<any>, Success, Error>(
+    handler: SerializedRpcHandler<Args, Success, Error>,
+    schema: RpcHandlerDecoder<Success, Error>,
+  ): RpcHandler<Args, Success, Error> =>
+  (...args) =>
+    Effect.promise(async () => {
+      try {
+        return await handler(...args);
+      } catch (error) {
+        console.error("Error calling handler", error);
+        throw error;
+      }
+    }).pipe(
+      Effect.map((exit): Exit.Exit<Success, Error> => {
+        if (exit._tag === "Success") {
+          return Exit.succeed(Schema.decodeSync(schema.success)(exit.value));
+        }
+        return Exit.failCause(
+          Cause.fromReasons(
+            exit.cause.map((reason): Cause.Reason<Error> => {
+              switch (reason._tag) {
+                case "Fail":
+                  return Cause.makeFailReason(
+                    Schema.decodeSync(schema.error)(reason.error),
+                  );
+                case "Die":
+                  return Cause.makeDieReason(
+                    Schema.decodeSync(Schema.DefectWithStack)(reason.defect),
+                  );
+                case "Interrupt":
+                  return Cause.makeInterruptReason(reason.fiberId);
+              }
+            }),
+          ),
+        );
+      }),
+      Effect.flatMap((exit) => exit),
+    );
+
+export const deserializeRpcHandlers = <T extends RpcHandlers>(
+  handlers: SerializedRpcHandlers<T>,
+  schema: RpcHandlerDecoders<T>,
+): T =>
+  Object.fromEntries(
+    Object.entries(schema).map(([key, schema]) => [
+      key,
+      deserializeRpcHandler(handlers[key as never], schema),
+    ]),
+  ) as T;
+
+export const defineSchema = <T extends RpcHandlers>(schema: {
+  [K in keyof T]: T[K] extends RpcHandler<any, infer Success, infer Error>
+    ? { success: Schema.Codec<Success, any>; error: Schema.Codec<Error, any> }
+    : never;
+}) => schema as RpcHandlerEncoders<T> & RpcHandlerDecoders<T>;

package/src/Sidecar/RpcPaths.ts

@@ -0,0 +1,29 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Hash from "effect/Hash";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as AlchemyContext from "../AlchemyContext.ts";
+
+export class RpcPaths extends Context.Service<
+  RpcPaths,
+  { readonly lock: string; readonly url: string }
+>()("RpcPaths") {}
+
+export const layer = (main: string) =>
+  Layer.effect(
+    RpcPaths,
+    Effect.gen(function* () {
+      const { dotAlchemy } = yield* AlchemyContext.AlchemyContext;
+      const path = yield* Path.Path;
+      const fs = yield* FileSystem.FileSystem;
+      const id = Math.abs(Hash.string(main));
+      const dir = path.resolve(dotAlchemy, "local");
+      yield* fs.makeDirectory(dir, { recursive: true });
+      return RpcPaths.of({
+        lock: path.join(dir, `${id}.lock`),
+        url: path.join(dir, `${id}.url`),
+      });
+    }),
+  );

package/src/Sidecar/RpcServer.ts

@@ -0,0 +1,80 @@
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Schedule from "effect/Schedule";
+import * as AlchemyContext from "../AlchemyContext.ts";
+import * as Lock from "./Lock.ts";
+import {
+  serializeRpcHandlers,
+  type RpcHandlerEncoders,
+  type RpcHandlers,
+} from "./RpcHandler.ts";
+import * as RpcPaths from "./RpcPaths.ts";
+import { makeBunWebSocketRpcServer } from "./RpcTransport.ts";
+
+export const layerServices = (main: string) =>
+  Layer.provideMerge(
+    Lock.LockLive,
+    Layer.provideMerge(RpcPaths.layer(main), AlchemyContext.AlchemyContextLive),
+  );
+
+export const makeRpcServer = Effect.fn(function* <T extends RpcHandlers, E, R>(
+  handlersEffect: Effect.Effect<T, E, R>,
+  schema: RpcHandlerEncoders<T>,
+) {
+  const lock = yield* Lock.Lock.use((lock) => lock.acquire);
+  const fs = yield* FileSystem.FileSystem;
+  const paths = yield* RpcPaths.RpcPaths;
+
+  const server = yield* Effect.gen(function* () {
+    const heartbeat = yield* Heartbeat;
+    const handlers = yield* handlersEffect;
+    const server = yield* Effect.acquireRelease(
+      Effect.sync(() =>
+        makeBunWebSocketRpcServer(() => {
+          const methods = Object.assign(
+            serializeRpcHandlers(handlers, schema),
+            {
+              heartbeat: () => Effect.runPromise(heartbeat.touch),
+              shutdown: () => Effect.runPromise(heartbeat.shutdown),
+            },
+          );
+          void methods.heartbeat();
+          return methods;
+        }),
+      ),
+      (server) => Effect.promise(() => server.stop(true)),
+    );
+    const address = `ws://${server.hostname}:${server.port}`;
+    yield* fs.writeFileString(paths.url, address);
+    yield* Effect.addFinalizer(() =>
+      fs.readFileString(paths.url).pipe(
+        Effect.flatMap((text) =>
+          text === address ? fs.remove(paths.url) : Effect.void,
+        ),
+        Effect.ignore,
+      ),
+    );
+    yield* heartbeat.await;
+  }).pipe(Effect.forkScoped);
+
+  yield* Fiber.joinAll([lock, server]);
+});
+
+const Heartbeat = Effect.gen(function* () {
+  let last = Date.now();
+  const fiber = yield* Effect.suspend(() => {
+    if (Date.now() - last > 10_000) {
+      return Effect.fail({ _tag: "Timeout" } as const);
+    }
+    return Effect.void;
+  }).pipe(Effect.repeat(Schedule.spaced("4 seconds")), Effect.forkScoped);
+  return {
+    touch: Effect.sync(() => {
+      last = Date.now();
+    }),
+    shutdown: Fiber.interrupt(fiber),
+    await: Fiber.join(fiber),
+  };
+});

package/src/Sidecar/RpcTransport.ts

@@ -0,0 +1,85 @@
+import type { ServerWebSocket } from "bun";
+import type { RpcCompatible, RpcTransport } from "capnweb";
+import { RpcSession } from "capnweb";
+
+export function makeBunWebSocketRpcServer<T extends RpcCompatible<T>>(
+  main: () => T,
+) {
+  return Bun.serve<{
+    transport: BunWebSocketRpcTransport;
+    session: RpcSession<T>;
+  }>({
+    port: 0,
+    fetch: (request, server) => {
+      if (server.upgrade(request, { data: undefined! })) {
+        return;
+      }
+      return new Response("Upgrade failed", { status: 400 });
+    },
+    websocket: {
+      open: (ws) => {
+        const transport = new BunWebSocketRpcTransport(ws);
+        const session = new RpcSession<T>(transport, main());
+        ws.data = { transport, session };
+      },
+      message: (ws, message) => {
+        ws.data.transport.dispatchMessage(message);
+      },
+      close: (ws, code, reason) => {
+        ws.data.transport.dispatchClose(code, reason);
+      },
+    },
+  });
+}
+
+class BunWebSocketRpcTransport implements RpcTransport {
+  private receiveQueue: Array<string> = [];
+  private receiveResolver?: (value: string) => void;
+  private receiveRejecter?: (reason: unknown) => void;
+  private error?: unknown;
+  constructor(private readonly ws: ServerWebSocket<any>) {}
+  async send(message: string): Promise<void> {
+    this.ws.send(message);
+  }
+  async receive(): Promise<string> {
+    const next = this.receiveQueue.shift();
+    if (next) {
+      return next;
+    } else if (this.error) {
+      throw this.error;
+    }
+    return new Promise((resolve, reject) => {
+      this.receiveResolver = resolve;
+      this.receiveRejecter = reject;
+    });
+  }
+  abort?(reason: any): void {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    this.ws.close(3000, message);
+    this.error ??= reason;
+  }
+  dispatchMessage(data: string | Buffer<ArrayBuffer>): void {
+    if (this.error) {
+      return;
+    }
+    data = typeof data === "string" ? data : data.toString("utf-8");
+
+    if (this.receiveResolver) {
+      this.receiveResolver(data);
+      this.receiveResolver = undefined;
+      this.receiveRejecter = undefined;
+    } else {
+      this.receiveQueue.push(data);
+    }
+  }
+  dispatchClose(code: number, reason: string): void {
+    if (!this.error) {
+      this.error = new Error(`WebSocket closed with code ${code}: ${reason}`);
+      if (this.receiveRejecter) {
+        this.receiveRejecter(this.error);
+        this.receiveRejecter = undefined;
+        this.receiveResolver = undefined;
+      }
+    }
+  }
+}

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://v2.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,57 @@ 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")], { mergeWithExisting: true }),
+);
+// override alchemy state store, CLI/reporting, state, and Config
+const alchemy = (overrides?: { dev?: boolean }) =>
+  Layer.mergeAll(
+    // CLI.inkCLI(),
+    // optional
+    overrides?.dev
+      ? Layer.provide(
+          Layer.effect(
+            AlchemyContext,
+            AlchemyContext.asEffect().pipe(
+              Effect.map((ctx) => ({ ...ctx, dev: overrides.dev! })),
+            ),
+          ),
+          AlchemyContextLive,
+        )
+      : 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;
+    dev?: boolean;
+  },
+) =>
+  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({ dev: options.dev }), platform)),
+    Effect.scoped,
+  );