@bitcobblers/wod-wiki-storage 0.35.2116 → 0.35.2119

package/dist/index.cjs

@@ -1,7 +1,9 @@
 'use strict';
 
+var wodWikiCore = require('@bitcobblers/wod-wiki-core');
+
 // src/schema.ts
-var DB_VERSION = 28;
+var DB_VERSION = 30;
 var COLUMN_TYPES = {
   notes: { date: "number", createdAt: "number" },
   page: { createdAt: "number" },
@@ -10,16 +12,9 @@ var COLUMN_TYPES = {
   tags: { createdAt: "number" },
   tag_types: { createdAt: "number" },
   note_tags: {},
-  segments: {
-    version: "number",
-    position: "number",
-    createdAt: "number",
-    updatedAt: "number",
-    isHistory: "boolean"
-  },
+  block_revisions: { version: "number", savedAt: "number" },
   sessions: {
-    segmentVersion: "number",
-    version: "number",
+    blockVersion: "number",
     startTime: "number",
     endTime: "number",
     duration: "number",
@@ -32,7 +27,7 @@ var COLUMN_TYPES = {
   attachments: { createdAt: "number" },
   events: {
     timestamp: "number",
-    segmentVersion: "number",
+    blockVersion: "number",
     line: "number",
     sourceStatementId: "number",
     stackLevel: "number",
@@ -45,7 +40,10 @@ var COLUMN_TYPES = {
   field_catalog_meta: {},
   efforts: { "baseAttributes.met": "number" },
   block_index: {
-    segmentVersion: "number",
+    blockVersion: "number",
+    sourceRevision: "number",
+    from: "number",
+    to: "number",
     position: "number",
     createdAt: "number",
     isStatic: "boolean"
@@ -92,17 +90,12 @@ var STORE_DEFS = [
     { name: "by-note-tag", keyPath: ["noteId", "tagId"], unique: true },
     { name: "by-user", keyPath: ["userId"] }
   ] },
-  // 5. segments
-  { name: "segments", keyPath: ["id", "version"], indexes: [
+  { name: "block_revisions", keyPath: ["noteId", "blockId", "version"], indexes: [
     { name: "by-note", keyPath: ["noteId"] },
-    { name: "by-type", keyPath: ["dataType"] },
-    { name: "by-page", keyPath: ["pageId"] },
-    { name: "by-history", keyPath: ["isHistory"] },
-    { name: "by-user", keyPath: ["userId"] }
+    { name: "by-block", keyPath: ["noteId", "blockId"] }
   ] },
   // 6. sessions
   { name: "sessions", keyPath: ["id"], indexes: [
-    { name: "by-segment", keyPath: ["segmentId"] },
     { name: "by-note", keyPath: ["noteId"] },
     { name: "by-completed", keyPath: ["createdAt"] },
     { name: "by-content", keyPath: ["blockContentId"] },
@@ -111,9 +104,6 @@ var STORE_DEFS = [
     { name: "by-origin", keyPath: ["origin"] },
     { name: "by-user", keyPath: ["userId"] }
   ] },
-  // 7. results — removed in V26: legacy alias of sessions. The V26 upgrade
-  // migrates any residual rows into `sessions` (projecting pre-V21 data.logs
-  // into event rows) before dropping the store; no compatibility alias.
   // 8. attachments
   { name: "attachments", keyPath: ["id"], indexes: [
     { name: "by-note", keyPath: ["noteId"] },
@@ -182,7 +172,6 @@ var USER_OWNED_STORES = [
   "tags",
   "tag_types",
   "note_tags",
-  "segments",
   "sessions",
   "attachments",
   "events",
@@ -243,7 +232,7 @@ function rangeFromIDB(query) {
     wire.lowerOpen = query.lowerOpen === true;
   }
   if (query.upper !== void 0 && query.upper !== null) {
-    wire.upper = query.upper;
+    wire.upper = Array.isArray(query.upper) ? query.upper.map((p) => Array.isArray(p) && p.length === 0 ? "\uFFFF" : p) : query.upper;
     wire.upperOpen = query.upperOpen === true;
   }
   return wire.lower !== void 0 || wire.upper !== void 0 ? wire : void 0;
@@ -275,9 +264,7 @@ function keyInRange(key, range) {
   }
   return true;
 }
-
-// src/domain.ts
-var DOMAIN_PROJECTION_VERSION = 1;
+var DOMAIN_PROJECTION_VERSION = 2;
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -288,13 +275,16 @@ function finiteNumbers(row, fields) {
   return fields.every((field) => typeof row[field] === "number" && Number.isFinite(row[field]));
 }
 function isNote(value) {
-  return isObject(value) && typeof value.id === "string" && typeof value.title === "string" && finiteNumbers(value, ["createdAt"]) && (value.date === void 0 || finiteNumbers(value, ["date"])) && optionalStrings(value, ["type", "sourceId", "catalog", "sourcePath", "seedOrigin", "seedChunkId"]) && (value.tags === void 0 || Array.isArray(value.tags) && value.tags.every((tag) => typeof tag === "string"));
+  if (!isObject(value) || typeof value.id !== "string" || typeof value.title !== "string" || typeof value.rawContent !== "string" || !Number.isSafeInteger(value.sourceRevision) || typeof value.sourceRevision !== "number" || value.sourceRevision < 1 || !isObject(value.blocks) || !finiteNumbers(value, ["createdAt"]) || value.date !== void 0 && !finiteNumbers(value, ["date"]) || !optionalStrings(value, ["type", "sourceId", "catalog", "sourcePath", "seedOrigin", "seedChunkId"]) || value.tags !== void 0 && (!Array.isArray(value.tags) || !value.tags.every((tag) => typeof tag === "string"))) return false;
+  try {
+    wodWikiCore.validateNoteBlocks(value.rawContent, value.blocks, value.sourceRevision);
+    return true;
+  } catch {
+    return false;
+  }
 }
 function isBlock(value) {
-  return isObject(value) && typeof value.id === "string" && typeof value.noteId === "string" && typeof value.segmentId === "string" && finiteNumbers(value, ["segmentVersion", "createdAt"]) && typeof value.dataType === "string" && typeof value.rawContent === "string" && typeof value.noteTitle === "string" && optionalStrings(value, ["blockContentId", "sourceId", "sourcePath", "routeId"]) && (value.position === void 0 || finiteNumbers(value, ["position"])) && (value.isStatic === void 0 || typeof value.isStatic === "boolean");
-}
-function isSegment(value) {
-  return isObject(value) && typeof value.id === "string" && typeof value.noteId === "string" && finiteNumbers(value, ["version", "createdAt"]) && typeof value.dataType === "string" && typeof value.rawContent === "string" && (value.data === null || isObject(value.data)) && optionalStrings(value, ["sourceContent", "pageId"]) && (value.position === void 0 || finiteNumbers(value, ["position"])) && (value.isHistory === void 0 || typeof value.isHistory === "boolean");
+  return isObject(value) && typeof value.id === "string" && typeof value.noteId === "string" && typeof value.blockId === "string" && finiteNumbers(value, ["blockVersion", "sourceRevision", "from", "to", "createdAt"]) && value.id === `${value.noteId}:${value.blockId}` && typeof value.blockVersion === "number" && Number.isSafeInteger(value.blockVersion) && value.blockVersion > 0 && typeof value.sourceRevision === "number" && Number.isSafeInteger(value.sourceRevision) && value.sourceRevision > 0 && typeof value.from === "number" && Number.isSafeInteger(value.from) && value.from >= 0 && typeof value.to === "number" && Number.isSafeInteger(value.to) && value.to > value.from && ["wod", "query", "widget", "embed"].includes(String(value.dataType)) && typeof value.rawContent === "string" && typeof value.noteTitle === "string" && optionalStrings(value, ["blockContentId", "sourceId", "sourcePath", "routeId"]) && (value.position === void 0 || finiteNumbers(value, ["position"])) && (value.isStatic === void 0 || typeof value.isStatic === "boolean");
 }
 function isTag(value) {
   return isObject(value) && typeof value.id === "string" && typeof value.label === "string" && finiteNumbers(value, ["createdAt"]) && optionalStrings(value, ["type"]);
@@ -306,7 +296,7 @@ function isLink(value) {
   return isObject(value) && typeof value.id === "string" && typeof value.noteId === "string" && typeof value.pageId === "string" && finiteNumbers(value, ["createdAt"]) && (value.position === void 0 || finiteNumbers(value, ["position"]));
 }
 function isEntry(value) {
-  return isObject(value) && isNote(value.note) && Array.isArray(value.segments) && value.segments.every(isSegment) && Array.isArray(value.tags) && value.tags.every(isTag) && Array.isArray(value.links) && value.links.every(isLink) && Array.isArray(value.pages) && value.pages.every(isPage);
+  return isObject(value) && isNote(value.note) && Array.isArray(value.tags) && value.tags.every(isTag) && Array.isArray(value.links) && value.links.every(isLink) && Array.isArray(value.pages) && value.pages.every(isPage);
 }
 function parseDomainQueryResult(value, plan) {
   if (!isObject(value) || value.projectionVersion !== DOMAIN_PROJECTION_VERSION || value.plan !== plan || !Array.isArray(value.rows) || typeof value.selectedCount !== "number" || !Number.isSafeInteger(value.selectedCount) || value.selectedCount < 0 || typeof value.matchedCount !== "number" || !Number.isSafeInteger(value.matchedCount) || value.matchedCount < 0 || value.matchedCount > value.selectedCount || value.rows.length > value.matchedCount) {
@@ -402,6 +392,100 @@ function bufferToOps(storeNames, buffer, cleared) {
   return ops;
 }
 
+// src/sql/errors.ts
+var StorageError = class extends Error {
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "StorageError";
+  }
+  status;
+  code;
+};
+
+// src/validation.ts
+function rowsEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (left instanceof ArrayBuffer && right instanceof ArrayBuffer) {
+    const a2 = new Uint8Array(left), b2 = new Uint8Array(right);
+    return a2.length === b2.length && a2.every((value, i) => value === b2[i]);
+  }
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+  if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, i) => rowsEqual(value, right[i]));
+  const a = Object.keys(left).filter((key) => Reflect.get(left, key) !== void 0);
+  const b = Object.keys(right).filter((key) => Reflect.get(right, key) !== void 0);
+  return a.length === b.length && a.every((key) => Object.hasOwn(right, key) && rowsEqual(Reflect.get(left, key), Reflect.get(right, key)));
+}
+function record(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new StorageError(400, "storage row must be an object");
+  return value;
+}
+function validateStorageRow(store, value) {
+  if (store !== "notes" && store !== "block_revisions" && store !== "sessions" && store !== "block_index") return;
+  const row = record(value);
+  const positive = (field) => typeof row[field] === "number" && Number.isSafeInteger(row[field]) && row[field] > 0;
+  const required = (field) => typeof row[field] === "string" && row[field].length > 0;
+  if (store === "notes") {
+    if (!required("id") || typeof row.title !== "string" || typeof row.rawContent !== "string" || !positive("sourceRevision") || typeof row.createdAt !== "number" || !Number.isFinite(row.createdAt) || "segments" in row || "segmentIds" in row || row.date !== void 0 && (typeof row.date !== "number" || !Number.isFinite(row.date)) || row.seedOrigin !== void 0 && row.seedOrigin !== "seed" && row.seedOrigin !== "user" || row.seedVersion !== void 0 && !positive("seedVersion") || row.tags !== void 0 && (!Array.isArray(row.tags) || !row.tags.every((tag) => typeof tag === "string")) || ["type", "sourceId", "sourcePath", "catalog", "seedChunkId"].some((field) => row[field] !== void 0 && typeof row[field] !== "string")) {
+      throw new StorageError(400, "invalid whole Note", "invalid_note_blocks");
+    }
+    try {
+      wodWikiCore.validateNoteBlocks(row.rawContent, record(row.blocks), row.sourceRevision);
+    } catch (error) {
+      throw new StorageError(400, error instanceof Error ? error.message : "invalid block map", "invalid_note_blocks");
+    }
+  } else if (store === "block_revisions") {
+    if (!required("noteId") || !required("blockId") || !positive("version") || typeof row.rawContent !== "string" || typeof row.savedAt !== "number" || !Number.isFinite(row.savedAt) || !["wod", "query", "widget", "embed"].includes(String(row.kind)) || (row.kind === "wod" ? row.dialect !== "time" && row.dialect !== "log" : row.dialect !== void 0 || row.sport !== void 0) || row.sport !== void 0 && typeof row.sport !== "string") throw new StorageError(400, "invalid block revision", "invalid_note_blocks");
+    try {
+      wodWikiCore.validateNoteBlocks(row.rawContent, { [String(row.blockId)]: {
+        id: String(row.blockId),
+        kind: row.kind,
+        version: row.version,
+        sourceRevision: 1,
+        from: 0,
+        to: row.rawContent.length,
+        ...row.dialect === void 0 ? {} : { dialect: row.dialect },
+        ...row.sport === void 0 ? {} : { sport: row.sport }
+      } }, 1);
+    } catch (error) {
+      throw new StorageError(400, error instanceof Error ? error.message : "invalid revision source", "invalid_note_blocks");
+    }
+  } else if (store === "sessions") {
+    if (!required("noteId") || !required("blockId") || !positive("blockVersion") || ["segmentId", "segmentVersion", "version", "rawContent", "script", "serializedScript", "source", "data", "logs"].some((field) => field in row)) {
+      throw new StorageError(400, "Session requires immutable block pin", "invalid_session_pin");
+    }
+  } else if (!required("noteId") || !required("blockId") || !positive("blockVersion") || !positive("sourceRevision") || row.id !== `${row.noteId}:${row.blockId}` || !Number.isSafeInteger(row.from) || !Number.isSafeInteger(row.to) || "segmentId" in row || "segmentVersion" in row || !["wod", "query", "widget", "embed"].includes(String(row.dataType)) || typeof row.rawContent !== "string" || typeof row.noteTitle !== "string" || typeof row.from !== "number" || typeof row.to !== "number" || row.from < 0 || row.to <= row.from) {
+    throw new StorageError(400, "invalid actionable block projection", "invalid_note_blocks");
+  }
+}
+function validateNoteWrite(previous, value) {
+  if (previous === void 0 || rowsEqual(previous, value)) return;
+  const before = record(previous), after = record(value);
+  if (typeof before.sourceRevision !== "number" || typeof after.sourceRevision !== "number" || after.sourceRevision < before.sourceRevision || (!rowsEqual(before.blocks, after.blocks) || before.rawContent !== after.rawContent) && after.sourceRevision <= before.sourceRevision) throw new StorageError(409, "stale Note source revision", "transaction_conflict");
+}
+function validateSessionWrite(previous, value) {
+  if (previous === void 0) return;
+  const before = record(previous), after = record(value);
+  if (before.noteId !== after.noteId || before.blockId !== after.blockId || before.blockVersion !== after.blockVersion)
+    throw new StorageError(409, "Session pin is immutable", "invalid_session_pin");
+}
+async function validateStoredPins(notes, sessions, getRevisions) {
+  const keys = [];
+  for (const note of notes) for (const block of Object.values(note.blocks)) keys.push([note.id, block.id, block.version]);
+  for (const session of sessions) keys.push([session.noteId, session.blockId, session.blockVersion]);
+  const revisions = await getRevisions(keys);
+  let i = 0;
+  for (const note of notes) for (const block of Object.values(note.blocks)) {
+    const revision = revisions[i++];
+    if (!revision || revision.kind !== block.kind || revision.rawContent !== note.rawContent.slice(block.from, block.to) || revision.dialect !== block.dialect || revision.sport !== block.sport) throw new StorageError(409, "Note block has no matching immutable revision", "invalid_note_blocks");
+  }
+  for (let sessionIndex = 0; sessionIndex < sessions.length; sessionIndex++) {
+    const revision = revisions[i++];
+    if (!revision || revision.kind !== "wod") throw new StorageError(409, "Session pin must reference a saved workout revision", "invalid_session_pin");
+  }
+}
+
 // src/api.ts
 async function request(http, method, path, init) {
   const qs = init?.params?.toString();
@@ -451,14 +535,14 @@ var ApiStorage = class {
     if (!def) throw new Error(`ApiStorage: unknown store '${store}'`);
     return def;
   }
-  makeView(store, buffer, cleared) {
-    return new ApiStore(this.http, this.def(store), store, buffer, cleared, this.getUserId);
+  makeView(store, buffer, cleared, checks, mutable = false) {
+    return new ApiStore(this.http, this.def(store), store, buffer, cleared, this.getUserId, checks, mutable);
   }
   readonly(store) {
     return this.makeView(store);
   }
   readwrite(store) {
-    return this.makeView(store);
+    return this.makeView(store, void 0, void 0, void 0, true);
   }
   async queryDomain(query) {
     const res = await this.http.fetchImpl(`${this.http.baseUrl}/v1/query`, {
@@ -473,21 +557,28 @@ var ApiStorage = class {
     if (!res.ok) throw new Error(`ApiStorage: POST /v1/query \u2192 ${res.status}`);
     return parseDomainQueryResult(await res.json(), query.plan);
   }
-  async transaction(_stores, _mode, fn) {
+  async transaction(stores, mode, fn) {
     const buffer = /* @__PURE__ */ new Map();
     const cleared = /* @__PURE__ */ new Set();
+    const checks = /* @__PURE__ */ new Map();
+    const scoped = new Set(stores);
+    const view = (store, mutable) => {
+      if (!scoped.has(store)) throw new Error("store outside transaction scope");
+      if (mutable && mode !== "readwrite") throw new Error("read-only transaction");
+      return this.makeView(store, buffer, cleared, checks, mutable);
+    };
     const tx = {
-      readonly: (store) => this.makeView(store, buffer, cleared),
-      readwrite: (store) => this.makeView(store, buffer, cleared)
+      readonly: (store) => view(store, false),
+      readwrite: (store) => view(store, true)
     };
     const result = await fn(tx);
-    await this.flush(buffer, cleared);
+    await this.flush(buffer, cleared, checks);
     return result;
   }
   /** Sends buffered ops as one server-side SQL transaction. */
-  async flush(buffer, cleared) {
+  async flush(buffer, cleared, checks) {
     const ops = bufferToOps(STORE_DEFS.map((d) => d.name), buffer, cleared);
-    if (ops.length > 0) await request(this.http, "POST", "/tx", { body: { ops } });
+    if (ops.length > 0) await request(this.http, "POST", "/tx", { body: { ops: [...checks.values(), ...ops] } });
   }
   async wipe() {
     await request(this.http, "POST", "/wipe");
@@ -496,13 +587,15 @@ var ApiStorage = class {
   }
 };
 var ApiStore = class {
-  constructor(http, def, store, buffer, cleared, getUserId) {
+  constructor(http, def, store, buffer, cleared, getUserId, checks, mutable = false) {
     this.http = http;
     this.def = def;
     this.store = store;
     this.buffer = buffer;
     this.cleared = cleared;
     this.getUserId = getUserId;
+    this.checks = checks;
+    this.mutable = mutable;
   }
   http;
   def;
@@ -510,6 +603,8 @@ var ApiStore = class {
   buffer;
   cleared;
   getUserId;
+  checks;
+  mutable;
   /** True when this tx has buffered writes for this store. */
   dirty() {
     return isDirty(this.store, this.buffer, this.cleared);
@@ -528,7 +623,16 @@ var ApiStore = class {
     const state = bufferedGet(this.store, k, this.buffer);
     if (state) return state.hit ? state.value : void 0;
     if (this.cleared?.has(this.store)) return void 0;
-    return remoteGet(this.http, this.store, k);
+    const value = await remoteGet(this.http, this.store, k);
+    const slot = bufferSlot(this.store, k);
+    if (!this.checks?.has(slot)) this.checks?.set(slot, { op: "check", store: this.store, key: k, value: structuredClone(value ?? null) });
+    return value;
+  }
+  async getMany(keys) {
+    return Promise.all(keys.map((key) => this.get(key)));
+  }
+  async getAllFromIndexMany(indexName, keys) {
+    return Promise.all(keys.map((key) => this.getAllFromIndex(indexName, key)));
   }
   async getAll(query, count) {
     const range = rangeFromIDB(query);
@@ -549,18 +653,28 @@ var ApiStore = class {
     return this.overlay(await this.serverRows(`index/${encodeURIComponent(indexName)}`, range), void 0, range, indexName).length;
   }
   /** Server rows for a list path, or none when this tx cleared the store. */
-  serverRows(path, range, count) {
-    if (this.cleared?.has(this.store)) return Promise.resolve([]);
-    return remoteList(this.http, this.store, path, range, count);
+  async serverRows(path, range, count) {
+    if (this.cleared?.has(this.store)) return [];
+    const rows = await remoteList(this.http, this.store, path, range, count);
+    for (const row of rows) {
+      const key = keyFromValue(this.def, row), slot = bufferSlot(this.store, key);
+      if (!this.checks?.has(slot)) this.checks?.set(slot, { op: "check", store: this.store, key, value: structuredClone(row) });
+    }
+    return rows;
   }
   /** Applies buffered puts and deletes before range filtering, ordering and paging. */
   overlay(rows, count, range, indexName) {
     return overlayRows(this.def, this.store, this.buffer, this.cleared, rows, count, range, indexName);
   }
   async put(value, _key) {
+    if (!this.mutable) throw new Error("read-only store");
     const userId = this.getUserId?.();
     const stored = userId ? stampUserOwned(this.store, value, userId) : value;
     const key = keyFromValue(this.def, stored);
+    if (this.store === "block_revisions") {
+      const previous = this.buffer?.get(bufferSlot(this.store, key));
+      if (previous?.kind === "put" && !rowsEqual(previous.value, stored)) throw new Error("immutable block revision collision");
+    }
     if (this.buffer) {
       this.buffer.set(bufferSlot(this.store, key), { kind: "put", value: stored });
       return key;
@@ -568,7 +682,21 @@ var ApiStore = class {
     await request(this.http, "POST", "/tx", { body: { ops: [{ op: "put", store: this.store, value: stored }] } });
     return key;
   }
+  async putMany(values, _keys) {
+    if (!this.mutable) throw new Error("read-only store");
+    if (this.buffer) {
+      const keys2 = [];
+      for (const value of values) keys2.push(await this.put(value));
+      return keys2;
+    }
+    const stored = values.map((value) => this.getUserId ? stampUserOwned(this.store, value, this.getUserId()) : value);
+    const keys = stored.map((value) => keyFromValue(this.def, value));
+    await request(this.http, "POST", "/tx", { body: { ops: stored.map((value) => ({ op: "put", store: this.store, value })) } });
+    return keys;
+  }
   async delete(key) {
+    if (!this.mutable) throw new Error("read-only store");
+    if (this.store === "block_revisions") throw new Error("block history requires explicit wipe");
     const range = isRange(key) ? key : void 0;
     if (range) {
       if (this.buffer) {
@@ -590,6 +718,8 @@ var ApiStore = class {
     await remoteDelete(this.http, this.store, k);
   }
   async clear() {
+    if (!this.mutable) throw new Error("read-only store");
+    if (this.store === "block_revisions") throw new Error("block history requires explicit wipe");
     if (this.buffer) {
       this.cleared?.add(this.store);
       const prefix = `${this.store}\0`;
@@ -618,6 +748,11 @@ exports.keyFromValue = keyFromValue;
 exports.keyInRange = keyInRange;
 exports.parseDomainQueryResult = parseDomainQueryResult;
 exports.rangeFromIDB = rangeFromIDB;
+exports.rowsEqual = rowsEqual;
 exports.stampUserOwned = stampUserOwned;
+exports.validateNoteWrite = validateNoteWrite;
+exports.validateSessionWrite = validateSessionWrite;
+exports.validateStorageRow = validateStorageRow;
+exports.validateStoredPins = validateStoredPins;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map