@chipmobilesdk/rn-local-db 0.4.0 → 0.5.0

package/lib/commonjs/query/compare.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asFilterValue = asFilterValue;
+exports.byteOrder = byteOrder;
+exports.compareValues = compareValues;
+exports.lookupField = lookupField;
+/**
+ * Comparison and field access semantics.
+ *
+ * Defined once here, used by the in-memory adapter directly and by the SQL
+ * builder for validation and cursor construction. Two implementations of
+ * these rules would drift, and the drift would show up as a conformance
+ * divergence that hides a real bug (research.md R8).
+ */
+
+/**
+ * A field is one of three things, and the difference is the whole point of
+ * FR-019: present with a value, present and null, or absent.
+ */
+
+function lookupField(data, field) {
+  if (!Object.prototype.hasOwnProperty.call(data, field)) {
+    return {
+      present: false
+    };
+  }
+  const value = data[field];
+  if (value === null) {
+    return {
+      present: true,
+      value: null
+    };
+  }
+  return {
+    present: true,
+    value: value
+  };
+}
+
+/**
+ * Ordering for values of the same declared type.
+ *
+ * Null sorts before every non-null value, matching SQLite's default so the
+ * two adapters agree without the SQL builder emitting NULLS FIRST/LAST
+ * clauses that older SQLite versions do not support.
+ */
+function compareValues(a, b) {
+  if (a === null && b === null) {
+    return 0;
+  }
+  if (a === null) {
+    return -1;
+  }
+  if (b === null) {
+    return 1;
+  }
+  if (typeof a === 'boolean' || typeof b === 'boolean') {
+    return Number(a) - Number(b);
+  }
+  if (typeof a === 'number' && typeof b === 'number') {
+    if (Number.isNaN(a) || Number.isNaN(b)) {
+      return Number.isNaN(a) && Number.isNaN(b) ? 0 : Number.isNaN(a) ? -1 : 1;
+    }
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  const sa = String(a);
+  const sb = String(b);
+  // Byte-order rather than locale collation: a locale-aware comparison would
+  // make the stored order depend on device settings, so the same data would
+  // page differently on two phones.
+  return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+
+/** Only primitives can be compared; a nested object is never a filter target. */
+function asFilterValue(value) {
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  return undefined;
+}
+
+/**
+ * Byte order, not locale collation.
+ *
+ * A locale-aware sort would make the reported order depend on device
+ * settings, so two phones holding identical data would report it differently.
+ */
+function byteOrder(a, b) {
+  if (a < b) {
+    return -1;
+  }
+  return a > b ? 1 : 0;
+}
+//# sourceMappingURL=compare.js.map

package/lib/commonjs/query/compare.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["lookupField","data","field","Object","prototype","hasOwnProperty","call","present","value","compareValues","a","b","Number","isNaN","sa","String","sb","asFilterValue","undefined","byteOrder"],"sourceRoot":"../../../src","sources":["query/compare.ts"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;;AAMO,SAASA,WAAWA,CAACC,IAAwB,EAAEC,KAAa,EAAe;EACjF,IAAI,CAACC,MAAM,CAACC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACL,IAAI,EAAEC,KAAK,CAAC,EAAE;IACvD,OAAO;MAAEK,OAAO,EAAE;IAAM,CAAC;EAC1B;EACA,MAAMC,KAAK,GAAGP,IAAI,CAACC,KAAK,CAAC;EACzB,IAAIM,KAAK,KAAK,IAAI,EAAE;IACnB,OAAO;MAAED,OAAO,EAAE,IAAI;MAAEC,KAAK,EAAE;IAAK,CAAC;EACtC;EACA,OAAO;IAAED,OAAO,EAAE,IAAI;IAAEC,KAAK,EAAEA;EAAsC,CAAC;AACvE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,aAAaA,CAACC,CAAc,EAAEC,CAAc,EAAU;EACrE,IAAID,CAAC,KAAK,IAAI,IAAIC,CAAC,KAAK,IAAI,EAAE;IAC7B,OAAO,CAAC;EACT;EACA,IAAID,CAAC,KAAK,IAAI,EAAE;IACf,OAAO,CAAC,CAAC;EACV;EACA,IAAIC,CAAC,KAAK,IAAI,EAAE;IACf,OAAO,CAAC;EACT;EACA,IAAI,OAAOD,CAAC,KAAK,SAAS,IAAI,OAAOC,CAAC,KAAK,SAAS,EAAE;IACrD,OAAOC,MAAM,CAACF,CAAC,CAAC,GAAGE,MAAM,CAACD,CAAC,CAAC;EAC7B;EACA,IAAI,OAAOD,CAAC,KAAK,QAAQ,IAAI,OAAOC,CAAC,KAAK,QAAQ,EAAE;IACnD,IAAIC,MAAM,CAACC,KAAK,CAACH,CAAC,CAAC,IAAIE,MAAM,CAACC,KAAK,CAACF,CAAC,CAAC,EAAE;MACvC,OAAOC,MAAM,CAACC,KAAK,CAACH,CAAC,CAAC,IAAIE,MAAM,CAACC,KAAK,CAACF,CAAC,CAAC,GAAG,CAAC,GAAGC,MAAM,CAACC,KAAK,CAACH,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;IACzE;IACA,OAAOA,CAAC,GAAGC,CAAC,GAAG,CAAC,CAAC,GAAGD,CAAC,GAAGC,CAAC,GAAG,CAAC,GAAG,CAAC;EAClC;EACA,MAAMG,EAAE,GAAGC,MAAM,CAACL,CAAC,CAAC;EACpB,MAAMM,EAAE,GAAGD,MAAM,CAACJ,CAAC,CAAC;EACpB;EACA;EACA;EACA,OAAOG,EAAE,GAAGE,EAAE,GAAG,CAAC,CAAC,GAAGF,EAAE,GAAGE,EAAE,GAAG,CAAC,GAAG,CAAC;AACtC;;AAEA;AACO,SAASC,aAAaA,CAACT,KAAoB,EAA2B;EAC5E,IACCA,KAAK,KAAK,IAAI,IACd,OAAOA,KAAK,KAAK,QAAQ,IACzB,OAAOA,KAAK,KAAK,QAAQ,IACzB,OAAOA,KAAK,KAAK,SAAS,EACzB;IACD,OAAOA,KAAK;EACb;EACA,OAAOU,SAAS;AACjB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,SAASA,CAACT,CAAS,EAAEC,CAAS,EAAU;EACvD,IAAID,CAAC,GAAGC,CAAC,EAAE;IACV,OAAO,CAAC,CAAC;EACV;EACA,OAAOD,CAAC,GAAGC,CAAC,GAAG,CAAC,GAAG,CAAC;AACrB","ignoreList":[]}

package/lib/commonjs/query/cursor.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeCursor = decodeCursor;
+exports.encodeCursor = encodeCursor;
+exports.isAfterCursor = isAfterCursor;
+var _errors = require("../contract/errors.js");
+var _errors2 = require("../diagnostics/errors.js");
+var _compare = require("./compare.js");
+var _sort = require("./sort.js");
+var _bytes = require("../platform/bytes.js");
+/**
+ * Keyset pagination cursors.
+ *
+ * Keyset rather than OFFSET for two reasons, both of which SC-007 measures:
+ * OFFSET degrades linearly at the 100,000-record budget because the engine
+ * still walks the skipped rows, and it shifts pages under concurrent writes
+ * so a record can be skipped or returned twice. A cursor anchored to the last
+ * row's sort values has neither problem.
+ */
+
+function shapeOf(sort) {
+  return sort.map(key => `${key.field}:${key.direction === 'desc' ? 'd' : 'a'}`).join(',');
+}
+function toBase64(value) {
+  if (_bytes.host.btoa) {
+    return _bytes.host.btoa(unescape(encodeURIComponent(value)));
+  }
+  return (0, _bytes.bytesToBase64)((0, _bytes.utf8Bytes)(value));
+}
+function fromBase64(value) {
+  if (_bytes.host.atob) {
+    return decodeURIComponent(escape(_bytes.host.atob(value)));
+  }
+  return (0, _bytes.utf8String)((0, _bytes.base64ToBytes)(value));
+}
+function encodeCursor(record, sort) {
+  const payload = {
+    k: shapeOf(sort),
+    v: sort.map(key => (0, _sort.sortValueOf)(record, key.field) ?? null)
+  };
+  return toBase64(JSON.stringify(payload));
+}
+function decodeCursor(cursor, sort) {
+  let payload;
+  try {
+    payload = JSON.parse(fromBase64(cursor));
+  } catch {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.CURSOR_INVALID, {
+      message: 'cursor is not decodable'
+    });
+  }
+  if (!payload || typeof payload.k !== 'string' || !Array.isArray(payload.v)) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.CURSOR_INVALID, {
+      message: 'cursor payload is malformed'
+    });
+  }
+  // A cursor from a differently sorted query would produce a silently wrong
+  // page rather than an error, so the shape is part of the cursor.
+  if (payload.k !== shapeOf(sort)) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.CURSOR_INVALID, {
+      message: 'cursor does not match this query shape'
+    });
+  }
+  if (payload.v.length !== sort.length) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.CURSOR_INVALID, {
+      message: 'cursor arity does not match sort'
+    });
+  }
+  return payload.v;
+}
+
+/**
+ * Is this record strictly after the cursor position, under the sort order?
+ *
+ * Lexicographic across the sort keys: equal on the first key means the second
+ * decides, and so on down to the id tiebreaker that guarantees a total order.
+ */
+function isAfterCursor(record, sort, anchor) {
+  for (let i = 0; i < sort.length; i += 1) {
+    const key = sort[i];
+    const direction = key.direction === 'desc' ? -1 : 1;
+    const value = (0, _sort.sortValueOf)(record, key.field) ?? null;
+    const result = (0, _compare.compareValues)(value, anchor[i] ?? null) * direction;
+    if (result > 0) {
+      return true;
+    }
+    if (result < 0) {
+      return false;
+    }
+  }
+  // Equal on every key including id — this is the anchor row itself.
+  return false;
+}
+//# sourceMappingURL=cursor.js.map

package/lib/commonjs/query/cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_errors2","_compare","_sort","_bytes","shapeOf","sort","map","key","field","direction","join","toBase64","value","host","btoa","unescape","encodeURIComponent","bytesToBase64","utf8Bytes","fromBase64","atob","decodeURIComponent","escape","utf8String","base64ToBytes","encodeCursor","record","payload","k","v","sortValueOf","JSON","stringify","decodeCursor","cursor","parse","raise","DiagnosticCodes","CURSOR_INVALID","message","Array","isArray","length","isAfterCursor","anchor","i","result","compareValues"],"sourceRoot":"../../../src","sources":["query/cursor.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/query/filter.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evaluateFilter = evaluateFilter;
+var _compare = require("./compare.js");
+/**
+ * Filter evaluation over a plain record.
+ *
+ * The in-memory adapter runs this directly. The SQLite adapter translates the
+ * same validated tree to SQL. Both must agree, which is why the semantics
+ * live here rather than in either of them.
+ */
+
+function equals(a, b) {
+  return (0, _compare.compareValues)(a, b) === 0 && a === null === (b === null);
+}
+function evaluateFilter(data, node) {
+  switch (node.op) {
+    case 'and':
+      return node.nodes.every(child => evaluateFilter(data, child));
+    case 'or':
+      return node.nodes.some(child => evaluateFilter(data, child));
+    case 'not':
+      return !evaluateFilter(data, node.node);
+    default:
+      break;
+  }
+  const lookup = (0, _compare.lookupField)(data, node.field);
+
+  // `exists` is the only operator that answers a question about presence,
+  // which is what keeps "absent" distinguishable from "null" (FR-019).
+  if (node.op === 'exists') {
+    return lookup.present === node.value;
+  }
+  if (!lookup.present) {
+    // An absent field satisfies nothing else — not even `ne` or `isNull`.
+    // SQL agrees: a comparison against a missing column yields NULL, which
+    // is not true.
+    return false;
+  }
+  const value = (0, _compare.asFilterValue)(lookup.value);
+  if (value === undefined) {
+    // A nested object or array is not comparable. Matching it would be a
+    // guess, so it simply does not satisfy a comparison.
+    return false;
+  }
+  switch (node.op) {
+    case 'isNull':
+      return value === null;
+    case 'isNotNull':
+      return value !== null;
+    case 'eq':
+      return equals(value, node.value);
+    case 'ne':
+      return !equals(value, node.value);
+    case 'lt':
+      return value !== null && node.value !== null && (0, _compare.compareValues)(value, node.value) < 0;
+    case 'lte':
+      return value !== null && node.value !== null && (0, _compare.compareValues)(value, node.value) <= 0;
+    case 'gt':
+      return value !== null && node.value !== null && (0, _compare.compareValues)(value, node.value) > 0;
+    case 'gte':
+      return value !== null && node.value !== null && (0, _compare.compareValues)(value, node.value) >= 0;
+    case 'in':
+      return node.value.some(candidate => equals(value, candidate));
+    case 'nin':
+      return !node.value.some(candidate => equals(value, candidate));
+    case 'between':
+      {
+        const [low, high] = node.value;
+        if (value === null || low === null || high === null) {
+          return false;
+        }
+        return (0, _compare.compareValues)(value, low) >= 0 && (0, _compare.compareValues)(value, high) <= 0;
+      }
+    default:
+      return false;
+  }
+}
+//# sourceMappingURL=filter.js.map

package/lib/commonjs/query/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_compare","require","equals","a","b","compareValues","evaluateFilter","data","node","op","nodes","every","child","some","lookup","lookupField","field","present","value","asFilterValue","undefined","candidate","low","high"],"sourceRoot":"../../../src","sources":["query/filter.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/query/paginate.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_PAGE_SIZE = void 0;
+exports.applyCursor = applyCursor;
+exports.buildPage = buildPage;
+exports.fetchLimitFor = fetchLimitFor;
+exports.resolvePageSize = resolvePageSize;
+var _config = require("../contract/config.js");
+var _cursor = require("./cursor.js");
+/**
+ * Page assembly over already-filtered, already-sorted records.
+ *
+ * Shared so the in-memory adapter and the SQLite adapter produce identical
+ * pages, including the `hasMore` signal and when a cursor is emitted.
+ */
+
+const DEFAULT_PAGE_SIZE = exports.DEFAULT_PAGE_SIZE = 50;
+function resolvePageSize(page) {
+  return page?.size ?? DEFAULT_PAGE_SIZE;
+}
+
+/** Fetch one extra row to answer `hasMore` without a second count query. */
+function fetchLimitFor(size) {
+  return Math.min(size, _config.Budgets.MAX_PAGE_SIZE) + 1;
+}
+function applyCursor(records, sort, cursor) {
+  if (!cursor) {
+    return records;
+  }
+  const anchor = (0, _cursor.decodeCursor)(cursor, sort);
+  return records.filter(record => (0, _cursor.isAfterCursor)(record, sort, anchor));
+}
+function buildPage(records, sort, size) {
+  const hasMore = records.length > size;
+  const page = hasMore ? records.slice(0, size) : records;
+  const last = page[page.length - 1];
+  return {
+    records: page,
+    // No cursor on the final page: handing one back invites a consumer to
+    // keep paging past the end and treat an empty page as an error.
+    cursor: hasMore && last ? (0, _cursor.encodeCursor)(last, sort) : undefined,
+    hasMore
+  };
+}
+//# sourceMappingURL=paginate.js.map

package/lib/commonjs/query/paginate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_config","require","_cursor","DEFAULT_PAGE_SIZE","exports","resolvePageSize","page","size","fetchLimitFor","Math","min","Budgets","MAX_PAGE_SIZE","applyCursor","records","sort","cursor","anchor","decodeCursor","filter","record","isAfterCursor","buildPage","hasMore","length","slice","last","encodeCursor","undefined"],"sourceRoot":"../../../src","sources":["query/paginate.ts"],"mappings":";;;;;;;;;;AAOA,IAAAA,OAAA,GAAAC,OAAA;AAGA,IAAAC,OAAA,GAAAD,OAAA;AAVA;AACA;AACA;AACA;AACA;AACA;;AAOO,MAAME,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAG,EAAE;AAE5B,SAASE,eAAeA,CAACC,IAA6B,EAAU;EACtE,OAAOA,IAAI,EAAEC,IAAI,IAAIJ,iBAAiB;AACvC;;AAEA;AACO,SAASK,aAAaA,CAACD,IAAY,EAAU;EACnD,OAAOE,IAAI,CAACC,GAAG,CAACH,IAAI,EAAEI,eAAO,CAACC,aAAa,CAAC,GAAG,CAAC;AACjD;AAEO,SAASC,WAAWA,CAC1BC,OAAY,EACZC,IAAe,EACfC,MAA0B,EACpB;EACN,IAAI,CAACA,MAAM,EAAE;IACZ,OAAOF,OAAO;EACf;EACA,MAAMG,MAAM,GAAG,IAAAC,oBAAY,EAACF,MAAM,EAAED,IAAI,CAAC;EACzC,OAAOD,OAAO,CAACK,MAAM,CAACC,MAAM,IAAI,IAAAC,qBAAa,EAACD,MAAM,EAAEL,IAAI,EAAEE,MAAM,CAAC,CAAC;AACrE;AAEO,SAASK,SAASA,CACxBR,OAA0B,EAC1BC,IAAe,EACfR,IAAY,EACI;EAChB,MAAMgB,OAAO,GAAGT,OAAO,CAACU,MAAM,GAAGjB,IAAI;EACrC,MAAMD,IAAI,GAAGiB,OAAO,GAAGT,OAAO,CAACW,KAAK,CAAC,CAAC,EAAElB,IAAI,CAAC,GAAGO,OAAO;EACvD,MAAMY,IAAI,GAAGpB,IAAI,CAACA,IAAI,CAACkB,MAAM,GAAG,CAAC,CAAC;EAClC,OAAO;IACNV,OAAO,EAAER,IAAI;IACb;IACA;IACAU,MAAM,EAAEO,OAAO,IAAIG,IAAI,GAAG,IAAAC,oBAAY,EAACD,IAAI,EAAEX,IAAI,CAAC,GAAGa,SAAS;IAC9DL;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/query/sort.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ID_SORT_KEY = void 0;
+exports.compareRecords = compareRecords;
+exports.sortRecords = sortRecords;
+exports.sortValueOf = sortValueOf;
+exports.withStableTiebreaker = withStableTiebreaker;
+var _compare = require("./compare.js");
+/**
+ * Sort ordering.
+ *
+ * The record id is always appended as the final sort key (FR-031). Without a
+ * tiebreaker, records with equal sort values come back in whatever order the
+ * engine happens to produce, which makes keyset pagination lose or repeat
+ * rows — the exact failure SC-007 forbids.
+ */
+
+const ID_SORT_KEY = exports.ID_SORT_KEY = {
+  field: 'id',
+  direction: 'asc'
+};
+
+/** Append `id ASC` unless the caller already sorted by it. */
+function withStableTiebreaker(sort) {
+  const keys = sort ? [...sort] : [];
+  if (!keys.some(key => key.field === 'id')) {
+    keys.push(ID_SORT_KEY);
+  }
+  return keys;
+}
+
+/** Sort values come from the record id or from a declared field. */
+function sortValueOf(record, field) {
+  if (field === 'id') {
+    return record.id;
+  }
+  const lookup = (0, _compare.lookupField)(record.data, field);
+  if (!lookup.present) {
+    // Absent sorts alongside null, matching how SQLite treats a NULL
+    // column, so the two adapters agree without special-casing.
+    return null;
+  }
+  return (0, _compare.asFilterValue)(lookup.value) ?? null;
+}
+function compareRecords(a, b, sort) {
+  for (const key of sort) {
+    const direction = key.direction === 'desc' ? -1 : 1;
+    const result = (0, _compare.compareValues)(sortValueOf(a, key.field) ?? null, sortValueOf(b, key.field) ?? null);
+    if (result !== 0) {
+      return result * direction;
+    }
+  }
+  return 0;
+}
+function sortRecords(records, sort) {
+  return [...records].sort((a, b) => compareRecords(a, b, sort));
+}
+//# sourceMappingURL=sort.js.map

package/lib/commonjs/query/sort.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_compare","require","ID_SORT_KEY","exports","field","direction","withStableTiebreaker","sort","keys","some","key","push","sortValueOf","record","id","lookup","lookupField","data","present","asFilterValue","value","compareRecords","a","b","result","compareValues","sortRecords","records"],"sourceRoot":"../../../src","sources":["query/sort.ts"],"mappings":";;;;;;;;;;AAWA,IAAAA,QAAA,GAAAC,OAAA;AAXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMO,MAAMC,WAAoB,GAAAC,OAAA,CAAAD,WAAA,GAAG;EAAEE,KAAK,EAAE,IAAI;EAAEC,SAAS,EAAE;AAAM,CAAC;;AAErE;AACO,SAASC,oBAAoBA,CAACC,IAA2B,EAAa;EAC5E,MAAMC,IAAI,GAAGD,IAAI,GAAG,CAAC,GAAGA,IAAI,CAAC,GAAG,EAAE;EAClC,IAAI,CAACC,IAAI,CAACC,IAAI,CAACC,GAAG,IAAIA,GAAG,CAACN,KAAK,KAAK,IAAI,CAAC,EAAE;IAC1CI,IAAI,CAACG,IAAI,CAACT,WAAW,CAAC;EACvB;EACA,OAAOM,IAAI;AACZ;;AAEA;AACO,SAASI,WAAWA,CAACC,MAAoB,EAAET,KAAa,EAAoC;EAClG,IAAIA,KAAK,KAAK,IAAI,EAAE;IACnB,OAAOS,MAAM,CAACC,EAAE;EACjB;EACA,MAAMC,MAAM,GAAG,IAAAC,oBAAW,EAACH,MAAM,CAACI,IAAI,EAAEb,KAAK,CAAC;EAC9C,IAAI,CAACW,MAAM,CAACG,OAAO,EAAE;IACpB;IACA;IACA,OAAO,IAAI;EACZ;EACA,OAAO,IAAAC,sBAAa,EAACJ,MAAM,CAACK,KAAK,CAAC,IAAI,IAAI;AAC3C;AAEO,SAASC,cAAcA,CAACC,CAAe,EAAEC,CAAe,EAAEhB,IAAe,EAAU;EACzF,KAAK,MAAMG,GAAG,IAAIH,IAAI,EAAE;IACvB,MAAMF,SAAS,GAAGK,GAAG,CAACL,SAAS,KAAK,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC;IACnD,MAAMmB,MAAM,GAAG,IAAAC,sBAAa,EAC3Bb,WAAW,CAACU,CAAC,EAAEZ,GAAG,CAACN,KAAK,CAAC,IAAI,IAAI,EACjCQ,WAAW,CAACW,CAAC,EAAEb,GAAG,CAACN,KAAK,CAAC,IAAI,IAC9B,CAAC;IACD,IAAIoB,MAAM,KAAK,CAAC,EAAE;MACjB,OAAOA,MAAM,GAAGnB,SAAS;IAC1B;EACD;EACA,OAAO,CAAC;AACT;AAEO,SAASqB,WAAWA,CAAyBC,OAAY,EAAEpB,IAAe,EAAO;EACvF,OAAO,CAAC,GAAGoB,OAAO,CAAC,CAACpB,IAAI,CAAC,CAACe,CAAC,EAAEC,CAAC,KAAKF,cAAc,CAACC,CAAC,EAAEC,CAAC,EAAEhB,IAAI,CAAC,CAAC;AAC/D","ignoreList":[]}

package/lib/commonjs/query/validate.js

@@ -0,0 +1,180 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateFilter = validateFilter;
+exports.validatePageSize = validatePageSize;
+exports.validateQuery = validateQuery;
+exports.validateSort = validateSort;
+var _config = require("../contract/config.js");
+var _errors = require("../contract/errors.js");
+var _errors2 = require("../diagnostics/errors.js");
+var _redact = require("../diagnostics/redact.js");
+var _declare = require("../schema/declare.js");
+/**
+ * Query validation, run before any SQL is built.
+ *
+ * Two things fall out of validating first: FR-034 is satisfied, and no
+ * consumer-supplied string ever reaches SQL construction — field names are
+ * resolved through the schema to a known column, and values bind as
+ * parameters. Injection stops being a thing to remember.
+ */
+
+function queryInvalid(message, collection) {
+  // The field name is named; its *value* never is (FR-079).
+  (0, _errors2.raise)(_errors.DiagnosticCodes.QUERY_INVALID, {
+    message,
+    detail: {
+      collection
+    }
+  });
+}
+const ORDERED_OPERATORS = new Set(['lt', 'lte', 'gt', 'gte', 'between']);
+function typeMatches(type, value) {
+  if (value === null) {
+    return true;
+  }
+  switch (type) {
+    case 'string':
+      return typeof value === 'string';
+    case 'number':
+    case 'timestamp':
+      return typeof value === 'number';
+    case 'boolean':
+      return typeof value === 'boolean';
+    default:
+      return false;
+  }
+}
+function validateField(collection, field) {
+  const declared = (0, _declare.fieldOf)(collection, field);
+  if (!declared) {
+    // Returning everything or nothing here would be worse than failing:
+    // a typo would silently change what the user sees.
+    queryInvalid(`filter references undeclared field ${(0, _redact.sanitizeIdentifier)(field)}`, collection.name);
+  }
+  return declared;
+}
+function validateFilter(collection, node) {
+  switch (node.op) {
+    case 'and':
+    case 'or':
+      {
+        if (!Array.isArray(node.nodes) || node.nodes.length === 0) {
+          queryInvalid(`${node.op} requires at least one child`, collection.name);
+        }
+        for (const child of node.nodes) {
+          validateFilter(collection, child);
+        }
+        return;
+      }
+    case 'not':
+      {
+        if (!node.node) {
+          queryInvalid('not requires a child', collection.name);
+        }
+        validateFilter(collection, node.node);
+        return;
+      }
+    case 'isNull':
+    case 'isNotNull':
+      {
+        validateField(collection, node.field);
+        return;
+      }
+    case 'exists':
+      {
+        validateField(collection, node.field);
+        if (typeof node.value !== 'boolean') {
+          queryInvalid('exists requires a boolean', collection.name);
+        }
+        return;
+      }
+    case 'in':
+    case 'nin':
+      {
+        const declared = validateField(collection, node.field);
+        if (!Array.isArray(node.value) || node.value.length === 0) {
+          queryInvalid(`${node.op} requires a non-empty array`, collection.name);
+        }
+        for (const value of node.value) {
+          if (!typeMatches(declared.type, value)) {
+            queryInvalid(`${node.op} value does not match field type`, collection.name);
+          }
+        }
+        return;
+      }
+    case 'between':
+      {
+        const declared = validateField(collection, node.field);
+        if (!Array.isArray(node.value) || node.value.length !== 2) {
+          queryInvalid('between requires exactly two bounds', collection.name);
+        }
+        for (const value of node.value) {
+          if (!typeMatches(declared.type, value)) {
+            queryInvalid('between bound does not match field type', collection.name);
+          }
+        }
+        return;
+      }
+    case 'eq':
+    case 'ne':
+    case 'lt':
+    case 'lte':
+    case 'gt':
+    case 'gte':
+      {
+        const declared = validateField(collection, node.field);
+        if (declared.type === 'boolean' && ORDERED_OPERATORS.has(node.op)) {
+          queryInvalid('ordered comparison is not defined for a boolean', collection.name);
+        }
+        if (!typeMatches(declared.type, node.value)) {
+          queryInvalid('filter value does not match field type', collection.name);
+        }
+        return;
+      }
+    default:
+      {
+        queryInvalid(`unsupported operator ${(0, _redact.sanitizeIdentifier)(String(node.op))}`, collection.name);
+      }
+  }
+}
+function validateSort(collection, sort) {
+  const seen = new Set();
+  for (const key of sort) {
+    validateField(collection, key.field);
+    if (seen.has(key.field)) {
+      queryInvalid(`duplicate sort field ${(0, _redact.sanitizeIdentifier)(key.field)}`, collection.name);
+    }
+    seen.add(key.field);
+    if (key.direction && key.direction !== 'asc' && key.direction !== 'desc') {
+      queryInvalid('sort direction must be asc or desc', collection.name);
+    }
+  }
+}
+function validatePageSize(size) {
+  if (!Number.isInteger(size) || size < 1 || size > _config.Budgets.MAX_PAGE_SIZE) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.PAGE_SIZE_INVALID, {
+      message: 'page size out of range',
+      detail: {
+        limit: _config.Budgets.MAX_PAGE_SIZE
+      }
+    });
+  }
+}
+function validateQuery(collection, query) {
+  if (!query) {
+    return;
+  }
+  if (query.filter) {
+    validateFilter(collection, query.filter);
+  }
+  if (query.sort) {
+    validateSort(collection, query.sort);
+  }
+  if (query.page) {
+    validatePageSize(query.page.size);
+  }
+}
+//# sourceMappingURL=validate.js.map

package/lib/commonjs/query/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_config","require","_errors","_errors2","_redact","_declare","queryInvalid","message","collection","raise","DiagnosticCodes","QUERY_INVALID","detail","ORDERED_OPERATORS","Set","typeMatches","type","value","validateField","field","declared","fieldOf","sanitizeIdentifier","name","validateFilter","node","op","Array","isArray","nodes","length","child","has","String","validateSort","sort","seen","key","add","direction","validatePageSize","size","Number","isInteger","Budgets","MAX_PAGE_SIZE","PAGE_SIZE_INVALID","limit","validateQuery","query","filter","page"],"sourceRoot":"../../../src","sources":["query/validate.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/schema/declare.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collectionTable = collectionTable;
+exports.fieldOf = fieldOf;
+exports.hasSoftDelete = hasSoftDelete;
+exports.hasTimestamps = hasTimestamps;
+exports.indexSchemas = indexSchemas;
+exports.isQueryable = isQueryable;
+exports.projectedColumn = projectedColumn;
+/**
+ * Schema lookup helpers shared by both adapters.
+ *
+ * Declaring a field makes it queryable — it does not restrict what a record
+ * may contain. `isQueryable` is the single answer to "may a filter or sort
+ * reference this?", so both adapters reject the same field names (FR-034).
+ */
+
+function indexSchemas(collections) {
+  return new Map(collections.map(collection => [collection.name, collection]));
+}
+function fieldOf(collection, name) {
+  return collection.fields?.find(field => field.name === name);
+}
+function isQueryable(collection, name) {
+  return fieldOf(collection, name) !== undefined;
+}
+function hasSoftDelete(collection) {
+  return collection.softDelete === true;
+}
+function hasTimestamps(collection) {
+  return collection.timestamps === true;
+}
+
+/** Column name for a projected queryable field. Prefixed to avoid colliding
+ * with the reserved columns (`id`, `payload`, `created_at`, ...). */
+function projectedColumn(field) {
+  return `f_${field}`;
+}
+
+/** Table name for a collection, prefixed for the same reason. */
+function collectionTable(name) {
+  return `c_${name}`;
+}
+//# sourceMappingURL=declare.js.map

package/lib/commonjs/schema/declare.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["indexSchemas","collections","Map","map","collection","name","fieldOf","fields","find","field","isQueryable","undefined","hasSoftDelete","softDelete","hasTimestamps","timestamps","projectedColumn","collectionTable"],"sourceRoot":"../../../src","sources":["schema/declare.ts"],"mappings":";;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMO,SAASA,YAAYA,CAACC,WAA+B,EAAe;EAC1E,OAAO,IAAIC,GAAG,CAACD,WAAW,CAACE,GAAG,CAACC,UAAU,IAAI,CAACA,UAAU,CAACC,IAAI,EAAED,UAAU,CAAC,CAAC,CAAC;AAC7E;AAEO,SAASE,OAAOA,CAACF,UAA4B,EAAEC,IAAY,EAAgC;EACjG,OAAOD,UAAU,CAACG,MAAM,EAAEC,IAAI,CAACC,KAAK,IAAIA,KAAK,CAACJ,IAAI,KAAKA,IAAI,CAAC;AAC7D;AAEO,SAASK,WAAWA,CAACN,UAA4B,EAAEC,IAAY,EAAW;EAChF,OAAOC,OAAO,CAACF,UAAU,EAAEC,IAAI,CAAC,KAAKM,SAAS;AAC/C;AAEO,SAASC,aAAaA,CAACR,UAA4B,EAAW;EACpE,OAAOA,UAAU,CAACS,UAAU,KAAK,IAAI;AACtC;AAEO,SAASC,aAAaA,CAACV,UAA4B,EAAW;EACpE,OAAOA,UAAU,CAACW,UAAU,KAAK,IAAI;AACtC;;AAEA;AACA;AACO,SAASC,eAAeA,CAACP,KAAa,EAAU;EACtD,OAAO,KAAKA,KAAK,EAAE;AACpB;;AAEA;AACO,SAASQ,eAAeA,CAACZ,IAAY,EAAU;EACrD,OAAO,KAAKA,IAAI,EAAE;AACnB","ignoreList":[]}