@chipmobilesdk/rn-local-db 0.3.0 → 0.5.0

package/lib/commonjs/scope/validate.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveScope = resolveScope;
+exports.validateDescriptor = validateDescriptor;
+var _errors = require("../contract/errors.js");
+var _errors2 = require("../diagnostics/errors.js");
+var _hash = require("./hash.js");
+var _normalize = require("./normalize.js");
+/**
+ * Scope validation and resolution.
+ *
+ * Validate, never repair (FR-013). The package never invents, derives, or
+ * defaults an identity of its own (FR-008).
+ */
+
+function invalid(reason) {
+  // The reason names the *component*, never its value — naming the value
+  // would put a scope component into an error, which FR-014 forbids.
+  (0, _errors2.raise)(_errors.DiagnosticCodes.INVALID_SCOPE, {
+    message: reason
+  });
+}
+function validateComponent(key, raw) {
+  if (raw === undefined || raw === null) {
+    return;
+  }
+  if (typeof raw !== 'string') {
+    invalid(`scope component ${key} must be a string`);
+  }
+  const normalized = (0, _normalize.normalizeComponent)(raw);
+  if (normalized.length === 0) {
+    invalid(`scope component ${key} is empty after normalization`);
+  }
+  if (_normalize.CONTROL_CHARACTER.test(normalized)) {
+    invalid(`scope component ${key} contains a control character`);
+  }
+  if ((0, _hash.utf8ByteLength)(normalized) > _normalize.MAX_COMPONENT_BYTES) {
+    invalid(`scope component ${key} exceeds the maximum length`);
+  }
+}
+function validateDescriptor(descriptor) {
+  if (!descriptor || typeof descriptor !== 'object') {
+    invalid('scope descriptor is required');
+  }
+  if (!_normalize.SCOPE_KINDS.includes(descriptor.kind)) {
+    invalid('scope kind is not recognised');
+  }
+
+  // Guest is the one kind with no identity, by design: an anonymous session
+  // still gets its own isolated scope rather than sharing a default.
+  if (descriptor.kind !== 'guest') {
+    const id = descriptor.id;
+    if (typeof id !== 'string' || (0, _normalize.normalizeComponent)(id).length === 0) {
+      invalid('scope id is required for this kind');
+    }
+  }
+  for (const key of _normalize.COMPONENT_ORDER) {
+    if (key === 'kind') {
+      continue;
+    }
+    validateComponent(key, descriptor[key]);
+  }
+}
+
+/**
+ * Deterministic: identical descriptors always resolve to the same scope, and
+ * descriptors differing in any component always resolve to different ones
+ * (FR-010).
+ */
+function resolveScope(descriptor) {
+  validateDescriptor(descriptor);
+  const normalized = (0, _normalize.normalizeDescriptor)(descriptor);
+  return {
+    key: (0, _hash.sha256Hex)(normalized.canonical),
+    kind: descriptor.kind
+  };
+}
+//# sourceMappingURL=validate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_errors2","_hash","_normalize","invalid","reason","raise","DiagnosticCodes","INVALID_SCOPE","message","validateComponent","key","raw","undefined","normalized","normalizeComponent","length","CONTROL_CHARACTER","test","utf8ByteLength","MAX_COMPONENT_BYTES","validateDescriptor","descriptor","SCOPE_KINDS","includes","kind","id","COMPONENT_ORDER","resolveScope","normalizeDescriptor","sha256Hex","canonical"],"sourceRoot":"../../../src","sources":["scope/validate.ts"],"mappings":";;;;;;;AAOA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,QAAA,GAAAD,OAAA;AACA,IAAAE,KAAA,GAAAF,OAAA;AACA,IAAAG,UAAA,GAAAH,OAAA;AAXA;AACA;AACA;AACA;AACA;AACA;;AAeA,SAASI,OAAOA,CAACC,MAAc,EAAS;EACvC;EACA;EACA,IAAAC,cAAK,EAACC,uBAAe,CAACC,aAAa,EAAE;IAAEC,OAAO,EAAEJ;EAAO,CAAC,CAAC;AAC1D;AAEA,SAASK,iBAAiBA,CAACC,GAAW,EAAEC,GAAY,EAAQ;EAC3D,IAAIA,GAAG,KAAKC,SAAS,IAAID,GAAG,KAAK,IAAI,EAAE;IACtC;EACD;EACA,IAAI,OAAOA,GAAG,KAAK,QAAQ,EAAE;IAC5BR,OAAO,CAAC,mBAAmBO,GAAG,mBAAmB,CAAC;EACnD;EACA,MAAMG,UAAU,GAAG,IAAAC,6BAAkB,EAACH,GAAG,CAAC;EAC1C,IAAIE,UAAU,CAACE,MAAM,KAAK,CAAC,EAAE;IAC5BZ,OAAO,CAAC,mBAAmBO,GAAG,+BAA+B,CAAC;EAC/D;EACA,IAAIM,4BAAiB,CAACC,IAAI,CAACJ,UAAU,CAAC,EAAE;IACvCV,OAAO,CAAC,mBAAmBO,GAAG,+BAA+B,CAAC;EAC/D;EACA,IAAI,IAAAQ,oBAAc,EAACL,UAAU,CAAC,GAAGM,8BAAmB,EAAE;IACrDhB,OAAO,CAAC,mBAAmBO,GAAG,6BAA6B,CAAC;EAC7D;AACD;AAEO,SAASU,kBAAkBA,CAACC,UAA8C,EAAQ;EACxF,IAAI,CAACA,UAAU,IAAI,OAAOA,UAAU,KAAK,QAAQ,EAAE;IAClDlB,OAAO,CAAC,8BAA8B,CAAC;EACxC;EACA,IAAI,CAACmB,sBAAW,CAACC,QAAQ,CAACF,UAAU,CAACG,IAAI,CAAC,EAAE;IAC3CrB,OAAO,CAAC,8BAA8B,CAAC;EACxC;;EAEA;EACA;EACA,IAAIkB,UAAU,CAACG,IAAI,KAAK,OAAO,EAAE;IAChC,MAAMC,EAAE,GAAGJ,UAAU,CAACI,EAAE;IACxB,IAAI,OAAOA,EAAE,KAAK,QAAQ,IAAI,IAAAX,6BAAkB,EAACW,EAAE,CAAC,CAACV,MAAM,KAAK,CAAC,EAAE;MAClEZ,OAAO,CAAC,oCAAoC,CAAC;IAC9C;EACD;EAEA,KAAK,MAAMO,GAAG,IAAIgB,0BAAe,EAAE;IAClC,IAAIhB,GAAG,KAAK,MAAM,EAAE;MACnB;IACD;IACAD,iBAAiB,CAACC,GAAG,EAAEW,UAAU,CAACX,GAAG,CAA0B,CAAC;EACjE;AACD;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASiB,YAAYA,CAACN,UAA2B,EAAiB;EACxED,kBAAkB,CAACC,UAAU,CAAC;EAC9B,MAAMR,UAAU,GAAG,IAAAe,8BAAmB,EAACP,UAAU,CAAC;EAClD,OAAO;IACNX,GAAG,EAAE,IAAAmB,eAAS,EAAChB,UAAU,CAACiB,SAAS,CAAC;IACpCN,IAAI,EAAEH,UAAU,CAACG;EAClB,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/sqlite/adapter.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSqliteAdapter = createSqliteAdapter;
+var _deletion = require("../adapter/deletion.js");
+var _lifecycle = require("../adapter/lifecycle.js");
+/**
+ * The on-device adapter.
+ *
+ * Deliberately a seam rather than an implementation. Everything it composes
+ * lives in `adapter/`, `migration/`, `artifacts/`, and this directory, so the
+ * in-memory adapter can be held to the same contract by the same conformance
+ * suite (FR-092) without either one being the "real" version the other
+ * approximates.
+ *
+ * Reached only through the lazy require in `adapter/index.ts`, so a consumer
+ * that runs the in-memory adapter in tests never loads the native peers.
+ */
+
+function createSqliteAdapter(options = {}) {
+  return {
+    name: 'sqlite',
+    open: config => (0, _lifecycle.openSqliteDatabase)(config, options),
+    deleteScopeData: _deletion.deleteScopeData,
+    deleteDatabase: _deletion.deleteDatabase,
+    resetScope: _deletion.resetScope
+  };
+}
+//# sourceMappingURL=adapter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_deletion","require","_lifecycle","createSqliteAdapter","options","name","open","config","openSqliteDatabase","deleteScopeData","deleteDatabase","resetScope"],"sourceRoot":"../../../src","sources":["sqlite/adapter.ts"],"mappings":";;;;;;AAcA,IAAAA,SAAA,GAAAC,OAAA;AACA,IAAAC,UAAA,GAAAD,OAAA;AAfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMO,SAASE,mBAAmBA,CAACC,OAAoB,GAAG,CAAC,CAAC,EAAkB;EAC9E,OAAO;IACNC,IAAI,EAAE,QAAQ;IACdC,IAAI,EAAEC,MAAM,IAAI,IAAAC,6BAAkB,EAACD,MAAM,EAAEH,OAAO,CAAC;IACnDK,eAAe,EAAfA,yBAAe;IACfC,cAAc,EAAdA,wBAAc;IACdC,UAAU,EAAVA;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/sqlite/batch.js

@@ -0,0 +1,218 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runBatch = runBatch;
+var _errors = require("../contract/errors.js");
+var _errors2 = require("../diagnostics/errors.js");
+var _budgets = require("../query/budgets.js");
+var _declare = require("../schema/declare.js");
+var _statements = require("./statements.js");
+/**
+ * Batch writes: many operations, one atomic unit, one outcome (FR-028).
+ *
+ * Every statement is resolved before any of them runs. That ordering is the
+ * point: a conflict or a missing record is reported with the database still
+ * untouched, so "the batch failed" and "the batch was partly applied" are
+ * never the same event. The statements then go to the engine's own
+ * `executeBatch`, which wraps them in a single transaction — the batch is
+ * atomic because SQLite makes it atomic, not because this file is careful.
+ *
+ * Resolution keeps an overlay of what earlier operations in the same batch
+ * did, so `insert` followed by `update` on the same id resolves against the
+ * batch's own effect rather than against the database as it was before it.
+ */
+
+function quoted(schema) {
+  return `"${(0, _declare.collectionTable)(schema.name)}"`;
+}
+
+/**
+ * Where a record stands, as this batch has left it so far. Three states, not
+ * two: a soft-deleted row is invisible to reads but still holds its primary
+ * key, so an insert over it conflicts and an upsert over it restores it — the
+ * same rules the collection API applies. Treating it as absent made a batch
+ * upsert issue an INSERT and fail the whole batch on the primary key.
+ */
+
+function conflict(schema, id) {
+  (0, _errors2.raise)(_errors.DiagnosticCodes.RECORD_CONFLICT, {
+    message: 'record already exists',
+    detail: {
+      collection: schema.name,
+      recordId: id
+    }
+  });
+}
+function missing(schema, id) {
+  (0, _errors2.raise)(_errors.DiagnosticCodes.RECORD_NOT_FOUND, {
+    message: 'record not found',
+    detail: {
+      collection: schema.name,
+      recordId: id
+    }
+  });
+}
+async function resolveInsert(resolver, operation) {
+  const {
+    schema,
+    now
+  } = resolver;
+  const payload = (0, _budgets.assertRecordWithinBudget)(schema.name, operation.record.data);
+  if ((await resolver.state(operation.record.id)) !== 'absent') {
+    conflict(schema, operation.record.id);
+  }
+  resolver.stage(operation.record.id, 'live');
+  return {
+    command: (0, _statements.insertStatement)(schema, operation.record.id, operation.record.data, now, payload),
+    outcome: {
+      operation: 'created',
+      id: operation.record.id
+    }
+  };
+}
+async function resolveUpdate(resolver, operation) {
+  const {
+    schema,
+    now
+  } = resolver;
+  const payload = (0, _budgets.assertRecordWithinBudget)(schema.name, operation.data);
+  if ((await resolver.state(operation.id)) !== 'live') {
+    missing(schema, operation.id);
+  }
+  return {
+    command: (0, _statements.updateStatement)(schema, operation.id, operation.data, now, payload, {
+      restore: false
+    }),
+    outcome: {
+      operation: 'updated',
+      id: operation.id
+    }
+  };
+}
+async function resolveUpsert(resolver, operation) {
+  const {
+    schema,
+    now
+  } = resolver;
+  const payload = (0, _budgets.assertRecordWithinBudget)(schema.name, operation.record.data);
+  const present = (await resolver.state(operation.record.id)) !== 'absent';
+  resolver.stage(operation.record.id, 'live');
+  return {
+    command: present ? (0, _statements.updateStatement)(schema, operation.record.id, operation.record.data, now, payload, {
+      restore: true
+    }) : (0, _statements.insertStatement)(schema, operation.record.id, operation.record.data, now, payload),
+    outcome: {
+      operation: present ? 'updated' : 'created',
+      id: operation.record.id
+    }
+  };
+}
+async function resolveDelete(resolver, operation) {
+  const {
+    schema
+  } = resolver;
+  if ((await resolver.state(operation.id)) !== 'live') {
+    missing(schema, operation.id);
+  }
+  resolver.stage(operation.id, 'absent');
+  return {
+    command: [`DELETE FROM ${quoted(schema)} WHERE id = ?`, [operation.id]],
+    outcome: {
+      operation: 'deleted',
+      id: operation.id
+    }
+  };
+}
+async function resolveSoftDelete(resolver, operation) {
+  const {
+    schema,
+    now
+  } = resolver;
+  if (!(0, _declare.hasSoftDelete)(schema)) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.CONFIG_INVALID, {
+      message: 'collection does not declare soft delete',
+      detail: {
+        collection: schema.name
+      }
+    });
+  }
+  if ((await resolver.state(operation.id)) !== 'live') {
+    missing(schema, operation.id);
+  }
+  resolver.stage(operation.id, 'softDeleted');
+  return {
+    command: [`UPDATE ${quoted(schema)} SET deleted_at = ? WHERE id = ?`, [now, operation.id]],
+    outcome: {
+      operation: 'deleted',
+      id: operation.id
+    }
+  };
+}
+function resolveOperation(resolver, operation) {
+  switch (operation.type) {
+    case 'insert':
+      return resolveInsert(resolver, operation);
+    case 'update':
+      return resolveUpdate(resolver, operation);
+    case 'upsert':
+      return resolveUpsert(resolver, operation);
+    case 'delete':
+      return resolveDelete(resolver, operation);
+    case 'softDelete':
+      return resolveSoftDelete(resolver, operation);
+    default:
+      (0, _errors2.raise)(_errors.DiagnosticCodes.CONFIG_INVALID, {
+        message: 'unsupported batch operation'
+      });
+  }
+}
+async function runBatch(context, operations) {
+  (0, _budgets.assertBatchWithinBudget)(operations.length);
+  const commands = [];
+  const outcomes = [];
+  const overlay = new Map();
+
+  // What the batch will touch, read once per collection (LDB-08). A batch of a
+  // thousand operations used to make a thousand SELECTs before its one write.
+  // The ids travel as one JSON parameter, so no variable limit applies.
+  const known = new Map();
+  const idsByCollection = new Map();
+  for (const operation of operations) {
+    const id = 'record' in operation ? operation.record.id : operation.id;
+    const ids = idsByCollection.get(operation.collection) ?? new Set();
+    ids.add(id);
+    idsByCollection.set(operation.collection, ids);
+  }
+  for (const [collection, ids] of idsByCollection) {
+    const schema = context.schemaFor(collection);
+    const result = await context.connection.execute(`SELECT id, deleted_at FROM ${quoted(schema)} WHERE id IN (SELECT value FROM json_each(?))`, [JSON.stringify([...ids])]);
+    for (const row of result.rows) {
+      known.set(`${schema.name}:${String(row.id)}`, row.deleted_at === null || row.deleted_at === undefined ? 'live' : 'softDeleted');
+    }
+  }
+  for (const operation of operations) {
+    const schema = context.schemaFor(operation.collection);
+    const resolver = {
+      schema,
+      now: context.now(),
+      async state(id) {
+        const key = `${schema.name}:${id}`;
+        return overlay.get(key) ?? known.get(key) ?? 'absent';
+      },
+      stage(id, state) {
+        overlay.set(`${schema.name}:${id}`, state);
+      }
+    };
+    const resolved = await resolveOperation(resolver, operation);
+    commands.push(resolved.command);
+    outcomes.push(resolved.outcome);
+  }
+  await context.connection.executeBatch(commands);
+  return {
+    applied: outcomes.length,
+    outcomes
+  };
+}
+//# sourceMappingURL=batch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_errors2","_budgets","_declare","_statements","quoted","schema","collectionTable","name","conflict","id","raise","DiagnosticCodes","RECORD_CONFLICT","message","detail","collection","recordId","missing","RECORD_NOT_FOUND","resolveInsert","resolver","operation","now","payload","assertRecordWithinBudget","record","data","state","stage","command","insertStatement","outcome","resolveUpdate","updateStatement","restore","resolveUpsert","present","resolveDelete","resolveSoftDelete","hasSoftDelete","CONFIG_INVALID","resolveOperation","type","runBatch","context","operations","assertBatchWithinBudget","length","commands","outcomes","overlay","Map","known","idsByCollection","ids","get","Set","add","set","schemaFor","result","connection","execute","JSON","stringify","row","rows","String","deleted_at","undefined","key","resolved","push","executeBatch","applied"],"sourceRoot":"../../../src","sources":["sqlite/batch.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/sqlite/catalog.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearScope = clearScope;
+exports.ensureCatalog = ensureCatalog;
+exports.listEntries = listEntries;
+exports.markDeleting = markDeleting;
+exports.readEntry = readEntry;
+exports.registerScope = registerScope;
+var _values = require("./values.js");
+/**
+ * The catalog: one registry per logical database, listing the scopes that
+ * exist.
+ *
+ * This is the only structure that spans scopes, so it is deliberately the
+ * smallest thing that answers the questions the package must answer without
+ * opening every scope file. It holds a digest, timestamps, and two posture
+ * flags — **no raw scope components** (FR-014), so a device with full disk
+ * access cannot mine it for identities or tenant names even though the
+ * catalog itself is never encrypted.
+ *
+ * The `deleting` flag is the load-bearing part. It is written before a scope
+ * deletion begins and cleared last, so a crash at any point leaves the
+ * interruption visible on the next open. Clearing it first would make an
+ * interrupted deletion look complete — the exact failure FR-063 exists to
+ * prevent.
+ */
+
+const CREATE_SCOPES = `CREATE TABLE IF NOT EXISTS scopes (
+  scope_key      TEXT PRIMARY KEY,
+  created_at     INTEGER NOT NULL,
+  deletion_state TEXT NOT NULL,
+  backup_posture TEXT NOT NULL,
+  encrypted      INTEGER NOT NULL
+)`;
+async function ensureCatalog(connection) {
+  await connection.execute(CREATE_SCOPES);
+}
+async function readEntry(connection, scopeKey) {
+  const result = await connection.execute('SELECT scope_key, created_at, deletion_state, backup_posture, encrypted FROM scopes WHERE scope_key = ?', [scopeKey]);
+  const row = result.rows[0];
+  if (!row) {
+    return null;
+  }
+  return {
+    scopeKey: (0, _values.text)(row.scope_key),
+    createdAt: (0, _values.num)(row.created_at),
+    deletionState: (0, _values.text)(row.deletion_state),
+    backupPosture: (0, _values.text)(row.backup_posture),
+    encrypted: (0, _values.num)(row.encrypted) === 1
+  };
+}
+async function listEntries(connection) {
+  const result = await connection.execute('SELECT scope_key, created_at, deletion_state, backup_posture, encrypted FROM scopes');
+  return result.rows.map(row => ({
+    scopeKey: (0, _values.text)(row.scope_key),
+    createdAt: (0, _values.num)(row.created_at),
+    deletionState: (0, _values.text)(row.deletion_state),
+    backupPosture: (0, _values.text)(row.backup_posture),
+    encrypted: (0, _values.num)(row.encrypted) === 1
+  }));
+}
+async function registerScope(connection, entry) {
+  await connection.execute(`INSERT INTO scopes (scope_key, created_at, deletion_state, backup_posture, encrypted)
+		 VALUES (?, ?, ?, ?, ?)
+		 ON CONFLICT(scope_key) DO UPDATE SET
+		   deletion_state = excluded.deletion_state,
+		   backup_posture = excluded.backup_posture,
+		   encrypted = excluded.encrypted`, [entry.scopeKey, entry.createdAt, entry.deletionState, entry.backupPosture, entry.encrypted ? 1 : 0]);
+}
+async function markDeleting(connection, scopeKey) {
+  await connection.execute('UPDATE scopes SET deletion_state = ? WHERE scope_key = ?', ['deleting', scopeKey]);
+}
+
+/** Cleared last, on purpose. See the note at the top of this file. */
+async function clearScope(connection, scopeKey) {
+  await connection.execute('DELETE FROM scopes WHERE scope_key = ?', [scopeKey]);
+}
+//# sourceMappingURL=catalog.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_values","require","CREATE_SCOPES","ensureCatalog","connection","execute","readEntry","scopeKey","result","row","rows","text","scope_key","createdAt","num","created_at","deletionState","deletion_state","backupPosture","backup_posture","encrypted","listEntries","map","registerScope","entry","markDeleting","clearScope"],"sourceRoot":"../../../src","sources":["sqlite/catalog.ts"],"mappings":";;;;;;;;;;;AAoBA,IAAAA,OAAA,GAAAC,OAAA;AApBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAcA,MAAMC,aAAa,GAAG;AACtB;AACA;AACA;AACA;AACA;AACA,EAAE;AAEK,eAAeC,aAAaA,CAACC,UAAsB,EAAiB;EAC1E,MAAMA,UAAU,CAACC,OAAO,CAACH,aAAa,CAAC;AACxC;AAEO,eAAeI,SAASA,CAC9BF,UAAsB,EACtBG,QAAgB,EACe;EAC/B,MAAMC,MAAM,GAAG,MAAMJ,UAAU,CAACC,OAAO,CACtC,yGAAyG,EACzG,CAACE,QAAQ,CACV,CAAC;EACD,MAAME,GAAG,GAAGD,MAAM,CAACE,IAAI,CAAC,CAAC,CAAC;EAC1B,IAAI,CAACD,GAAG,EAAE;IACT,OAAO,IAAI;EACZ;EACA,OAAO;IACNF,QAAQ,EAAE,IAAAI,YAAI,EAACF,GAAG,CAACG,SAAS,CAAC;IAC7BC,SAAS,EAAE,IAAAC,WAAG,EAACL,GAAG,CAACM,UAAU,CAAC;IAC9BC,aAAa,EAAE,IAAAL,YAAI,EAACF,GAAG,CAACQ,cAAc,CAAuB;IAC7DC,aAAa,EAAE,IAAAP,YAAI,EAACF,GAAG,CAACU,cAAc,CAA4B;IAClEC,SAAS,EAAE,IAAAN,WAAG,EAACL,GAAG,CAACW,SAAS,CAAC,KAAK;EACnC,CAAC;AACF;AAEO,eAAeC,WAAWA,CAACjB,UAAsB,EAA2B;EAClF,MAAMI,MAAM,GAAG,MAAMJ,UAAU,CAACC,OAAO,CACtC,qFACD,CAAC;EACD,OAAOG,MAAM,CAACE,IAAI,CAACY,GAAG,CAACb,GAAG,KAAK;IAC9BF,QAAQ,EAAE,IAAAI,YAAI,EAACF,GAAG,CAACG,SAAS,CAAC;IAC7BC,SAAS,EAAE,IAAAC,WAAG,EAACL,GAAG,CAACM,UAAU,CAAC;IAC9BC,aAAa,EAAE,IAAAL,YAAI,EAACF,GAAG,CAACQ,cAAc,CAAuB;IAC7DC,aAAa,EAAE,IAAAP,YAAI,EAACF,GAAG,CAACU,cAAc,CAA4B;IAClEC,SAAS,EAAE,IAAAN,WAAG,EAACL,GAAG,CAACW,SAAS,CAAC,KAAK;EACnC,CAAC,CAAC,CAAC;AACJ;AAEO,eAAeG,aAAaA,CAACnB,UAAsB,EAAEoB,KAAmB,EAAiB;EAC/F,MAAMpB,UAAU,CAACC,OAAO,CACvB;AACF;AACA;AACA;AACA;AACA,oCAAoC,EAClC,CACCmB,KAAK,CAACjB,QAAQ,EACdiB,KAAK,CAACX,SAAS,EACfW,KAAK,CAACR,aAAa,EACnBQ,KAAK,CAACN,aAAa,EACnBM,KAAK,CAACJ,SAAS,GAAG,CAAC,GAAG,CAAC,CAEzB,CAAC;AACF;AAEO,eAAeK,YAAYA,CAACrB,UAAsB,EAAEG,QAAgB,EAAiB;EAC3F,MAAMH,UAAU,CAACC,OAAO,CAAC,0DAA0D,EAAE,CACpF,UAAU,EACVE,QAAQ,CACR,CAAC;AACH;;AAEA;AACO,eAAemB,UAAUA,CAACtB,UAAsB,EAAEG,QAAgB,EAAiB;EACzF,MAAMH,UAAU,CAACC,OAAO,CAAC,wCAAwC,EAAE,CAACE,QAAQ,CAAC,CAAC;AAC/E","ignoreList":[]}

package/lib/commonjs/sqlite/connection.js

@@ -0,0 +1,210 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertReadable = assertReadable;
+exports.openConnection = openConnection;
+var _errors = require("../contract/errors.js");
+var _errors2 = require("../diagnostics/errors.js");
+var _mapNative = require("../diagnostics/map-native.js");
+var _fs = require("../platform/fs.js");
+var _transactionQueue = require("./transaction-queue.js");
+var _native = require("./native.js");
+/**
+ * One connection per database file.
+ *
+ * Two things about this file carry design weight:
+ *
+ * **Scope isolation is the file boundary.** A connection is opened against
+ * one scope's `data.db`, whose directory is named by the scope digest and
+ * never by the components (FR-014). No SQL this package could generate — and
+ * none a future bug could generate — reaches another scope's rows, because
+ * they are in a file this connection never opened (research.md R2).
+ *
+ * **A transaction owns the connection while it runs, and only its own
+ * executor reaches it.** Every operation queues on the connection, and a
+ * transaction holds the queue until it settles. Work issued through the
+ * connection meanwhile — a background sync, a second screen — waits and then
+ * runs on its own, rather than joining the transaction and vanishing with its
+ * rollback. Until 0.2.0 `execute` routed into whatever transaction was in
+ * flight, which is how an unrelated write was lost. Work meant to be part of
+ * the transaction goes through the executor the transaction hands out
+ * (`tx.collection`, `tx.attachments`).
+ */
+
+/**
+ * The executor a transaction body runs against, plus the one control it
+ * needs. `rollback` is handed to the body rather than returned from
+ * `transaction`, so an explicit abort cannot outlive the transaction it
+ * belongs to.
+ */
+
+function splitPath(path) {
+  const index = path.lastIndexOf('/');
+  return index === -1 ? {
+    location: '',
+    name: path
+  } : {
+    location: path.slice(0, index),
+    name: path.slice(index + 1)
+  };
+}
+async function openConnection(options) {
+  const {
+    location,
+    name
+  } = splitPath(options.path);
+  const encrypted = options.encryptionKey !== undefined;
+  try {
+    await (0, _fs.fileSystem)().mkdir(location);
+  } catch (error) {
+    (0, _mapNative.raiseNative)(error, {
+      operation: 'open'
+    });
+  }
+  let database;
+  try {
+    database = (0, _native.engine)().open({
+      name,
+      location,
+      // Passing the key only when encryption is on keeps an unencrypted
+      // database from being opened as an encrypted one with an empty key,
+      // which SQLCipher accepts and which would produce a file neither
+      // posture can reopen.
+      ...(encrypted ? {
+        encryptionKey: options.encryptionKey
+      } : {})
+    });
+  } catch (error) {
+    (0, _mapNative.raiseNative)(error, {
+      operation: 'open',
+      encrypted
+    });
+  }
+  let closed = false;
+  let active = null;
+  const queue = (0, _transactionQueue.createTransactionQueue)();
+  const assertOpen = () => {
+    if (closed) {
+      (0, _errors2.raise)(_errors.DiagnosticCodes.CLOSED_HANDLE, {
+        message: 'connection is closed'
+      });
+    }
+  };
+  const classify = sql => /^\s*select|^\s*pragma|^\s*explain/i.test(sql) ? 'read' : 'write';
+  const connection = {
+    path: options.path,
+    encrypted,
+    execute(sql, params = []) {
+      assertOpen();
+      // Never into an in-flight transaction: queued behind it instead. See
+      // the note at the top of this file.
+      return queue.run(async () => {
+        try {
+          return await database.execute(sql, params);
+        } catch (error) {
+          (0, _mapNative.raiseNative)(error, {
+            operation: classify(sql),
+            encrypted
+          });
+        }
+      });
+    },
+    async transaction(fn) {
+      assertOpen();
+      if (active) {
+        // Nested transactions would need savepoints and would let a
+        // partial rollback look like a full one. Refused rather than
+        // queued: a body that opened a second transaction would otherwise
+        // wait on itself forever.
+        (0, _errors2.raise)(_errors.DiagnosticCodes.TRANSACTION_STATE, {
+          message: 'a transaction is already in flight on this connection'
+        });
+      }
+      return queue.runTransaction(async () => {
+        try {
+          return await database.transaction(async tx => {
+            active = tx;
+            let settled = false;
+            try {
+              return await fn({
+                execute: (sql, params = []) => {
+                  if (settled) {
+                    // After an explicit rollback the body is still running
+                    // inside the engine's callback. Its remaining statements
+                    // are refused, not run in autocommit (LDB-V1).
+                    (0, _errors2.raise)(_errors.DiagnosticCodes.TRANSACTION_STATE, {
+                      message: 'transaction already rolled back'
+                    });
+                  }
+                  return tx.execute(sql, params);
+                },
+                rollback: async () => {
+                  await tx.rollback();
+                  settled = true;
+                }
+              });
+            } finally {
+              active = null;
+            }
+          });
+        } catch (error) {
+          (0, _mapNative.raiseNative)(error, {
+            operation: 'transaction',
+            encrypted
+          });
+        }
+      });
+    },
+    executeBatch(commands) {
+      assertOpen();
+      return queue.run(async () => {
+        try {
+          await database.executeBatch(commands);
+        } catch (error) {
+          (0, _mapNative.raiseNative)(error, {
+            operation: 'write',
+            encrypted
+          });
+        }
+      });
+    },
+    async close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      try {
+        await database.close();
+      } catch {
+        // A close that fails leaves nothing for a caller to do, and
+        // reporting it would turn an orderly sign-out into an error.
+      }
+    }
+  };
+
+  // Write-ahead logging so a reader is not blocked by the writer — FR-045's
+  // "reads proceed while a write is in flight" is this pragma plus op-sqlite's
+  // single-writer serialization, not a lock this package maintains.
+  await connection.execute('PRAGMA journal_mode = WAL');
+  await connection.execute('PRAGMA foreign_keys = ON');
+  // Durability over speed: a half-written record after a crash is exactly
+  // what FR-039 promises never happens.
+  await connection.execute('PRAGMA synchronous = FULL');
+  return connection;
+}
+
+/**
+ * Confirm a freshly opened database is readable.
+ *
+ * Deliberately not `PRAGMA integrity_check`: that walks the whole file and
+ * would put open time far past the 150-millisecond budget on a large scope.
+ * One trivial read is enough to surface the failures that matter at open —
+ * a wrong key, a truncated file, a malformed header — because all three fail
+ * it, and the error mapping keeps them distinguishable (FR-076, FR-078).
+ */
+async function assertReadable(connection) {
+  await connection.execute('SELECT count(*) AS n FROM sqlite_master');
+}
+//# sourceMappingURL=connection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_errors2","_mapNative","_fs","_transactionQueue","_native","splitPath","path","index","lastIndexOf","location","name","slice","openConnection","options","encrypted","encryptionKey","undefined","fileSystem","mkdir","error","raiseNative","operation","database","engine","open","closed","active","queue","createTransactionQueue","assertOpen","raise","DiagnosticCodes","CLOSED_HANDLE","message","classify","sql","test","connection","execute","params","run","transaction","fn","TRANSACTION_STATE","runTransaction","tx","settled","rollback","executeBatch","commands","close","assertReadable"],"sourceRoot":"../../../src","sources":["sqlite/connection.ts"],"mappings":";;;;;;;AAsBA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AACA,IAAAE,UAAA,GAAAF,OAAA;AACA,IAAAG,GAAA,GAAAH,OAAA;AACA,IAAAI,iBAAA,GAAAJ,OAAA;AACA,IAAAK,OAAA,GAAAL,OAAA;AA3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAmBA;AACA;AACA;AACA;AACA;AACA;;AAmBA,SAASM,SAASA,CAACC,IAAY,EAAsC;EACpE,MAAMC,KAAK,GAAGD,IAAI,CAACE,WAAW,CAAC,GAAG,CAAC;EACnC,OAAOD,KAAK,KAAK,CAAC,CAAC,GAChB;IAAEE,QAAQ,EAAE,EAAE;IAAEC,IAAI,EAAEJ;EAAK,CAAC,GAC5B;IAAEG,QAAQ,EAAEH,IAAI,CAACK,KAAK,CAAC,CAAC,EAAEJ,KAAK,CAAC;IAAEG,IAAI,EAAEJ,IAAI,CAACK,KAAK,CAACJ,KAAK,GAAG,CAAC;EAAE,CAAC;AACnE;AAEO,eAAeK,cAAcA,CAACC,OAA8B,EAAuB;EACzF,MAAM;IAAEJ,QAAQ;IAAEC;EAAK,CAAC,GAAGL,SAAS,CAACQ,OAAO,CAACP,IAAI,CAAC;EAClD,MAAMQ,SAAS,GAAGD,OAAO,CAACE,aAAa,KAAKC,SAAS;EAErD,IAAI;IACH,MAAM,IAAAC,cAAU,EAAC,CAAC,CAACC,KAAK,CAACT,QAAQ,CAAC;EACnC,CAAC,CAAC,OAAOU,KAAK,EAAE;IACf,IAAAC,sBAAW,EAACD,KAAK,EAAE;MAAEE,SAAS,EAAE;IAAO,CAAC,CAAC;EAC1C;EAEA,IAAIC,QAAwB;EAC5B,IAAI;IACHA,QAAQ,GAAG,IAAAC,cAAM,EAAC,CAAC,CAACC,IAAI,CAAC;MACxBd,IAAI;MACJD,QAAQ;MACR;MACA;MACA;MACA;MACA,IAAIK,SAAS,GAAG;QAAEC,aAAa,EAAEF,OAAO,CAACE;MAAc,CAAC,GAAG,CAAC,CAAC;IAC9D,CAAC,CAAC;EACH,CAAC,CAAC,OAAOI,KAAK,EAAE;IACf,IAAAC,sBAAW,EAACD,KAAK,EAAE;MAAEE,SAAS,EAAE,MAAM;MAAEP;IAAU,CAAC,CAAC;EACrD;EAEA,IAAIW,MAAM,GAAG,KAAK;EAClB,IAAIC,MAAgC,GAAG,IAAI;EAC3C,MAAMC,KAAK,GAAG,IAAAC,wCAAsB,EAAC,CAAC;EAEtC,MAAMC,UAAU,GAAGA,CAAA,KAAY;IAC9B,IAAIJ,MAAM,EAAE;MACX,IAAAK,cAAK,EAACC,uBAAe,CAACC,aAAa,EAAE;QAAEC,OAAO,EAAE;MAAuB,CAAC,CAAC;IAC1E;EACD,CAAC;EAED,MAAMC,QAAQ,GAAIC,GAAW,IAC5B,oCAAoC,CAACC,IAAI,CAACD,GAAG,CAAC,GAAG,MAAM,GAAG,OAAO;EAElE,MAAME,UAAsB,GAAG;IAC9B/B,IAAI,EAAEO,OAAO,CAACP,IAAI;IAClBQ,SAAS;IAETwB,OAAOA,CAACH,GAAG,EAAEI,MAAM,GAAG,EAAE,EAAE;MACzBV,UAAU,CAAC,CAAC;MACZ;MACA;MACA,OAAOF,KAAK,CAACa,GAAG,CAAC,YAAY;QAC5B,IAAI;UACH,OAAO,MAAMlB,QAAQ,CAACgB,OAAO,CAACH,GAAG,EAAEI,MAAM,CAAC;QAC3C,CAAC,CAAC,OAAOpB,KAAK,EAAE;UACf,IAAAC,sBAAW,EAACD,KAAK,EAAE;YAAEE,SAAS,EAAEa,QAAQ,CAACC,GAAG,CAAC;YAAErB;UAAU,CAAC,CAAC;QAC5D;MACD,CAAC,CAAC;IACH,CAAC;IAED,MAAM2B,WAAWA,CAACC,EAAE,EAAE;MACrBb,UAAU,CAAC,CAAC;MACZ,IAAIH,MAAM,EAAE;QACX;QACA;QACA;QACA;QACA,IAAAI,cAAK,EAACC,uBAAe,CAACY,iBAAiB,EAAE;UACxCV,OAAO,EAAE;QACV,CAAC,CAAC;MACH;MACA,OAAON,KAAK,CAACiB,cAAc,CAAC,YAAY;QACvC,IAAI;UACH,OAAO,MAAMtB,QAAQ,CAACmB,WAAW,CAAC,MAAMI,EAAE,IAAI;YAC7CnB,MAAM,GAAGmB,EAAE;YACX,IAAIC,OAAO,GAAG,KAAK;YACnB,IAAI;cACH,OAAO,MAAMJ,EAAE,CAAC;gBACfJ,OAAO,EAAEA,CAACH,GAAG,EAAEI,MAAM,GAAG,EAAE,KAAK;kBAC9B,IAAIO,OAAO,EAAE;oBACZ;oBACA;oBACA;oBACA,IAAAhB,cAAK,EAACC,uBAAe,CAACY,iBAAiB,EAAE;sBACxCV,OAAO,EAAE;oBACV,CAAC,CAAC;kBACH;kBACA,OAAOY,EAAE,CAACP,OAAO,CAACH,GAAG,EAAEI,MAAM,CAAC;gBAC/B,CAAC;gBACDQ,QAAQ,EAAE,MAAAA,CAAA,KAAY;kBACrB,MAAMF,EAAE,CAACE,QAAQ,CAAC,CAAC;kBACnBD,OAAO,GAAG,IAAI;gBACf;cACD,CAAC,CAAC;YACH,CAAC,SAAS;cACTpB,MAAM,GAAG,IAAI;YACd;UACD,CAAC,CAAC;QACH,CAAC,CAAC,OAAOP,KAAK,EAAE;UACf,IAAAC,sBAAW,EAACD,KAAK,EAAE;YAAEE,SAAS,EAAE,aAAa;YAAEP;UAAU,CAAC,CAAC;QAC5D;MACD,CAAC,CAAC;IACH,CAAC;IAEDkC,YAAYA,CAACC,QAAQ,EAAE;MACtBpB,UAAU,CAAC,CAAC;MACZ,OAAOF,KAAK,CAACa,GAAG,CAAC,YAAY;QAC5B,IAAI;UACH,MAAMlB,QAAQ,CAAC0B,YAAY,CAACC,QAAQ,CAAC;QACtC,CAAC,CAAC,OAAO9B,KAAK,EAAE;UACf,IAAAC,sBAAW,EAACD,KAAK,EAAE;YAAEE,SAAS,EAAE,OAAO;YAAEP;UAAU,CAAC,CAAC;QACtD;MACD,CAAC,CAAC;IACH,CAAC;IAED,MAAMoC,KAAKA,CAAA,EAAG;MACb,IAAIzB,MAAM,EAAE;QACX;MACD;MACAA,MAAM,GAAG,IAAI;MACb,IAAI;QACH,MAAMH,QAAQ,CAAC4B,KAAK,CAAC,CAAC;MACvB,CAAC,CAAC,MAAM;QACP;QACA;MAAA;IAEF;EACD,CAAC;;EAED;EACA;EACA;EACA,MAAMb,UAAU,CAACC,OAAO,CAAC,2BAA2B,CAAC;EACrD,MAAMD,UAAU,CAACC,OAAO,CAAC,0BAA0B,CAAC;EACpD;EACA;EACA,MAAMD,UAAU,CAACC,OAAO,CAAC,2BAA2B,CAAC;EAErD,OAAOD,UAAU;AAClB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAec,cAAcA,CAACd,UAAsB,EAAiB;EAC3E,MAAMA,UAAU,CAACC,OAAO,CAAC,yCAAyC,CAAC;AACpE","ignoreList":[]}