@kyneta/prisma-store 1.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Duane Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# @kyneta/prisma-store
+
+`@kyneta/exchange` storage backend that takes a caller-supplied `PrismaClient` and uses Prisma's typed query API natively.
+
+## Installation
+
+```sh
+pnpm add @kyneta/prisma-store
+```
+
+Peer dependencies: `@kyneta/exchange`, `@kyneta/schema`, `@kyneta/sql-store-core`, `@prisma/client`.
+
+## Schema
+
+Copy [`schema.prisma.example`](./schema.prisma.example) into your existing `schema.prisma` and run `prisma generate` and `prisma migrate dev`:
+
+```prisma
+model KynetaMeta {
+  docId String @id @map("doc_id")
+  data  Json
+  @@map("kyneta_meta")
+}
+
+model KynetaRecord {
+  docId   String  @map("doc_id")
+  seq     Int
+  kind    String
+  payload String?
+  blob    Bytes?
+  @@id([docId, seq])
+  @@map("kyneta_records")
+}
+```
+
+Both models work on Postgres (`Json` → JSONB, `Bytes` → BYTEA), SQLite (`Json` → TEXT, `Bytes` → BLOB), and MySQL (`Json` → JSON, `Bytes` → LONGBLOB).
+
+## Usage
+
+```ts
+import { PrismaClient } from "@prisma/client"
+import { Exchange } from "@kyneta/exchange"
+import { PrismaStore } from "@kyneta/prisma-store"
+
+const prisma = new PrismaClient()
+const store = new PrismaStore({ client: prisma })
+
+const exchange = new Exchange({
+  stores: [store],
+  // ...
+})
+
+// On shutdown:
+// await exchange.shutdown()
+// await prisma.$disconnect()
+```
+
+The model accessors default to `prisma.kynetaMeta` and `prisma.kynetaRecord` (matching `model KynetaMeta` / `model KynetaRecord`). To use different model names:
+
+```ts
+const store = new PrismaStore({
+  client: prisma,
+  metaModel: "appMeta",      // matches `model AppMeta`
+  recordModel: "appRecord",  // matches `model AppRecord`
+})
+```
+
+## Why `unknown` typing?
+
+`PrismaStoreOptions.client` is typed as `unknown`. Capturing Prisma's generic `findUnique<Args>` / `upsert<Args>` types without depending on `@prisma/client`'s types directly is genuinely hard, and depending on them pins this package to a specific Prisma major version. The `unknown`-with-internal-cast approach trades compile-time safety inside `@kyneta/prisma-store` for version-portability across Prisma releases.
+
+The user-facing call site retains full type safety: the caller passes their own typed `PrismaClient` in. Internally, the store casts once to a minimal structural interface for the methods it calls (`findUnique`, `findMany`, `upsert`, `create`, `deleteMany`, `aggregate`, `$transaction`).
+
+## Lifecycle
+
+The caller owns the connection lifecycle. `PrismaStore.close()` is a no-op; the caller calls `prisma.$disconnect()` on shutdown.
+
+## See also
+
+- [`@kyneta/sql-store-core`](../sql-core/) — pure helpers shared with `sqlite-store` and `postgres-store`.
+- [`@kyneta/sqlite-store`](../sqlite/) — universal SQLite backend (no Prisma).
+- [`@kyneta/postgres-store`](../postgres/) — async-native Postgres backend (no Prisma, uses `pg` directly).

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { DocId, Store, StoreMeta, StoreRecord } from "@kyneta/exchange";
+
+//#region src/index.d.ts
+interface PrismaStoreOptions {
+  /** The PrismaClient. Pass `prisma` directly. */
+  client: unknown;
+  /** Property name on the client. Default matches `model KynetaMeta`. */
+  metaModel?: string;
+  /** Property name on the client. Default matches `model KynetaRecord`. */
+  recordModel?: string;
+}
+declare class PrismaStore implements Store {
+  #private;
+  constructor(options: PrismaStoreOptions);
+  append(docId: DocId, record: StoreRecord): Promise<void>;
+  loadAll(docId: DocId): AsyncIterable<StoreRecord>;
+  replace(docId: DocId, records: StoreRecord[]): Promise<void>;
+  delete(docId: DocId): Promise<void>;
+  currentMeta(docId: DocId): Promise<StoreMeta | null>;
+  listDocIds(prefix?: string): AsyncIterable<DocId>;
+  close(): Promise<void>;
+}
+/**
+ * Async only for ergonomic parity with `createPostgresStore` — does
+ * no schema validation. Prisma's typed accessors enforce model presence
+ * at compile time; runtime failures surface on first call.
+ */
+declare function createPrismaStore(options: PrismaStoreOptions): Promise<Store>;
+//#endregion
+export { PrismaStore, PrismaStoreOptions, createPrismaStore };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;UAqFiB,kBAAA;;EAEf,MAAA;EAFiC;EAKjC,SAAA;EALiC;EAQjC,WAAA;AAAA;AAAA,cAOW,WAAA,YAAuB,KAAA;EAAA;cAMtB,OAAA,EAAS,kBAAA;EAgCf,MAAA,CAAO,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,WAAA,GAAc,OAAA;EAqC1C,OAAA,CAAQ,KAAA,EAAO,KAAA,GAAQ,aAAA,CAAc,WAAA;EAetC,OAAA,CAAQ,KAAA,EAAO,KAAA,EAAO,OAAA,EAAS,WAAA,KAAgB,OAAA;EAmC/C,MAAA,CAAO,KAAA,EAAO,KAAA,GAAQ,OAAA;EAStB,WAAA,CAAY,KAAA,EAAO,KAAA,GAAQ,OAAA,CAAQ,SAAA;EAMlC,UAAA,CAAW,MAAA,YAAkB,aAAA,CAAc,KAAA;EAiB5C,KAAA,CAAA,GAAS,OAAA;AAAA;;;;;;iBAsCK,iBAAA,CACpB,OAAA,EAAS,kBAAA,GACR,OAAA,CAAQ,KAAA"}

package/dist/index.js

@@ -0,0 +1,154 @@
+import { SeqNoTracker } from "@kyneta/exchange";
+import { fromRow, planAppend, planReplace } from "@kyneta/sql-store-core";
+//#region src/index.ts
+var PrismaStore = class {
+	#client;
+	#seqNos = new SeqNoTracker();
+	#metaModelName;
+	#recordModelName;
+	constructor(options) {
+		this.#client = options.client;
+		this.#metaModelName = options.metaModel ?? "kynetaMeta";
+		this.#recordModelName = options.recordModel ?? "kynetaRecord";
+	}
+	get #meta() {
+		return this.#client[this.#metaModelName];
+	}
+	get #records() {
+		return this.#client[this.#recordModelName];
+	}
+	#txModels(tx) {
+		return {
+			meta: tx[this.#metaModelName],
+			records: tx[this.#recordModelName]
+		};
+	}
+	async append(docId, record) {
+		const plan = planAppend(docId, record, await this.currentMeta(docId), await this.#seqNos.next(docId, async () => {
+			return (await this.#records.aggregate({
+				where: { docId },
+				_max: { seq: true }
+			}))._max.seq ?? null;
+		}));
+		await this.#client.$transaction(async (tx) => {
+			const { meta, records } = this.#txModels(tx);
+			if (plan.upsertMeta !== null) {
+				const dataValue = JSON.parse(plan.upsertMeta.data);
+				await meta.upsert({
+					where: { docId },
+					create: {
+						docId,
+						data: dataValue
+					},
+					update: { data: dataValue }
+				});
+			}
+			const { row } = plan.insertRecord;
+			await records.create({ data: {
+				docId,
+				seq: plan.insertRecord.seq,
+				kind: row.kind,
+				payload: row.payload,
+				blob: row.blob
+			} });
+		});
+	}
+	async *loadAll(docId) {
+		const rows = await this.#records.findMany({
+			where: { docId },
+			orderBy: { seq: "asc" }
+		});
+		for (const r of rows) yield fromRow({
+			kind: r.kind === "meta" ? "meta" : "entry",
+			payload: r.payload,
+			blob: r.blob ?? null
+		});
+	}
+	async replace(docId, records) {
+		const plan = planReplace(records, await this.currentMeta(docId));
+		await this.#client.$transaction(async (tx) => {
+			const { meta, records: recordsModel } = this.#txModels(tx);
+			await recordsModel.deleteMany({ where: { docId } });
+			for (const { seq, row } of plan.records) await recordsModel.create({ data: {
+				docId,
+				seq,
+				kind: row.kind,
+				payload: row.payload,
+				blob: row.blob
+			} });
+			const dataValue = JSON.parse(plan.upsertMeta.data);
+			await meta.upsert({
+				where: { docId },
+				create: {
+					docId,
+					data: dataValue
+				},
+				update: { data: dataValue }
+			});
+		});
+		this.#seqNos.reset(docId, records.length - 1);
+	}
+	async delete(docId) {
+		await this.#client.$transaction(async (tx) => {
+			const { meta, records } = this.#txModels(tx);
+			await records.deleteMany({ where: { docId } });
+			await meta.deleteMany({ where: { docId } });
+		});
+		this.#seqNos.remove(docId);
+	}
+	async currentMeta(docId) {
+		const row = await this.#meta.findUnique({ where: { docId } });
+		if (row === null) return null;
+		return parseMetaData(row.data);
+	}
+	async *listDocIds(prefix) {
+		if (prefix === void 0) {
+			const rows = await this.#meta.findMany({ select: { docId: true } });
+			for (const r of rows) yield r.docId;
+			return;
+		}
+		const upper = prefixUpperBound(prefix);
+		const rows = await this.#meta.findMany({
+			where: { docId: upper === null ? { gte: prefix } : {
+				gte: prefix,
+				lt: upper
+			} },
+			select: { docId: true }
+		});
+		for (const r of rows) yield r.docId;
+	}
+	async close() {}
+};
+/**
+* Prisma's `Json` field arrives parsed on Postgres/MySQL but as a raw
+* string on SQLite — the only place where the underlying database
+* type leaks through Prisma's abstraction.
+*/
+function parseMetaData(value) {
+	if (typeof value === "string") return JSON.parse(value);
+	return value;
+}
+function prefixUpperBound(prefix) {
+	if (prefix.length === 0) return null;
+	const codes = Array.from(prefix);
+	for (let i = codes.length - 1; i >= 0; i--) {
+		const code = codes[i].codePointAt(0);
+		if (code < 1114111) {
+			const next = String.fromCodePoint(code + 1);
+			return codes.slice(0, i).join("") + next;
+		}
+	}
+	return null;
+}
+/**
+* Async only for ergonomic parity with `createPostgresStore` — does
+* no schema validation. Prisma's typed accessors enforce model presence
+* at compile time; runtime failures surface on first call.
+*/
+async function createPrismaStore(options) {
+	return new PrismaStore(options);
+}
+//#endregion
+export { PrismaStore, createPrismaStore };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["#client","#seqNos","#metaModelName","#recordModelName","#meta","#records","#txModels"],"sources":["../src/index.ts"],"sourcesContent":["// Prisma-based Store backend.\n//\n// Why `unknown`-typed client: capturing Prisma's generic typed\n// accessors without a hard dep on `@prisma/client` types is brittle,\n// and depending on them pins this package to one Prisma major. The\n// trade is less compile-time safety inside this package (one cast to\n// the structural interfaces below) for version portability across\n// Prisma releases. Caller's call site stays fully typed.\n\nimport {\n  type DocId,\n  SeqNoTracker,\n  type Store,\n  type StoreMeta,\n  type StoreRecord,\n} from \"@kyneta/exchange\"\nimport {\n  fromRow,\n  planAppend,\n  planReplace,\n  type RowShape,\n} from \"@kyneta/sql-store-core\"\n\n// ---------------------------------------------------------------------------\n// Internal structural types — narrow shapes for the Prisma methods we use\n// ---------------------------------------------------------------------------\n\ninterface MetaRow {\n  docId: string\n  data: unknown\n}\n\ninterface RecordRow {\n  docId: string\n  seq: number\n  kind: string\n  payload: string | null\n  blob: Uint8Array | null\n}\n\ninterface MetaModel {\n  findUnique(args: { where: { docId: string } }): Promise<MetaRow | null>\n  findMany(args: {\n    where?: { docId?: { gte?: string; lt?: string } }\n    select: { docId: true }\n  }): Promise<Array<{ docId: string }>>\n  upsert(args: {\n    where: { docId: string }\n    create: { docId: string; data: unknown }\n    update: { data: unknown }\n  }): Promise<MetaRow>\n  delete(args: { where: { docId: string } }): Promise<unknown>\n  deleteMany(args: { where: { docId: string } }): Promise<unknown>\n}\n\ninterface RecordModel {\n  findMany(args: {\n    where: { docId: string }\n    orderBy: { seq: \"asc\" }\n  }): Promise<RecordRow[]>\n  create(args: { data: RecordRow }): Promise<unknown>\n  deleteMany(args: { where: { docId: string } }): Promise<unknown>\n  aggregate(args: {\n    where: { docId: string }\n    _max: { seq: true }\n  }): Promise<{ _max: { seq: number | null } }>\n}\n\ninterface PrismaClientLike {\n  $transaction<R>(fn: (tx: PrismaTransactionLike) => Promise<R>): Promise<R>\n}\n\n/**\n * Real Prisma's `tx` exposes the same model accessors as the client.\n * Indexed by string so caller-chosen model names (via `metaModel` /\n * `recordModel` options) resolve through the same lookup path.\n */\ninterface PrismaTransactionLike {\n  readonly [k: string]: unknown\n}\n\n// ---------------------------------------------------------------------------\n// Options\n// ---------------------------------------------------------------------------\n\nexport interface PrismaStoreOptions {\n  /** The PrismaClient. Pass `prisma` directly. */\n  client: unknown\n\n  /** Property name on the client. Default matches `model KynetaMeta`. */\n  metaModel?: string\n\n  /** Property name on the client. Default matches `model KynetaRecord`. */\n  recordModel?: string\n}\n\n// ---------------------------------------------------------------------------\n// PrismaStore\n// ---------------------------------------------------------------------------\n\nexport class PrismaStore implements Store {\n  readonly #client: PrismaClientLike\n  readonly #seqNos = new SeqNoTracker()\n  readonly #metaModelName: string\n  readonly #recordModelName: string\n\n  constructor(options: PrismaStoreOptions) {\n    this.#client = options.client as PrismaClientLike\n    this.#metaModelName = options.metaModel ?? \"kynetaMeta\"\n    this.#recordModelName = options.recordModel ?? \"kynetaRecord\"\n  }\n\n  get #meta(): MetaModel {\n    return (this.#client as unknown as Record<string, unknown>)[\n      this.#metaModelName\n    ] as MetaModel\n  }\n\n  get #records(): RecordModel {\n    return (this.#client as unknown as Record<string, unknown>)[\n      this.#recordModelName\n    ] as RecordModel\n  }\n\n  #txModels(tx: PrismaTransactionLike): {\n    meta: MetaModel\n    records: RecordModel\n  } {\n    return {\n      meta: tx[this.#metaModelName] as MetaModel,\n      records: tx[this.#recordModelName] as RecordModel,\n    }\n  }\n\n  // -------------------------------------------------------------------------\n  // Store interface\n  // -------------------------------------------------------------------------\n\n  async append(docId: DocId, record: StoreRecord): Promise<void> {\n    const existingMeta = await this.currentMeta(docId)\n    const seq = await this.#seqNos.next(docId, async () => {\n      const result = await this.#records.aggregate({\n        where: { docId },\n        _max: { seq: true },\n      })\n      return result._max.seq ?? null\n    })\n\n    const plan = planAppend(docId, record, existingMeta, seq)\n\n    await this.#client.$transaction(async tx => {\n      const { meta, records } = this.#txModels(tx)\n\n      if (plan.upsertMeta !== null) {\n        const dataValue = JSON.parse(plan.upsertMeta.data) as unknown\n        await meta.upsert({\n          where: { docId },\n          create: { docId, data: dataValue },\n          update: { data: dataValue },\n        })\n      }\n\n      const { row } = plan.insertRecord\n      await records.create({\n        data: {\n          docId,\n          seq: plan.insertRecord.seq,\n          kind: row.kind,\n          payload: row.payload,\n          blob: row.blob,\n        },\n      })\n    })\n  }\n\n  async *loadAll(docId: DocId): AsyncIterable<StoreRecord> {\n    const rows = await this.#records.findMany({\n      where: { docId },\n      orderBy: { seq: \"asc\" },\n    })\n    for (const r of rows) {\n      const row: RowShape = {\n        kind: r.kind === \"meta\" ? \"meta\" : \"entry\",\n        payload: r.payload as string,\n        blob: r.blob ?? null,\n      }\n      yield fromRow(row)\n    }\n  }\n\n  async replace(docId: DocId, records: StoreRecord[]): Promise<void> {\n    const existingMeta = await this.currentMeta(docId)\n    const plan = planReplace(records, existingMeta)\n\n    await this.#client.$transaction(async tx => {\n      const { meta, records: recordsModel } = this.#txModels(tx)\n\n      await recordsModel.deleteMany({ where: { docId } })\n\n      for (const { seq, row } of plan.records) {\n        await recordsModel.create({\n          data: {\n            docId,\n            seq,\n            kind: row.kind,\n            payload: row.payload,\n            blob: row.blob,\n          },\n        })\n      }\n\n      const dataValue = JSON.parse(plan.upsertMeta.data) as unknown\n      await meta.upsert({\n        where: { docId },\n        create: { docId, data: dataValue },\n        update: { data: dataValue },\n      })\n    })\n\n    // Must run after commit. A `$transaction` rejection (failed COMMIT\n    // or callback throw) propagates past this line; cache stays\n    // unmutated. Inside the callback would corrupt it on rollback.\n    this.#seqNos.reset(docId, records.length - 1)\n  }\n\n  async delete(docId: DocId): Promise<void> {\n    await this.#client.$transaction(async tx => {\n      const { meta, records } = this.#txModels(tx)\n      await records.deleteMany({ where: { docId } })\n      await meta.deleteMany({ where: { docId } })\n    })\n    this.#seqNos.remove(docId)\n  }\n\n  async currentMeta(docId: DocId): Promise<StoreMeta | null> {\n    const row = await this.#meta.findUnique({ where: { docId } })\n    if (row === null) return null\n    return parseMetaData(row.data) as StoreMeta\n  }\n\n  async *listDocIds(prefix?: string): AsyncIterable<DocId> {\n    if (prefix === undefined) {\n      const rows = await this.#meta.findMany({ select: { docId: true } })\n      for (const r of rows) yield r.docId\n      return\n    }\n\n    const upper = prefixUpperBound(prefix)\n    const rows = await this.#meta.findMany({\n      where: {\n        docId: upper === null ? { gte: prefix } : { gte: prefix, lt: upper },\n      },\n      select: { docId: true },\n    })\n    for (const r of rows) yield r.docId\n  }\n\n  async close(): Promise<void> {\n    // Caller owns the lifecycle (`prisma.$disconnect()`).\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Prisma's `Json` field arrives parsed on Postgres/MySQL but as a raw\n * string on SQLite — the only place where the underlying database\n * type leaks through Prisma's abstraction.\n */\nfunction parseMetaData(value: unknown): unknown {\n  if (typeof value === \"string\") return JSON.parse(value)\n  return value\n}\n\nfunction prefixUpperBound(prefix: string): string | null {\n  if (prefix.length === 0) return null\n  const codes = Array.from(prefix)\n  for (let i = codes.length - 1; i >= 0; i--) {\n    const ch = codes[i] as string\n    const code = ch.codePointAt(0) as number\n    if (code < 0x10ffff) {\n      const next = String.fromCodePoint(code + 1)\n      return codes.slice(0, i).join(\"\") + next\n    }\n  }\n  return null\n}\n\n/**\n * Async only for ergonomic parity with `createPostgresStore` — does\n * no schema validation. Prisma's typed accessors enforce model presence\n * at compile time; runtime failures surface on first call.\n */\nexport async function createPrismaStore(\n  options: PrismaStoreOptions,\n): Promise<Store> {\n  return new PrismaStore(options)\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@kyneta/prisma-store",
+  "version": "1.5.0",
+  "description": "Prisma-based storage backend for @kyneta/exchange",
+  "author": "Duane Johnson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/halecraft/kyneta",
+    "directory": "packages/exchange/stores/prisma"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "schema.prisma.example"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./src": "./src/index.ts",
+    "./src/*": "./src/*",
+    "./schema.prisma.example": "./schema.prisma.example"
+  },
+  "peerDependencies": {
+    "@kyneta/exchange": "^1.5.0",
+    "@kyneta/schema": "^1.5.0",
+    "@kyneta/sql-store-core": "^1.5.0",
+    "@prisma/client": "^5.0.0 || ^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "tsdown": "^0.21.9",
+    "typescript": "^5.9.2",
+    "vitest": "^4.0.17",
+    "@kyneta/exchange": "^1.5.0",
+    "@kyneta/sql-store-core": "^1.5.0",
+    "@kyneta/schema": "^1.5.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "verify logic",
+    "verify": "verify"
+  }
+}

package/schema.prisma.example

@@ -0,0 +1,26 @@
+// @kyneta/prisma-store — canonical Prisma schema fragment.
+//
+// Copy these models into your existing schema.prisma. The model
+// accessors (e.g. `prisma.kynetaMeta`, `prisma.kynetaRecord`) are
+// what you pass into the PrismaStore constructor.
+//
+// Both models work on Postgres (Json → JSONB, Bytes → BYTEA),
+// SQLite (Json → TEXT, Bytes → BLOB), and MySQL (Json → JSON,
+// Bytes → LONGBLOB). Round-trip through `loadAll` is portable across
+// these targets.
+
+model KynetaMeta {
+  docId String @id @map("doc_id")
+  data  Json
+  @@map("kyneta_meta")
+}
+
+model KynetaRecord {
+  docId   String  @map("doc_id")
+  seq     Int
+  kind    String
+  payload String?
+  blob    Bytes?
+  @@id([docId, seq])
+  @@map("kyneta_records")
+}

package/src/__tests__/prisma-store.test.ts

@@ -0,0 +1,306 @@
+// prisma-store — unit tests over a structural Prisma mock.
+//
+// These tests exercise the PrismaStore's translation of Store calls
+// into Prisma model-accessor calls without depending on @prisma/client
+// at runtime (which would force a real schema generation step). The
+// full conformance suite runs against Prisma+SQLite as part of the
+// integration tests in tests/integration. Here we only verify:
+//
+// 1. PrismaStore accepts a structurally-typed accessor object.
+// 2. The model names default to `kynetaMeta` / `kynetaRecord`,
+//    overridable via options.
+// 3. Append, currentMeta, loadAll, listDocIds, delete, replace each
+//    call the expected mock methods with the expected args.
+//
+// The structural-typing test is the load-bearing claim of the
+// `unknown`-with-internal-cast approach: any caller-supplied
+// PrismaClient with the right method signatures must work.
+
+import type { StoreMeta } from "@kyneta/exchange"
+import { SYNC_AUTHORITATIVE } from "@kyneta/schema"
+import { describe, expect, it } from "vitest"
+import { PrismaStore } from "../index.js"
+
+const baseMeta: StoreMeta = {
+  replicaType: ["plain", 1, 0] as const,
+  syncProtocol: SYNC_AUTHORITATIVE,
+  schemaHash: "00test",
+}
+
+interface MockState {
+  metas: Map<string, unknown>
+  records: Array<{
+    docId: string
+    seq: number
+    kind: string
+    payload: string | null
+    blob: Uint8Array | null
+  }>
+  txCalls: number
+}
+
+function makeMockClient(state: MockState): unknown {
+  const metaModel = {
+    async findUnique(args: { where: { docId: string } }) {
+      const data = state.metas.get(args.where.docId)
+      if (data === undefined) return null
+      return { docId: args.where.docId, data }
+    },
+    async findMany(args: {
+      where?: { docId?: { gte?: string; lt?: string } }
+      select: { docId: true }
+    }) {
+      const ids = Array.from(state.metas.keys())
+      const docIdFilter = args.where?.docId
+      const filtered =
+        docIdFilter === undefined
+          ? ids
+          : ids.filter(id => {
+              const { gte, lt } = docIdFilter
+              if (gte !== undefined && id < gte) return false
+              if (lt !== undefined && id >= lt) return false
+              return true
+            })
+      return filtered.map(docId => ({ docId }))
+    },
+    async upsert(args: {
+      where: { docId: string }
+      create: { docId: string; data: unknown }
+      update: { data: unknown }
+    }) {
+      state.metas.set(args.where.docId, args.update.data)
+      return { docId: args.where.docId, data: args.update.data }
+    },
+    async delete(args: { where: { docId: string } }) {
+      state.metas.delete(args.where.docId)
+      return null
+    },
+    async deleteMany(args: { where: { docId: string } }) {
+      state.metas.delete(args.where.docId)
+      return null
+    },
+  }
+
+  const recordModel = {
+    async findMany(args: {
+      where: { docId: string }
+      orderBy: { seq: "asc" }
+    }) {
+      return state.records
+        .filter(r => r.docId === args.where.docId)
+        .sort((a, b) => a.seq - b.seq)
+    },
+    async create(args: {
+      data: {
+        docId: string
+        seq: number
+        kind: string
+        payload: string | null
+        blob: Uint8Array | null
+      }
+    }) {
+      state.records.push(args.data)
+      return null
+    },
+    async deleteMany(args: { where: { docId: string } }) {
+      state.records = state.records.filter(r => r.docId !== args.where.docId)
+      return null
+    },
+    async aggregate(args: { where: { docId: string }; _max: { seq: true } }) {
+      const seqs = state.records
+        .filter(r => r.docId === args.where.docId)
+        .map(r => r.seq)
+      return { _max: { seq: seqs.length === 0 ? null : Math.max(...seqs) } }
+    },
+  }
+
+  // The client's `$transaction` passes the same client object back as
+  // its `tx` argument. This means callers who wrap or rename outer
+  // model accessors (renamed model names; fault-injected methods) see
+  // those wrappings inside the transaction too, mirroring real Prisma's
+  // behavior where `tx` exposes the same model accessors as the client.
+  const client: Record<string, unknown> = {
+    kynetaMeta: metaModel,
+    kynetaRecord: recordModel,
+  }
+  client.$transaction = async <R>(
+    fn: (tx: unknown) => Promise<R>,
+  ): Promise<R> => {
+    state.txCalls += 1
+    // Snapshot for rollback.
+    const snapshot = {
+      metas: new Map(state.metas),
+      records: state.records.slice(),
+    }
+    try {
+      return await fn(client)
+    } catch (e) {
+      state.metas = snapshot.metas
+      state.records = snapshot.records
+      throw e
+    }
+  }
+  return client
+}
+
+function freshState(): MockState {
+  return { metas: new Map(), records: [], txCalls: 0 }
+}
+
+describe("PrismaStore — structural mock", () => {
+  it("append + loadAll round-trips a meta and an entry", async () => {
+    const state = freshState()
+    const store = new PrismaStore({ client: makeMockClient(state) })
+
+    await store.append("doc-1", { kind: "meta", meta: baseMeta })
+    await store.append("doc-1", {
+      kind: "entry",
+      payload: { kind: "entirety", encoding: "json", data: '{"x":1}' },
+      version: "v1",
+    })
+
+    expect(state.txCalls).toBe(2)
+    expect(state.metas.size).toBe(1)
+    expect(state.records).toHaveLength(2)
+
+    const out: unknown[] = []
+    for await (const r of store.loadAll("doc-1")) out.push(r)
+    expect(out).toHaveLength(2)
+  })
+
+  it("currentMeta returns null for nonexistent doc", async () => {
+    const store = new PrismaStore({ client: makeMockClient(freshState()) })
+    expect(await store.currentMeta("none")).toBeNull()
+  })
+
+  it("currentMeta returns a parsed StoreMeta after append", async () => {
+    const state = freshState()
+    const store = new PrismaStore({ client: makeMockClient(state) })
+    await store.append("doc-1", { kind: "meta", meta: baseMeta })
+
+    const meta = await store.currentMeta("doc-1")
+    expect(meta).toEqual(baseMeta)
+  })
+
+  it("delete clears both meta and records", async () => {
+    const state = freshState()
+    const store = new PrismaStore({ client: makeMockClient(state) })
+    await store.append("doc-1", { kind: "meta", meta: baseMeta })
+    await store.append("doc-1", {
+      kind: "entry",
+      payload: { kind: "entirety", encoding: "json", data: "{}" },
+      version: "v1",
+    })
+
+    await store.delete("doc-1")
+
+    expect(state.metas.size).toBe(0)
+    expect(state.records).toHaveLength(0)
+  })
+
+  it("replace swaps the record stream and updates meta", async () => {
+    const state = freshState()
+    const store = new PrismaStore({ client: makeMockClient(state) })
+    await store.append("doc-1", { kind: "meta", meta: baseMeta })
+    await store.append("doc-1", {
+      kind: "entry",
+      payload: { kind: "since", encoding: "json", data: "{}" },
+      version: "v1",
+    })
+    await store.append("doc-1", {
+      kind: "entry",
+      payload: { kind: "since", encoding: "json", data: "{}" },
+      version: "v2",
+    })
+
+    await store.replace("doc-1", [
+      { kind: "meta", meta: baseMeta },
+      {
+        kind: "entry",
+        payload: { kind: "entirety", encoding: "json", data: "{}" },
+        version: "v3",
+      },
+    ])
+
+    const records = state.records
+      .filter(r => r.docId === "doc-1")
+      .sort((a, b) => a.seq - b.seq)
+    expect(records).toHaveLength(2)
+  })
+
+  it("listDocIds(prefix) range-scans, no LIKE-pattern surface", async () => {
+    const state = freshState()
+    const store = new PrismaStore({ client: makeMockClient(state) })
+
+    await store.append("100%_done", { kind: "meta", meta: baseMeta })
+    await store.append("100_other", { kind: "meta", meta: baseMeta })
+    await store.append("100xyz", { kind: "meta", meta: baseMeta })
+    await store.append("other", { kind: "meta", meta: baseMeta })
+
+    const matched: string[] = []
+    for await (const id of store.listDocIds("100%")) matched.push(id)
+    expect(matched).toEqual(["100%_done"])
+  })
+
+  it("custom model names override defaults", async () => {
+    const state = freshState()
+    // Build a mock with non-default model names by aliasing the same
+    // model objects under the requested keys. The mock's $transaction
+    // passes the client back as `tx`, so the renamed accessors are
+    // visible both at the top level and inside transactions.
+    const base = makeMockClient(state) as Record<string, unknown>
+    const renamed: Record<string, unknown> = {
+      app_meta: base.kynetaMeta,
+      app_record: base.kynetaRecord,
+    }
+    renamed.$transaction = async (fn: (tx: unknown) => Promise<unknown>) =>
+      fn(renamed)
+
+    const store = new PrismaStore({
+      client: renamed,
+      metaModel: "app_meta",
+      recordModel: "app_record",
+    })
+
+    await store.append("doc-1", { kind: "meta", meta: baseMeta })
+    expect(state.metas.size).toBe(1)
+  })
+
+  it("transaction rejection leaves observable state unchanged", async () => {
+    const state = freshState()
+    const base = makeMockClient(state) as Record<string, unknown>
+
+    // Wrap $transaction so the SECOND call throws before its callback runs.
+    // Models a real Prisma `$transaction` that rejects (e.g. failed COMMIT).
+    let txCount = 0
+    const baseTx = base.$transaction as <R>(
+      fn: (tx: unknown) => Promise<R>,
+    ) => Promise<R>
+    base.$transaction = async <R>(fn: (tx: unknown) => Promise<R>) => {
+      txCount += 1
+      if (txCount === 2) throw new Error("fault")
+      return baseTx(fn)
+    }
+
+    const store = new PrismaStore({ client: base })
+
+    // First append: tx #1 — succeeds, schemaHash="primer" persists.
+    await store.append("doc-1", {
+      kind: "meta",
+      meta: { ...baseMeta, schemaHash: "primer" },
+    })
+
+    // Second append: tx #2 — rejects.
+    await expect(
+      store.append("doc-1", {
+        kind: "meta",
+        meta: { ...baseMeta, schemaHash: "injected" },
+      }),
+    ).rejects.toThrow("fault")
+
+    // No write happened in tx #2 → state still has the primer's meta.
+    const meta = await store.currentMeta("doc-1")
+    expect(meta?.schemaHash).toBe("primer")
+    expect(state.records).toHaveLength(1)
+  })
+})

package/src/index.ts

@@ -0,0 +1,300 @@
+// Prisma-based Store backend.
+//
+// Why `unknown`-typed client: capturing Prisma's generic typed
+// accessors without a hard dep on `@prisma/client` types is brittle,
+// and depending on them pins this package to one Prisma major. The
+// trade is less compile-time safety inside this package (one cast to
+// the structural interfaces below) for version portability across
+// Prisma releases. Caller's call site stays fully typed.
+
+import {
+  type DocId,
+  SeqNoTracker,
+  type Store,
+  type StoreMeta,
+  type StoreRecord,
+} from "@kyneta/exchange"
+import {
+  fromRow,
+  planAppend,
+  planReplace,
+  type RowShape,
+} from "@kyneta/sql-store-core"
+
+// ---------------------------------------------------------------------------
+// Internal structural types — narrow shapes for the Prisma methods we use
+// ---------------------------------------------------------------------------
+
+interface MetaRow {
+  docId: string
+  data: unknown
+}
+
+interface RecordRow {
+  docId: string
+  seq: number
+  kind: string
+  payload: string | null
+  blob: Uint8Array | null
+}
+
+interface MetaModel {
+  findUnique(args: { where: { docId: string } }): Promise<MetaRow | null>
+  findMany(args: {
+    where?: { docId?: { gte?: string; lt?: string } }
+    select: { docId: true }
+  }): Promise<Array<{ docId: string }>>
+  upsert(args: {
+    where: { docId: string }
+    create: { docId: string; data: unknown }
+    update: { data: unknown }
+  }): Promise<MetaRow>
+  delete(args: { where: { docId: string } }): Promise<unknown>
+  deleteMany(args: { where: { docId: string } }): Promise<unknown>
+}
+
+interface RecordModel {
+  findMany(args: {
+    where: { docId: string }
+    orderBy: { seq: "asc" }
+  }): Promise<RecordRow[]>
+  create(args: { data: RecordRow }): Promise<unknown>
+  deleteMany(args: { where: { docId: string } }): Promise<unknown>
+  aggregate(args: {
+    where: { docId: string }
+    _max: { seq: true }
+  }): Promise<{ _max: { seq: number | null } }>
+}
+
+interface PrismaClientLike {
+  $transaction<R>(fn: (tx: PrismaTransactionLike) => Promise<R>): Promise<R>
+}
+
+/**
+ * Real Prisma's `tx` exposes the same model accessors as the client.
+ * Indexed by string so caller-chosen model names (via `metaModel` /
+ * `recordModel` options) resolve through the same lookup path.
+ */
+interface PrismaTransactionLike {
+  readonly [k: string]: unknown
+}
+
+// ---------------------------------------------------------------------------
+// Options
+// ---------------------------------------------------------------------------
+
+export interface PrismaStoreOptions {
+  /** The PrismaClient. Pass `prisma` directly. */
+  client: unknown
+
+  /** Property name on the client. Default matches `model KynetaMeta`. */
+  metaModel?: string
+
+  /** Property name on the client. Default matches `model KynetaRecord`. */
+  recordModel?: string
+}
+
+// ---------------------------------------------------------------------------
+// PrismaStore
+// ---------------------------------------------------------------------------
+
+export class PrismaStore implements Store {
+  readonly #client: PrismaClientLike
+  readonly #seqNos = new SeqNoTracker()
+  readonly #metaModelName: string
+  readonly #recordModelName: string
+
+  constructor(options: PrismaStoreOptions) {
+    this.#client = options.client as PrismaClientLike
+    this.#metaModelName = options.metaModel ?? "kynetaMeta"
+    this.#recordModelName = options.recordModel ?? "kynetaRecord"
+  }
+
+  get #meta(): MetaModel {
+    return (this.#client as unknown as Record<string, unknown>)[
+      this.#metaModelName
+    ] as MetaModel
+  }
+
+  get #records(): RecordModel {
+    return (this.#client as unknown as Record<string, unknown>)[
+      this.#recordModelName
+    ] as RecordModel
+  }
+
+  #txModels(tx: PrismaTransactionLike): {
+    meta: MetaModel
+    records: RecordModel
+  } {
+    return {
+      meta: tx[this.#metaModelName] as MetaModel,
+      records: tx[this.#recordModelName] as RecordModel,
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Store interface
+  // -------------------------------------------------------------------------
+
+  async append(docId: DocId, record: StoreRecord): Promise<void> {
+    const existingMeta = await this.currentMeta(docId)
+    const seq = await this.#seqNos.next(docId, async () => {
+      const result = await this.#records.aggregate({
+        where: { docId },
+        _max: { seq: true },
+      })
+      return result._max.seq ?? null
+    })
+
+    const plan = planAppend(docId, record, existingMeta, seq)
+
+    await this.#client.$transaction(async tx => {
+      const { meta, records } = this.#txModels(tx)
+
+      if (plan.upsertMeta !== null) {
+        const dataValue = JSON.parse(plan.upsertMeta.data) as unknown
+        await meta.upsert({
+          where: { docId },
+          create: { docId, data: dataValue },
+          update: { data: dataValue },
+        })
+      }
+
+      const { row } = plan.insertRecord
+      await records.create({
+        data: {
+          docId,
+          seq: plan.insertRecord.seq,
+          kind: row.kind,
+          payload: row.payload,
+          blob: row.blob,
+        },
+      })
+    })
+  }
+
+  async *loadAll(docId: DocId): AsyncIterable<StoreRecord> {
+    const rows = await this.#records.findMany({
+      where: { docId },
+      orderBy: { seq: "asc" },
+    })
+    for (const r of rows) {
+      const row: RowShape = {
+        kind: r.kind === "meta" ? "meta" : "entry",
+        payload: r.payload as string,
+        blob: r.blob ?? null,
+      }
+      yield fromRow(row)
+    }
+  }
+
+  async replace(docId: DocId, records: StoreRecord[]): Promise<void> {
+    const existingMeta = await this.currentMeta(docId)
+    const plan = planReplace(records, existingMeta)
+
+    await this.#client.$transaction(async tx => {
+      const { meta, records: recordsModel } = this.#txModels(tx)
+
+      await recordsModel.deleteMany({ where: { docId } })
+
+      for (const { seq, row } of plan.records) {
+        await recordsModel.create({
+          data: {
+            docId,
+            seq,
+            kind: row.kind,
+            payload: row.payload,
+            blob: row.blob,
+          },
+        })
+      }
+
+      const dataValue = JSON.parse(plan.upsertMeta.data) as unknown
+      await meta.upsert({
+        where: { docId },
+        create: { docId, data: dataValue },
+        update: { data: dataValue },
+      })
+    })
+
+    // Must run after commit. A `$transaction` rejection (failed COMMIT
+    // or callback throw) propagates past this line; cache stays
+    // unmutated. Inside the callback would corrupt it on rollback.
+    this.#seqNos.reset(docId, records.length - 1)
+  }
+
+  async delete(docId: DocId): Promise<void> {
+    await this.#client.$transaction(async tx => {
+      const { meta, records } = this.#txModels(tx)
+      await records.deleteMany({ where: { docId } })
+      await meta.deleteMany({ where: { docId } })
+    })
+    this.#seqNos.remove(docId)
+  }
+
+  async currentMeta(docId: DocId): Promise<StoreMeta | null> {
+    const row = await this.#meta.findUnique({ where: { docId } })
+    if (row === null) return null
+    return parseMetaData(row.data) as StoreMeta
+  }
+
+  async *listDocIds(prefix?: string): AsyncIterable<DocId> {
+    if (prefix === undefined) {
+      const rows = await this.#meta.findMany({ select: { docId: true } })
+      for (const r of rows) yield r.docId
+      return
+    }
+
+    const upper = prefixUpperBound(prefix)
+    const rows = await this.#meta.findMany({
+      where: {
+        docId: upper === null ? { gte: prefix } : { gte: prefix, lt: upper },
+      },
+      select: { docId: true },
+    })
+    for (const r of rows) yield r.docId
+  }
+
+  async close(): Promise<void> {
+    // Caller owns the lifecycle (`prisma.$disconnect()`).
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Prisma's `Json` field arrives parsed on Postgres/MySQL but as a raw
+ * string on SQLite — the only place where the underlying database
+ * type leaks through Prisma's abstraction.
+ */
+function parseMetaData(value: unknown): unknown {
+  if (typeof value === "string") return JSON.parse(value)
+  return value
+}
+
+function prefixUpperBound(prefix: string): string | null {
+  if (prefix.length === 0) return null
+  const codes = Array.from(prefix)
+  for (let i = codes.length - 1; i >= 0; i--) {
+    const ch = codes[i] as string
+    const code = ch.codePointAt(0) as number
+    if (code < 0x10ffff) {
+      const next = String.fromCodePoint(code + 1)
+      return codes.slice(0, i).join("") + next
+    }
+  }
+  return null
+}
+
+/**
+ * Async only for ergonomic parity with `createPostgresStore` — does
+ * no schema validation. Prisma's typed accessors enforce model presence
+ * at compile time; runtime failures surface on first call.
+ */
+export async function createPrismaStore(
+  options: PrismaStoreOptions,
+): Promise<Store> {
+  return new PrismaStore(options)
+}