@framers/sql-storage-adapter 0.7.1 → 0.7.3

package/dist/cjs/shared/parameterUtils.js

@@ -0,0 +1,59 @@
+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 parameterUtils_exports = {};
+__export(parameterUtils_exports, {
+  expandNamedParameters: () => expandNamedParameters,
+  normaliseParameters: () => normaliseParameters
+});
+module.exports = __toCommonJS(parameterUtils_exports);
+const normaliseParameters = (parameters) => {
+  if (parameters == null) {
+    return {};
+  }
+  if (Array.isArray(parameters)) {
+    return { positional: parameters };
+  }
+  if (typeof parameters === "object") {
+    return { named: parameters };
+  }
+  return { positional: [parameters] };
+};
+const expandNamedParameters = (named) => {
+  const expanded = { ...named };
+  for (const [rawKey, value] of Object.entries(named)) {
+    if (!rawKey)
+      continue;
+    const key = rawKey.replace(/^[:@$]/, "");
+    if (!key)
+      continue;
+    if (!(key in expanded))
+      expanded[key] = value;
+    if (!(`:${key}` in expanded))
+      expanded[`:${key}`] = value;
+    if (!(`@${key}` in expanded))
+      expanded[`@${key}`] = value;
+    if (!(`$${key}` in expanded))
+      expanded[`$${key}`] = value;
+  }
+  return expanded;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expandNamedParameters,
+  normaliseParameters
+});

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

@@ -0,0 +1,11 @@
+import type { PostgresAdapterOptions } from '../adapters/postgresAdapter.js';
+/** A string with something in it. */
+export declare const isNonEmpty: (value: unknown) => value is string;
+/**
+ * Whether Postgres options name a server: a pool of the caller's, a
+ * connection string, or a host, database or user.
+ * `{ connectionString: process.env.DATABASE_URL }` with DATABASE_URL unset
+ * names none.
+ */
+export declare const namesPostgresServer: (options: PostgresAdapterOptions | undefined) => boolean;
+//# sourceMappingURL=postgresTarget.d.ts.map

package/dist/cjs/shared/postgresTarget.js

@@ -0,0 +1,30 @@
+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 postgresTarget_exports = {};
+__export(postgresTarget_exports, {
+  isNonEmpty: () => isNonEmpty,
+  namesPostgresServer: () => namesPostgresServer
+});
+module.exports = __toCommonJS(postgresTarget_exports);
+const isNonEmpty = (value) => typeof value === "string" && value.length > 0;
+const namesPostgresServer = (options) => Boolean(options && (Boolean(options.pool) || isNonEmpty(options.connectionString) || isNonEmpty(options.host) || isNonEmpty(options.database) || isNonEmpty(options.user)));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNonEmpty,
+  namesPostgresServer
+});

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

@@ -0,0 +1,43 @@
+/**
+ * Segments keep one user's tables apart from another's in a database they
+ * share. On PostgreSQL a segment is a schema of its own; on the SQLite family a
+ * database file of its own; on IndexedDB and Capacitor a database name of its
+ * own. A segment name is the same on every backend, so one name gives a host
+ * the same separation on the server, the desktop, the phone and the browser.
+ *
+ * This module imports nothing, so browser bundles can include it.
+ */
+/**
+ * Checks a segment name and returns it.
+ *
+ * A segment name is lower-case letters, digits and underscores, starts with a
+ * letter or an underscore, and has at most 63 characters: an unquoted
+ * PostgreSQL identifier, and a safe file, IndexedDB and Capacitor database
+ * name. It is not `public`, `information_schema` or a name beginning with
+ * `pg_`, which PostgreSQL keeps for its own schemas.
+ *
+ * @throws {Error} When the name is not one a segment can take.
+ */
+export declare const validateSegment: (segment: string) => string;
+/**
+ * The name of a segment's database: `name` followed by `-` and the segment,
+ * or `name` itself when there is no segment. For IndexedDB and Capacitor
+ * database names: `app-db` and segment `agentos` give `app-db-agentos`.
+ *
+ * @throws {Error} When the segment is not one a segment name can take.
+ */
+export declare const segmentName: (name: string, segment: string | undefined) => string;
+/**
+ * The file of a segment's database: the segment goes between the file's name
+ * and its extension (`/data/app.sqlite3` and segment `agentos` give
+ * `/data/app-agentos.sqlite3`), or after a name with no extension. A `file:`
+ * URI keeps its query, and SQLite's in-memory names (`:memory:`,
+ * `file::memory:`) stay as they are, since each in-memory connection is a
+ * database of its own. Without a segment the path is returned as it is.
+ *
+ * @throws {Error} When the segment is not one a segment name can take.
+ */
+export declare const segmentFilePath: (filePath: string, segment: string | undefined) => string;
+/** Whether a path names an in-memory SQLite database, which no file holds. */
+export declare const namesInMemoryDatabase: (filePath: string) => boolean;
+//# sourceMappingURL=segment.d.ts.map

package/dist/cjs/shared/segment.js

@@ -0,0 +1,63 @@
+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 segment_exports = {};
+__export(segment_exports, {
+  namesInMemoryDatabase: () => namesInMemoryDatabase,
+  segmentFilePath: () => segmentFilePath,
+  segmentName: () => segmentName,
+  validateSegment: () => validateSegment
+});
+module.exports = __toCommonJS(segment_exports);
+const MAX_SEGMENT_LENGTH = 63;
+const SEGMENT_PATTERN = /^[a-z_][a-z0-9_]*$/;
+const RESERVED_SEGMENTS = /* @__PURE__ */ new Set(["public", "information_schema"]);
+const validateSegment = (segment) => {
+  if (typeof segment !== "string" || !SEGMENT_PATTERN.test(segment) || segment.length > MAX_SEGMENT_LENGTH) {
+    throw new Error(`Invalid segment ${JSON.stringify(segment)}: a segment name is lower-case letters, digits and underscores, starts with a letter or an underscore, and has at most ${MAX_SEGMENT_LENGTH} characters.`);
+  }
+  if (RESERVED_SEGMENTS.has(segment) || segment.startsWith("pg_")) {
+    throw new Error(`Invalid segment "${segment}": PostgreSQL keeps public, information_schema and the names beginning with pg_ for its own schemas.`);
+  }
+  return segment;
+};
+const segmentName = (name, segment) => segment === void 0 ? name : `${name}-${validateSegment(segment)}`;
+const isInMemoryPath = (filePath) => filePath === "" || filePath === ":memory:" || filePath.startsWith("file::memory:");
+const segmentFilePath = (filePath, segment) => {
+  if (segment === void 0)
+    return filePath;
+  validateSegment(segment);
+  if (isInMemoryPath(filePath))
+    return filePath;
+  const queryAt = filePath.startsWith("file:") ? filePath.search(/[?#]/) : -1;
+  const pathPart = queryAt === -1 ? filePath : filePath.slice(0, queryAt);
+  const rest = queryAt === -1 ? "" : filePath.slice(queryAt);
+  const nameAt = Math.max(pathPart.lastIndexOf("/"), pathPart.lastIndexOf("\\"), pathPart.startsWith("file:") ? 4 : -1) + 1;
+  const directory = pathPart.slice(0, nameAt);
+  const name = pathPart.slice(nameAt);
+  const extensionAt = name.lastIndexOf(".");
+  const segmented = extensionAt > 0 ? `${name.slice(0, extensionAt)}-${segment}${name.slice(extensionAt)}` : `${name}-${segment}`;
+  return `${directory}${segmented}${rest}`;
+};
+const namesInMemoryDatabase = isInMemoryPath;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  namesInMemoryDatabase,
+  segmentFilePath,
+  segmentName,
+  validateSegment
+});

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

@@ -0,0 +1,14 @@
+import type { StorageAdapter } from '../core/contracts/index.js';
+/** Function that runs one asynchronous operation after earlier operations finish. */
+export type SerializedTransactionRunner = <T>(operation: () => Promise<T>) => Promise<T>;
+/**
+ * Create a FIFO runner for adapters whose transactions share one connection.
+ *
+ * The queue tail always resolves, even when an operation rejects, so a failed
+ * transaction cannot poison later work. Each caller installs its own release
+ * promise before yielding, which preserves invocation order.
+ */
+export declare const createSerializedTransactionRunner: () => SerializedTransactionRunner;
+/** Create a callback-scoped adapter view for an already-open transaction. */
+export declare const createSharedConnectionTransactionAdapter: (owner: StorageAdapter) => StorageAdapter;
+//# sourceMappingURL=serializedTransaction.d.ts.map

package/dist/cjs/shared/serializedTransaction.js

@@ -0,0 +1,74 @@
+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 serializedTransaction_exports = {};
+__export(serializedTransaction_exports, {
+  createSerializedTransactionRunner: () => createSerializedTransactionRunner,
+  createSharedConnectionTransactionAdapter: () => createSharedConnectionTransactionAdapter
+});
+module.exports = __toCommonJS(serializedTransaction_exports);
+const createSerializedTransactionRunner = () => {
+  let tail = Promise.resolve();
+  return async (operation) => {
+    const previous = tail;
+    let release;
+    tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  };
+};
+class SharedConnectionTransactionAdapter {
+  constructor(owner) {
+    this.owner = owner;
+    this.kind = owner.kind;
+    this.capabilities = owner.capabilities;
+    if (owner.batch) {
+      this.batch = (operations) => owner.batch(operations);
+    }
+  }
+  async open(_options) {
+  }
+  async run(statement, parameters) {
+    return this.owner.run(statement, parameters);
+  }
+  async get(statement, parameters) {
+    return this.owner.get(statement, parameters);
+  }
+  async all(statement, parameters) {
+    return this.owner.all(statement, parameters);
+  }
+  async exec(script) {
+    await this.owner.exec(script);
+  }
+  async transaction(fn) {
+    return fn(this);
+  }
+  async close() {
+  }
+}
+const createSharedConnectionTransactionAdapter = (owner) => new SharedConnectionTransactionAdapter(owner);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSerializedTransactionRunner,
+  createSharedConnectionTransactionAdapter
+});

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

@@ -0,0 +1,27 @@
+/**
+ * Splits a multi-statement SQL script into individual statements without
+ * cutting inside the SQL surface forms a naive `.split(';')` mishandles.
+ *
+ * Recognised constructs that suppress top-level `;` splitting:
+ * - `--` line comments (terminate at the next newline or EOF)
+ * - `/* ... *\/` block comments, with Postgres-style nesting
+ * - `'...'` single-quoted strings, including the `''` escape for an apostrophe
+ * - `"..."` double-quoted identifiers, including the `""` escape
+ * - `$$...$$` and `$tag$...$tag$` dollar-quoted strings
+ *
+ * A bare `$` not followed by a valid tag character or another `$` is treated
+ * as a literal `$` so positional parameters (`$1`, `$2`, ...) round-trip.
+ *
+ * The function returns trimmed, non-empty statements. It does not parse SQL
+ * beyond what's needed to find top-level statement separators, and it does
+ * not validate or modify statement contents.
+ *
+ * Postgres E-string escape syntax (`E'...\n...'`) is parsed conservatively:
+ * the `E` prefix is ignored and standard `''` escape rules apply. Migrations
+ * in this codebase do not rely on backslash escapes, so this is sufficient.
+ *
+ * @param script - Multi-statement SQL script (may include comments and strings).
+ * @returns Array of trimmed individual statements, in input order.
+ */
+export declare const splitSqlStatements: (script: string) => string[];
+//# sourceMappingURL=splitSqlStatements.d.ts.map

package/dist/cjs/shared/splitSqlStatements.js

@@ -0,0 +1,163 @@
+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 splitSqlStatements_exports = {};
+__export(splitSqlStatements_exports, {
+  splitSqlStatements: () => splitSqlStatements
+});
+module.exports = __toCommonJS(splitSqlStatements_exports);
+const splitSqlStatements = (script) => {
+  const length = script.length;
+  const statements = [];
+  let buffer = "";
+  let i = 0;
+  const pushBuffer = () => {
+    const trimmed = buffer.trim();
+    if (trimmed.length > 0) {
+      statements.push(trimmed);
+    }
+    buffer = "";
+  };
+  const isIdentStart = (ch) => ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch === "_";
+  const isIdentCont = (ch) => isIdentStart(ch) || ch >= "0" && ch <= "9";
+  const readDollarTag = (start) => {
+    if (script[start] !== "$")
+      return null;
+    if (start + 1 >= length)
+      return null;
+    if (script[start + 1] === "$") {
+      return "$$";
+    }
+    if (!isIdentStart(script[start + 1]))
+      return null;
+    let j = start + 2;
+    while (j < length && isIdentCont(script[j])) {
+      j += 1;
+    }
+    if (j >= length || script[j] !== "$")
+      return null;
+    return script.slice(start, j + 1);
+  };
+  while (i < length) {
+    const ch = script[i];
+    const next = i + 1 < length ? script[i + 1] : "";
+    if (ch === "-" && next === "-") {
+      buffer += ch + next;
+      i += 2;
+      while (i < length && script[i] !== "\n") {
+        buffer += script[i];
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      buffer += ch + next;
+      i += 2;
+      let depth = 1;
+      while (i < length && depth > 0) {
+        const c = script[i];
+        const n = i + 1 < length ? script[i + 1] : "";
+        if (c === "/" && n === "*") {
+          buffer += c + n;
+          i += 2;
+          depth += 1;
+        } else if (c === "*" && n === "/") {
+          buffer += c + n;
+          i += 2;
+          depth -= 1;
+        } else {
+          buffer += c;
+          i += 1;
+        }
+      }
+      continue;
+    }
+    if (ch === "'") {
+      buffer += ch;
+      i += 1;
+      while (i < length) {
+        const c = script[i];
+        if (c === "'") {
+          if (i + 1 < length && script[i + 1] === "'") {
+            buffer += "''";
+            i += 2;
+            continue;
+          }
+          buffer += c;
+          i += 1;
+          break;
+        }
+        buffer += c;
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      buffer += ch;
+      i += 1;
+      while (i < length) {
+        const c = script[i];
+        if (c === '"') {
+          if (i + 1 < length && script[i + 1] === '"') {
+            buffer += '""';
+            i += 2;
+            continue;
+          }
+          buffer += c;
+          i += 1;
+          break;
+        }
+        buffer += c;
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "$") {
+      const tag = readDollarTag(i);
+      if (tag !== null) {
+        buffer += tag;
+        i += tag.length;
+        while (i < length) {
+          if (script[i] === "$") {
+            const close = readDollarTag(i);
+            if (close === tag) {
+              buffer += close;
+              i += close.length;
+              break;
+            }
+          }
+          buffer += script[i];
+          i += 1;
+        }
+        continue;
+      }
+    }
+    if (ch === ";") {
+      pushBuffer();
+      i += 1;
+      continue;
+    }
+    buffer += ch;
+    i += 1;
+  }
+  pushBuffer();
+  return statements;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  splitSqlStatements
+});

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

@@ -0,0 +1,48 @@
+import type { StorageParameters } from '../core/contracts/index.js';
+/** A statement and its values, ready for node-postgres. */
+export interface PostgresStatement {
+    text: string;
+    values: unknown[];
+}
+/**
+ * Rewrites a statement's placeholders for node-postgres, which takes only
+ * `$1`, `$2`, ... Outside literals, quoted identifiers, dollar-quoted strings
+ * and comments:
+ *
+ * - Named parameters: each `@name` becomes the next `$n`, bound to that name's value.
+ * - A statement that already uses `$n` placeholders is sent as written, its
+ *   `?` operators included.
+ * - Otherwise `??` becomes `?` (the jsonb key-exists operator), `?|` and `?&`
+ *   stay operators (`?||` and `?&&` are a placeholder followed by `||` or
+ *   `&&`), and each other `?` becomes the next `$n`. A statement run without
+ *   parameters keeps its `?`, so the jsonb `?` operator works in it as written.
+ */
+export declare const toPostgresStatement: (statement: string, parameters?: StorageParameters) => PostgresStatement;
+/** A statement and its parameters, ready for a SQLite engine. */
+export interface SqliteStatement {
+    statement: string;
+    parameters?: StorageParameters;
+}
+/**
+ * A value as the SQLite adapters bind it. better-sqlite3 refuses booleans,
+ * Dates and objects, and sql.js refuses Dates and binds an array as a blob,
+ * so: a boolean binds as 1 or 0, a Date as its ISO 8601 text (an Invalid Date
+ * is refused), an array or a plain object as JSON text, and undefined as
+ * NULL. Strings, numbers, bigints, null and bytes bind as they are.
+ */
+export declare const toSqliteValue: (value: unknown) => unknown;
+/**
+ * The statement and values a SQLite adapter binds: `$n` placeholders become
+ * `?` (see rewriteDollarPlaceholders above) and each value is converted with
+ * toSqliteValue, positional and named alike.
+ */
+export declare const toSqliteStatement: (statement: string, parameters?: StorageParameters) => SqliteStatement;
+/**
+ * better-sqlite3 binds every JavaScript number as a REAL (sqlite3_bind_double),
+ * so 7 reaches SQL as 7.0: `CAST(? AS TEXT)` gives '7.0', a TEXT column
+ * stores '7.0', and a comparison with a JSON element misses. It binds a
+ * BigInt as an INTEGER, so this hands it each safe integer as one. sql.js
+ * binds integers in the 32-bit range as INTEGER already.
+ */
+export declare const integersAsBigInt: (parameters?: StorageParameters) => StorageParameters;
+//# sourceMappingURL=sqlPlaceholders.d.ts.map