alchemy 2.0.0-beta.43 → 2.0.0-beta.44

package/src/Sidecar/RpcClient.ts

@@ -1,142 +0,0 @@
-import { newWebSocketRpcSession } from "capnweb";
-import * as Context from "effect/Context";
-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 Schema from "effect/Schema";
-import * as ChildProcess from "effect/unstable/process/ChildProcess";
-import * as Lock from "./Lock.ts";
-import {
-  deserializeRpcHandlers,
-  type RpcHandlerDecoders,
-  type RpcHandlers,
-  type SerializedRpcHandlers,
-} from "./RpcHandler.ts";
-import * as RpcPaths from "./RpcPaths.ts";
-
-export const RpcClientService = <Self, T extends RpcHandlers>() =>
-  Context.Service<Self, T>();
-
-class RpcClientError extends Schema.TaggedErrorClass<RpcClientError>()(
-  "RpcClientError",
-  {
-    reason: Schema.Literals(["InvalidURL", "WebSocketError"]),
-    message: Schema.String,
-    cause: Schema.optional(Schema.DefectWithStack),
-  },
-) {}
-
-export const layer = <Self, T extends RpcHandlers>(
-  tag: Context.ServiceClass<Self, any, T>,
-  options: {
-    main: string;
-    schema: RpcHandlerDecoders<T>;
-  },
-) =>
-  Layer.effect(
-    tag,
-    Effect.gen(function* () {
-      const fiber = yield* maybeStartRpcServer(options.main).pipe(
-        Effect.flatMap(() => RpcSession),
-        Effect.map((session) =>
-          deserializeRpcHandlers(
-            session as SerializedRpcHandlers<T>,
-            options.schema,
-          ),
-        ),
-        Effect.retry(Schedule.exponential("100 millis")),
-        Effect.provide(
-          Layer.provideMerge(Lock.LockLive, RpcPaths.layer(options.main)),
-        ),
-        Effect.forkScoped,
-      );
-      return new Proxy({} as T, {
-        get(_, prop) {
-          return (...args: any[]) =>
-            Fiber.join(fiber).pipe(
-              Effect.flatMap((session) => session[prop as never](...args)),
-            );
-        },
-      });
-    }),
-  );
-
-const maybeStartRpcServer = Effect.fn(function* (main: string) {
-  const lock = yield* Lock.Lock;
-  if (!(yield* lock.check)) {
-    main = RpcPaths.sanitizeSidecarMain(main);
-    const bin = typeof globalThis.Bun !== "undefined" ? "bun" : "node";
-    yield* Effect.logDebug("[RpcClient] Starting RPC server", main);
-    yield* ChildProcess.make(bin, { bun: ["run", main], node: [main] }[bin], {
-      stdout: "inherit",
-      stderr: "inherit",
-      extendEnv: true,
-      // Effect's default behavior is detached: true on posix and false on Windows.
-      // Ideally we would set detached: true on Windows, but that would create a separate console window for every server instance.
-    });
-  } else {
-    yield* Effect.logDebug("[RpcClient] RPC server already running", main);
-  }
-});
-
-const RpcSession = Effect.gen(function* () {
-  const paths = yield* RpcPaths.RpcPaths;
-  const fs = yield* FileSystem.FileSystem;
-  const ws = yield* fs.readFileString(paths.url).pipe(
-    Effect.flatMap((url) =>
-      Effect.try({
-        try: () => new URL(url),
-        catch: (e) =>
-          new RpcClientError({
-            reason: "InvalidURL",
-            message: `"${url}" is not a valid URL`,
-            cause: e,
-          }),
-      }),
-    ),
-    Effect.flatMap((url) =>
-      Effect.callback<WebSocket, RpcClientError>((resume) => {
-        const ws = new WebSocket(url);
-        ws.onopen = () => resume(Effect.succeed(ws));
-        ws.onerror = (e) =>
-          resume(
-            Effect.fail(
-              new RpcClientError({
-                reason: "WebSocketError",
-                message: "WebSocket connection failed",
-                cause: e,
-              }),
-            ),
-          );
-        return Effect.sync(() => ws.close());
-      }),
-    ),
-    Effect.retry({
-      while: (e) => e.reason !== "WebSocketError",
-      schedule: Schedule.spaced("50 millis"),
-      times: 100,
-    }),
-    Effect.retry({
-      while: (e) => e.reason === "WebSocketError",
-      schedule: Schedule.exponential("100 millis"),
-      times: 3,
-    }),
-  );
-  const session = yield* Effect.acquireRelease(
-    Effect.sync(() =>
-      newWebSocketRpcSession<{
-        heartbeat: () => Promise<void>;
-        shutdown: () => Promise<void>;
-      }>(ws),
-    ),
-    (session) => Effect.sync(() => session[Symbol.dispose]()),
-  );
-  yield* Effect.promise(() => session.heartbeat()).pipe(
-    Effect.repeat(Schedule.spaced("1 second")),
-    Effect.ensuring(Effect.promise(() => session.shutdown())),
-    Effect.forkScoped,
-  );
-  return session;
-});

package/src/Sidecar/RpcHandler.ts

@@ -1,205 +0,0 @@
-import type { RpcCompatible } from "capnweb";
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import { flow } from "effect/Function";
-import * as Redacted from "effect/Redacted";
-import * as Schema from "effect/Schema";
-
-type RpcHandler<Args extends Array<any>, Success, Error> = (
-  ...args: Args
-) => Effect.Effect<Success, Error>;
-
-type SerializedArgs<T> = string & { __serializedArgs: T };
-
-type SerializedRpcHandler<Args, Success, Error> = (
-  args: SerializedArgs<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> =>
-  flow(
-    (args) =>
-      Effect.sync(
-        () =>
-          JSON.parse(args, (_, value) => {
-            if (
-              typeof value === "object" &&
-              value !== null &&
-              "_tag" in value &&
-              value._tag === "Redacted"
-            ) {
-              return Redacted.make(value.value);
-            }
-            return value;
-          }) as Args,
-      ),
-    Effect.flatMap((args) => handler(...args)),
-    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 encodeRedacted = (value: unknown): unknown => {
-  if (Redacted.isRedacted(value)) {
-    return { _tag: "Redacted", value: Redacted.value(value) };
-  }
-  if (Array.isArray(value)) {
-    return value.map(encodeRedacted);
-  }
-  if (value && typeof value === "object" && !("toJSON" in value)) {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, child]) => [key, encodeRedacted(child)]),
-    );
-  }
-  return value;
-};
-
-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 {
-        const serializedArgs = JSON.stringify(
-          encodeRedacted(args),
-        ) as SerializedArgs<Args>;
-        return await handler(serializedArgs);
-      } 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

@@ -1,39 +0,0 @@
-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 { fileURLToPath } from "node:url";
-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(sanitizeSidecarMain(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`),
-      });
-    }),
-  );
-
-/**
- * The sidecar main file is provided using `import.meta.resolve("./SidecarServer.ts", import.meta.url)`.
- * This changes the extension to .js if you're currently running in js.
- */
-export const sanitizeSidecarMain = (url: string) => {
-  const main = fileURLToPath(url);
-  return import.meta.url.endsWith(".js") ? main.replace(".ts", ".js") : main;
-};

package/src/Sidecar/RpcServer.ts

@@ -1,153 +0,0 @@
-import { RpcSession, type RpcCompatible, type RpcTransport } from "capnweb";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Fiber from "effect/Fiber";
-import * as FileSystem from "effect/FileSystem";
-import * as Schedule from "effect/Schedule";
-import type * as Scope from "effect/Scope";
-import * as Lock from "./Lock.ts";
-import {
-  serializeRpcHandlers,
-  type RpcHandlerEncoders,
-  type RpcHandlers,
-} from "./RpcHandler.ts";
-import * as RpcPaths from "./RpcPaths.ts";
-
-export class RpcServer extends Context.Service<
-  RpcServer,
-  {
-    make: <T extends RpcCompatible<T>>(
-      main: () => T,
-    ) => Effect.Effect<
-      {
-        readonly url: string;
-      },
-      never,
-      Scope.Scope
-    >;
-  }
->()("RpcServer") {}
-
-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* RpcServer.use((server) =>
-      server.make(() =>
-        Object.assign(serializeRpcHandlers(handlers, schema), {
-          heartbeat: () => Effect.runPromise(heartbeat.touch),
-          shutdown: () => Effect.runPromise(heartbeat.shutdown),
-        }),
-      ),
-    );
-    yield* fs.writeFileString(paths.url, server.url);
-    yield* Effect.addFinalizer(() =>
-      fs.readFileString(paths.url).pipe(
-        Effect.flatMap((text) =>
-          text === server.url ? 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),
-  };
-});
-
-interface ServerWebSocketLike {
-  send: (message: string) => any | Promise<any>;
-  close: (code?: number, reason?: string) => void;
-}
-
-export type WebSocketRpcSession<T extends RpcCompatible<T>> = ReturnType<
-  typeof makeWebSocketRpcSession<T>
->;
-
-export function makeWebSocketRpcSession<T extends RpcCompatible<T>>(
-  ws: ServerWebSocketLike,
-  main: () => T,
-) {
-  const { transport, dispatch } = makeWebSocketRpcTransport(ws);
-  const session = new RpcSession(transport, main());
-  return { session, dispatch };
-}
-
-function makeWebSocketRpcTransport(ws: ServerWebSocketLike) {
-  let receiveQueue: Array<string> = [];
-  let receiveResolver: ((value: string) => void) | undefined;
-  let receiveRejecter: ((reason: unknown) => void) | undefined;
-  let error: unknown | undefined;
-  return {
-    transport: {
-      send: async (message: string) => await ws.send(message),
-      receive: async () => {
-        const next = receiveQueue.shift();
-        if (next) {
-          return next;
-        } else if (error) {
-          throw error;
-        }
-        return new Promise<string>((resolve, reject) => {
-          receiveResolver = resolve;
-          receiveRejecter = reject;
-        });
-      },
-      abort: (reason: unknown) => {
-        const message =
-          reason instanceof Error ? reason.message : String(reason);
-        ws.close(3000, message);
-        error ??= reason;
-      },
-    } satisfies RpcTransport,
-    dispatch: {
-      message: (data: string | Buffer<ArrayBuffer>) => {
-        if (error) {
-          return;
-        }
-        data = typeof data === "string" ? data : data.toString("utf-8");
-        if (receiveResolver) {
-          receiveResolver(data);
-          receiveResolver = undefined;
-          receiveRejecter = undefined;
-        } else {
-          receiveQueue.push(data);
-        }
-      },
-      close: (code: number, reason: string) => {
-        if (!error) {
-          error = new Error(`WebSocket closed with code ${code}: ${reason}`);
-          if (receiveRejecter) {
-            receiveRejecter(error);
-            receiveRejecter = undefined;
-            receiveResolver = undefined;
-          }
-        }
-      },
-    },
-  };
-}

package/src/Sidecar/RpcServerBun.ts

@@ -1,41 +0,0 @@
-import type { RpcCompatible } from "capnweb";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import type { WebSocketRpcSession } from "./RpcServer.ts";
-import { makeWebSocketRpcSession, RpcServer } from "./RpcServer.ts";
-
-export const RpcServerBun = Layer.succeed(
-  RpcServer,
-  RpcServer.of({
-    make: <T extends RpcCompatible<T>>(main: () => T) =>
-      Effect.acquireRelease(
-        Effect.sync(() =>
-          Bun.serve<WebSocketRpcSession<T>>({
-            port: 0,
-            fetch: (request, server) => {
-              if (server.upgrade(request, { data: undefined! })) {
-                return;
-              }
-              return new Response("Upgrade failed", { status: 400 });
-            },
-            websocket: {
-              open: (ws) => {
-                ws.data = makeWebSocketRpcSession(ws, main);
-              },
-              message: (ws, message) => {
-                ws.data.dispatch.message(message);
-              },
-              close: (ws, code, reason) => {
-                ws.data.dispatch.close(code, reason);
-              },
-            },
-          }),
-        ),
-        (server) => Effect.sync(() => server.stop(true)),
-      ).pipe(
-        Effect.map((server) => ({
-          url: `ws://${server.hostname}:${server.port}`,
-        })),
-      ),
-  }),
-);

package/src/Sidecar/RpcServerNode.ts

@@ -1,51 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { WebSocketServer, type Server } from "ws";
-import { makeWebSocketRpcSession, RpcServer } from "./RpcServer.ts";
-
-export const RpcServerNode = Layer.succeed(
-  RpcServer,
-  RpcServer.of({
-    make: Effect.fnUntraced(function* (main) {
-      const server = new WebSocketServer({ host: "127.0.0.1", port: 0 });
-      const url = yield* Effect.callback<string>((resume) => {
-        server.on("connection", (ws) => {
-          const session = makeWebSocketRpcSession(ws, main);
-          ws.on("message", (data) => {
-            session.dispatch.message(data.toString());
-          });
-          ws.on("close", (code, reason) => {
-            session.dispatch.close(code, reason.toString());
-          });
-        });
-        server.on("error", (error) => {
-          resume(Effect.die(error));
-        });
-        server.on("listening", () => {
-          resume(getServerAddress(server));
-        });
-      });
-      yield* Effect.addFinalizer(() => Effect.sync(() => server.close()));
-      return { url };
-    }),
-  }),
-);
-
-function getServerAddress(server: Server): Effect.Effect<string> {
-  const address = server.address();
-  if (
-    typeof address === "object" &&
-    address !== null &&
-    "address" in address &&
-    "port" in address
-  ) {
-    return Effect.succeed(
-      `ws://${address.address === "::" ? "localhost" : address.address}:${address.port}`,
-    );
-  }
-  return Effect.die(
-    new Error(
-      `Server address is not an object with address and port properties: ${JSON.stringify(address)}`,
-    ),
-  );
-}

package/src/Sidecar/RpcServices.ts

@@ -1,48 +0,0 @@
-import * as ConfigProvider from "effect/ConfigProvider";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as AlchemyContext from "../AlchemyContext.ts";
-import { withProfileOverride } from "../Auth/Profile.ts";
-import type { ExecStackOptionsEncoded } from "../Cli/commands/deploy.ts";
-import { loadConfigProvider } from "../Util/ConfigProvider.ts";
-import * as Lock from "./Lock.ts";
-import * as RpcPaths from "./RpcPaths.ts";
-
-export const layer = (main: string) =>
-  Layer.provideMerge(
-    Lock.LockLive,
-    Layer.provideMerge(
-      RpcPaths.layer(main),
-      Layer.mergeAll(
-        AlchemyContext.AlchemyContextLive,
-        makeConfigProvider(),
-        Layer.unwrap(
-          Effect.promise(() => {
-            if ("Bun" in globalThis) {
-              return import("./RpcServerBun.ts").then((m) => m.RpcServerBun);
-            } else {
-              return import("./RpcServerNode.js").then((m) => m.RpcServerNode);
-            }
-          }),
-        ),
-      ),
-    ),
-  );
-
-const makeConfigProvider = () => {
-  let options: Partial<ExecStackOptionsEncoded>;
-  try {
-    options = JSON.parse(
-      process.env.ALCHEMY_EXEC_OPTIONS!,
-    ) as ExecStackOptionsEncoded;
-  } catch {
-    options = {};
-  }
-  const envFile = Option.fromUndefinedOr(options.envFile);
-  return ConfigProvider.layer(
-    loadConfigProvider(envFile).pipe(
-      Effect.map((base) => withProfileOverride(base, options.profile)),
-    ),
-  );
-};