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

package/src/Cloudflare/Zaraz/index.ts

@@ -0,0 +1,25 @@
+export * from "./ZarazConfig.ts";
+export type {
+  InferZarazEcommerceEvents,
+  InferZarazEvents,
+  ZarazClientProperties,
+  ZarazEcommerce,
+  ZarazEcommerceCheckoutStep,
+  ZarazEcommerceEvents,
+  ZarazEcommerceOrder,
+  ZarazEcommercePayment,
+  ZarazEcommerceProduct,
+  ZarazEcommercePromotion,
+  ZarazEcommerceRefund,
+  ZarazEcommerceSearch,
+  ZarazEventContract,
+  ZarazEventMap,
+  ZarazEventName,
+  ZarazEventProperties,
+  ZarazHttpEvent,
+  ZarazHttpEventsPayload,
+  ZarazSetScope,
+  ZarazSystem,
+  ZarazTrack,
+  ZarazWebApi,
+} from "./ZarazEventTypes.ts";

package/src/Cloudflare/index.ts

@@ -21,3 +21,4 @@ export * from "./VpcService/index.ts";
 export * from "./Website/index.ts";
 export * from "./Workers/index.ts";
 export * from "./Workers/RpcAsync.ts";
+export * from "./Zaraz/index.ts";

package/src/Local/RpcProvider.ts

@@ -0,0 +1,102 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { Scope } from "effect/Scope";
+import type { Platform } from "../Platform.ts";
+import * as Provider from "../Provider.ts";
+import type { ResourceClass, ResourceLike } from "../Resource.ts";
+import { RpcProviderProxy } from "./RpcProviderProxy.ts";
+
+/**
+ * Constructs an RpcProvider for a given resource.
+ *
+ * An RpcProvider is a resource provider that can run in a separate process.
+ * This is used for local development so that the resource provider and its state can outlive the user's code when it is hot-reloaded.
+ * If the {@link RpcProviderProxy} is provided, the provider is run in a separate process, which we communicate with here using a websocket.
+ * Otherwise, the given effect is used to construct the provider directly.
+ *
+ * @note If the provider is running in a separate process, you may not need to construct all of its layers in this process.
+ *       You can use {@link providerServices} or {@link providerServicesEffect} to construct such layers only when they are needed.
+ *
+ * @example
+ * ```ts
+ * export const MyProvider = RpcProvider.effect(
+ *   MyResource,
+ *   import.meta.resolve("./my-rpc-provider-server.ts"),
+ *   Effect.gen(function* () {
+ *     return {
+ *       diff: ...,
+ *       reconcile: ...,
+ *       delete: ...,
+ *     }
+ *   })
+ * )
+ * ```
+ *
+ * @param cls - The tag of the resource class to construct a provider for.
+ * @param serverEntryUrl - The main file for the server entry point, if the provider is to be run in a separate process. This is typically obtained using `import.meta.url` or `import.meta.resolve`.
+ * @param eff - The Effect to use to construct the provider.
+ * @returns A layer containing the RpcProvider.
+ */
+export const effect = <
+  R extends ResourceLike,
+  Req = never,
+  ReadReq = never,
+  DiffReq = never,
+  PrecreateReq = never,
+  ReconcileReq = never,
+  DeleteReq = never,
+  TailReq = never,
+  LogsReq = never,
+>(
+  cls: ResourceClass<R> | Platform<R, any, any, any, any>,
+  serverEntryUrl: string,
+  eff: Effect.Effect<
+    Provider.ProviderService<
+      R,
+      ReadReq,
+      DiffReq,
+      PrecreateReq,
+      ReconcileReq,
+      DeleteReq,
+      TailReq,
+      LogsReq
+    >,
+    never,
+    Req
+  >,
+) =>
+  Provider.effect(
+    cls,
+    Effect.gen(function* () {
+      const client = yield* Effect.serviceOption(RpcProviderProxy);
+      if (client._tag === "None") return yield* eff;
+      return yield* client.value.get(serverEntryUrl, cls.Type);
+    }),
+  );
+
+/**
+ * Conditionally constructs a layer for use by an RpcProvider.
+ * If the {@link RpcProviderProxy} is present in context, the layer is empty because it will not be used in this process.
+ * Otherwise, the given layer is returned.
+ * @param self - The layer that is used by the RpcProvider.
+ * @returns A layer that is empty if the {@link RpcProviderProxy} is present in context, otherwise the given layer.
+ */
+export const providerServices = <ROut, E, RIn>(
+  self: Layer.Layer<ROut, E, RIn>,
+): Layer.Layer<ROut, E, RIn> => providerServicesEffect(Effect.succeed(self));
+
+/**
+ * Conditionally constructs a layer for use by an RpcProvider.
+ * If the {@link RpcProviderProxy} is present in context, the layer is empty because it will not be used in this process.
+ * Otherwise, the given layer is returned.
+ * @param self - An effect which returns a layer that is used by the RpcProvider.
+ */
+export const providerServicesEffect = <A, E1, R1, E, R>(
+  self: Effect.Effect<Layer.Layer<A, E1, R1>, E, R>,
+): Layer.Layer<A, E | E1, R1 | Exclude<R, Scope>> =>
+  Effect.serviceOption(RpcProviderProxy).pipe(
+    Effect.flatMap((client) =>
+      client._tag === "None" ? self : (Effect.succeed(Layer.empty) as never),
+    ),
+    Layer.unwrap,
+  );

package/src/Local/RpcProviderProxy.ts

@@ -0,0 +1,86 @@
+import { newWebSocketRpcSession, type RpcStub } from "capnweb";
+import * as Cache from "effect/Cache";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as HttpBody from "effect/unstable/http/HttpBody";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { AlchemyContext } from "../AlchemyContext.ts";
+import type { ProviderService } from "../Provider.ts";
+import type { ResourceLike } from "../Resource.ts";
+import { Stack } from "../Stack.ts";
+import { unwrapRpcHandlers } from "./RpcSerialization.ts";
+import type { RpcProxyApi } from "./RpcServer.ts";
+import type { RpcSpawnPayload } from "./RpcSpawner.ts";
+
+export class RpcProviderProxy extends Context.Service<
+  RpcProviderProxy,
+  {
+    readonly get: <R extends ResourceLike>(
+      serverEntryUrl: string,
+      providerName: R["Type"],
+    ) => Effect.Effect<ProviderService<R>, never, AlchemyContext | Stack>;
+  }
+>()("alchemy/Local/RpcProviderProxy") {}
+
+export const SPAWNER_URL_ENV_KEY = "ALCHEMY_RPC_SPAWNER_URL" as const;
+
+const make = Effect.fnUntraced(function* (spawnerUrl: string) {
+  const client = yield* HttpClient.HttpClient;
+
+  const getSession = Effect.fnUntraced(
+    function* (serverEntryUrl: string) {
+      const alchemyContext = yield* AlchemyContext;
+      const stack = yield* Stack;
+      const payload: RpcSpawnPayload = {
+        serverEntryUrl,
+        alchemyContext,
+        stack: { name: stack.name, stage: stack.stage },
+      };
+      const response = yield* client.post(spawnerUrl, {
+        body: yield* HttpBody.json(payload),
+      });
+      const websocketUrl = yield* response.text;
+      return newWebSocketRpcSession(websocketUrl) as RpcStub<RpcProxyApi>;
+    },
+    (effect, serverEntryUrl) =>
+      Effect.catch(effect, (error) =>
+        Effect.die(
+          new Error(
+            `Failed to create provider RPC session for "${serverEntryUrl}"`,
+            {
+              cause: error,
+            },
+          ),
+        ),
+      ),
+  );
+
+  const cache = yield* Cache.make({
+    lookup: getSession,
+    capacity: Infinity,
+    requireServicesAt: "lookup",
+  });
+
+  return RpcProviderProxy.of({
+    get: Effect.fnUntraced(function* (mainUrl, providerName) {
+      const session = yield* cache.lookup(mainUrl);
+      const provider = yield* Effect.promise(
+        () =>
+          session.getProvider(providerName) as ReturnType<
+            RpcProxyApi["getProvider"]
+          >,
+      );
+      return unwrapRpcHandlers(provider, ["tail"]);
+    }),
+  });
+});
+
+export const layer = (url: string) => Layer.effect(RpcProviderProxy, make(url));
+
+export const fromEnv = () =>
+  Layer.effect(
+    RpcProviderProxy,
+    Config.string(SPAWNER_URL_ENV_KEY).pipe(Effect.flatMap(make)),
+  );

package/src/Local/RpcSerialization.ts

@@ -0,0 +1,225 @@
+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";
+import * as Stream from "effect/Stream";
+import * as NodeUtil from "node:util";
+import * as Output from "../Output.ts";
+
+type RpcEffectHandler<Args extends Array<any>, Success, Error> = (
+  ...args: Args
+) => Effect.Effect<Success, Error>;
+
+type RpcWrappedEffectHandler<Args extends Array<any>, Success, Error> = (
+  args: Args,
+) => Promise<RpcSerializedExit<Success, Error>>;
+
+type RpcStreamHandler<Args extends Array<any>, Success, Error> = (
+  ...args: Args
+) => Stream.Stream<Success, Error>;
+
+type RpcWrappedStreamHandler<Args extends Array<any>, Success, Error> = (
+  args: Args,
+) => RpcSerializedStream<Success, Error>;
+
+type RpcSerializedStream<Success, _Error> = ReadableStream<Success>;
+
+type RpcSerializedExit<Success, Error> =
+  | { _tag: "Success"; value: Success }
+  | { _tag: "Failure"; cause: Array<RpcSerializedCause<Error>> };
+
+type RpcSerializedCause<Error> =
+  | { _tag: "Fail"; error: Error }
+  | { _tag: "Die"; defect: unknown }
+  | { _tag: "Interrupt"; fiberId: number | undefined };
+
+export type RpcWrapped<T> =
+  T extends RpcEffectHandler<infer Args, infer Success, infer Error>
+    ? RpcWrappedEffectHandler<Args, Success, Error>
+    : T extends RpcStreamHandler<infer Args, infer Success, infer Error>
+      ? RpcWrappedStreamHandler<Args, Success, Error>
+      : T extends Record<string, any>
+        ? { [K in keyof T]: RpcWrapped<T[K]> }
+        : T;
+
+export type RpcUnwrapped<T> =
+  T extends RpcWrappedEffectHandler<infer Args, infer Success, infer Error>
+    ? RpcEffectHandler<Args, Success, Error>
+    : T extends RpcWrappedStreamHandler<infer Args, infer Success, infer Error>
+      ? RpcStreamHandler<Args, Success, Error>
+      : T extends Record<string, any>
+        ? { [K in keyof T]: RpcUnwrapped<T[K]> }
+        : T;
+
+export const wrapRpcHandlers = <T extends Record<string, any>>(
+  handlers: T,
+  streamKeys?: Array<keyof T>,
+): RpcWrapped<T> => {
+  return Object.fromEntries(
+    Object.entries(handlers).map(([key, value]) => [
+      key,
+      typeof value === "function"
+        ? streamKeys?.includes(key)
+          ? wrapRpcStreamHandler(value)
+          : wrapRpcEffectHandler(value)
+        : typeof value === "object" && value !== null
+          ? wrapRpcHandlers(value)
+          : value,
+    ]),
+  ) as RpcWrapped<T>;
+};
+
+export const unwrapRpcHandlers = <T extends Record<string, any>>(
+  handlers: RpcWrapped<T>,
+  streamKeys?: Array<keyof T>,
+): RpcUnwrapped<T> => {
+  return Object.fromEntries(
+    Object.entries(handlers).map(([key, value]) => [
+      key,
+      typeof value === "function"
+        ? streamKeys?.includes(key)
+          ? unwrapRpcStreamHandler(value)
+          : unwrapRpcEffectHandler(value)
+        : typeof value === "object" && value !== null
+          ? unwrapRpcHandlers(value)
+          : value,
+    ]),
+  ) as RpcUnwrapped<T>;
+};
+
+const serializeError = Schema.encodeSync(Schema.Defect);
+
+const wrapRpcEffectHandler = <Args extends Array<any>, Success, Error>(
+  handler: RpcEffectHandler<Args, Success, Error>,
+): RpcWrappedEffectHandler<Args, Success, Error> =>
+  flow(
+    (args) => deserializeRpcArgs(args) as Args,
+    (args) => handler(...args),
+    Effect.exit,
+    Effect.map((exit): RpcSerializedExit<Success, Error> => {
+      if (exit._tag === "Success") {
+        return { _tag: "Success", value: exit.value };
+      }
+      return {
+        _tag: "Failure",
+        cause: exit.cause.reasons.map((reason): RpcSerializedCause<Error> => {
+          switch (reason._tag) {
+            case "Fail":
+              return { _tag: "Fail", error: serializeError(reason.error) };
+            case "Die":
+              return { _tag: "Die", defect: serializeError(reason.defect) };
+            case "Interrupt":
+              return { _tag: "Interrupt", fiberId: reason.fiberId };
+          }
+        }),
+      };
+    }),
+    Effect.runPromise,
+  );
+
+const wrapRpcStreamHandler = <Args extends Array<any>, Success, Error>(
+  handler: RpcStreamHandler<Args, Success, Error>,
+): RpcWrappedStreamHandler<Args, Success, Error> =>
+  flow(
+    (args) => deserializeRpcArgs(args) as Args,
+    (args) => handler(...args),
+    (stream) => Stream.toReadableStream(stream),
+  );
+
+const unwrapRpcEffectHandler = <Args extends Array<any>, Success, Error>(
+  handler: RpcWrappedEffectHandler<Args, Success, Error>,
+): RpcEffectHandler<Args, Success, Error> =>
+  flow(
+    (...args) => serializeRpcArgs(args) as Args,
+    (args) => Effect.promise(() => handler(args)),
+    Effect.flatMap((exit): Exit.Exit<Success, Error> => {
+      if (exit._tag === "Success") {
+        return Exit.succeed(exit.value);
+      }
+      return Exit.failCause(
+        Cause.fromReasons(
+          exit.cause.map((reason): Cause.Reason<Error> => {
+            switch (reason._tag) {
+              case "Fail":
+                return Cause.makeFailReason(reason.error);
+              case "Die":
+                return Cause.makeDieReason(reason.defect);
+              case "Interrupt":
+                return Cause.makeInterruptReason(reason.fiberId);
+            }
+          }),
+        ),
+      );
+    }),
+  );
+
+const unwrapRpcStreamHandler = <Args extends Array<any>, Success, Error>(
+  handler: RpcWrappedStreamHandler<Args, Success, Error>,
+): RpcStreamHandler<Args, Success, Error> =>
+  flow(
+    (...args) => serializeRpcArgs(args) as Args,
+    (args) => handler(args),
+    (stream) =>
+      Stream.fromReadableStream({
+        evaluate: () => stream,
+        onError: (error) => error as Error,
+      }),
+  );
+
+const serializeRpcArgs = (value: unknown): unknown => {
+  if (Redacted.isRedacted(value)) {
+    return { _tag: "Redacted", value: Redacted.value(value) };
+  }
+  if (Output.isOutput(value)) {
+    return {
+      _tag: "Output",
+      description: NodeUtil.inspect(value),
+    };
+  }
+  if (typeof value === "function") {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return value.map(serializeRpcArgs);
+  }
+  if (value && typeof value === "object" && !("toJSON" in value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [
+        key,
+        serializeRpcArgs(child),
+      ]),
+    );
+  }
+  return value;
+};
+
+const deserializeRpcArgs = (value: unknown): unknown => {
+  if (Array.isArray(value)) {
+    return value.map(deserializeRpcArgs);
+  } else if (typeof value === "object" && value !== null) {
+    // These values are serialized as `{_tag: "Redacted", value: ...}` and `{_tag: "Output", description: ...}`,
+    // so we need to detect them manually - Redacted.isRedacted and Output.isOutput do not work.
+    if ("_tag" in value && value._tag === "Redacted" && "value" in value) {
+      return Redacted.make(value.value);
+    } else if (
+      "_tag" in value &&
+      value._tag === "Output" &&
+      "description" in value &&
+      typeof value.description === "string"
+    ) {
+      return new Output.NamedExpr(
+        new Output.EffectExpr(Output.VoidExpr, () => Effect.never),
+        value.description,
+      );
+    }
+    return Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [
+        key,
+        deserializeRpcArgs(child),
+      ]),
+    );
+  }
+  return value;
+};

package/src/Local/RpcServer.ts

@@ -0,0 +1,138 @@
+import * as Console from "effect/Console";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Scope from "effect/Scope";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import type { HttpClient } from "effect/unstable/http/HttpClient";
+import type { ProviderService } from "../Provider.ts";
+import type { ResourceLike } from "../Resource.ts";
+import {
+  platformLayer,
+  PlatformServices,
+  runMain,
+} from "../Util/PlatformServices.ts";
+import * as RpcSerialization from "./RpcSerialization.ts";
+import * as RpcServerEnvironment from "./RpcServerEnvironment.ts";
+import {
+  makeServerRpcSession,
+  type ServerRpcSession,
+  type ServerWebSocketLike,
+} from "./RpcServerSession.ts";
+
+/**
+ * A service that exposes one or more resource providers over RPC.
+ * This returns `never` because it is meant to be used with `Layer.launch` (see {@link launch}).
+ */
+export class RpcServer extends Context.Service<RpcServer, never>()(
+  "alchemy/Local/RpcServer",
+) {}
+
+/**
+ * The RPC API that is implemented by the server and consumed by {@link RpcProviderProxy}.
+ */
+export interface RpcProxyApi {
+  /**
+   * Retrieves a provider from the RPC server context.
+   * The consumer must unwrap the provider using {@link RpcSerialization.unwrapRpcHandlers} before using it.
+   */
+  readonly getProvider: <R extends ResourceLike>(
+    type: R["Type"],
+  ) => Promise<RpcSerialization.RpcWrapped<ProviderService<R>>>;
+}
+
+const serverPlatformLayer = platformLayer({
+  bun: async () => {
+    const { RpcServerBun } = await import("./RpcServerBun.ts");
+    return RpcServerBun;
+  },
+  node: async () => {
+    const { RpcServerNode } = await import("./RpcServerNode.ts");
+    return RpcServerNode;
+  },
+});
+
+/**
+ * Launches an RPC server that serves the given providers.
+ * Alchemy globals such as `AlchemyContext`, `Profile`, and `Stack` are inherited from the parent via {@link RpcServerEnvironment.fromEnv} and should not be provided manually.
+ * `PlatformServices` and `HttpClient` are also included.
+ *
+ * @example
+ * ```ts
+ * RpcServer.launch(
+ *   Layer.merge(
+ *     FunctionProvider,
+ *     QueueProvider,
+ *   ),
+ * );
+ * ```
+ *
+ * @param providers - A layer containing the providers to serve.
+ */
+export const launch = <ROut, E>(
+  providers: Layer.Layer<
+    ROut,
+    E,
+    | Scope.Scope
+    | RpcServerEnvironment.RpcEnvironmentServices
+    | PlatformServices
+    | HttpClient
+  >,
+) =>
+  serverPlatformLayer.pipe(
+    Layer.provide(providers),
+    Layer.provide(RpcServerEnvironment.fromEnv()),
+    Layer.provide(Layer.merge(PlatformServices, FetchHttpClient.layer)),
+    Layer.launch,
+    Effect.scoped,
+    runMain,
+  );
+
+/**
+ * Constructs an `RpcServer` layer using the given server implementation.
+ * @param serve - A function that spawns a websocket server and returns its URL.
+ * @returns An `RpcServer` layer.
+ */
+export const layerServer = (
+  serve: (handlers: {
+    /** Creates a new RPC session over the given websocket. */
+    createRpcSession: (
+      ws: ServerWebSocketLike,
+    ) => ServerRpcSession<RpcProxyApi>;
+    /** Called when the parent connection, indicated by the `/parent` path, is established. */
+    parentConnected: () => void;
+    /** Called when the parent disconnects. The server will shut down when this is called. */
+    parentDisconnected: () => void;
+  }) => Effect.Effect<{ readonly url: string }, never, Scope.Scope>,
+) =>
+  Layer.effect(
+    RpcServer,
+    Effect.gen(function* () {
+      const context = yield* Effect.context();
+      const connected = yield* Deferred.make<void>();
+      const disconnected = yield* Deferred.make<void>();
+      const { url } = yield* serve({
+        createRpcSession: (ws) =>
+          makeServerRpcSession<RpcProxyApi>(ws, {
+            getProvider: async <R extends ResourceLike>(type: R["Type"]) => {
+              const provider = context.mapUnsafe.get(type);
+              if (!provider) {
+                throw new Error(`Provider "${type}" not found`);
+              }
+              return RpcSerialization.wrapRpcHandlers(
+                provider as ProviderService<R>,
+                ["tail"],
+              );
+            },
+          }),
+        parentConnected: () => Deferred.doneUnsafe(connected, Effect.void),
+        parentDisconnected: () =>
+          Deferred.doneUnsafe(disconnected, Effect.void),
+      });
+      yield* Console.log(`<ALCHEMY_RPC_ADDRESS>${url}</ALCHEMY_RPC_ADDRESS>`);
+      yield* Deferred.await(connected).pipe(Effect.timeout("10 seconds")); // TODO(john): should the timeout be shorter?
+      yield* Deferred.await(disconnected);
+      return yield* Effect.interrupt;
+    }),
+  );

package/src/Local/RpcServerBun.ts

@@ -0,0 +1,59 @@
+import * as Effect from "effect/Effect";
+import * as RpcServer from "./RpcServer.ts";
+import type { ServerRpcSession } from "./RpcServerSession.ts";
+
+export const RpcServerBun = RpcServer.layerServer(
+  Effect.fnUntraced(function* ({
+    parentConnected,
+    parentDisconnected,
+    createRpcSession,
+  }) {
+    const server = yield* Effect.sync(() =>
+      Bun.serve<
+        { type: "session"; session: ServerRpcSession<any> } | { type: "parent" }
+      >({
+        port: 0,
+        fetch: (request, server) => {
+          const url = new URL(request.url);
+          if (
+            server.upgrade(request, {
+              data:
+                url.pathname === "/parent" ? { type: "parent" } : undefined!,
+            })
+          ) {
+            return;
+          }
+          return new Response("Upgrade failed", { status: 400 });
+        },
+        websocket: {
+          open: (ws) => {
+            if (ws.data && ws.data.type === "parent") {
+              parentConnected();
+            } else {
+              ws.data = {
+                type: "session",
+                session: createRpcSession(ws),
+              };
+            }
+          },
+          message: (ws, message) => {
+            if (ws.data.type === "session") {
+              ws.data.session.dispatch.message(message);
+            }
+          },
+          close: (ws, code, reason) => {
+            if (ws.data.type === "session") {
+              ws.data.session.dispatch.close(code, reason);
+            } else if (ws.data.type === "parent") {
+              parentDisconnected();
+            }
+          },
+        },
+      }),
+    );
+    yield* Effect.addFinalizer(() => Effect.sync(() => server.stop(true)));
+    return {
+      url: `ws://${server.hostname}:${server.port}`,
+    };
+  }),
+);

package/src/Local/RpcServerEnvironment.ts

@@ -0,0 +1,55 @@
+import * as Config from "effect/Config";
+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 { AlchemyContext } from "../AlchemyContext.ts";
+import { AuthProviders } from "../Auth/AuthProvider.ts";
+import { CredentialsStoreLive } from "../Auth/Credentials.ts";
+import { ProfileLive, withProfileOverride } from "../Auth/Profile.ts";
+import { Stack } from "../Stack.ts";
+import { Stage } from "../Stage.ts";
+import { loadConfigProvider } from "../Util/ConfigProvider.ts";
+
+export interface RpcServerEnvironment {
+  alchemyContext: AlchemyContext["Service"];
+  profile: string | undefined;
+  envFile: string | undefined;
+  stack: {
+    name: string;
+    stage: string;
+  };
+}
+
+export type RpcEnvironmentServices = Layer.Success<ReturnType<typeof layer>>;
+
+export const layer = (environment: RpcServerEnvironment) =>
+  Layer.mergeAll(
+    ProfileLive,
+    CredentialsStoreLive,
+    Layer.succeed(AuthProviders, {}),
+    ConfigProvider.layer(
+      loadConfigProvider(Option.fromUndefinedOr(environment.envFile)).pipe(
+        Effect.map((base) => withProfileOverride(base, environment.profile)),
+      ),
+    ),
+    Layer.succeed(AlchemyContext, environment.alchemyContext),
+    Layer.succeed(Stack, {
+      name: environment.stack.name,
+      stage: environment.stack.stage,
+      resources: {},
+      bindings: {},
+      actions: {},
+    }),
+    Layer.succeed(Stage, environment.stack.stage),
+  );
+
+export const RPC_SERVER_ENVIRONMENT_KEY =
+  "ALCHEMY_RPC_SERVER_ENVIRONMENT" as const;
+
+export const fromEnv = () =>
+  Config.string(RPC_SERVER_ENVIRONMENT_KEY).pipe(
+    Config.map(JSON.parse),
+    Effect.map((environment) => layer(environment)),
+    Layer.unwrap,
+  );