@akterjs/effect 0.0.0-stage → 0.1.0

package/src/host/blob/reference/blob-forks.sql.ts

@@ -0,0 +1,125 @@
+import { Array as Arr, Effect, Option } from "effect";
+import type { SqlClient, SqlError } from "effect/sql";
+
+import { BlobTransferError } from "#src/contract/file/blob-transfer.errors";
+import type { CatalogEffect } from "./blob-catalog.sql.js";
+import type { BlobLink } from "./blob-receipts.sql.js";
+
+interface ForkIdentity {
+  readonly operation: string;
+  readonly origin: string;
+}
+
+interface ForkRow extends ForkIdentity {
+  readonly state: string;
+}
+
+interface ForkStorage {
+  readonly actor: string;
+  readonly sql: SqlClient.SqlClient;
+}
+
+interface BlobForks {
+  readonly activate: (fork: ForkIdentity) => CatalogEffect<void>;
+  readonly begin: (fork: ForkIdentity) => CatalogEffect<boolean>;
+  readonly entries: (after: string) => Effect.Effect<readonly BlobLink[], SqlError.SqlError>;
+  readonly inherit: (file: Omit<BlobLink, "actor">) => CatalogEffect<void>;
+  readonly pending: Effect.Effect<boolean, SqlError.SqlError>;
+}
+
+const metadataPageSize = 100;
+
+const refused = (): BlobTransferError =>
+  BlobTransferError.make({ blob: "", message: "the file fork target is not available for this operation" });
+
+const ownerIn = ({ actor, sql }: ForkStorage, state: string): Effect.Effect<boolean, SqlError.SqlError> =>
+  Effect.map(
+    sql`SELECT actor FROM akter_blob_owners WHERE actor = ${actor} AND state = ${state}`,
+    Arr.isReadonlyArrayNonEmpty,
+  );
+
+const recordedFork = (sql: SqlClient.SqlClient): Effect.Effect<Option.Option<ForkRow>, SqlError.SqlError> =>
+  Effect.map(sql<ForkRow>`SELECT origin, operation, state FROM akter_blob_fork WHERE id = 1`, Arr.head);
+
+const forkMatches = (row: ForkRow, expected: ForkIdentity): boolean =>
+  row.origin === expected.origin && row.operation === expected.operation;
+
+const beginFork = (storage: ForkStorage, fork: ForkIdentity): CatalogEffect<boolean> =>
+  storage.sql.withTransaction(
+    Effect.gen(function* prepareFork() {
+      const active = yield* ownerIn(storage, "active");
+      const recorded = yield* recordedFork(storage.sql);
+
+      if (active && Option.isSome(recorded) && forkMatches(recorded.value, fork) && recorded.value.state === "active") {
+        return false;
+      }
+
+      const occupied =
+        yield* storage.sql`SELECT path FROM akter_blob_links UNION ALL SELECT receipt FROM akter_blob_receipts UNION ALL SELECT claim FROM akter_blob_ancestry LIMIT 1`;
+
+      if (!active || Option.isSome(recorded) || Arr.isReadonlyArrayNonEmpty(occupied)) {
+        return yield* refused();
+      }
+
+      yield* storage.sql`INSERT INTO akter_blob_fork (id, origin, operation, state) VALUES (1, ${fork.origin}, ${fork.operation}, 'preparing')`;
+      yield* storage.sql`UPDATE akter_blob_owners SET state = 'preparing' WHERE actor = ${storage.actor}`;
+
+      return true;
+    }),
+  );
+
+const inheritFile = (storage: ForkStorage, file: Omit<BlobLink, "actor">): CatalogEffect<void> =>
+  storage.sql.withTransaction(
+    Effect.gen(function* inheritFileLink() {
+      const preparing = yield* ownerIn(storage, "preparing");
+
+      if (!preparing) {
+        return yield* refused();
+      }
+
+      return yield* Effect.asVoid(
+        storage.sql`INSERT INTO akter_blob_links (path, actor, blob, claim, bytes, sha256, grant, written_at) VALUES (${file.path}, ${storage.actor}, ${file.blob}, ${file.claim}, ${file.bytes}, ${file.sha256}, ${file.grant}, ${file.writtenAt})`,
+      );
+    }),
+  );
+
+const activateFork = (storage: ForkStorage, fork: ForkIdentity): CatalogEffect<void> =>
+  storage.sql.withTransaction(
+    Effect.gen(function* activateFileFork() {
+      const recorded = yield* recordedFork(storage.sql);
+      const preparing = yield* ownerIn(storage, "preparing");
+
+      if (
+        !preparing ||
+        Option.isNone(recorded) ||
+        recorded.value.state !== "preparing" ||
+        !forkMatches(recorded.value, fork)
+      ) {
+        return yield* refused();
+      }
+
+      yield* storage.sql`UPDATE akter_blob_fork SET state = 'active' WHERE id = 1`;
+
+      return yield* Effect.asVoid(
+        storage.sql`UPDATE akter_blob_owners SET state = 'active' WHERE actor = ${storage.actor}`,
+      );
+    }),
+  );
+
+const inheritedEntries = (
+  { actor, sql }: ForkStorage,
+  after: string,
+): Effect.Effect<readonly BlobLink[], SqlError.SqlError> =>
+  sql<BlobLink>`SELECT path, actor, blob, claim, bytes, sha256, grant, written_at AS writtenAt FROM akter_blob_links WHERE actor = ${actor} AND path > ${after} AND EXISTS (SELECT 1 FROM akter_blob_owners WHERE actor = ${actor} AND state = 'active') ORDER BY path LIMIT ${metadataPageSize}`;
+
+const blobForks = (storage: ForkStorage): BlobForks => ({
+  activate: (fork) => activateFork(storage, fork),
+  begin: (fork) => beginFork(storage, fork),
+  entries: (after) => inheritedEntries(storage, after),
+  inherit: (file) => inheritFile(storage, file),
+  pending: ownerIn(storage, "preparing"),
+});
+
+export { blobForks };
+
+export type { BlobForks, ForkIdentity };

package/src/host/blob/reference/blob-lineage.sql.ts

@@ -0,0 +1,63 @@
+import { Array as Arr, Effect } from "effect";
+import type { SqlClient, SqlError } from "effect/sql";
+
+import { BlobTransferError } from "#src/contract/file/blob-transfer.errors";
+import type { CatalogEffect } from "./blob-catalog.sql.js";
+
+interface LineageFork {
+  readonly actor: string;
+  readonly origin: string;
+}
+
+interface BlobLineage {
+  readonly checkFork: (fork: LineageFork) => CatalogEffect<void>;
+  readonly recordFork: (fork: LineageFork) => CatalogEffect<void>;
+}
+
+const prepareLineages = (sql: SqlClient.SqlClient): Effect.Effect<void, SqlError.SqlError> =>
+  Effect.asVoid(sql`CREATE INDEX IF NOT EXISTS akter_blob_actors_parent ON akter_blob_actors (parent, actor)`);
+
+const checkFork = (sql: SqlClient.SqlClient, { actor, origin }: LineageFork): CatalogEffect<void> =>
+  sql.withTransaction(
+    Effect.gen(function* checkLineage() {
+      const erased =
+        yield* sql`SELECT actor FROM akter_blob_actors WHERE actor IN (${actor}, ${origin}) AND state = 'erased'`;
+
+      const rebound =
+        yield* sql`SELECT actor FROM akter_blob_actors WHERE actor = ${actor} AND parent IS NOT NULL AND parent != ${origin}`;
+
+      const cyclic =
+        yield* sql`WITH RECURSIVE ancestry(actor) AS (SELECT ${origin} UNION SELECT parent FROM akter_blob_actors JOIN ancestry ON akter_blob_actors.actor = ancestry.actor WHERE parent IS NOT NULL) SELECT actor FROM ancestry WHERE actor = ${actor}`;
+
+      if (
+        Arr.isReadonlyArrayNonEmpty(erased) ||
+        Arr.isReadonlyArrayNonEmpty(rebound) ||
+        Arr.isReadonlyArrayNonEmpty(cyclic)
+      ) {
+        return yield* BlobTransferError.make({
+          blob: "",
+          message: "the fork lineage is erased, cyclic, or already bound",
+        });
+      }
+
+      return yield* Effect.void;
+    }),
+  );
+
+const recordFork = (sql: SqlClient.SqlClient, fork: LineageFork): CatalogEffect<void> =>
+  sql.withTransaction(
+    Effect.gen(function* recordLineage() {
+      yield* checkFork(sql, fork);
+      yield* sql`INSERT INTO akter_blob_actors (actor, state) VALUES (${fork.origin}, 'active') ON CONFLICT DO NOTHING`;
+      yield* sql`INSERT INTO akter_blob_actors (actor, state, parent) VALUES (${fork.actor}, 'active', ${fork.origin}) ON CONFLICT (actor) DO UPDATE SET parent = excluded.parent`;
+    }),
+  );
+
+const blobLineage = (sql: SqlClient.SqlClient): BlobLineage => ({
+  checkFork: (fork) => checkFork(sql, fork),
+  recordFork: (fork) => recordFork(sql, fork),
+});
+
+export { blobLineage, prepareLineages };
+
+export type { BlobLineage };

package/src/host/blob/reference/blob-reads.pure.ts

@@ -0,0 +1,172 @@
+import { Array as Arr, Deferred, Effect, Option, Ref, Semaphore, Stream } from "effect";
+import type { SecureRandom } from "effect/crypto";
+
+import { BlobTransferError } from "#src/contract/file/blob-transfer.errors";
+import type { BlobRange, Opening } from "#src/host/blob/blob-sealing.contract";
+import type { BlobClaim } from "./blob-catalog.sql.js";
+import type { BlobTransfers, Download, TransferEffect, TransferHome } from "./blob-transfer.pure.js";
+
+interface ReadLease extends BlobClaim {
+  readonly grant: string;
+}
+
+interface ReadSource {
+  readonly home: TransferHome;
+  readonly random: SecureRandom.SecureRandom["Service"];
+}
+
+interface ReadState extends ReadSource {
+  readonly active: Ref.Ref<Set<string>>;
+  readonly closed: Ref.Ref<boolean>;
+  readonly drained: Deferred.Deferred<boolean>;
+  readonly guard: Semaphore.Semaphore;
+}
+
+interface BlobReads {
+  readonly close: Effect.Effect<void>;
+  readonly download: BlobTransfers["download"];
+  readonly open: BlobTransfers["open"];
+  readonly recover: TransferEffect<void>;
+}
+
+const oneRegistryOperation = 1;
+
+const noReaders = 0;
+
+const pinWith = (state: ReadState, opening: Omit<Opening, "filename">): TransferEffect<ReadLease> =>
+  state.guard.withPermits(oneRegistryOperation)(
+    Effect.gen(function* acquireRead() {
+      if (yield* Ref.get(state.closed)) {
+        return yield* BlobTransferError.make({ blob: "", message: "the file home is closed" });
+      }
+
+      const claim = yield* state.random.uuidV4();
+      const lease = { actor: opening.actor, blob: opening.blob, claim, grant: opening.grant };
+
+      yield* state.home.catalog.pin(lease);
+      yield* Ref.update(state.active, (active) => new Set(active).add(claim));
+
+      return lease;
+    }),
+  );
+
+const lookupWith = ({ owner, path }: Download): TransferEffect<Omit<Opening, "filename">> =>
+  Effect.gen(function* lookupDownload() {
+    const lookup = Effect.andThen(owner.receipts.active, owner.receipts.link(path));
+    const found = yield* owner.exclusive(owner.transaction(lookup));
+
+    const linked = yield* Effect.fromOption(found).pipe(
+      Effect.mapError(() => BlobTransferError.make({ blob: "", message: "the actor file does not exist" })),
+    );
+
+    return { actor: owner.actor, blob: linked.blob, grant: linked.grant };
+  });
+
+const forgetWith = (state: ReadState, claim: string): Effect.Effect<void> =>
+  Effect.gen(function* forgetRead() {
+    const remaining = yield* Ref.modify(state.active, (active) => {
+      const next = new Set(active);
+
+      next.delete(claim);
+
+      return [next.size, next];
+    });
+
+    const closed = yield* Ref.get(state.closed);
+
+    if (closed && remaining === noReaders) {
+      yield* Deferred.succeed(state.drained, true);
+    }
+  });
+
+const releaseWith = (state: ReadState, lease: ReadLease): TransferEffect<void> => {
+  const released = state.home.catalog.release(lease).pipe(Effect.ensuring(forgetWith(state, lease.claim)));
+
+  return state.guard.withPermits(oneRegistryOperation)(released);
+};
+
+const readWith = (
+  state: ReadState,
+  acquire: TransferEffect<ReadLease>,
+  range?: BlobRange,
+): ReturnType<BlobTransfers["download"]> =>
+  Stream.unwrap(
+    Effect.gen(function* openDownload() {
+      const lease = yield* Effect.acquireRelease(acquire, (held) => Effect.orDie(releaseWith(state, held)));
+
+      const opening = { actor: lease.actor, blob: lease.blob, grant: lease.grant };
+
+      return Option.match(Option.fromNullishOr(range), {
+        onNone: () => state.home.directory.open(opening),
+        onSome: (requested) => state.home.directory.open({ ...opening, range: requested }),
+      });
+    }),
+  );
+
+const closeWith = (state: ReadState): Effect.Effect<void> =>
+  Effect.gen(function* closeReads() {
+    yield* state.guard.withPermits(oneRegistryOperation)(
+      Effect.gen(function* refuseReads() {
+        yield* Ref.set(state.closed, true);
+
+        const active = yield* Ref.get(state.active);
+
+        if (active.size === noReaders) {
+          yield* Deferred.succeed(state.drained, true);
+        }
+      }),
+    );
+    yield* Deferred.await(state.drained);
+  });
+
+const recoverWith = (state: ReadState): TransferEffect<void> =>
+  state.guard.withPermits(oneRegistryOperation)(
+    Effect.gen(function* recoverReads() {
+      let after = "";
+
+      for (;;) {
+        const readers = yield* state.home.catalog.readers(after);
+
+        if (!Arr.isReadonlyArrayNonEmpty(readers)) {
+          return;
+        }
+
+        const active = yield* Ref.get(state.active);
+
+        yield* Effect.forEach(
+          Arr.filter(readers, (reader) => !active.has(reader.claim)),
+          (reader) => state.home.catalog.release(reader),
+          { discard: true },
+        );
+        after = Arr.lastNonEmpty(readers).claim;
+      }
+    }),
+  );
+
+const blobReads = ({ home, random }: ReadSource): Effect.Effect<BlobReads> =>
+  Effect.gen(function* makeBlobReads() {
+    const registry = yield* Effect.all({
+      active: Ref.make(new Set<string>()),
+      closed: Ref.make(false),
+      drained: Deferred.make<boolean>(),
+      guard: Semaphore.make(oneRegistryOperation),
+    });
+
+    const state = { ...registry, home, random };
+
+    return {
+      close: closeWith(state),
+      download: (request) =>
+        readWith(
+          state,
+          Effect.flatMap(lookupWith(request), (opening) => pinWith(state, opening)),
+          request.range,
+        ),
+      open: (opening) => readWith(state, pinWith(state, opening), opening.range),
+      recover: recoverWith(state),
+    };
+  });
+
+export { blobReads };
+
+export type { BlobReads };