@chipmobilesdk/rn-local-db 0.4.0 → 0.5.0

package/lib/commonjs/sqlite/sql-builder.js

@@ -0,0 +1,253 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildFilter = buildFilter;
+exports.buildKeysetPredicate = buildKeysetPredicate;
+exports.buildOrderBy = buildOrderBy;
+var _declare = require("../schema/declare.js");
+/**
+ * Filter tree to parameterized SQL.
+ *
+ * Nothing a consumer supplies is ever concatenated into a statement. Field
+ * names are resolved through the schema first — validation has already run
+ * and rejected anything undeclared (FR-034) — so the only identifiers that
+ * reach SQL are ones this package generated from a declaration it checked.
+ * Values bind as parameters, without exception. Injection stops being a thing
+ * to remember and becomes a thing the shape of the code prevents.
+ *
+ * The other half of this file is keyset pagination. `OFFSET` was rejected for
+ * two measured reasons (research.md R6): it 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 — the exact failure SC-007 forbids.
+ */
+
+const TRUE = {
+  sql: '1',
+  params: []
+};
+const FALSE = {
+  sql: '0',
+  params: []
+};
+function columnFor(field) {
+  return field === 'id' ? 'id' : `"${(0, _declare.projectedColumn)(field)}"`;
+}
+
+/**
+ * The JSON path for a declared field.
+ *
+ * Safe to interpolate: the field name came from a schema declaration that
+ * validation already matched against `^[A-Za-z][A-Za-z0-9_]{0,62}$`, so it
+ * cannot carry a quote, a dollar sign, or a path separator.
+ */
+function jsonType(field) {
+  return `json_type(payload, '$.${field}')`;
+}
+
+/** Present, and holding something a comparison can be defined over. */
+function presentPrimitive(field) {
+  return `(${jsonType(field)} IS NOT NULL AND ${jsonType(field)} NOT IN ('object', 'array'))`;
+}
+
+/** Present and explicitly null — the condition `isNull` actually means. */
+function isExplicitNull(field) {
+  return `${jsonType(field)} = 'null'`;
+}
+
+/** Booleans project to 0/1, so a bound parameter has to match. */
+function bind(value) {
+  return typeof value === 'boolean' ? value ? 1 : 0 : value;
+}
+function comparison(node) {
+  const field = node.field;
+  const column = columnFor(field);
+  switch (node.op) {
+    case 'exists':
+      return {
+        sql: node.value ? `${jsonType(field)} IS NOT NULL` : `${jsonType(field)} IS NULL`,
+        params: []
+      };
+    case 'isNull':
+      return {
+        sql: isExplicitNull(field),
+        params: []
+      };
+    case 'isNotNull':
+      return {
+        sql: `(${jsonType(field)} IS NOT NULL AND ${jsonType(field)} != 'null')`,
+        params: []
+      };
+    case 'eq':
+      // Matching an explicit null needs the JSON type: `col = NULL` is
+      // NULL in SQL, which is not true, and a projected NULL cannot tell
+      // "absent" from "null" on its own.
+      return node.value === null ? {
+        sql: isExplicitNull(field),
+        params: []
+      } : {
+        sql: `${column} = ?`,
+        params: [bind(node.value)]
+      };
+    case 'ne':
+      return node.value === null ? {
+        sql: `(${presentPrimitive(field)} AND ${jsonType(field)} != 'null')`,
+        params: []
+      } : {
+        sql: `(${presentPrimitive(field)} AND ${column} IS NOT ?)`,
+        params: [bind(node.value)]
+      };
+    case 'lt':
+    case 'lte':
+    case 'gt':
+    case 'gte':
+      {
+        if (node.value === null) {
+          // An ordered comparison against null has no answer; SQL would
+          // return NULL and the in-memory adapter returns false. Being
+          // explicit keeps the two identical.
+          return FALSE;
+        }
+        const operator = {
+          lt: '<',
+          lte: '<=',
+          gt: '>',
+          gte: '>='
+        }[node.op];
+        return {
+          sql: `(${column} IS NOT NULL AND ${column} ${operator} ?)`,
+          params: [bind(node.value)]
+        };
+      }
+    case 'between':
+      {
+        const [low, high] = node.value;
+        if (low === null || high === null) {
+          return FALSE;
+        }
+        return {
+          sql: `(${column} IS NOT NULL AND ${column} BETWEEN ? AND ?)`,
+          params: [bind(low), bind(high)]
+        };
+      }
+    case 'in':
+    case 'nin':
+      {
+        const values = node.value;
+        const nonNull = values.filter(value => value !== null);
+        const acceptsNull = values.length !== nonNull.length;
+        const clauses = [];
+        const params = [];
+        if (nonNull.length > 0) {
+          clauses.push(`${column} IN (${nonNull.map(() => '?').join(', ')})`);
+          params.push(...nonNull.map(value => bind(value)));
+        }
+        if (acceptsNull) {
+          clauses.push(isExplicitNull(field));
+        }
+        const membership = clauses.length > 0 ? `(${clauses.join(' OR ')})` : '0';
+        if (node.op === 'in') {
+          return {
+            sql: membership,
+            params
+          };
+        }
+        // `nin` excludes, but only among records that have the field at
+        // all: an absent field satisfies no comparison, negated or not.
+        return {
+          sql: `(${presentPrimitive(field)} AND NOT IFNULL(${membership}, 0))`,
+          params
+        };
+      }
+    default:
+      return FALSE;
+  }
+}
+function buildFilter(node) {
+  if (!node) {
+    return TRUE;
+  }
+  switch (node.op) {
+    case 'and':
+    case 'or':
+      {
+        const parts = node.nodes.map(child => buildFilter(child));
+        return {
+          sql: `(${parts.map(part => part.sql).join(node.op === 'and' ? ' AND ' : ' OR ')})`,
+          params: parts.flatMap(part => part.params)
+        };
+      }
+    case 'not':
+      {
+        const inner = buildFilter(node.node);
+        // IFNULL, because NOT NULL is NULL in SQL and would quietly drop
+        // rows the in-memory adapter keeps.
+        return {
+          sql: `(NOT IFNULL(${inner.sql}, 0))`,
+          params: inner.params
+        };
+      }
+    default:
+      return comparison(node);
+  }
+}
+function buildOrderBy(sort) {
+  return sort.map(key => `${columnFor(key.field)} ${key.direction === 'desc' ? 'DESC' : 'ASC'}`).join(', ');
+}
+
+/**
+ * The keyset predicate: everything strictly after the cursor position.
+ *
+ * Lexicographic across the sort keys — equal on the first means the second
+ * decides, down to the `id` tiebreaker that guarantees a total order. NULL is
+ * treated as smaller than every value, matching both SQLite's default
+ * ordering and `compareValues`, so the two adapters page identically.
+ */
+function buildKeysetPredicate(sort, anchor) {
+  const params = [];
+  const build = index => {
+    if (index >= sort.length) {
+      return '0';
+    }
+    const key = sort[index];
+    const column = columnFor(key.field);
+    const value = anchor[index] ?? null;
+    const descending = key.direction === 'desc';
+    let strictly;
+    if (descending) {
+      if (value === null) {
+        // Nothing sorts before null, so a descending walk anchored on
+        // null has nothing left ahead of it on this key.
+        strictly = '0';
+      } else {
+        strictly = `(${column} IS NULL OR ${column} < ?)`;
+        params.push(bind(value));
+      }
+    } else if (value === null) {
+      strictly = `${column} IS NOT NULL`;
+    } else {
+      strictly = `${column} > ?`;
+      params.push(bind(value));
+    }
+    const equal = `${column} IS ?`;
+    const equalParam = bind(value);
+    if (index === sort.length - 1) {
+      return strictly;
+    }
+
+    // Params are pushed in the order the fragments are concatenated, so the
+    // equality parameter has to land between this key's comparison and the
+    // next key's fragment.
+    const head = `(${strictly} OR (${equal} AND `;
+    params.push(equalParam);
+    const tail = build(index + 1);
+    return `${head}${tail}))`;
+  };
+  return {
+    sql: build(0),
+    params
+  };
+}
+//# sourceMappingURL=sql-builder.js.map

package/lib/commonjs/sqlite/sql-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_declare","require","TRUE","sql","params","FALSE","columnFor","field","projectedColumn","jsonType","presentPrimitive","isExplicitNull","bind","value","comparison","node","column","op","operator","lt","lte","gt","gte","low","high","values","nonNull","filter","acceptsNull","length","clauses","push","map","join","membership","buildFilter","parts","nodes","child","part","flatMap","inner","buildOrderBy","sort","key","direction","buildKeysetPredicate","anchor","build","index","descending","strictly","equal","equalParam","head","tail"],"sourceRoot":"../../../src","sources":["sqlite/sql-builder.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/sqlite/statements.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertStatement = insertStatement;
+exports.updateStatement = updateStatement;
+var _declare = require("../schema/declare.js");
+var _rowCodec = require("./row-codec.js");
+/**
+ * The write statements, built in one place (LDB-12).
+ *
+ * The collection API and the batch each used to assemble their own INSERT and
+ * UPDATE text. Two copies of the same rule is how a batch upsert came to treat
+ * a soft-deleted row differently from a collection upsert.
+ */
+
+// Built once per table and column list rather than on every write (PERF-10).
+const insertTexts = new Map();
+function insertText(table, columns) {
+  const key = `${table}|${columns.join(',')}`;
+  let sql = insertTexts.get(key);
+  if (sql === undefined) {
+    sql = `INSERT INTO "${table}" (${columns.map(name => `"${name}"`).join(', ')}) VALUES (${columns.map(() => '?').join(', ')})`;
+    insertTexts.set(key, sql);
+  }
+  return sql;
+}
+
+/**
+ * `ignore` leaves a row that already holds the id untouched and reports zero
+ * rows affected, so a conflict is detected without a SELECT beforehand.
+ */
+function insertStatement(schema, id, data, now, payload, onConflict = 'fail') {
+  const {
+    columns,
+    values
+  } = (0, _rowCodec.insertColumns)(schema, id, data, now, payload);
+  const sql = insertText((0, _declare.collectionTable)(schema.name), columns);
+  return [onConflict === 'ignore' ? `${sql} ON CONFLICT(id) DO NOTHING` : sql, values];
+}
+function updateStatement(schema, id, data, now, payload, options = {}) {
+  const {
+    columns,
+    values
+  } = (0, _rowCodec.updateAssignments)(schema, data, now, payload);
+  const assignments = columns.map(name => `"${name}" = ?`);
+  if (options.restore === true && (0, _declare.hasSoftDelete)(schema)) {
+    assignments.push('deleted_at = NULL');
+  }
+  const live = options.liveOnly === true ? ' AND deleted_at IS NULL' : '';
+  return [`UPDATE "${(0, _declare.collectionTable)(schema.name)}" SET ${assignments.join(', ')} WHERE id = ?${live}`, [...values, id]];
+}
+//# sourceMappingURL=statements.js.map

package/lib/commonjs/sqlite/statements.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_declare","require","_rowCodec","insertTexts","Map","insertText","table","columns","key","join","sql","get","undefined","map","name","set","insertStatement","schema","id","data","now","payload","onConflict","values","insertColumns","collectionTable","updateStatement","options","updateAssignments","assignments","restore","hasSoftDelete","push","live","liveOnly"],"sourceRoot":"../../../src","sources":["sqlite/statements.ts"],"mappings":";;;;;;;AAQA,IAAAA,QAAA,GAAAC,OAAA;AAEA,IAAAC,SAAA,GAAAD,OAAA;AAVA;AACA;AACA;AACA;AACA;AACA;AACA;;AAUA;AACA,MAAME,WAAW,GAAG,IAAIC,GAAG,CAAiB,CAAC;AAE7C,SAASC,UAAUA,CAACC,KAAa,EAAEC,OAA0B,EAAU;EACtE,MAAMC,GAAG,GAAG,GAAGF,KAAK,IAAIC,OAAO,CAACE,IAAI,CAAC,GAAG,CAAC,EAAE;EAC3C,IAAIC,GAAG,GAAGP,WAAW,CAACQ,GAAG,CAACH,GAAG,CAAC;EAC9B,IAAIE,GAAG,KAAKE,SAAS,EAAE;IACtBF,GAAG,GAAG,gBAAgBJ,KAAK,MAAMC,OAAO,CAACM,GAAG,CAACC,IAAI,IAAI,IAAIA,IAAI,GAAG,CAAC,CAACL,IAAI,CAAC,IAAI,CAAC,aAAaF,OAAO,CAC9FM,GAAG,CAAC,MAAM,GAAG,CAAC,CACdJ,IAAI,CAAC,IAAI,CAAC,GAAG;IACfN,WAAW,CAACY,GAAG,CAACP,GAAG,EAAEE,GAAG,CAAC;EAC1B;EACA,OAAOA,GAAG;AACX;;AAEA;AACA;AACA;AACA;AACO,SAASM,eAAeA,CAC9BC,MAAwB,EACxBC,EAAU,EACVC,IAAgB,EAChBC,GAAW,EACXC,OAAe,EACfC,UAA6B,GAAG,MAAM,EAC1B;EACZ,MAAM;IAAEf,OAAO;IAAEgB;EAAO,CAAC,GAAG,IAAAC,uBAAa,EAACP,MAAM,EAAEC,EAAE,EAAEC,IAAI,EAAEC,GAAG,EAAEC,OAAO,CAAC;EACzE,MAAMX,GAAG,GAAGL,UAAU,CAAC,IAAAoB,wBAAe,EAACR,MAAM,CAACH,IAAI,CAAC,EAAEP,OAAO,CAAC;EAC7D,OAAO,CAACe,UAAU,KAAK,QAAQ,GAAG,GAAGZ,GAAG,6BAA6B,GAAGA,GAAG,EAAEa,MAAM,CAAC;AACrF;AASO,SAASG,eAAeA,CAC9BT,MAAwB,EACxBC,EAAU,EACVC,IAAgB,EAChBC,GAAW,EACXC,OAAe,EACfM,OAAsB,GAAG,CAAC,CAAC,EACf;EACZ,MAAM;IAAEpB,OAAO;IAAEgB;EAAO,CAAC,GAAG,IAAAK,2BAAiB,EAACX,MAAM,EAAEE,IAAI,EAAEC,GAAG,EAAEC,OAAO,CAAC;EACzE,MAAMQ,WAAW,GAAGtB,OAAO,CAACM,GAAG,CAACC,IAAI,IAAI,IAAIA,IAAI,OAAO,CAAC;EACxD,IAAIa,OAAO,CAACG,OAAO,KAAK,IAAI,IAAI,IAAAC,sBAAa,EAACd,MAAM,CAAC,EAAE;IACtDY,WAAW,CAACG,IAAI,CAAC,mBAAmB,CAAC;EACtC;EACA,MAAMC,IAAI,GAAGN,OAAO,CAACO,QAAQ,KAAK,IAAI,GAAG,yBAAyB,GAAG,EAAE;EACvE,OAAO,CACN,WAAW,IAAAT,wBAAe,EAACR,MAAM,CAACH,IAAI,CAAC,SAASe,WAAW,CAACpB,IAAI,CAAC,IAAI,CAAC,gBAAgBwB,IAAI,EAAE,EAC5F,CAAC,GAAGV,MAAM,EAAEL,EAAE,CAAC,CACf;AACF","ignoreList":[]}

package/lib/commonjs/sqlite/transaction-queue.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TRANSACTION_WAIT_LIMIT_MS = void 0;
+exports.createTransactionQueue = createTransactionQueue;
+var _errors = require("../contract/errors.js");
+var _errors2 = require("../diagnostics/errors.js");
+/**
+ * The per-handle queue that keeps a transaction to itself.
+ *
+ * A transaction holds the queue until it settles; work arriving meanwhile
+ * through the handle waits its turn and then runs on its own, instead of
+ * joining the transaction and vanishing with its rollback (LDB-01). Shared by
+ * the SQLite connection and the memory adapter so both isolate the same way.
+ *
+ * Pure: no engine, no React, so the memory adapter can use it without loading
+ * native code.
+ */
+
+/**
+ * How long work through the handle waits behind a transaction before it is
+ * refused.
+ *
+ * Not a performance budget: it exists for the one wait that never ends. A
+ * transaction body that awaits the handle's own `collection()` or
+ * `attachments()` is waiting on work queued behind itself. Until 0.2.0 that
+ * work ran inside the transaction; now it is refused after this long with a
+ * message naming `tx.collection()` / `tx.attachments()`, and the transaction
+ * rolls back, rather than both waiting forever.
+ */
+const TRANSACTION_WAIT_LIMIT_MS = exports.TRANSACTION_WAIT_LIMIT_MS = 10_000;
+function createTransactionQueue(waitLimitMs = TRANSACTION_WAIT_LIMIT_MS) {
+  /** Tail of the queue. Never rejects, so one failure cannot stall the rest. */
+  let tail = Promise.resolve();
+  /** Transactions queued or running. Only work behind one of them can deadlock. */
+  let transactions = 0;
+  const enqueue = work => {
+    const run = tail.then(work, work);
+    tail = run.catch(() => undefined);
+    return run;
+  };
+  return {
+    run(work) {
+      if (transactions === 0) {
+        return enqueue(work);
+      }
+      let abandoned = false;
+      let timer;
+      const started = enqueue(() => {
+        clearTimeout(timer);
+        // Refused while waiting: it must not run late, after its caller was
+        // already told it failed.
+        return abandoned ? Promise.resolve(undefined) : work();
+      });
+      const refused = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          abandoned = true;
+          try {
+            (0, _errors2.raise)(_errors.DiagnosticCodes.TRANSACTION_STATE, {
+              message: 'waited too long behind an in-flight transaction; inside a transaction body use tx.collection() and tx.attachments(), not the handle'
+            });
+          } catch (error) {
+            reject(error);
+          }
+        }, waitLimitMs);
+      });
+      return Promise.race([started, refused]);
+    },
+    runTransaction(work) {
+      transactions += 1;
+      return enqueue(work).finally(() => {
+        transactions -= 1;
+      });
+    }
+  };
+}
+//# sourceMappingURL=transaction-queue.js.map

package/lib/commonjs/sqlite/transaction-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_errors2","TRANSACTION_WAIT_LIMIT_MS","exports","createTransactionQueue","waitLimitMs","tail","Promise","resolve","transactions","enqueue","work","run","then","catch","undefined","abandoned","timer","started","clearTimeout","refused","_","reject","setTimeout","raise","DiagnosticCodes","TRANSACTION_STATE","message","error","race","runTransaction","finally"],"sourceRoot":"../../../src","sources":["sqlite/transaction-queue.ts"],"mappings":";;;;;;;AAYA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AAbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAME,yBAAyB,GAAAC,OAAA,CAAAD,yBAAA,GAAG,MAAM;AASxC,SAASE,sBAAsBA,CACrCC,WAAmB,GAAGH,yBAAyB,EAC5B;EACnB;EACA,IAAII,IAAsB,GAAGC,OAAO,CAACC,OAAO,CAAC,CAAC;EAC9C;EACA,IAAIC,YAAY,GAAG,CAAC;EAEpB,MAAMC,OAAO,GAAOC,IAAsB,IAAiB;IAC1D,MAAMC,GAAG,GAAGN,IAAI,CAACO,IAAI,CAACF,IAAI,EAAEA,IAAI,CAAC;IACjCL,IAAI,GAAGM,GAAG,CAACE,KAAK,CAAC,MAAMC,SAAS,CAAC;IACjC,OAAOH,GAAG;EACX,CAAC;EAED,OAAO;IACNA,GAAGA,CAAID,IAAsB,EAAc;MAC1C,IAAIF,YAAY,KAAK,CAAC,EAAE;QACvB,OAAOC,OAAO,CAACC,IAAI,CAAC;MACrB;MAEA,IAAIK,SAAS,GAAG,KAAK;MACrB,IAAIC,KAAgD;MACpD,MAAMC,OAAO,GAAGR,OAAO,CAAC,MAAM;QAC7BS,YAAY,CAACF,KAAK,CAAC;QACnB;QACA;QACA,OAAOD,SAAS,GAAGT,OAAO,CAACC,OAAO,CAACO,SAAc,CAAC,GAAGJ,IAAI,CAAC,CAAC;MAC5D,CAAC,CAAC;MACF,MAAMS,OAAO,GAAG,IAAIb,OAAO,CAAQ,CAACc,CAAC,EAAEC,MAAM,KAAK;QACjDL,KAAK,GAAGM,UAAU,CAAC,MAAM;UACxBP,SAAS,GAAG,IAAI;UAChB,IAAI;YACH,IAAAQ,cAAK,EAACC,uBAAe,CAACC,iBAAiB,EAAE;cACxCC,OAAO,EACN;YACF,CAAC,CAAC;UACH,CAAC,CAAC,OAAOC,KAAK,EAAE;YACfN,MAAM,CAACM,KAAK,CAAC;UACd;QACD,CAAC,EAAEvB,WAAW,CAAC;MAChB,CAAC,CAAC;MACF,OAAOE,OAAO,CAACsB,IAAI,CAAC,CAACX,OAAO,EAAEE,OAAO,CAAC,CAAC;IACxC,CAAC;IAEDU,cAAcA,CAAInB,IAAsB,EAAc;MACrDF,YAAY,IAAI,CAAC;MACjB,OAAOC,OAAO,CAACC,IAAI,CAAC,CAACoB,OAAO,CAAC,MAAM;QAClCtB,YAAY,IAAI,CAAC;MAClB,CAAC,CAAC;IACH;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/sqlite/transactions.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runInTransaction = runInTransaction;
+/**
+ * The transaction primitive.
+ *
+ * A transaction never spans two scopes, and not because a check forbids it:
+ * a transaction runs on one connection, a connection is opened against one
+ * scope's file, and the public surface offers no way to reach a second one
+ * from inside. FR-038 is a type error rather than a runtime one (research.md
+ * R2).
+ *
+ * Rollback fidelity is SQLite's, not this package's. A failure at any step
+ * unwinds through the engine's own `ROLLBACK`, which is the only way SC-006's
+ * "identical to its pre-transaction state, every time" survives a process
+ * kill halfway through.
+ */
+
+/**
+ * Run `body` inside one transaction on one scope.
+ *
+ * Deliberately thin. The interesting behavior — read-your-own-writes,
+ * terminal-state rejection, what a settled transaction does when used again —
+ * belongs to `adapter/transaction.ts`, where both adapters can be held to the
+ * same rules.
+ */
+function runInTransaction(connection, body) {
+  return connection.transaction(body);
+}
+//# sourceMappingURL=transactions.js.map

package/lib/commonjs/sqlite/transactions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["runInTransaction","connection","body","transaction"],"sourceRoot":"../../../src","sources":["sqlite/transactions.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,gBAAgBA,CAC/BC,UAAsB,EACtBC,IAA6C,EAChC;EACb,OAAOD,UAAU,CAACE,WAAW,CAACD,IAAI,CAAC;AACpC","ignoreList":[]}

package/lib/commonjs/sqlite/values.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.maybeNum = maybeNum;
+exports.maybeText = maybeText;
+exports.num = num;
+exports.text = text;
+/**
+ * Reading values back out of a result row.
+ *
+ * The engine hands back `unknown` per column, and every read site would
+ * otherwise repeat the same `String(...)` / `Number(...)` coercion with a
+ * slightly different null check. One place to do it means one place where the
+ * "NULL means absent, not empty string" rule is decided.
+ */
+
+function text(value) {
+  return typeof value === 'string' ? value : String(value);
+}
+function num(value) {
+  return typeof value === 'number' ? value : Number(value);
+}
+function maybeText(value) {
+  return value == null ? null : text(value);
+}
+function maybeNum(value) {
+  return value == null ? null : num(value);
+}
+//# sourceMappingURL=values.js.map

package/lib/commonjs/sqlite/values.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["text","value","String","num","Number","maybeText","maybeNum"],"sourceRoot":"../../../src","sources":["sqlite/values.ts"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,SAASA,IAAIA,CAACC,KAAc,EAAU;EAC5C,OAAO,OAAOA,KAAK,KAAK,QAAQ,GAAGA,KAAK,GAAGC,MAAM,CAACD,KAAkC,CAAC;AACtF;AAEO,SAASE,GAAGA,CAACF,KAAc,EAAU;EAC3C,OAAO,OAAOA,KAAK,KAAK,QAAQ,GAAGA,KAAK,GAAGG,MAAM,CAACH,KAAwB,CAAC;AAC5E;AAEO,SAASI,SAASA,CAACJ,KAAc,EAAiB;EACxD,OAAOA,KAAK,IAAI,IAAI,GAAG,IAAI,GAAGD,IAAI,CAACC,KAAK,CAAC;AAC1C;AAEO,SAASK,QAAQA,CAACL,KAAc,EAAiB;EACvD,OAAOA,KAAK,IAAI,IAAI,GAAG,IAAI,GAAGE,GAAG,CAACF,KAAK,CAAC;AACzC","ignoreList":[]}

package/lib/commonjs/testing/conformance/attachments.js

@@ -0,0 +1,180 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.registerAttachmentConformance = registerAttachmentConformance;
+var _errors = require("../../contract/errors.js");
+var _errors2 = require("../../diagnostics/errors.js");
+var _bytes = require("../../platform/bytes.js");
+/** US7: artifacts the package owns, and the reconciliation that keeps them honest. */
+function registerAttachmentConformance(context) {
+  describe('conformance: attachments', () => {
+    beforeEach(() => context.reset());
+    const scope = {
+      kind: 'guest'
+    };
+    const content = (0, _bytes.bytesToBase64)((0, _bytes.utf8Bytes)('hello attachment'));
+    it('stores a reference alongside the artifact', async () => {
+      const handle = await context.adapter.open(context.configFor(scope));
+      const attachments = handle.attachments();
+      const reference = await attachments.write({
+        id: 'a1',
+        owner: {
+          collection: 'notes',
+          id: 'n1'
+        },
+        contentType: 'text/plain',
+        content
+      });
+      expect(reference.size).toBe((0, _bytes.base64ToBytes)(content).length);
+      expect(await attachments.read('a1')).toBe(content);
+      expect((await attachments.availability('a1')).state).toBe('available');
+      await handle.close();
+    });
+    it('reads a byte range without materialising the whole artifact', async () => {
+      const handle = await context.adapter.open(context.configFor(scope));
+      const attachments = handle.attachments();
+      await attachments.write({
+        id: 'a1',
+        contentType: 'text/plain',
+        content
+      });
+      const slice = await attachments.read('a1', {
+        offset: 0,
+        length: 5
+      });
+      expect((0, _bytes.utf8String)((0, _bytes.base64ToBytes)(slice))).toBe('hello');
+      await handle.close();
+    });
+    it('lists the attachments belonging to a record', async () => {
+      const handle = await context.adapter.open(context.configFor(scope));
+      const attachments = handle.attachments();
+      await attachments.write({
+        id: 'a1',
+        owner: {
+          collection: 'notes',
+          id: 'n1'
+        },
+        contentType: 'text/plain',
+        content
+      });
+      await attachments.write({
+        id: 'a2',
+        contentType: 'text/plain',
+        content
+      });
+      const owned = await attachments.listFor({
+        collection: 'notes',
+        id: 'n1'
+      });
+      expect(owned.map(r => r.id)).toEqual(['a1']);
+      await handle.close();
+    });
+    it('reports a missing artifact without making the record unreadable', async () => {
+      const handle = await context.adapter.open(context.configFor(scope));
+      await handle.collection('notes').insert({
+        id: 'n1',
+        data: {
+          title: 'has media'
+        }
+      });
+      const attachments = handle.attachments();
+      await attachments.write({
+        id: 'a1',
+        owner: {
+          collection: 'notes',
+          id: 'n1'
+        },
+        contentType: 'text/plain',
+        content
+      });
+
+      // Remove the artifact behind the package's back.
+      await context.removeArtifactBehindTheScenes(handle.scopeKey, 'a1');
+      expect((await attachments.availability('a1')).state).toBe('missing');
+      expect((await handle.collection('notes').get('n1')).data.title).toBe('has media');
+      await handle.close();
+    });
+    it('finds an orphaned artifact and a dangling reference', async () => {
+      const handle = await context.adapter.open(context.configFor(scope));
+      const attachments = handle.attachments();
+      await attachments.write({
+        id: 'a1',
+        contentType: 'text/plain',
+        content
+      });
+      await context.removeReferenceBehindTheScenes(handle.scopeKey, 'a1');
+      await attachments.write({
+        id: 'a2',
+        contentType: 'text/plain',
+        content
+      });
+      await context.removeArtifactBehindTheScenes(handle.scopeKey, 'a2');
+      const report = await attachments.reconcile();
+      expect(report.orphanedArtifacts).toEqual(['a1']);
+      expect(report.danglingReferences).toEqual(['a2']);
+      const removed = await attachments.reconcile({
+        removeOrphans: true
+      });
+      expect(removed.removedArtifacts).toEqual(['a1']);
+      expect((await attachments.reconcile()).orphanedArtifacts).toEqual([]);
+      await handle.close();
+    });
+    it('rolls a reference back with its transaction', async () => {
+      const handle = await context.adapter.open(context.configFor(scope));
+      try {
+        await handle.transaction(async tx => {
+          await tx.collection('notes').insert({
+            id: 'n1',
+            data: {
+              title: 'x'
+            }
+          });
+          await tx.attachments().write({
+            id: 'a1',
+            contentType: 'text/plain',
+            content
+          });
+          throw new Error('injected');
+        });
+      } catch {
+        // Expected.
+      }
+      expect(await handle.collection('notes').find('n1')).toBeNull();
+      // The reference is gone; the artifact on disk is not, which is
+      // exactly why reconciliation exists.
+      const report = await handle.attachments().reconcile();
+      expect(report.orphanedArtifacts).toEqual(['a1']);
+      await handle.close();
+    });
+    it('rejects an artifact over the size budget', async () => {
+      const handle = await context.adapter.open(context.configFor(scope));
+      const huge = (0, _bytes.bytesToBase64)(new Uint8Array(101 * 1024 * 1024));
+      let thrown;
+      try {
+        await handle.attachments().write({
+          id: 'big',
+          contentType: 'application/octet-stream',
+          content: huge
+        });
+      } catch (error) {
+        thrown = error;
+      }
+      expect((0, _errors2.isCode)(thrown, _errors.DiagnosticCodes.ATTACHMENT_WRITE_FAILED)).toBe(true);
+      await handle.close();
+    });
+    it('removes artifacts when the scope is deleted', async () => {
+      const handle = await context.adapter.open(context.configFor(scope));
+      await handle.attachments().write({
+        id: 'a1',
+        contentType: 'text/plain',
+        content
+      });
+      await handle.close();
+      const outcome = await context.adapter.deleteScopeData(context.scopeTargetFor(scope));
+      expect(outcome.removedArtifacts).toContain('a1');
+    });
+  });
+}
+//# sourceMappingURL=attachments.js.map