@effect-agent/storage-sqlite 0.0.1-beta.0

package/src/sqlite-storage-config.ts

@@ -0,0 +1,37 @@
+import { Context, Schema } from "effect";
+
+const ObservationPollInterval = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const BusyTimeoutMillis = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const OwnershipLeaseMillis = Schema.Int.check(Schema.isGreaterThan(0));
+
+/**
+ * Validated construction configuration consumed by the SQLite storage Layer. The database
+ * identity itself belongs to the SqlClient Layer; duplicating it here could silently diverge
+ * from the connection actually in use.
+ */
+export class SqliteStorageConfigValue extends Schema.Class<SqliteStorageConfigValue>(
+  "@effect-agent/storage-sqlite/SqliteStorageConfigValue",
+)({
+  observationPollInterval: ObservationPollInterval,
+  /** Bounded SQLITE_BUSY retry window for write-lock acquisition, in milliseconds. */
+  busyTimeout: BusyTimeoutMillis,
+  /**
+   * Submission ownership lease duration in milliseconds (D5). The lease is a liveness hint
+   * that makes an abandoned claim reclaimable; correctness never depends on it because every
+   * canonical append is fenced by producer epoch. Convenience layers default this to
+   * `DEFAULT_OWNERSHIP_LEASE_DURATION` from `@effect-agent/session`.
+   */
+  ownershipLeaseDuration: OwnershipLeaseMillis,
+  /**
+   * Re-verify every stored payload and digest chain while opening the store. Per-operation
+   * Schema decoding and the digest chain already fail clearly on corrupt rows, so the full
+   * scan is an explicit opt-in integrity audit rather than a startup requirement.
+   */
+  verifyOnOpen: Schema.Boolean,
+}) {}
+
+/** Explicit SQLite storage configuration authority. */
+export class SqliteStorageConfig extends Context.Service<
+  SqliteStorageConfig,
+  SqliteStorageConfigValue
+>()("@effect-agent/storage-sqlite/SqliteStorageConfig") {}

package/src/sqlite-storage-failpoint.ts

@@ -0,0 +1,50 @@
+import { Context, Effect, Layer, Ref } from "effect";
+
+import { SqliteStorageFailpointError, type SqliteStorageFailpointLocation } from "./errors.ts";
+
+export type SqliteStorageFailpointHandler = (
+  location: SqliteStorageFailpointLocation,
+) => Effect.Effect<void, SqliteStorageFailpointError>;
+
+const noFailpoint: SqliteStorageFailpointHandler = () => Effect.void;
+
+/** Test-only control for replacing the active SQLite failpoint handler. */
+export class SqliteStorageFailpointTestControl extends Context.Service<
+  SqliteStorageFailpointTestControl,
+  {
+    readonly clear: Effect.Effect<void>;
+    readonly setHandler: (handler: SqliteStorageFailpointHandler) => Effect.Effect<void>;
+  }
+>()("@effect-agent/storage-sqlite/SqliteStorageFailpointTestControl") {}
+
+/** Explicit fault-injection authority used at SQLite operation boundaries. */
+export class SqliteStorageFailpoint extends Context.Service<
+  SqliteStorageFailpoint,
+  {
+    readonly hit: SqliteStorageFailpointHandler;
+  }
+>()("@effect-agent/storage-sqlite/SqliteStorageFailpoint") {
+  /** Production default: no fault injection. */
+  static readonly layer = Layer.succeed(this)({ hit: noFailpoint });
+
+  /** Reusable test Layer with a control service backed by the same handler Ref. */
+  static readonly layerTest = Layer.effectContext(
+    Effect.gen(function* () {
+      const handler = yield* Ref.make<SqliteStorageFailpointHandler>(noFailpoint);
+      return Context.make(
+        SqliteStorageFailpoint,
+        SqliteStorageFailpoint.of({
+          hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))),
+        }),
+      ).pipe(
+        Context.add(
+          SqliteStorageFailpointTestControl,
+          SqliteStorageFailpointTestControl.of({
+            clear: Ref.set(handler, noFailpoint),
+            setHandler: (next) => Ref.set(handler, next),
+          }),
+        ),
+      );
+    }),
+  );
+}