@framers/sql-storage-adapter 0.7.2 → 0.7.4

package/dist/cjs/fts/PostgresFts.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PostgresFts_exports = {};
+__export(PostgresFts_exports, {
+  PostgresFts: () => PostgresFts
+});
+module.exports = __toCommonJS(PostgresFts_exports);
+class PostgresFts {
+  constructor() {
+    this._contentTable = "";
+    this._columns = [];
+    this._lang = "english";
+  }
+  createIndex(config) {
+    const ct = config.contentTable ?? config.table;
+    this._contentTable = ct;
+    this._columns = config.columns;
+    const colConcat = config.columns.map((c) => `COALESCE(${c}, '')`).join(" || ' ' || ");
+    const lang = this._tokenizerToLang(config.tokenizer);
+    this._lang = lang;
+    return [
+      `ALTER TABLE ${ct} ADD COLUMN IF NOT EXISTS _tsv tsvector`,
+      `CREATE INDEX IF NOT EXISTS idx_${config.table}_tsv ON ${ct} USING GIN(_tsv)`,
+      `UPDATE ${ct} SET _tsv = to_tsvector('${lang}', ${colConcat}) WHERE _tsv IS NULL`
+    ].join(";\n");
+  }
+  matchClause(_indexName, queryPlaceholder) {
+    return `_tsv @@ plainto_tsquery('${this._lang}', ${queryPlaceholder})`;
+  }
+  rankExpression(_indexName, queryPlaceholder) {
+    const qp = queryPlaceholder ?? "$1";
+    return `ts_rank(_tsv, plainto_tsquery('${this._lang}', ${qp}))`;
+  }
+  rebuildCommand(_indexName) {
+    const ct = this._contentTable;
+    const colConcat = this._columns.map((c) => `COALESCE(${c}, '')`).join(" || ' ' || ");
+    return `UPDATE ${ct} SET _tsv = to_tsvector('${this._lang}', ${colConcat})`;
+  }
+  syncInsert(_indexName, _rowIdExpr, columns) {
+    const ct = this._contentTable;
+    const colConcat = columns.map((_, index) => `COALESCE($${index + 2}, '')`).join(" || ' ' || ");
+    return `UPDATE ${ct} SET _tsv = to_tsvector('${this._lang}', ${colConcat}) WHERE id = $1`;
+  }
+  sanitizeQuery(input) {
+    return input;
+  }
+  joinClause(contentTable, contentAlias, _ftsAlias, _indexName) {
+    return `${contentTable} ${contentAlias}`;
+  }
+  /** Map FTS5-style tokenizer strings to Postgres text search configurations. */
+  _tokenizerToLang(tokenizer) {
+    if (!tokenizer)
+      return "english";
+    if (tokenizer.includes("porter"))
+      return "english";
+    return "simple";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresFts
+});

package/dist/cjs/fts/SqliteFts5.d.ts

@@ -0,0 +1,22 @@
+import type { IFullTextSearch } from '../core/contracts/fts.js';
+/**
+ * SQLite FTS5 full-text search implementation.
+ *
+ * Uses FTS5 virtual tables with external-content support, porter/ascii
+ * tokenizers, and rowid-based joins to the content table.
+ */
+export declare class SqliteFts5 implements IFullTextSearch {
+    createIndex(config: {
+        table: string;
+        columns: string[];
+        contentTable?: string;
+        tokenizer?: string;
+    }): string;
+    matchClause(indexName: string, queryPlaceholder: string): string;
+    rankExpression(indexName: string, _queryPlaceholder?: string): string;
+    rebuildCommand(indexName: string): string;
+    syncInsert(indexName: string, rowIdExpr: string, columns: string[]): string;
+    sanitizeQuery(input: string): string;
+    joinClause(contentTable: string, contentAlias: string, ftsAlias: string, indexName: string): string;
+}
+//# sourceMappingURL=SqliteFts5.d.ts.map

package/dist/cjs/fts/SqliteFts5.js

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SqliteFts5_exports = {};
+__export(SqliteFts5_exports, {
+  SqliteFts5: () => SqliteFts5
+});
+module.exports = __toCommonJS(SqliteFts5_exports);
+class SqliteFts5 {
+  createIndex(config) {
+    const parts = [...config.columns];
+    if (config.contentTable) {
+      parts.push(`content='${config.contentTable}'`);
+      parts.push(`content_rowid='rowid'`);
+    }
+    if (config.tokenizer) {
+      parts.push(`tokenize='${config.tokenizer}'`);
+    }
+    return `CREATE VIRTUAL TABLE IF NOT EXISTS ${config.table} USING fts5(${parts.join(", ")})`;
+  }
+  matchClause(indexName, queryPlaceholder) {
+    return `${indexName} MATCH ${queryPlaceholder}`;
+  }
+  rankExpression(indexName, _queryPlaceholder) {
+    return `${indexName}.rank`;
+  }
+  rebuildCommand(indexName) {
+    return `INSERT INTO ${indexName}(${indexName}) VALUES('rebuild')`;
+  }
+  syncInsert(indexName, rowIdExpr, columns) {
+    const placeholders = columns.map(() => "?").join(", ");
+    return `INSERT INTO ${indexName} (rowid, ${columns.join(", ")}) VALUES (${rowIdExpr}, ${placeholders})`;
+  }
+  sanitizeQuery(input) {
+    return input.replace(/[*()":^~{}[\]\\]/g, "").split(/\s+/).filter((w) => w.length > 0).map((w) => `"${w}"`).join(" OR ");
+  }
+  joinClause(contentTable, contentAlias, ftsAlias, indexName) {
+    return `${indexName} ${ftsAlias} JOIN ${contentTable} ${contentAlias} ON ${contentAlias}.rowid = ${ftsAlias}.rowid`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SqliteFts5
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,31 @@
+export * from './types/index.js';
+export * from './core/database.js';
+export * from './core/resolver.js';
+export * from './adapters/betterSqliteAdapter.js';
+export * from './adapters/sqlJsAdapter.js';
+export * from './adapters/indexedDbAdapter.js';
+export * from './adapters/capacitorSqliteAdapter.js';
+export * from './adapters/postgresAdapter.js';
+export * from './adapters/supabase.js';
+export * from './adapters/baseStorageAdapter.js';
+export * from './features/backup/cloudBackup.js';
+export * from './features/migrations/dataExport.js';
+export * from './features/migrations/dataImport.js';
+export * from './features/migrations/migration.js';
+export * from './features/migrations/schemaMigrations.js';
+export * from './features/auth/authJsAdapter.js';
+export * from './features/sync/syncManager.js';
+export * from './shared/parameterUtils.js';
+export { segmentFilePath, segmentName, validateSegment } from './shared/segment.js';
+export { SqliteDialect } from './dialects/SqliteDialect.js';
+export { PostgresDialect } from './dialects/PostgresDialect.js';
+export { SqliteFts5 } from './fts/SqliteFts5.js';
+export { PostgresFts } from './fts/PostgresFts.js';
+export { NodeBlobCodec } from './codecs/NodeBlobCodec.js';
+export { BrowserBlobCodec } from './codecs/BrowserBlobCodec.js';
+export { SqliteFileExporter } from './exporters/SqliteFileExporter.js';
+export { PostgresExporter } from './exporters/PostgresExporter.js';
+export { createStorageFeatures } from './core/contracts/features.js';
+export { isUniqueViolation } from './shared/errors.js';
+export { setStorageLogger, getStorageLogger, type StorageLogger } from './shared/logger.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.js

@@ -0,0 +1,103 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dist_exports = {};
+__export(dist_exports, {
+  BrowserBlobCodec: () => import_BrowserBlobCodec.BrowserBlobCodec,
+  NodeBlobCodec: () => import_NodeBlobCodec.NodeBlobCodec,
+  PostgresDialect: () => import_PostgresDialect.PostgresDialect,
+  PostgresExporter: () => import_PostgresExporter.PostgresExporter,
+  PostgresFts: () => import_PostgresFts.PostgresFts,
+  SqliteDialect: () => import_SqliteDialect.SqliteDialect,
+  SqliteFileExporter: () => import_SqliteFileExporter.SqliteFileExporter,
+  SqliteFts5: () => import_SqliteFts5.SqliteFts5,
+  createStorageFeatures: () => import_features.createStorageFeatures,
+  getStorageLogger: () => import_logger.getStorageLogger,
+  isUniqueViolation: () => import_errors.isUniqueViolation,
+  segmentFilePath: () => import_segment.segmentFilePath,
+  segmentName: () => import_segment.segmentName,
+  setStorageLogger: () => import_logger.setStorageLogger,
+  validateSegment: () => import_segment.validateSegment
+});
+module.exports = __toCommonJS(dist_exports);
+__reExport(dist_exports, require("./types/index.js"), module.exports);
+__reExport(dist_exports, require("./core/database.js"), module.exports);
+__reExport(dist_exports, require("./core/resolver.js"), module.exports);
+__reExport(dist_exports, require("./adapters/betterSqliteAdapter.js"), module.exports);
+__reExport(dist_exports, require("./adapters/sqlJsAdapter.js"), module.exports);
+__reExport(dist_exports, require("./adapters/indexedDbAdapter.js"), module.exports);
+__reExport(dist_exports, require("./adapters/capacitorSqliteAdapter.js"), module.exports);
+__reExport(dist_exports, require("./adapters/postgresAdapter.js"), module.exports);
+__reExport(dist_exports, require("./adapters/supabase.js"), module.exports);
+__reExport(dist_exports, require("./adapters/baseStorageAdapter.js"), module.exports);
+__reExport(dist_exports, require("./features/backup/cloudBackup.js"), module.exports);
+__reExport(dist_exports, require("./features/migrations/dataExport.js"), module.exports);
+__reExport(dist_exports, require("./features/migrations/dataImport.js"), module.exports);
+__reExport(dist_exports, require("./features/migrations/migration.js"), module.exports);
+__reExport(dist_exports, require("./features/migrations/schemaMigrations.js"), module.exports);
+__reExport(dist_exports, require("./features/auth/authJsAdapter.js"), module.exports);
+__reExport(dist_exports, require("./features/sync/syncManager.js"), module.exports);
+__reExport(dist_exports, require("./shared/parameterUtils.js"), module.exports);
+var import_segment = require("./shared/segment.js");
+var import_SqliteDialect = require("./dialects/SqliteDialect.js");
+var import_PostgresDialect = require("./dialects/PostgresDialect.js");
+var import_SqliteFts5 = require("./fts/SqliteFts5.js");
+var import_PostgresFts = require("./fts/PostgresFts.js");
+var import_NodeBlobCodec = require("./codecs/NodeBlobCodec.js");
+var import_BrowserBlobCodec = require("./codecs/BrowserBlobCodec.js");
+var import_SqliteFileExporter = require("./exporters/SqliteFileExporter.js");
+var import_PostgresExporter = require("./exporters/PostgresExporter.js");
+var import_features = require("./core/contracts/features.js");
+var import_errors = require("./shared/errors.js");
+var import_logger = require("./shared/logger.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserBlobCodec,
+  NodeBlobCodec,
+  PostgresDialect,
+  PostgresExporter,
+  PostgresFts,
+  SqliteDialect,
+  SqliteFileExporter,
+  SqliteFts5,
+  createStorageFeatures,
+  getStorageLogger,
+  isUniqueViolation,
+  segmentFilePath,
+  segmentName,
+  setStorageLogger,
+  validateSegment,
+  ...require("./types/index.js"),
+  ...require("./core/database.js"),
+  ...require("./core/resolver.js"),
+  ...require("./adapters/betterSqliteAdapter.js"),
+  ...require("./adapters/sqlJsAdapter.js"),
+  ...require("./adapters/indexedDbAdapter.js"),
+  ...require("./adapters/capacitorSqliteAdapter.js"),
+  ...require("./adapters/postgresAdapter.js"),
+  ...require("./adapters/supabase.js"),
+  ...require("./adapters/baseStorageAdapter.js"),
+  ...require("./features/backup/cloudBackup.js"),
+  ...require("./features/migrations/dataExport.js"),
+  ...require("./features/migrations/dataImport.js"),
+  ...require("./features/migrations/migration.js"),
+  ...require("./features/migrations/schemaMigrations.js"),
+  ...require("./features/auth/authJsAdapter.js"),
+  ...require("./features/sync/syncManager.js"),
+  ...require("./shared/parameterUtils.js")
+});

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/shared/connectionGate.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Keeps statements from outside an open transaction out of it.
+ *
+ * An adapter whose transactions share one connection runs BEGIN, the
+ * callback's statements and COMMIT on that connection. While the callback
+ * awaits, a statement another caller issues would otherwise run on the same
+ * connection inside the open transaction: a write would be undone if the
+ * transaction rolled back, and a read would see rows the transaction has not
+ * committed. The gate makes such a statement wait until the transaction ends.
+ *
+ * A statement issued from inside the transaction runs in it. Through the
+ * callback's handle it carries the transaction's token, so it is admitted
+ * whatever async context runs it. Through the adapter itself, from code the
+ * callback runs, the callback's async context tells it apart, so the gate needs
+ * a context store (Node's AsyncLocalStorage). Without one, the gate either
+ * admits every statement that carries no token at once, which is how the
+ * adapters behaved before the gate, or makes it wait like any outside caller,
+ * so that the handle is the only way into an open transaction: the adapters
+ * that run in a browser or a WebView, where there is no context store, wait.
+ *
+ * This module imports nothing from Node, so browser bundles can include it;
+ * the adapter that runs on Node passes the store in.
+ */
+/** The part of Node's `AsyncLocalStorage` the gate uses. */
+export interface TransactionContextStore {
+    run<R>(store: symbol, callback: () => R): R;
+    getStore(): symbol | undefined;
+    /** Releases the store; Node collects an enabled store only after this. */
+    disable(): void;
+}
+/** The gate of one shared connection. */
+export interface ConnectionGate {
+    /**
+     * True when a statement must wait: a transaction is open and the statement
+     * is not its own. A transaction handle passes its token; any other caller is
+     * judged by its async context.
+     */
+    blocks(token?: symbol): boolean;
+    /** True when a transaction is open and the caller runs inside it. */
+    inside(): boolean;
+    /** The open transaction's token, for a handle made inside it; null when none is open. */
+    openToken(): symbol | null;
+    /** Settles when the open transaction ends; at once when none is open. */
+    ended(): Promise<void>;
+    /**
+     * Runs one transaction's body with the gate closed to callers outside it.
+     * The body receives the transaction's token for its handle, and runs in its
+     * own async context, so code it runs is admitted too. The caller runs one
+     * body at a time (the adapter's transaction queue).
+     */
+    hold<T>(body: (token: symbol) => Promise<T>): Promise<T>;
+    /** Releases the context store when the connection closes. */
+    dispose(): void;
+}
+/** How a gate treats a statement that carries no token. */
+export interface ConnectionGateOptions {
+    /**
+     * When there is no context store: 'admit' runs such a statement at once (the
+     * default, how the adapters behaved before the gate); 'wait' holds it until
+     * the open transaction ends, so only the transaction's handle reaches it.
+     */
+    withoutContext?: 'admit' | 'wait';
+}
+/**
+ * Creates the gate of one shared connection.
+ *
+ * @param context - Node's AsyncLocalStorage, or null where there is none.
+ * @param options - What the gate does with a token-less statement when there
+ *   is no context store.
+ */
+export declare const createConnectionGate: (context: TransactionContextStore | null, options?: ConnectionGateOptions) => ConnectionGate;
+/** Reports a statement that is still waiting for an open transaction after a while. */
+export interface LongWaitWatch {
+    /** How long a statement may wait before `onLongWait` is called. */
+    afterMs: number;
+    /** Called once per waiting statement that passes `afterMs`. */
+    onLongWait: () => void;
+}
+/**
+ * Runs `work` once the gate admits it. `work` starts the statement: it runs it
+ * (a synchronous adapter) or sends it (an asynchronous one), and the last check
+ * and that start happen in the same turn, so no transaction can open between
+ * them; a caller woken when a transaction ends checks again, since the next
+ * transaction may already be open.
+ *
+ * @param token - The transaction's token when the statement comes through a
+ *   transaction handle; a handle whose transaction has ended waits like any
+ *   outside caller.
+ * @param watch - Reports a statement that waits long, which is how a callback
+ *   that issues a statement through the adapter instead of its handle shows
+ *   on an adapter whose gate makes such statements wait.
+ */
+export declare const whenAdmitted: <T>(gate: ConnectionGate, work: () => T | PromiseLike<T>, token?: symbol, watch?: LongWaitWatch) => Promise<T>;
+//# sourceMappingURL=connectionGate.d.ts.map

package/dist/cjs/shared/connectionGate.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var connectionGate_exports = {};
+__export(connectionGate_exports, {
+  createConnectionGate: () => createConnectionGate,
+  whenAdmitted: () => whenAdmitted
+});
+module.exports = __toCommonJS(connectionGate_exports);
+const createConnectionGate = (context, options = {}) => {
+  let open = null;
+  const waitWithoutContext = options.withoutContext === "wait";
+  return {
+    blocks: (token) => {
+      if (open === null)
+        return false;
+      if (token !== void 0)
+        return token !== open.id;
+      if (context === null)
+        return waitWithoutContext;
+      return context.getStore() !== open.id;
+    },
+    inside: () => open !== null && context !== null && context.getStore() === open.id,
+    openToken: () => open?.id ?? null,
+    ended: () => open?.done ?? Promise.resolve(),
+    async hold(body) {
+      const id = /* @__PURE__ */ Symbol("transaction");
+      let release;
+      const done = new Promise((resolve) => {
+        release = resolve;
+      });
+      open = { id, done };
+      try {
+        return await (context ? context.run(id, () => body(id)) : body(id));
+      } finally {
+        open = null;
+        release();
+      }
+    },
+    dispose: () => {
+      context?.disable();
+    }
+  };
+};
+const whenAdmitted = async (gate, work, token, watch) => {
+  if (gate.blocks(token)) {
+    const timer = watch ? setTimeout(watch.onLongWait, watch.afterMs) : void 0;
+    try {
+      while (gate.blocks(token)) {
+        await gate.ended();
+      }
+    } finally {
+      if (timer !== void 0)
+        clearTimeout(timer);
+    }
+  }
+  return work();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createConnectionGate,
+  whenAdmitted
+});

package/dist/cjs/shared/errors.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Error checks that read the same failure from every adapter.
+ */
+/**
+ * Whether `error` is a unique or primary-key violation, from any adapter:
+ * PostgreSQL's SQLSTATE `23505` (`unique_violation`, pg's `code`),
+ * better-sqlite3's `SQLITE_CONSTRAINT_UNIQUE` and
+ * `SQLITE_CONSTRAINT_PRIMARYKEY`, and the "UNIQUE constraint failed" message
+ * that sql.js, the IndexedDB adapter and the Capacitor plugin give. An error
+ * that wraps one as its `cause`, to any depth up to ten, counts too.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await db.run('INSERT INTO users (email) VALUES (?)', [email]);
+ * } catch (error) {
+ *   if (isUniqueViolation(error)) return { taken: true };
+ *   throw error;
+ * }
+ * ```
+ */
+export declare const isUniqueViolation: (error: unknown) => boolean;
+//# sourceMappingURL=errors.d.ts.map

package/dist/cjs/shared/errors.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  isUniqueViolation: () => isUniqueViolation
+});
+module.exports = __toCommonJS(errors_exports);
+const SQLITE_UNIQUE_CODES = /* @__PURE__ */ new Set(["SQLITE_CONSTRAINT_UNIQUE", "SQLITE_CONSTRAINT_PRIMARYKEY"]);
+const SQLITE_UNIQUE_MESSAGE = /\bUNIQUE constraint failed\b/;
+const MAX_CAUSE_DEPTH = 10;
+const isUniqueViolation = (error) => {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current !== null && typeof current === "object" && !seen.has(current) && seen.size < MAX_CAUSE_DEPTH) {
+    seen.add(current);
+    const { code, message } = current;
+    if (code === "23505")
+      return true;
+    if (typeof code === "string" && SQLITE_UNIQUE_CODES.has(code))
+      return true;
+    if (typeof message === "string" && SQLITE_UNIQUE_MESSAGE.test(message))
+      return true;
+    current = current.cause;
+  }
+  return false;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isUniqueViolation
+});

package/dist/cjs/shared/logger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Where the library's log lines go. A host hands its own logger in, and
+ * pino's logger fits as it is: each call passes the line's fields first and
+ * its message second, as pino takes them. Without one, lines go to the
+ * console, as the library has always written them.
+ */
+export interface StorageLogger {
+    debug?(fields: Record<string, unknown>, message: string): void;
+    info(fields: Record<string, unknown>, message: string): void;
+    warn(fields: Record<string, unknown>, message: string): void;
+    error(fields: Record<string, unknown>, message: string): void;
+}
+/**
+ * Routes every line the library writes to `logger`, from then on and in every
+ * adapter. `null` routes them back to the console.
+ *
+ * @example
+ * ```typescript
+ * import pino from 'pino';
+ * setStorageLogger(pino({ name: 'storage' }));
+ * ```
+ */
+export declare const setStorageLogger: (logger: StorageLogger | null) => void;
+/** The logger the library writes to now. */
+export declare const getStorageLogger: () => StorageLogger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/cjs/shared/logger.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+__export(logger_exports, {
+  getStorageLogger: () => getStorageLogger,
+  setStorageLogger: () => setStorageLogger
+});
+module.exports = __toCommonJS(logger_exports);
+const prefix = (fields) => `[${typeof fields.scope === "string" ? fields.scope : "StorageAdapter"}]`;
+const consoleLogger = {
+  debug: (fields, message) => console.log(`${prefix(fields)} ${message}`),
+  info: (fields, message) => console.info(`${prefix(fields)} ${message}`),
+  warn: (fields, message) => console.warn(`${prefix(fields)} ${message}`),
+  error: (fields, message) => console.error(`${prefix(fields)} ${message}`)
+};
+let current = consoleLogger;
+const setStorageLogger = (logger) => {
+  current = logger ?? consoleLogger;
+};
+const getStorageLogger = () => current;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStorageLogger,
+  setStorageLogger
+});

package/dist/cjs/shared/parameterUtils.d.ts

@@ -0,0 +1,16 @@
+import type { StorageParameters } from '../core/contracts/index.js';
+/**
+ * Normalises parameter payloads into a tuple of named/object parameters and positional arrays.
+ */
+export declare const normaliseParameters: (parameters?: StorageParameters) => {
+    named?: Record<string, unknown>;
+    positional?: Array<unknown>;
+};
+/**
+ * Named parameters under every key sql.js may look them up by. sql.js binds a
+ * named value only under the key that matches the placeholder as written
+ * (":id", "@id", "$id"); better-sqlite3 takes the bare key ("id"). Expanding
+ * every variant lets one payload work on both.
+ */
+export declare const expandNamedParameters: (named: Record<string, unknown>) => Record<string, unknown>;
+//# sourceMappingURL=parameterUtils.d.ts.map