@chipmobilesdk/rn-local-db 0.3.0 → 0.5.0

package/lib/commonjs/adapter/handle.js

@@ -0,0 +1,259 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildHandle = buildHandle;
+exports.schemaFor = schemaFor;
+var _errors = require("../contract/errors.js");
+var _availability = require("../artifacts/availability.js");
+var _cascade = require("../artifacts/cascade.js");
+var _reconcile = require("../artifacts/reconcile.js");
+var _store = require("../artifacts/store.js");
+var _derive = require("../crypto/derive.js");
+var _errors2 = require("../diagnostics/errors.js");
+var _devLog = require("../diagnostics/dev-log.js");
+var _faults = require("../diagnostics/faults.js");
+var _sort = require("../query/sort.js");
+var _batch = require("../sqlite/batch.js");
+var _indexCoverage = require("../sqlite/index-coverage.js");
+var _transactions = require("../sqlite/transactions.js");
+var _budgets = require("./budgets.js");
+var _collection = require("./collection.js");
+var _deletion = require("./deletion.js");
+var _transaction = require("./transaction.js");
+/**
+ * The handle an open returns: collections, transactions, batches and
+ * attachments over one connection, bound to one scope.
+ *
+ * Scope is bound here and nowhere else. The handle carries its scope key and
+ * no operation on it accepts a scope argument, so there is no `switchScope`
+ * to misuse and no read that could address another scope (FR-008a, FR-015).
+ */
+
+function schemaFor(schemas, name) {
+  const schema = schemas.get(name);
+  if (!schema) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.CONFIG_INVALID, {
+      message: 'collection is not declared',
+      detail: {
+        collection: name
+      }
+    });
+  }
+  return schema;
+}
+function buildHandle(context) {
+  const {
+    config,
+    connection,
+    layout,
+    scope,
+    schemas
+  } = context;
+  let closed = false;
+  // Set when a deletion took the connection away rather than the app closing it.
+  let revoked = false;
+  const releaseNative = async () => {
+    // The key goes first: a close that fails at the filesystem must not
+    // leave key material alive in a handle nobody can use (FR-098).
+    context.key?.release();
+    await connection.close();
+    (0, _budgets.releaseHandleSlot)();
+  };
+  const unregister = (0, _deletion.registerOpenHandle)(config.name, scope.key, async () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    revoked = true;
+    await releaseNative();
+  });
+  const assertUsable = () => {
+    if (closed && !revoked) {
+      (0, _errors2.raise)(_errors.DiagnosticCodes.CLOSED_HANDLE, {
+        message: 'handle is closed'
+      });
+    }
+    if (revoked || (0, _deletion.isScopeInvalidated)(config.name, scope.key)) {
+      // The deletion did not wait for this handle, and this handle does
+      // not get to keep answering from data that is gone (FR-059a).
+      (0, _errors2.raise)(_errors.DiagnosticCodes.SCOPE_DELETED, {
+        message: 'scope was deleted beneath this handle',
+        detail: {
+          scopeKey: scope.key
+        }
+      });
+    }
+  };
+
+  // Everything below is built against an explicit executor: the connection for
+  // the handle, the transaction's own executor inside `transaction`. Nothing
+  // infers which one from the connection's state, which is how a write from
+  // outside used to be swallowed by an in-flight transaction (LDB-01).
+  const artifactsOn = executor => ({
+    executor: () => executor,
+    layout,
+    scopeKey: scope.key,
+    artifactKey: attachmentId => context.key ? (0, _derive.deriveArtifactKey)(context.key.value(), scope.key, attachmentId) : null,
+    now: context.now
+  });
+  const rawCollection = (name, executor) => {
+    assertUsable();
+    return (0, _devLog.instrument)(name, 'sqlite', (0, _collection.createSqlCollection)({
+      executor: () => executor,
+      schema: schemaFor(schemas, name),
+      now: context.now,
+      assertUsable
+    }));
+  };
+
+  /**
+   * Record deletion optionally takes its artifacts with it (FR-070).
+   *
+   * Off unless the app asks: a package that deleted a user's files as a side
+   * effect of a record delete would be making a decision that is not its to
+   * make. The outcome carries what was removed and what could not be.
+   */
+  const collectionOn = (name, executor, deferred) => {
+    const ops = rawCollection(name, executor);
+    if (config.cascadeAttachments !== true) {
+      return ops;
+    }
+    return {
+      ...ops,
+      async delete(id) {
+        const outcome = await ops.delete(id);
+        const cascade = await (0, _cascade.cascadeForOwner)(artifactsOn(executor), executor, {
+          collection: name,
+          id
+        }, deferred);
+        return {
+          ...outcome,
+          cascade
+        };
+      }
+    };
+  };
+  const attachmentsOn = (executor, deferred) => {
+    const artifacts = artifactsOn(executor);
+    return {
+      write(input) {
+        assertUsable();
+        return (0, _store.writeArtifact)(artifacts, input);
+      },
+      read(id, range) {
+        assertUsable();
+        return (0, _store.readArtifact)(artifacts, id, range);
+      },
+      availability(id) {
+        assertUsable();
+        return (0, _availability.artifactAvailability)(artifacts, executor, id);
+      },
+      remove(id) {
+        assertUsable();
+        return (0, _store.removeArtifact)(artifacts, id, deferred);
+      },
+      listFor(owner) {
+        assertUsable();
+        return (0, _store.listReferencesFor)(executor, owner);
+      },
+      reconcile(options) {
+        assertUsable();
+        return (0, _reconcile.reconcileArtifacts)(artifacts, executor, options);
+      }
+    };
+  };
+  const collectionFor = name => collectionOn(name, connection);
+  const attachments = attachmentsOn(connection);
+  const handle = {
+    scopeKey: scope.key,
+    schemaVersion: context.schemaVersion,
+    backupPosture: context.posture,
+    isEncrypted: context.key !== null,
+    collection: collectionFor,
+    async transaction(fn) {
+      assertUsable();
+      const pendingUnlinks = [];
+      const deferred = {
+        add: path => pendingUnlinks.push(path)
+      };
+      let aborted = false;
+      const result = await (0, _transactions.runInTransaction)(connection, async tx => {
+        const managed = (0, _transaction.createTransaction)({
+          collection: name => collectionOn(name, tx, deferred),
+          attachments: () => attachmentsOn(tx, deferred),
+          rollback: async () => {
+            aborted = true;
+            await tx.rollback();
+          }
+        });
+        const value = await fn(managed.transaction);
+        if (!managed.isSettled()) {
+          (0, _faults.throwIfFaulted)('commit');
+        }
+        managed.settle();
+        return value;
+      });
+      // Committed (a thrown body never gets here). Only now are files whose
+      // references the transaction deleted safe to remove; one that cannot be
+      // removed stays on disk as an orphan reconciliation reports.
+      if (!aborted) {
+        for (const path of pendingUnlinks) {
+          await (0, _cascade.unlinkArtifact)(path);
+        }
+      }
+      return result;
+    },
+    async batch(operations) {
+      assertUsable();
+      const outcome = await (0, _batch.runBatch)({
+        connection,
+        schemaFor: name => schemaFor(schemas, name),
+        now: context.now
+      }, operations);
+      if (config.cascadeAttachments !== true) {
+        return outcome;
+      }
+      // The batch has committed, so its hard deletes cascade exactly as a
+      // collection delete does. Skipping them left every attachment of a
+      // batch-deleted record behind as an orphan.
+      const artifacts = artifactsOn(connection);
+      const outcomes = [];
+      for (const [index, operation] of operations.entries()) {
+        const written = outcome.outcomes[index];
+        if (operation.type !== 'delete') {
+          outcomes.push(written);
+          continue;
+        }
+        const cascade = await (0, _cascade.cascadeForOwner)(artifacts, connection, {
+          collection: operation.collection,
+          id: operation.id
+        });
+        outcomes.push({
+          ...written,
+          cascade
+        });
+      }
+      return {
+        ...outcome,
+        outcomes
+      };
+    },
+    attachments: () => attachments,
+    explain(collection, query) {
+      assertUsable();
+      return (0, _indexCoverage.explainQuery)(connection, schemaFor(schemas, collection), query, (0, _sort.withStableTiebreaker)(query?.sort));
+    },
+    async close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      unregister();
+      await releaseNative();
+    }
+  };
+  return handle;
+}
+//# sourceMappingURL=handle.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_availability","_cascade","_reconcile","_store","_derive","_errors2","_devLog","_faults","_sort","_batch","_indexCoverage","_transactions","_budgets","_collection","_deletion","_transaction","schemaFor","schemas","name","schema","get","raise","DiagnosticCodes","CONFIG_INVALID","message","detail","collection","buildHandle","context","config","connection","layout","scope","closed","revoked","releaseNative","key","release","close","releaseHandleSlot","unregister","registerOpenHandle","assertUsable","CLOSED_HANDLE","isScopeInvalidated","SCOPE_DELETED","scopeKey","artifactsOn","executor","artifactKey","attachmentId","deriveArtifactKey","value","now","rawCollection","instrument","createSqlCollection","collectionOn","deferred","ops","cascadeAttachments","delete","id","outcome","cascade","cascadeForOwner","attachmentsOn","artifacts","write","input","writeArtifact","read","range","readArtifact","availability","artifactAvailability","remove","removeArtifact","listFor","owner","listReferencesFor","reconcile","options","reconcileArtifacts","collectionFor","attachments","handle","schemaVersion","backupPosture","posture","isEncrypted","transaction","fn","pendingUnlinks","add","path","push","aborted","result","runInTransaction","tx","managed","createTransaction","rollback","isSettled","throwIfFaulted","settle","unlinkArtifact","batch","operations","runBatch","outcomes","index","operation","entries","written","type","explain","query","explainQuery","withStableTiebreaker","sort"],"sourceRoot":"../../../src","sources":["adapter/handle.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/adapter/index.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deleteDatabase = deleteDatabase;
+exports.deleteScopeData = deleteScopeData;
+exports.openDatabase = openDatabase;
+exports.resetScope = resetScope;
+exports.setStorageAdapter = setStorageAdapter;
+/**
+ * The public lifecycle functions.
+ *
+ * Scope deletion and reset are module-level rather than handle methods: they
+ * must work whether or not a handle is open on the target (FR-059), and
+ * `resetScope` in particular must never be reachable as a fallback from
+ * `openDatabase` (FR-057a).
+ *
+ * The active adapter is resolved lazily so a consuming app that only ever
+ * uses the in-memory adapter in tests never loads the native peers.
+ */
+
+let override = null;
+let cached = null;
+
+/**
+ * Swap the adapter. Intended for tests and for the demo app's in-memory
+ * mode; production code never calls this.
+ */
+function setStorageAdapter(adapter) {
+  override = adapter;
+}
+function activeAdapter() {
+  if (override) {
+    return override;
+  }
+  if (!cached) {
+    // Lazy require, matching how rn-auth and rn-camera reach their native
+    // peers: importing at module scope would pull op-sqlite into every
+    // consumer, including ones that only run the in-memory adapter.
+    const {
+      createSqliteAdapter
+    } = require('../sqlite/adapter');
+    cached = createSqliteAdapter();
+  }
+  return cached;
+}
+function openDatabase(config) {
+  return activeAdapter().open(config);
+}
+function deleteScopeData(config) {
+  return activeAdapter().deleteScopeData(config);
+}
+function deleteDatabase(config) {
+  return activeAdapter().deleteDatabase(config);
+}
+
+/**
+ * Destructive. Discards one scope's data and leaves it ready for a clean
+ * first-run migration. Named apart from `deleteScopeData` deliberately: one
+ * is a lifecycle operation, the other is an admission that a database is
+ * broken.
+ */
+function resetScope(config) {
+  return activeAdapter().resetScope(config);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["override","cached","setStorageAdapter","adapter","activeAdapter","createSqliteAdapter","require","openDatabase","config","open","deleteScopeData","deleteDatabase","resetScope"],"sourceRoot":"../../../src","sources":["adapter/index.ts"],"mappings":";;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMA,IAAIA,QAA+B,GAAG,IAAI;AAC1C,IAAIC,MAA6B,GAAG,IAAI;;AAExC;AACA;AACA;AACA;AACO,SAASC,iBAAiBA,CAACC,OAA8B,EAAQ;EACvEH,QAAQ,GAAGG,OAAO;AACnB;AAEA,SAASC,aAAaA,CAAA,EAAmB;EACxC,IAAIJ,QAAQ,EAAE;IACb,OAAOA,QAAQ;EAChB;EACA,IAAI,CAACC,MAAM,EAAE;IACZ;IACA;IACA;IACA,MAAM;MAAEI;IAAoB,CAAC,GAAGC,OAAO,CAAC,mBAAmB,CAE1D;IACDL,MAAM,GAAGI,mBAAmB,CAAC,CAAC;EAC/B;EACA,OAAOJ,MAAM;AACd;AAEO,SAASM,YAAYA,CAACC,MAAsB,EAA2B;EAC7E,OAAOJ,aAAa,CAAC,CAAC,CAACK,IAAI,CAACD,MAAM,CAAC;AACpC;AAEO,SAASE,eAAeA,CAACF,MAAyB,EAA4B;EACpF,OAAOJ,aAAa,CAAC,CAAC,CAACM,eAAe,CAACF,MAAM,CAAC;AAC/C;AAEO,SAASG,cAAcA,CAACH,MAA4B,EAA4B;EACtF,OAAOJ,aAAa,CAAC,CAAC,CAACO,cAAc,CAACH,MAAM,CAAC;AAC9C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASI,UAAUA,CAACJ,MAAyB,EAA4B;EAC/E,OAAOJ,aAAa,CAAC,CAAC,CAACQ,UAAU,CAACJ,MAAM,CAAC;AAC1C","ignoreList":[]}

package/lib/commonjs/adapter/lifecycle.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.openSqliteDatabase = openSqliteDatabase;
+var _errors = require("../contract/errors.js");
+var _keyProvider = require("../crypto/key-provider.js");
+var _provider = require("../crypto/provider.js");
+var _errors2 = require("../diagnostics/errors.js");
+var _faults = require("../diagnostics/faults.js");
+var _executor = require("../migration/executor.js");
+var _backupAndroidVerify = require("../platform/backup-android-verify.js");
+var _backupIos = require("../platform/backup-ios.js");
+var _location = require("../platform/location.js");
+var _declare = require("../schema/declare.js");
+var _validateConfig = require("../schema/validate-config.js");
+var _validate = require("../scope/validate.js");
+var _catalog = require("../sqlite/catalog.js");
+var _connection = require("../sqlite/connection.js");
+var _native = require("../sqlite/native.js");
+var _budgets = require("./budgets.js");
+var _deletion = require("./deletion.js");
+var _handle = require("./handle.js");
+var _schemaSync = require("./schema-sync.js");
+/**
+ * Opening and closing a database.
+ *
+ * The order of operations here is the design, not an implementation detail:
+ *
+ * 1. **Validate everything first.** Configuration, scope, and the migration
+ *    chain are checked before a file is touched, so a developer error is
+ *    reported against an untouched database (FR-006, FR-053).
+ * 2. **Consult the catalog before opening the scope file.** A posture
+ *    mismatch is detectable there; discovering it from SQLCipher's "file is
+ *    not a database" would report corruption for what is actually an app
+ *    configuration change (FR-101).
+ * 3. **Migrate before returning.** Nothing observes a half-migrated schema,
+ *    because there is no handle to observe it with until the chain completes
+ *    (FR-055). A failure returns no handle at all (FR-050).
+ *
+ * The handle itself is built in `handle.ts`.
+ */
+
+function resolveEncryption(config) {
+  if (config.encryption?.enabled !== true) {
+    return false;
+  }
+  // Writing plaintext to a file the app believes is encrypted is the one
+  // outcome worse than refusing to open (research.md R1a).
+  if (!(0, _native.isEncryptionAvailable)()) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.ENCRYPTION_UNAVAILABLE, {
+      message: 'encryption was requested but SQLCipher is not compiled into this build'
+    });
+  }
+  if (!(0, _provider.isCipherAvailable)()) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.ENCRYPTION_UNAVAILABLE, {
+      message: 'encryption was requested but the cipher peer is not installed'
+    });
+  }
+  return true;
+}
+async function assertPostureMatches(catalog, scope, encrypted) {
+  const entry = await (0, _catalog.readEntry)(catalog, scope.key);
+  if (!entry) {
+    return;
+  }
+  if (entry.deletionState === 'deleting') {
+    // An interrupted deletion is reported rather than opened over: the
+    // scope is neither present nor gone, and presenting it as healthy is
+    // the one answer FR-063 forbids. `deleteScopeData` finishes the job.
+    (0, _errors2.raise)(_errors.DiagnosticCodes.SCOPE_DELETED, {
+      message: 'a previous deletion of this scope was interrupted',
+      detail: {
+        scopeKey: scope.key
+      }
+    });
+  }
+  if (entry.encrypted !== encrypted) {
+    // In-place conversion is not supported this phase (FR-103). Reporting
+    // the mismatch lets an app migrate deliberately; opening would either
+    // fail obscurely or write the wrong posture.
+    (0, _errors2.raise)(_errors.DiagnosticCodes.ENCRYPTION_MISMATCH, {
+      message: 'encryption posture does not match the stored database',
+      detail: {
+        scopeKey: scope.key
+      }
+    });
+  }
+}
+async function openSqliteDatabase(config, options = {}) {
+  const now = options.now ?? (() => Date.now());
+  (0, _validateConfig.validateConfig)(config);
+  (0, _faults.throwIfFaulted)('open');
+  const scope = (0, _validate.resolveScope)(config.scope);
+  const encrypted = resolveEncryption(config);
+  const includeInBackup = config.backup?.includeInPlatformBackup === true;
+  const layout = (0, _location.layoutFor)(config.name);
+  await (0, _backupIos.ensureManagedRoot)(layout, includeInBackup);
+  const catalog = await (0, _connection.openConnection)({
+    path: layout.catalogPath
+  });
+  let key = null;
+  let connection = null;
+  let released = false;
+  const releaseConnection = async () => {
+    if (released || !connection) {
+      return;
+    }
+    released = true;
+    await connection.close();
+    (0, _budgets.releaseHandleSlot)();
+  };
+  try {
+    await (0, _catalog.ensureCatalog)(catalog);
+    await assertPostureMatches(catalog, scope, encrypted);
+    if (encrypted) {
+      key = await (0, _keyProvider.acquireKey)(config.encryption, scope);
+    }
+    (0, _budgets.acquireHandleSlot)();
+    try {
+      connection = await (0, _connection.openConnection)({
+        path: layout.scopeDataPath(scope.key),
+        ...(key ? {
+          encryptionKey: key.value()
+        } : {})
+      });
+    } catch (error) {
+      (0, _budgets.releaseHandleSlot)();
+      throw error;
+    }
+    await (0, _connection.assertReadable)(connection);
+    const schemas = (0, _declare.indexSchemas)(config.collections);
+    // No DDL at all when the declaration is the one already applied (LDB-07).
+    const schema = await (0, _schemaSync.syncSchema)(connection, config);
+    const scopeConnection = connection;
+    const schemaVersion = await (0, _executor.runMigrations)({
+      connection: scopeConnection,
+      config,
+      schemaFor: name => (0, _handle.schemaFor)(schemas, name),
+      now,
+      closeOnFailure: releaseConnection,
+      ledgerReady: schema.unchanged
+    });
+    await schema.record();
+    await (0, _catalog.registerScope)(catalog, {
+      scopeKey: scope.key,
+      createdAt: now(),
+      deletionState: 'active',
+      backupPosture: includeInBackup ? 'included' : 'excluded',
+      encrypted
+    });
+    await catalog.close();
+    (0, _deletion.clearScopeInvalidation)(config.name, scope.key);
+    return (0, _handle.buildHandle)({
+      config,
+      connection: scopeConnection,
+      key,
+      layout,
+      now,
+      schemaVersion,
+      schemas,
+      scope,
+      posture: (0, _backupAndroidVerify.effectivePostureFor)(layout, includeInBackup, _backupIos.iosPosture)
+    });
+  } catch (error) {
+    // No usable handle after a failed open (FR-002). Anything already
+    // acquired is released here rather than left for a caller who is about
+    // to be handed an exception instead of a handle.
+    key?.release();
+    await releaseConnection();
+    await catalog.close();
+    throw error;
+  }
+}
+//# sourceMappingURL=lifecycle.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_keyProvider","_provider","_errors2","_faults","_executor","_backupAndroidVerify","_backupIos","_location","_declare","_validateConfig","_validate","_catalog","_connection","_native","_budgets","_deletion","_handle","_schemaSync","resolveEncryption","config","encryption","enabled","isEncryptionAvailable","raise","DiagnosticCodes","ENCRYPTION_UNAVAILABLE","message","isCipherAvailable","assertPostureMatches","catalog","scope","encrypted","entry","readEntry","key","deletionState","SCOPE_DELETED","detail","scopeKey","ENCRYPTION_MISMATCH","openSqliteDatabase","options","now","Date","validateConfig","throwIfFaulted","resolveScope","includeInBackup","backup","includeInPlatformBackup","layout","layoutFor","name","ensureManagedRoot","openConnection","path","catalogPath","connection","released","releaseConnection","close","releaseHandleSlot","ensureCatalog","acquireKey","acquireHandleSlot","scopeDataPath","encryptionKey","value","error","assertReadable","schemas","indexSchemas","collections","schema","syncSchema","scopeConnection","schemaVersion","runMigrations","schemaFor","closeOnFailure","ledgerReady","unchanged","record","registerScope","createdAt","backupPosture","clearScopeInvalidation","buildHandle","posture","effectivePostureFor","iosPosture","release"],"sourceRoot":"../../../src","sources":["adapter/lifecycle.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/adapter/schema-sync.js

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.syncSchema = syncSchema;
+var _store = require("../artifacts/store.js");
+var _rowCodec = require("../sqlite/row-codec.js");
+var _values = require("../sqlite/values.js");
+/**
+ * Bringing the physical tables in line with the declared schema, and skipping
+ * that work when nothing changed (LDB-07, LDB-11).
+ *
+ * Until 0.4.0 every open ran the whole set — CREATE TABLE, PRAGMA table_info,
+ * CREATE INDEX per index, for every collection — some sixty native round-trips
+ * for ten collections, on the startup path. The applied schema is now recorded
+ * in `_meta`; an open whose declaration matches it runs no DDL at all.
+ */
+
+/** Bumped whenever the DDL this package generates changes, so it is re-applied once. */
+const DDL_VERSION = 1;
+const FINGERPRINT_KEY = 'schema_fingerprint';
+
+/** What was declared, and by which generation of this package's DDL. */
+function fingerprintOf(config) {
+  return JSON.stringify([DDL_VERSION, config.collections]);
+}
+async function appliedFingerprint(connection) {
+  try {
+    const result = await connection.execute('SELECT value FROM _meta WHERE key = ?', [FINGERPRINT_KEY]);
+    const row = result.rows[0];
+    return row ? (0, _values.text)(row.value) : null;
+  } catch {
+    // A database that has never been opened has no `_meta` yet.
+    return null;
+  }
+}
+
+/** `unique` and the column list of an index, read back from the statement SQLite stored. */
+function definitionOf(sql) {
+  const unique = /^\s*CREATE\s+UNIQUE\s/i.test(sql);
+  const columns = sql.slice(sql.lastIndexOf('(') + 1, sql.lastIndexOf(')')).replace(/["\s]/g, '');
+  return `${unique ? 'unique' : 'plain'}:${columns}`;
+}
+
+/**
+ * Indexes follow their declaration (LDB-11). `CREATE INDEX IF NOT EXISTS` keyed
+ * on the name alone meant that adding `unique: true` to an existing index, or
+ * changing its fields, did nothing, and an index no longer declared stayed
+ * forever. An index whose definition changed is dropped and recreated, and one
+ * of this package's that is no longer declared is dropped. Only indexes carrying
+ * the collection's own prefix are touched.
+ */
+async function syncIndexes(connection, schema) {
+  const table = `c_${schema.name}`;
+  const existing = await connection.execute("SELECT name, sql FROM sqlite_master WHERE type = 'index' AND tbl_name = ? AND sql IS NOT NULL", [table]);
+  const current = new Map(existing.rows.map(row => [(0, _values.text)(row.name), (0, _values.text)(row.sql)]));
+  const wanted = new Map((0, _rowCodec.createIndexSql)(schema).map(statement => {
+    const name = /INDEX IF NOT EXISTS "([^"]+)"/.exec(statement)?.[1] ?? '';
+    return [name, statement];
+  }));
+  for (const index of schema.indexes ?? []) {
+    // Indexes created before 0.2.0 carry the bare declared name; they are
+    // recreated under the collection-scoped one. No row data moves.
+    if (current.has(index.name) && index.name !== (0, _rowCodec.physicalIndexName)(schema, index.name)) {
+      await connection.execute(`DROP INDEX IF EXISTS "${index.name}"`);
+    }
+  }
+  for (const [name, sql] of current) {
+    const statement = wanted.get(name);
+    const ours = name.startsWith(`${table}__`);
+    if (statement === undefined && ours || statement && definitionOf(statement) !== definitionOf(sql)) {
+      await connection.execute(`DROP INDEX IF EXISTS "${name}"`);
+    }
+  }
+  for (const statement of wanted.values()) {
+    await connection.execute(statement);
+  }
+}
+
+/**
+ * Adding a column rather than recreating the table is what makes declaring a
+ * new queryable field non-destructive: the payload already holds the value, so
+ * the new column is backfilled from it and no record is rewritten by hand
+ * (research.md R6).
+ */
+async function ensureCollection(connection, schema) {
+  await connection.execute((0, _rowCodec.createTableSql)(schema));
+  const info = await connection.execute(`PRAGMA table_info("c_${schema.name}")`);
+  const present = new Set(info.rows.map(row => (0, _values.text)(row.name)));
+  for (const field of schema.fields ?? []) {
+    const column = `f_${field.name}`;
+    if (present.has(column)) {
+      continue;
+    }
+    await connection.execute((0, _rowCodec.addColumnSql)(schema, field));
+    // The same projection a write applies (`projectValue`): an object or an
+    // array projects to NULL. A bare json_extract backfilled those as JSON
+    // text, so a filter matched old records and new ones differently (LDB-11).
+    const path = `'$."${field.name}"'`;
+    await connection.execute(`UPDATE "c_${schema.name}" SET "${column}" = CASE WHEN json_type(payload, ${path}) IN ('object', 'array') THEN NULL ELSE json_extract(payload, ${path}) END`);
+  }
+  await syncIndexes(connection, schema);
+}
+async function syncSchema(connection, config) {
+  const fingerprint = fingerprintOf(config);
+  if ((await appliedFingerprint(connection)) === fingerprint) {
+    return {
+      unchanged: true,
+      record: async () => undefined
+    };
+  }
+  for (const schema of config.collections) {
+    await ensureCollection(connection, schema);
+  }
+  await (0, _store.ensureAttachmentTable)(connection);
+  return {
+    unchanged: false,
+    async record() {
+      await connection.execute('INSERT INTO _meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value', [FINGERPRINT_KEY, fingerprint]);
+    }
+  };
+}
+//# sourceMappingURL=schema-sync.js.map