@akterjs/effect 0.0.0-stage → 0.1.0

package/src/runtime/local-file-clients.layer.ts

@@ -0,0 +1,112 @@
+import { Array as Arr, Effect, Layer, Option, Stream } from "effect";
+import type { Scope } from "effect";
+
+import { Akter } from "#src/contract/akter.service";
+import { ActorFileClients } from "#src/contract/file/file-client.adapter";
+import type {
+  FileAddress,
+  FileClient,
+  FileClientFailure,
+  FileListing,
+  FileRange,
+} from "#src/contract/file/file-client.contract";
+import { BlobTransferError } from "#src/contract/file/blob-transfer.errors";
+import { FileNotFoundError } from "#src/contract/file/file-not-found.errors";
+import { filePathOf } from "#src/contract/file/file-path.pure";
+import { fileListingOf } from "#src/contract/file/file-listing.pure";
+import { filePage } from "#src/host/blob/reference/blob-file-page.sql";
+import { ActorHost } from "#src/serve/engine/actor-host.service";
+
+interface FileBinding {
+  readonly address: FileAddress;
+  readonly host: ActorHost["Service"];
+}
+
+const noBytes = 0n;
+
+const outsideActor = Effect.flatMap(Effect.serviceOption(Akter), (actor) => {
+  if (Option.isSome(actor)) {
+    return Effect.fail(
+      BlobTransferError.make({
+        blob: "",
+        message: "use the file client outside actor commands and queries, and Akter.files inside them",
+      }),
+    );
+  }
+
+  return Effect.void;
+});
+
+const uploadWith = ({ address, host }: FileBinding): FileClient["upload"] =>
+  Effect.fnUntraced(function* upload<Failure, Services>(
+    source: Stream.Stream<Uint8Array, Failure, Services>,
+  ): Effect.fn.Return<string, Failure | FileClientFailure, Services | Scope.Scope> {
+    yield* outsideActor;
+
+    const { home, kick, owner } = yield* host.prepareFiles(address);
+
+    return yield* Effect.tap(home.transfers.upload({ owner, source }), () => kick);
+  }, Effect.scoped);
+
+const downloadWith = (
+  { address, host }: FileBinding,
+  path: string,
+  range?: FileRange,
+): ReturnType<FileClient["download"]> =>
+  Stream.unwrap(
+    Effect.gen(function* download() {
+      yield* outsideActor;
+      const valid = yield* filePathOf(path);
+      const found = yield* host.currentFiles(address);
+
+      if (Option.isNone(found)) {
+        return yield* FileNotFoundError.make({ path: valid });
+      }
+
+      const { home, owner } = found.value;
+      const link = yield* owner.exclusive(owner.transaction(owner.receipts.link(valid)));
+      const file = yield* Effect.mapError(Effect.fromOption(link), () => FileNotFoundError.make({ path: valid }));
+      const opening = { actor: owner.actor, blob: file.blob, grant: file.grant };
+
+      return Option.match(Option.fromNullishOr(range), {
+        onNone: () => home.transfers.open(opening),
+        onSome: (requested) => home.transfers.open({ ...opening, range: requested }),
+      });
+    }),
+  );
+
+const pageWith = ({ address, host }: FileBinding, listing: FileListing): ReturnType<FileClient["list"]> =>
+  Effect.gen(function* list() {
+    yield* outsideActor;
+    const valid = yield* fileListingOf(listing);
+    const found = yield* host.currentFiles(address);
+
+    if (Option.isNone(found)) {
+      return { cursor: Option.none(), entries: [] };
+    }
+
+    const { owner, sql } = found.value;
+
+    return yield* owner.exclusive(owner.transaction(filePage({ actor: owner.actor, listing: valid, sql })));
+  }).pipe(Effect.scoped);
+
+const clientWith = (binding: FileBinding): FileClient => ({
+  download: (path, range) => downloadWith(binding, path, range),
+  fileUsage: (listing = {}) =>
+    Effect.map(pageWith(binding, listing), (page) => ({
+      ...page,
+      bytes: Arr.reduce(page.entries, noBytes, (total, file) => total + BigInt(file.bytes)),
+    })),
+  list: (listing = {}) => pageWith(binding, listing),
+  upload: uploadWith(binding),
+});
+
+/** The file client of one actor on this host, outside its commands and queries. */
+const hostFileClient = clientWith;
+
+const localFileClients: Layer.Layer<ActorFileClients, never, ActorHost> = Layer.effect(
+  ActorFileClients,
+  Effect.map(ActorHost, (host) => ({ connect: (address: FileAddress): FileClient => clientWith({ address, host }) })),
+);
+
+export { hostFileClient, localFileClients };

package/src/runtime/local-job-runtime.layer.ts

@@ -0,0 +1,38 @@
+import { Effect, Layer, Path } from "effect";
+import type { FileSystem } from "effect";
+import type { ChildProcessSpawner } from "effect/process";
+
+import { ActorSecrets } from "#src/contract/secret/actor-secrets.adapter";
+import { JobComputers } from "#src/host/computer/job-computers.service";
+import { LocalComputers } from "#src/host/computer/local-computers.adapter";
+import { JobEngine } from "#src/host/job/job-engine.adapter";
+
+/** What the local engine's computers run on: the disk and a process spawner. */
+type ComputerNeeds = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path;
+
+/** What binding the computers needs: the computers to bind, and what they run on. */
+type BinderNeeds = ComputerNeeds | JobComputers;
+
+/**
+ * The local engine's job runtime, for an app layer whose job handlers need the `WorkflowEngine`. Its job activities
+ * read their declared secrets from the current `ConfigProvider`: the process environment, as Bun loads it with `.env`.
+ * With `AKTER_LOCAL_COMPUTERS` on, they reach the computers of the store `Akter.local` serves through
+ * `Actor.computer(key)`, because both hold the same `JobComputers`, as they hold the same job engine.
+ */
+const jobs = Layer.mergeAll(JobEngine.layerWorkflow, ActorSecrets.fromConfig, JobComputers.layer);
+
+/** Binds the app's job computers to local computers under each store the engine serves: its `computers` directory. */
+const computersBinder = Effect.fnUntraced(function* computersBinder() {
+  const computers = yield* JobComputers;
+  const services = yield* Effect.context<ComputerNeeds>();
+  const path = yield* Path.Path;
+
+  return (store: string): Effect.Effect<void> =>
+    Effect.flatMap(LocalComputers.make(path.join(store, "computers")), computers.bind).pipe(
+      Effect.provideContext(services),
+    );
+});
+
+export { computersBinder, jobs };
+
+export type { BinderNeeds, ComputerNeeds };

package/src/serve/archive/archived-actors.layer.ts

@@ -0,0 +1,97 @@
+import { Array as Arr, Context, Effect, FileSystem, Layer, Option, Path } from "effect";
+import { SecureRandom } from "effect/crypto";
+
+import { adoptArchivedFiles } from "#src/host/blob/export/blob-archive.sql";
+import { lineageOf } from "#src/host/fork/actor-fork.sql";
+import { stripArchivedFiles } from "#src/host/blob/reference/blob-receipts.sql";
+import { LocalBlobHomes } from "#src/host/file/local-blob-home.service";
+import type { LocalBlobHome } from "#src/host/file/local-blob-home.service";
+import { SqliteDriver } from "#src/host/sqlite/sqlite-driver.service";
+import { blobHashing } from "#src/runtime/blob-hashing.layer";
+import { ActorLocation } from "#src/serve/engine/actor-location.service";
+import type { ActorAddress } from "#src/serve/engine/actor-location.service";
+import { fileIdentity } from "#src/serve/engine/actor-residents.pure";
+
+interface Adopting {
+  readonly home: LocalBlobHome;
+  readonly location: ActorLocation["Service"];
+  readonly sqlite: SqliteDriver["Service"];
+}
+
+const filesFolder = "files";
+
+/**
+ * Prepares an actor's database file for an `.akter` archive: every file grant blanked and the export holds dropped,
+ * with the file rewritten so none of them stays in its free pages. Its state, history and file paths are unchanged.
+ */
+const strip = Effect.fnUntraced(function* stripArchived(filename: string) {
+  const services = yield* Layer.build(SqliteDriver.layerNode);
+  const sql = yield* Context.get(services, SqliteDriver).open(filename);
+
+  yield* stripArchivedFiles(sql);
+}, Effect.scoped);
+
+const adoptActor = Effect.fnUntraced(function* adoptActorFiles(
+  { home, location, sqlite }: Adopting,
+  address: ActorAddress,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const { database, directory } = location.locate(address);
+  const files = path.join(directory, filesFolder);
+  const sql = yield* sqlite.open(database);
+
+  yield* adoptArchivedFiles({
+    actor: fileIdentity(address),
+    adopt: home.transfers.adopt,
+    sql,
+    stored: (sha256) => fileSystem.stream(path.join(files, sha256)),
+  });
+  yield* fileSystem.remove(files, { force: true, recursive: true });
+}, Effect.scoped);
+
+/**
+ * Takes the files of every actor in an imported folder into the folder's own file home, `files-home`, the one
+ * `akter dev` opens: each actor's `files/<sha256>` is adopted under the actor's local identity, its database is
+ * rewritten for it, and its `files/` folder is removed. Run it before anything serves the folder.
+ */
+const adopt = Effect.fnUntraced(function* adoptArchived(folder: string) {
+  const path = yield* Path.Path;
+
+  const services = yield* Layer.build(
+    Layer.mergeAll(ActorLocation.directory(folder), SqliteDriver.layerNode, blobHashing, SecureRandom.layerWebCrypto),
+  );
+
+  const home = yield* Effect.provide(LocalBlobHomes.open(path.join(folder, "files-home")), services);
+  const location = Context.get(services, ActorLocation);
+  const actors = yield* location.list;
+  const adopting = { home, location, sqlite: Context.get(services, SqliteDriver) };
+
+  yield* Effect.forEach(actors, (address) => adoptActor(adopting, address), { discard: true });
+}, Effect.scoped);
+
+const forkOf = Effect.fnUntraced(function* forkOf(sqlite: SqliteDriver["Service"], directory: string) {
+  const path = yield* Path.Path;
+  const sql = yield* sqlite.open(path.join(directory, "actor.db"));
+  const recorded = yield* lineageOf(sql);
+  const actor = { key: path.basename(directory), type: path.basename(path.dirname(directory)) };
+
+  return Option.map(recorded, ({ forkId, origin, version }) => ({ actor, fork: forkId, forkedAt: version, origin }));
+}, Effect.scoped);
+
+/**
+ * The lineage of every forked actor in an export's staging folder, in the folder's order: the actor by its type and
+ * key folder, the engine-specific identity of the actor it was forked from (`origin`), the fork's id, and the
+ * parent's commit version at the cut (`forkedAt`). An actor that was never forked has none.
+ */
+const lineage = Effect.fnUntraced(function* archivedLineage(folder: string) {
+  const services = yield* Layer.build(Layer.merge(ActorLocation.directory(folder), SqliteDriver.layerNode));
+  const location = Context.get(services, ActorLocation);
+  const sqlite = Context.get(services, SqliteDriver);
+  const actors = yield* location.list;
+  const forks = yield* Effect.forEach(actors, (address) => forkOf(sqlite, location.locate(address).directory));
+
+  return Arr.getSomes(forks);
+}, Effect.scoped);
+
+export const ArchivedActors = { adopt, lineage, strip } as const;

package/src/serve/archive/archived-store.layer.ts

@@ -0,0 +1,46 @@
+import { Array as Arr, Context, Effect, FileSystem, Layer, Option, Path, String as Str } from "effect";
+
+import { SqliteDriver } from "#src/host/sqlite/sqlite-driver.service";
+import {
+  environmentRow,
+  environmentsFolder,
+  ownDirectory,
+  recordFile,
+  servingRow,
+  snapshotsFolder,
+} from "#src/serve/environment/environment-records.sql";
+
+/**
+ * The store an `.akter` archive of `folder` holds: the environment its record says serves, the folder itself for
+ * `dev` or `environments/<name>` for a promoted branch. A folder with no record, such as an export's staging folder,
+ * is its own store. The record is read query-only, so a running `akter dev` is never disturbed.
+ */
+const served = Effect.fnUntraced(function* servedStore(folder: string) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const record = path.join(folder, recordFile);
+
+  if (!(yield* fileSystem.exists(record))) {
+    return folder;
+  }
+
+  const services = yield* Layer.build(SqliteDriver.layerNode);
+  const sql = yield* Context.get(services, SqliteDriver).openQueryOnly(record);
+  const serving = yield* servingRow({ sql });
+  const row = yield* environmentRow({ name: serving.environment, sql });
+
+  return path.resolve(folder, Option.match(row, { onNone: () => ownDirectory, onSome: (found) => found.directory }));
+}, Effect.scoped);
+
+/**
+ * Whether a path in a data directory, relative and with `/` separators, belongs to its environments rather than to
+ * the serving store: the record and its journal files, every snapshot and every other environment's store. No
+ * archive holds them; an archive is one environment's export.
+ */
+const isEnvironmentEntry = (relative: string): boolean => {
+  const top = Option.getOrElse(Arr.head(Str.split("/")(relative)), () => relative);
+
+  return top === environmentsFolder || top === snapshotsFolder || Str.startsWith(recordFile)(top);
+};
+
+export const ArchivedStore = { isEnvironmentEntry, served } as const;

package/src/serve/engine/actor-engine.layer.ts

@@ -0,0 +1,46 @@
+import { Context, Effect, Layer, Option } from "effect";
+import type { FileSystem, Path } from "effect";
+
+import { handlersKey } from "#src/contract/actor/actor-definition.pure";
+import { ActorJournal } from "#src/contract/history/actor-journal.service";
+import type { ActorNotRegisteredError } from "#src/contract/actor/actor-not-registered.errors";
+import { ActorRegistry } from "#src/contract/actor/actor-registry.service";
+import type { HostedActor } from "#src/contract/actor/actor.contract";
+import { ActorDatabase } from "#src/host/actor/actor-database.service";
+import { CommandRunner } from "#src/host/command/command-runner.service";
+
+import { ActorHost } from "./actor-host.service.js";
+import { ActorLocation } from "./actor-location.service.js";
+
+const providedHandlers = Layer.effect(
+  ActorRegistry,
+  Effect.gen(function* findProvidedHandlers() {
+    const provided = yield* Effect.context();
+    const registered = yield* ActorRegistry.make;
+
+    return {
+      lookup: (name: string): Effect.Effect<HostedActor, ActorNotRegisteredError> =>
+        Option.match(Context.getOption(provided, handlersKey(name)), {
+          onNone: () => registered.lookup(name),
+          onSome: Effect.succeed,
+        }),
+      register: registered.register,
+    };
+  }),
+);
+
+const actorEngine = (
+  directory: string,
+): Layer.Layer<ActorHost | ActorRegistry, never, FileSystem.FileSystem | Path.Path> =>
+  ActorHost.layer.pipe(
+    Layer.provideMerge(providedHandlers),
+    Layer.provide([ActorDatabase.layerNode, ActorLocation.directory(directory), CommandRunner.layer]),
+    Layer.fresh,
+  );
+
+const hostJournal: Layer.Layer<ActorJournal, never, ActorHost> = Layer.effect(
+  ActorJournal,
+  ActorHost.use((host) => Effect.succeed({ coveredSince: host.coveredSince, read: host.history })),
+);
+
+export { actorEngine, hostJournal, providedHandlers };