@effect-agent/storage-sqlite 0.0.1-beta.4 → 0.0.1-beta.5

package/dist/index.mjs

@@ -5,19 +5,19 @@ import * as SqlClient from "effect/unstable/sql/SqlClient";
 import { NodeCrypto } from "@effect/platform-node";
 //#region src/errors.ts
 /** The SQLite file uses a private-development format this adapter cannot read. */
-var SqliteStorageCompatibilityError = class extends Schema.TaggedErrorClass()("SqliteStorageCompatibilityError", {
+var SqliteStorageCompatibilityError = class extends Schema.TaggedError()("SqliteStorageCompatibilityError", {
 	actualVersion: Schema.Int,
 	message: Schema.String,
 	supportedVersion: Schema.Int
 }) {};
 /** Stored bytes failed the current Schema and cannot be used as recovery truth. */
-var SqliteStorageCorruptionError = class extends Schema.TaggedErrorClass()("SqliteStorageCorruptionError", {
+var SqliteStorageCorruptionError = class extends Schema.TaggedError()("SqliteStorageCorruptionError", {
 	message: Schema.String,
 	rowKey: Schema.String,
 	table: Schema.String
 }) {};
 /** SQLite infrastructure failed while opening or operating the store. */
-var SqliteStorageError = class extends Schema.TaggedErrorClass()("SqliteStorageError", {
+var SqliteStorageError = class extends Schema.TaggedError()("SqliteStorageError", {
 	cause: Schema.optionalKey(Schema.Defect()),
 	message: Schema.String,
 	operation: Schema.String
@@ -27,7 +27,7 @@ var SqliteStorageError = class extends Schema.TaggedErrorClass()("SqliteStorageE
 * SubmissionLedger port as the typed `LedgerError` with this error preserved as its cause,
 * so the adapter-level tag is never erased.
 */
-var SqliteLedgerError = class extends Schema.TaggedErrorClass()("SqliteLedgerError", {
+var SqliteLedgerError = class extends Schema.TaggedError()("SqliteLedgerError", {
 	cause: Schema.optionalKey(Schema.Defect()),
 	message: Schema.String,
 	operation: Schema.String
@@ -36,7 +36,7 @@ var SqliteLedgerError = class extends Schema.TaggedErrorClass()("SqliteLedgerErr
 * A canonical batch retry conflicts with existing append state. Tail conflicts carry the
 * actual committed tail as a diagnostic resume hint.
 */
-var SqliteAppendConflict = class extends Schema.TaggedErrorClass()("SqliteAppendConflict", {
+var SqliteAppendConflict = class extends Schema.TaggedError()("SqliteAppendConflict", {
 	message: Schema.String,
 	reason: Schema.Literals([
 		"batch-digest",
@@ -51,7 +51,7 @@ var SqliteAppendConflict = class extends Schema.TaggedErrorClass()("SqliteAppend
 * require the exact registered epoch, so both older and newer unregistered epochs are fenced;
 * a newer epoch takes over by materializing first.
 */
-var SqliteFenceRejected = class extends Schema.TaggedErrorClass()("SqliteFenceRejected", {
+var SqliteFenceRejected = class extends Schema.TaggedError()("SqliteFenceRejected", {
 	actualEpoch: ProducerEpoch,
 	message: Schema.String,
 	producerEpoch: ProducerEpoch
@@ -61,13 +61,13 @@ var SqliteFenceRejected = class extends Schema.TaggedErrorClass()("SqliteFenceRe
 * timeout (SQLITE_BUSY / SQLITE_LOCKED). Another transiently coexisting owner is writing;
 * the operation did not mutate canonical state and is safe to retry.
 */
-var SqliteWriteContention = class extends Schema.TaggedErrorClass()("SqliteWriteContention", {
+var SqliteWriteContention = class extends Schema.TaggedError()("SqliteWriteContention", {
 	cause: Schema.optionalKey(Schema.Defect()),
 	message: Schema.String,
 	operation: Schema.String
 }) {};
 /** A checkpoint conflicts with a previously stored checkpoint at the same offset. */
-var SqliteCheckpointConflict = class extends Schema.TaggedErrorClass()("SqliteCheckpointConflict", { message: Schema.String }) {};
+var SqliteCheckpointConflict = class extends Schema.TaggedError()("SqliteCheckpointConflict", { message: Schema.String }) {};
 const SqliteStorageFailpointLocation = Schema.Literals([
 	"materialize:before",
 	"materialize:after",
@@ -123,7 +123,7 @@ const SqliteStorageFailpointLocation = Schema.Literals([
 	"ledger:child-settled:after"
 ]);
 /** Deterministic test-only fault or pause injected at a SQLite operation boundary. */
-var SqliteStorageFailpointError = class extends Schema.TaggedErrorClass()("SqliteStorageFailpointError", { location: SqliteStorageFailpointLocation }) {
+var SqliteStorageFailpointError = class extends Schema.TaggedError()("SqliteStorageFailpointError", { location: SqliteStorageFailpointLocation }) {
 	get message() {
 		return `Injected SQLite storage failure at ${this.location}.`;
 	}
@@ -550,6 +550,25 @@ const makeJournal = (sql, failpoint) => {
 		yield* Effect.orDie(connection.executeUnprepared("ROLLBACK", [], void 0));
 		return yield* exit;
 	})).pipe(Effect.withSpan("SqliteJournal.withWriteTransaction", { attributes: { operation } })));
+	/**
+	* Runs a read-only snapshot under a deferred transaction. Effect's SQLite client now
+	* starts every writable-client `withTransaction` with `BEGIN IMMEDIATE`, which is the
+	* right default for mutations but would make exports take the write lock and block a
+	* concurrent append. Reserving the connection and beginning explicitly preserves the
+	* adapter's snapshot-with-concurrent-writer contract. As with the write helper, a failed
+	* `BEGIN` is reported directly because there is no transaction to roll back.
+	*/
+	const withReadTransaction = (operation) => (effect) => Effect.uninterruptibleMask((restore) => Effect.scoped(Effect.gen(function* () {
+		const connection = yield* sql.reserve.pipe(Effect.mapError(storageError(operation)));
+		yield* connection.executeUnprepared("BEGIN", [], void 0).pipe(Effect.mapError(storageError(operation)));
+		const exit = yield* restore(Effect.provideService(effect, sql.transactionService, [connection, 0])).pipe(Effect.exit);
+		if (Exit.isSuccess(exit)) {
+			yield* connection.executeUnprepared("COMMIT", [], void 0).pipe(Effect.mapError(storageError(operation)));
+			return exit.value;
+		}
+		yield* Effect.orDie(connection.executeUnprepared("ROLLBACK", [], void 0));
+		return yield* exit;
+	})).pipe(Effect.withSpan("SqliteJournal.withReadTransaction", { attributes: { operation } })));
 	const materialize = Effect.fn("SqliteJournal.materialize")(function* (conversationId, createdAt, emptyTailDigest, producerEpoch) {
 		if (conversationId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(emptyTailDigest) > MAX_STORED_TEXT_BYTES) return yield* SqliteStorageError.make({
 			operation: "materialize conversation",
@@ -783,7 +802,7 @@ const makeJournal = (sql, failpoint) => {
 		return yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}>${request.fromSequenceExclusive}`, rows);
 	});
 	const exportConversation = Effect.fn("SqliteJournal.exportConversation")(function* (conversationId) {
-		return yield* sql.withTransaction(Effect.gen(function* () {
+		return yield* withReadTransaction("export transaction")(Effect.gen(function* () {
 			const conversationRows = yield* sql`
             SELECT
               conversation_id,
@@ -836,7 +855,7 @@ const makeJournal = (sql, failpoint) => {
 				records: yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", conversationId, recordRows),
 				checkpoints: yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", conversationId, checkpointRows)
 			});
-		})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(storageError("export transaction")(error))));
+		}));
 	});
 	const saveCheckpoint = Effect.fn("SqliteJournal.saveCheckpoint")(function* (checkpoint) {
 		if (checkpoint.conversationId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(checkpoint.checkpointJson) > MAX_STORED_TEXT_BYTES) return yield* SqliteStorageError.make({
@@ -935,7 +954,7 @@ const makeJournal = (sql, failpoint) => {
 		read,
 		saveCheckpoint,
 		scanStoredPayloads: Effect.fn("SqliteJournal.scanStoredPayloads")(function* () {
-			return yield* sql.withTransaction(Effect.gen(function* () {
+			return yield* withReadTransaction("startup scan transaction")(Effect.gen(function* () {
 				const conversations = yield* sql`
             SELECT
               conversation_id,
@@ -983,7 +1002,7 @@ const makeJournal = (sql, failpoint) => {
 					records: yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
 					checkpoints: yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
 				};
-			})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(storageError("startup scan transaction")(error))));
+			}));
 		}),
 		withWriteTransaction
 	};