sailfork / t3code-github / .repos/ alchemy-effect/ packages/ alchemy/ src/ Alchemist/ Runtime.ts

import * as ConfigProvider from "effect/ConfigProvider";
import * as Effect from "effect/Effect";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import type { HttpClient } from "effect/http/HttpClient";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as LogLevel from "effect/LogLevel";
import type { PlatformError } from "effect/PlatformError";
import { type AlchemyContext, AlchemyContextLive } from "../AlchemyContext.ts";
import { ArtifactStore, createArtifactStore } from "../Artifacts.ts";
import { type CredentialsStore, CredentialsStoreLive } from "../Auth/Credentials.ts";
import { type ProfileStore, ProfileStoreLive } from "../Auth/Profile.ts";
import * as Interaction from "../Interaction.ts";
import { makePlainConsoleSink } from "../Util/ConsoleSink.ts";
import { PlatformServices } from "../Util/PlatformServices.ts";
import { authRegistryLayer } from "./AuthRegistry.ts";

/** The services {@link layer} provides; every Alchemist operation runs under them. */
export type Services =
  | AlchemyContext
  | ArtifactStore
  | CredentialsStore
  | HttpClient
  | Interaction.Interaction
  | ProfileStore
  | PlatformServices;

/**
 * Log lines on the console. The caller's own loggers stay; only Effect's
 * default console logger gives way to this sink, so lines print once. Typed
 * events are left to `onEvent` subscribers (a renderer, or the caller's own
 * handler).
 *
 * Info and above only: records replayed from sidecars and child processes
 * bypass the fiber's minimum level, so the sink applies its own.
 */
const consoleSink = makePlainConsoleSink();
const ConsoleLog = Layer.unwrap(
  Effect.map(Logger.CurrentLoggers, (current) =>
    Logger.layer([
      ...[...current].filter((logger) => logger !== Logger.defaultLogger),
      Logger.make<unknown, void>((options) => {
        if (LogLevel.isGreaterThanOrEqualTo(options.logLevel, "Info")) consoleSink.log(options);
      }),
    ]),
  ),
);

/**
 * All services required by the programmatic Alchemist API.
 *
 * Log lines print on the console. Typed events are log records too; observe
 * them around a call with {@link import("../Events.ts").onEvent}.
 * The non-interactive Interaction default serves the engine paths that need
 * one (state-store confirms fail typed; profile probes never prompt).
 *
 * @example
 * ```ts
 * Effect.runPromise(
 *   program.pipe(Effect.provide(Alchemist.layer()), Effect.scoped),
 * )
 * ```
 */
export const layer = (): Layer.Layer<Services, PlatformError> =>
  Layer.mergeAll(
    Layer.mergeAll(AlchemyContextLive, ProfileStoreLive, CredentialsStoreLive).pipe(
      Layer.provideMerge(PlatformServices),
    ),
    FetchHttpClient.layer,
    ConfigProvider.layer(ConfigProvider.fromEnv()),
    Layer.succeed(ArtifactStore, createArtifactStore()),
    Interaction.layerNonInteractive(),
    ConsoleLog,
    authRegistryLayer,
  );