alchemy-effect 0.5.0 → 0.6.2

package/src/Daemon/RpcServer.ts

@@ -0,0 +1,231 @@
+import * as NodeSocketServer from "@effect/platform-node/NodeSocketServer";
+import * as Deferred from "effect/Deferred";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Ref from "effect/Ref";
+import * as Schedule from "effect/Schedule";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+import { type SQLiteConnection } from "../SQLite/index.ts";
+import { SQLite } from "../SQLite/SQLite.ts";
+import {
+  ALCHEMY_DIR,
+  DB_FILE,
+  ensureAlchemyDir,
+  PROCESSES_DIR,
+  resolveSocketPath,
+  SOCKET_FILE,
+} from "./Config.ts";
+import { ProcessAlreadyExists, ProcessNotFound } from "./Errors.ts";
+import { acquireLock, isProcessAlive } from "./Lock.ts";
+import { makeProcessRegistry } from "./ProcessRegistry.ts";
+import { DaemonRpcs } from "./RpcSchema.ts";
+
+// Re-export platform layers needed by the entry point
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { BunSQLite } from "../SQLite/index.ts";
+
+export { BunSQLite, NodeServices };
+
+const IDLE_TIMEOUT = Duration.seconds(10);
+
+export const main = Effect.gen(function* () {
+  const shutdownSignal = yield* Deferred.make<void>();
+
+  yield* Effect.logInfo("Acquiring daemon lock…");
+  yield* acquireLock(shutdownSignal);
+
+  const db = yield* initDb;
+  yield* cleanupOrphans(db);
+
+  yield* cleanStaleSocket;
+
+  const socketPath = yield* resolveSocketPath;
+  yield* Effect.logInfo("Starting daemon socket server…");
+
+  const socketServerLayer = NodeSocketServer.layer({ path: socketPath });
+
+  yield* Effect.addFinalizer(() =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      yield* fs.remove(socketPath, { force: true }).pipe(Effect.ignore);
+    }),
+  );
+
+  const watchdog = yield* makeIdleWatchdog(shutdownSignal);
+  yield* watchdog.startWatchdog;
+  yield* watchdog.recordHeartbeat;
+
+  const procRegistry = yield* makeProcessRegistry(db);
+
+  const rpcServerLayer = RpcServer.layer(DaemonRpcs).pipe(
+    Layer.provide(RpcServer.layerProtocolSocketServer),
+    Layer.provide(RpcSerialization.layerJson),
+    Layer.provide(socketServerLayer),
+    Layer.provide(makeHandlersLayer(watchdog, procRegistry)),
+    Layer.provide(NodeServices.layer),
+    Layer.provide(BunSQLite),
+  );
+
+  yield* Layer.launch(rpcServerLayer).pipe(Effect.forkScoped);
+
+  yield* Effect.logInfo("Daemon ready");
+
+  yield* watchdog.awaitShutdown;
+}).pipe(Effect.scoped);
+
+// ---------------------------------------------------------------------------
+// Socket lifecycle
+// ---------------------------------------------------------------------------
+
+const cleanStaleSocket = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const dir = path.resolve(ALCHEMY_DIR);
+  const socketPath = path.join(dir, SOCKET_FILE);
+  yield* fs.remove(socketPath, { force: true });
+});
+
+// ---------------------------------------------------------------------------
+// SQLite — process metadata persistence
+// ---------------------------------------------------------------------------
+
+const initDb = Effect.gen(function* () {
+  const sqlite = yield* SQLite;
+  const path = yield* Path.Path;
+  const dir = yield* ensureAlchemyDir;
+  const dbPath = path.join(dir, DB_FILE);
+  const db = yield* sqlite.open(dbPath);
+
+  yield* db.exec(`
+    CREATE TABLE IF NOT EXISTS processes (
+      id TEXT PRIMARY KEY,
+      pid INTEGER NOT NULL,
+      command TEXT NOT NULL,
+      args TEXT NOT NULL,
+      cwd TEXT,
+      started_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+
+  return db;
+});
+
+interface ProcessRow {
+  id: string;
+  pid: number;
+  command: string;
+  args: string;
+  cwd: string | null;
+}
+
+// ---------------------------------------------------------------------------
+// Boot cleanup — kill orphans from a previous crashed daemon
+// ---------------------------------------------------------------------------
+
+const cleanupOrphans = (db: SQLiteConnection) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const dir = yield* ensureAlchemyDir;
+    const processesDir = path.join(dir, PROCESSES_DIR);
+
+    const stmt = yield* db.prepare<ProcessRow>("SELECT id, pid FROM processes");
+    const orphans = yield* stmt.all();
+
+    if (orphans.length === 0) return;
+
+    yield* Effect.logInfo(`Cleaning up ${orphans.length} orphan process(es)…`);
+
+    for (const orphan of orphans) {
+      yield* isProcessAlive(orphan.pid).pipe(
+        Effect.flatMap((alive) =>
+          alive
+            ? Effect.sync(() => {
+                try {
+                  process.kill(orphan.pid, "SIGKILL");
+                } catch {}
+              })
+            : Effect.void,
+        ),
+      );
+
+      yield* fs
+        .remove(path.join(processesDir, orphan.id), {
+          recursive: true,
+          force: true,
+        })
+        .pipe(Effect.ignore);
+    }
+
+    const delStmt = yield* db.prepare("DELETE FROM processes");
+    yield* delStmt.run();
+
+    yield* Effect.logInfo(`Cleaned up ${orphans.length} orphan(s)`);
+  });
+
+// ---------------------------------------------------------------------------
+// Idle shutdown — heartbeat-based
+// ---------------------------------------------------------------------------
+
+const makeIdleWatchdog = (shutdownSignal: Deferred.Deferred<void>) =>
+  Effect.gen(function* () {
+    const lastHeartbeat = yield* Ref.make(Date.now());
+
+    const recordHeartbeat = Ref.set(lastHeartbeat, Date.now());
+
+    const startWatchdog = Effect.gen(function* () {
+      yield* Effect.gen(function* () {
+        yield* Effect.sleep(IDLE_TIMEOUT);
+        const last = yield* Ref.get(lastHeartbeat);
+        const elapsed = Date.now() - last;
+        if (elapsed >= Duration.toMillis(IDLE_TIMEOUT)) {
+          yield* Effect.logInfo("No heartbeat received — shutting down daemon");
+          yield* Deferred.succeed(shutdownSignal, void 0);
+        }
+      }).pipe(
+        Effect.repeat(Schedule.spaced(IDLE_TIMEOUT)),
+        Effect.asVoid,
+        Effect.forkChild,
+      );
+    });
+
+    const awaitShutdown = Deferred.await(shutdownSignal);
+
+    return { recordHeartbeat, startWatchdog, awaitShutdown };
+  });
+
+// ---------------------------------------------------------------------------
+// RPC handler layer
+// ---------------------------------------------------------------------------
+
+const makeHandlersLayer = (
+  watchdog: Effect.Success<ReturnType<typeof makeIdleWatchdog>>,
+  procRegistry: Effect.Success<ReturnType<typeof makeProcessRegistry>>,
+) =>
+  DaemonRpcs.toLayer({
+    heartbeat: () =>
+      Effect.gen(function* () {
+        yield* Effect.logInfo("Heartbeat received");
+        yield* watchdog.recordHeartbeat;
+      }),
+    spawn: (req) =>
+      procRegistry.spawnProcess(req).pipe(
+        Effect.catchIf(
+          (e): e is Exclude<typeof e, ProcessAlreadyExists> =>
+            !(e instanceof ProcessAlreadyExists),
+          (e) => Effect.die(e),
+        ),
+      ),
+    kill: (req) =>
+      procRegistry.killProcess(req).pipe(
+        Effect.catchIf(
+          (e): e is Exclude<typeof e, ProcessNotFound> =>
+            !(e instanceof ProcessNotFound),
+          (e) => Effect.die(e),
+        ),
+      ),
+    watch: (req) => procRegistry.watchProcess(req),
+  });

package/src/Daemon/index.ts

@@ -0,0 +1,25 @@
+export {
+  ALCHEMY_DIR,
+  DB_FILE,
+  ensureAlchemyDir,
+  LOCK_DIR_NAME,
+  PID_FILE_NAME,
+  PROCESSES_DIR,
+  resolveAlchemyDir,
+  resolveSocketPath,
+  SOCKET_FILE,
+} from "./Config.ts";
+
+export { Daemon, DaemonLive, makeClient } from "./Client.ts";
+export type { DaemonClient } from "./Client.ts";
+
+export {
+  DaemonAlreadyRunning,
+  LockCompromised,
+  ProcessAlreadyExists,
+  ProcessNotFound,
+} from "./Errors.ts";
+
+export { DaemonRpcs } from "./RpcSchema.ts";
+
+export { main as daemonMain } from "./RpcServer.ts";

package/src/Destroy.ts

@@ -0,0 +1,15 @@
+import * as Effect from "effect/Effect";
+import { apply } from "./Apply.ts";
+import * as Plan from "./Plan.ts";
+import { Stack } from "./Stack.ts";
+
+export const destroy = () =>
+  Stack.use((stack) =>
+    Plan.make({
+      name: stack.name,
+      stage: stack.stage,
+      resources: {},
+      bindings: {},
+      output: {},
+    }),
+  ).pipe(Effect.flatMap(apply));

package/src/Diff.ts

@@ -0,0 +1,142 @@
+import * as Effect from "effect/Effect";
+import type { Input } from "./Input.ts";
+import * as Output from "./Output.ts";
+import type { BindingNode } from "./Plan.ts";
+import type { ResourceBinding } from "./Resource.ts";
+import { isPrimitive } from "./Util/data.ts";
+
+export type Diff = NoopDiff | UpdateDiff | ReplaceDiff;
+
+export interface NoopDiff {
+  action: "noop";
+  stables?: undefined;
+}
+
+export interface UpdateDiff {
+  action: "update";
+  /** properties that won't change as part of this update */
+  stables?: string[];
+}
+
+export interface ReplaceDiff {
+  action: "replace";
+  deleteFirst?: boolean;
+  stables?: undefined;
+}
+
+/**
+ * Returns true when `value` (or any nested leaf) is still an unresolved
+ * plan-time expression — i.e. an `Output`/`Expr` or an `Effect` that was
+ * not fully evaluated by `resolveInput` in Plan.ts.
+ *
+ * Use at the top of a provider `diff` to short-circuit before field access:
+ *
+ * ```ts
+ * if (!isResolved(news)) return undefined;
+ * const resolved = news as MyProps;
+ * ```
+ */
+export const hasUnresolvedInputs = <T>(value: Input<NoInfer<T>>): value is T =>
+  _hasUnresolved(value);
+
+export const isResolved = <T>(value: Input<T>): value is T =>
+  !_hasUnresolved(value);
+
+const _hasUnresolved = (value: unknown): boolean => {
+  if (value == null || isPrimitive(value)) return false;
+  if (Output.isExpr(value) || Effect.isEffect(value)) return true;
+  if (Array.isArray(value)) return value.some(_hasUnresolved);
+  if (typeof value === "object") {
+    return Object.values(value as Record<string, unknown>).some(_hasUnresolved);
+  }
+  return false;
+};
+
+export const somePropsAreDifferent = <Props extends Record<string, any>>(
+  olds: Props,
+  news: Props,
+  props: (keyof Props)[],
+) => {
+  for (const prop of props) {
+    if (olds[prop] !== news[prop]) {
+      return true;
+    }
+  }
+  return false;
+};
+
+export const anyPropsAreDifferent = <Props extends Record<string, any>>(
+  olds: Props,
+  news: Props,
+) => {
+  for (const prop in olds) {
+    if (olds[prop] !== news[prop]) {
+      return true;
+    }
+  }
+  for (const prop in news) {
+    if (!(prop in olds)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+export const havePropsChanged = <Props extends object>(
+  oldProps: Props | undefined,
+  newProps: Props,
+) =>
+  Output.hasOutputs(newProps) ||
+  JSON.stringify(canonicalize(oldProps ?? {})) !==
+    JSON.stringify(canonicalize(newProps ?? {}));
+
+/**
+ * Sort-keys deep equality for plain data (objects, arrays, primitives).
+ * Use in provider `diff` handlers instead of ad-hoc `JSON.stringify` comparisons.
+ */
+export const deepEqual = (a: unknown, b: unknown): boolean =>
+  JSON.stringify(canonicalize(a ?? undefined)) ===
+  JSON.stringify(canonicalize(b ?? undefined));
+
+const canonicalize = (value: unknown): unknown => {
+  if (Array.isArray(value)) {
+    return value.map(canonicalize);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, nested]) => [key, canonicalize(nested)]),
+    );
+  }
+  return value;
+};
+
+export const diffBindings = (
+  oldBindings: ResourceBinding[],
+  newBindings: ResourceBinding[],
+): BindingNode[] => {
+  const oldMap = new Map(oldBindings.map((b) => [b.sid, b]));
+  const newMap = new Map(newBindings.map((b) => [b.sid, b]));
+  return [
+    ...Array.from(oldMap)
+      .filter(([sid]) => !newMap.has(sid))
+      .map(([sid, old]) => ({
+        sid,
+        action: "delete" as const,
+        data: old.data,
+      })),
+    ...Array.from(newMap).map(([sid, binding]) => {
+      const old = oldMap.get(sid);
+      return {
+        sid,
+        action: (!old
+          ? "create"
+          : havePropsChanged(old.data, binding.data)
+            ? "update"
+            : "noop") as BindingNode["action"],
+        data: binding.data,
+      };
+    }),
+  ];
+};

package/src/ExecutionContext.ts

@@ -0,0 +1,30 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as ServiceMap from "effect/ServiceMap";
+import type { HttpEffect } from "./Http.ts";
+import type { Output } from "./Output.ts";
+import { GenericService } from "./Util/service.ts";
+
+export interface BaseExecutionContext {
+  Type: string;
+  id: string;
+  env: Record<string, any>;
+  get<T>(key: string): Effect.Effect<T>;
+  set(id: string, output: Output): Effect.Effect<string>;
+  exports?: Effect.Effect<Record<string, any>>;
+  serve?<Req = never>(
+    handler: HttpEffect<Req>,
+  ): Effect.Effect<void, never, Req>;
+}
+
+export interface ExecutionContext<
+  Ctx extends BaseExecutionContext = BaseExecutionContext,
+> extends ServiceMap.Service<`ExecutionContext<${Ctx["Type"]}>`, Ctx> {}
+
+export const ExecutionContext = GenericService<{
+  <Ctx extends BaseExecutionContext>(type: Ctx["Type"]): ExecutionContext<Ctx>;
+}>()("Alchemy::ExecutionContext");
+
+export const CurrentExecutionContext = Effect.serviceOption(
+  ExecutionContext,
+).pipe(Effect.map(Option.getOrUndefined));

package/src/FQN.ts

@@ -0,0 +1,94 @@
+import type { NamespaceNode } from "./Namespace.ts";
+
+/**
+ * Separator used in FQN strings.
+ */
+export const FQN_SEPARATOR = "/";
+
+/**
+ * Encode an FQN for safe filesystem storage.
+ * Replaces `/` (FQN separator) with `__` to avoid subdirectory creation.
+ */
+export const encodeFqn = (fqn: string): string =>
+  fqn.replaceAll(FQN_SEPARATOR, "__");
+
+/**
+ * Decode a filename back to FQN.
+ */
+export const decodeFqn = (filename: string): string =>
+  filename.replaceAll("__", FQN_SEPARATOR);
+
+/**
+ * Convert a NamespaceNode chain to an array of namespace IDs, from root to leaf.
+ *
+ * @example
+ * ```ts
+ * const ns = { Id: "Child", Parent: { Id: "Parent", Parent: { Id: "Root" } } };
+ * toPath(ns); // ["Root", "Parent", "Child"]
+ * ```
+ */
+export const toPath = (ns: NamespaceNode | undefined): string[] => {
+  if (!ns) return [];
+  const path: string[] = [];
+  let current: NamespaceNode | undefined = ns;
+  while (current) {
+    path.unshift(current.Id);
+    current = current.Parent;
+  }
+  return path;
+};
+
+/**
+ * Create a fully-qualified name (FQN) from a namespace and logical ID.
+ * The FQN is a flat key suitable for state storage.
+ *
+ * @example
+ * ```ts
+ * const ns = { Id: "Child", Parent: { Id: "Parent" } };
+ * toFqn(ns, "MyResource"); // "Parent/Child/MyResource"
+ * toFqn(undefined, "MyResource"); // "MyResource"
+ * ```
+ */
+export const toFqn = (
+  ns: NamespaceNode | undefined,
+  logicalId: string,
+): string => {
+  const path = toPath(ns);
+  path.push(logicalId);
+  return path.join(FQN_SEPARATOR);
+};
+
+/**
+ * Parse an FQN back into namespace path segments and the logical ID.
+ *
+ * @example
+ * ```ts
+ * parseFqn("Parent/Child/MyResource"); // { path: ["Parent", "Child"], logicalId: "MyResource" }
+ * parseFqn("MyResource"); // { path: [], logicalId: "MyResource" }
+ * ```
+ */
+export const parseFqn = (
+  fqn: string,
+): { path: string[]; logicalId: string } => {
+  const parts = fqn.split(FQN_SEPARATOR);
+  const logicalId = parts.pop()!;
+  return { path: parts, logicalId };
+};
+
+/**
+ * Reconstruct a NamespaceNode chain from a path array.
+ *
+ * @example
+ * ```ts
+ * fromPath(["Parent", "Child"]);
+ * // { Id: "Child", Parent: { Id: "Parent" } }
+ * ```
+ */
+export const fromPath = (path: string[]): NamespaceNode | undefined => {
+  if (path.length === 0) return undefined;
+  let node: NamespaceNode | undefined;
+  for (const id of path) {
+    node = { Id: id, Parent: node };
+  }
+  return node;
+};

package/src/Http.ts

@@ -0,0 +1,105 @@
+import * as BunHttpServerPlatform from "@effect/platform-bun/BunHttpServer";
+import * as NodeHttpServerPlatform from "@effect/platform-node/NodeHttpServer";
+import * as Cause from "effect/Cause";
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import type { Scope } from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import type { HttpBodyError } from "effect/unstable/http/HttpBody";
+import type { HttpServerError } from "effect/unstable/http/HttpServerError";
+import { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as NodeHttp from "node:http";
+
+// TODO(sam): move to this https://github.com/Effect-TS/effect/blob/main/packages/platform/README.md#http-server
+// import * as HttpServer from "effect/unstable/http/HttpServer";
+
+// Effect.gen(function* () {
+//   yield* HttpServer.serve()()
+// });
+
+export type HttpEffect<Req = never> = Effect.Effect<
+  HttpServerResponse.HttpServerResponse,
+  HttpServerError | HttpBodyError,
+  HttpServerRequest | Scope | Req
+>;
+
+export const serve = <Req = never>(
+  handler: Effect.Effect<
+    HttpServerResponse.HttpServerResponse,
+    HttpServerError | HttpBodyError,
+    HttpServerRequest | Scope | Req
+  >,
+) =>
+  Effect.serviceOption(HttpServer).pipe(
+    Effect.map(Option.getOrUndefined),
+    Effect.tap((http) => Effect.logInfo("http", http)),
+    Effect.flatMap((http) => (http ? http.serve(handler) : Effect.void)),
+  );
+
+export class HttpServer extends ServiceMap.Service<
+  HttpServer,
+  {
+    serve: <Req = never>(
+      handler: Effect.Effect<
+        HttpServerResponse.HttpServerResponse,
+        HttpServerError | HttpBodyError,
+        Req
+      >,
+      options?: {
+        port?: number;
+      },
+    ) => Effect.Effect<void, never, Exclude<Req, HttpServerRequest> | Scope>;
+  }
+>()("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",
+    });
+
+    return Effect.map(
+      Effect.all([Effect.logInfo(message), Effect.logInfo(cause)]),
+      () =>
+        HttpServerResponse.text(message, {
+          status: 500,
+          statusText: message,
+        }),
+    );
+  });
+
+const resolvePort = (options: { port?: number } | undefined) =>
+  options?.port !== undefined
+    ? Effect.succeed(options.port)
+    : Config.number("PORT").pipe(Config.withDefault(3000)).asEffect();
+
+/** Bun runtime (`Bun.serve`). */
+export const BunHttpServer = () =>
+  Layer.succeed(HttpServer, {
+    serve: (handler, options) =>
+      Effect.gen(function* () {
+        const port = yield* resolvePort(options);
+        const server = yield* BunHttpServerPlatform.make({ port });
+        yield* server.serve(safeHttpEffect(handler));
+      }).pipe(Effect.orDie),
+  });
+
+/** Node.js runtime (`node:http`). */
+export const NodeHttpServer = () =>
+  Layer.succeed(HttpServer, {
+    serve: (handler, options) =>
+      Effect.gen(function* () {
+        const port = yield* resolvePort(options);
+        const server = yield* NodeHttpServerPlatform.make(
+          NodeHttp.createServer,
+          {
+            port,
+          },
+        );
+        yield* server.serve(safeHttpEffect(handler));
+      }).pipe(Effect.orDie),
+  });