@framers/sql-storage-adapter 0.7.2 → 0.7.4

package/dist/cjs/dialects/PostgresDialect.js

@@ -0,0 +1,143 @@
+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 PostgresDialect_exports = {};
+__export(PostgresDialect_exports, {
+  PostgresDialect: () => PostgresDialect
+});
+module.exports = __toCommonJS(PostgresDialect_exports);
+var import_shared = require("./shared.js");
+const COLUMN_TYPES = {
+  text: "TEXT",
+  integer: "INTEGER",
+  bigint: "BIGINT",
+  real: "DOUBLE PRECISION",
+  boolean: "BOOLEAN",
+  timestamp: "TIMESTAMPTZ",
+  json: "JSONB",
+  uuid: "UUID",
+  blob: "BYTEA"
+};
+const CAST_TYPES = {
+  text: "text",
+  integer: "integer",
+  real: "double precision",
+  timestamp: "timestamptz"
+};
+const ISO_TEXT = `'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'`;
+class PostgresDialect {
+  constructor() {
+    this.name = "postgres";
+  }
+  insertOrIgnore(table, columns, placeholders) {
+    return `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders.join(", ")}) ON CONFLICT DO NOTHING`;
+  }
+  insertOrReplace(table, columns, placeholders, primaryKey) {
+    return this.upsert(table, columns, placeholders, [primaryKey ?? columns[0]]);
+  }
+  upsert(table, columns, placeholders, conflictColumns, updateColumns) {
+    const updates = (0, import_shared.upsertUpdateColumns)(columns, conflictColumns, updateColumns);
+    const action = updates.length ? `DO UPDATE SET ${updates.map((column) => `${column} = EXCLUDED.${column}`).join(", ")}` : "DO NOTHING";
+    return `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders.join(", ")}) ON CONFLICT (${conflictColumns.join(", ")}) ${action}`;
+  }
+  jsonExtract(column, jsonPath) {
+    const path = jsonPath.replace(/^\$\./, "");
+    const parts = path.split(".");
+    if (parts.length === 1) {
+      return `(${column}::jsonb)->>'${parts[0]}'`;
+    }
+    const args = parts.map((p) => `'${p}'`).join(", ");
+    return `jsonb_extract_path_text(${column}::jsonb, ${args})`;
+  }
+  jsonExtractAs(column, jsonPath, type) {
+    (0, import_shared.checkChoice)("jsonExtractAs type", type, ["text", "integer", "real", "json"]);
+    const path = `'{${(0, import_shared.parseJsonPath)(jsonPath).join(",")}}'`;
+    if (type === "json")
+      return `((${column})::jsonb #> ${path})`;
+    const text = `((${column})::jsonb #>> ${path})`;
+    if (type === "text")
+      return text;
+    return `(${text})::${type === "integer" ? "integer" : "double precision"}`;
+  }
+  jsonArrayContains(jsonArray, valueExpr) {
+    return `EXISTS (SELECT 1 FROM jsonb_array_elements_text((${jsonArray})::jsonb) AS element(value) WHERE element.value = CAST(${valueExpr} AS text))`;
+  }
+  ifnull(expr, fallback) {
+    return `COALESCE(${expr}, ${fallback})`;
+  }
+  autoIncrementPrimaryKey() {
+    return "INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY";
+  }
+  columnType(kind) {
+    (0, import_shared.checkChoice)("columnType kind", kind, Object.keys(COLUMN_TYPES));
+    return COLUMN_TYPES[kind];
+  }
+  pragma(_key, _value) {
+    return null;
+  }
+  placeholder(index) {
+    return `$${index + 1}`;
+  }
+  now() {
+    return "now()";
+  }
+  cast(expr, type) {
+    (0, import_shared.checkChoice)("cast type", type, ["text", "integer", "real", "timestamp"]);
+    return `CAST(${expr} AS ${CAST_TYPES[type]})`;
+  }
+  addInterval(expr, amount, unit) {
+    return `((${expr})::timestamptz + interval '${(0, import_shared.intervalSeconds)(amount, unit)} seconds')`;
+  }
+  dateBucket(unit, expr) {
+    return `to_char(date_trunc('${(0, import_shared.checkDateBucketUnit)(unit)}', (${expr})::timestamptz AT TIME ZONE 'UTC'), ${ISO_TEXT})`;
+  }
+  ilike(expr, pattern) {
+    return `${expr} ILIKE ${pattern}`;
+  }
+  inList(expr, items) {
+    return items.length ? `${expr} IN (${items.join(", ")})` : "(1 = 0)";
+  }
+  inArray(expr, arrayParam) {
+    return `${expr} = ANY(${arrayParam})`;
+  }
+  rowLock(mode, wait = "wait") {
+    (0, import_shared.checkChoice)("rowLock mode", mode, ["update", "share"]);
+    (0, import_shared.checkChoice)("rowLock wait", wait, ["wait", "skipLocked", "noWait"]);
+    const lock = mode === "update" ? " FOR UPDATE" : " FOR SHARE";
+    return wait === "skipLocked" ? `${lock} SKIP LOCKED` : wait === "noWait" ? `${lock} NOWAIT` : lock;
+  }
+  advisoryTransactionLock(keyExpr) {
+    return `SELECT pg_advisory_xact_lock(${keyExpr})`;
+  }
+  greatest(...exprs) {
+    if (exprs.length === 0)
+      throw new Error("greatest needs at least one expression.");
+    return `GREATEST(${exprs.join(", ")})`;
+  }
+  least(...exprs) {
+    if (exprs.length === 0)
+      throw new Error("least needs at least one expression.");
+    return `LEAST(${exprs.join(", ")})`;
+  }
+  uuid() {
+    return "gen_random_uuid()";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresDialect
+});

package/dist/cjs/dialects/SqliteDialect.d.ts

@@ -0,0 +1,35 @@
+import type { CastType, ColumnKind, DateBucketUnit, IntervalUnit, JsonValueType, SqlDialect } from '../core/contracts/dialect.js';
+/**
+ * SQLite dialect implementation.
+ *
+ * Generates SQLite SQL: `INSERT OR IGNORE`, `ON CONFLICT ... DO UPDATE`
+ * upserts, `json_extract()`, `ifnull()`, `strftime()` times in ISO 8601 UTC
+ * text, `PRAGMA`, and positional `?` placeholders.
+ */
+export declare class SqliteDialect implements SqlDialect {
+    readonly name: "sqlite";
+    insertOrIgnore(table: string, columns: string[], placeholders: string[]): string;
+    insertOrReplace(table: string, columns: string[], placeholders: string[], primaryKey?: string): string;
+    upsert(table: string, columns: string[], placeholders: string[], conflictColumns: string[], updateColumns?: string[]): string;
+    jsonExtract(column: string, jsonPath: string): string;
+    jsonExtractAs(column: string, jsonPath: string, type: JsonValueType): string;
+    jsonArrayContains(jsonArray: string, valueExpr: string): string;
+    ifnull(expr: string, fallback: string): string;
+    autoIncrementPrimaryKey(): string;
+    columnType(kind: ColumnKind): string;
+    pragma(key: string, value: string): string | null;
+    placeholder(_index: number): string;
+    now(): string;
+    cast(expr: string, type: CastType): string;
+    addInterval(expr: string, amount: number, unit: IntervalUnit): string;
+    dateBucket(unit: DateBucketUnit, expr: string): string;
+    ilike(expr: string, pattern: string): string;
+    inList(expr: string, items: string[]): string;
+    inArray(expr: string, arrayParam: string): string;
+    rowLock(mode: 'update' | 'share', wait?: 'wait' | 'skipLocked' | 'noWait'): string;
+    advisoryTransactionLock(_keyExpr: string): string | null;
+    greatest(...exprs: string[]): string;
+    least(...exprs: string[]): string;
+    uuid(): string;
+}
+//# sourceMappingURL=SqliteDialect.d.ts.map

package/dist/cjs/dialects/SqliteDialect.js

@@ -0,0 +1,142 @@
+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 SqliteDialect_exports = {};
+__export(SqliteDialect_exports, {
+  SqliteDialect: () => SqliteDialect
+});
+module.exports = __toCommonJS(SqliteDialect_exports);
+var import_shared = require("./shared.js");
+const ISO_FORMAT = "%Y-%m-%dT%H:%M:%fZ";
+const BUCKET_FORMATS = {
+  minute: "%Y-%m-%dT%H:%M:00.000Z",
+  hour: "%Y-%m-%dT%H:00:00.000Z",
+  day: "%Y-%m-%dT00:00:00.000Z",
+  month: "%Y-%m-01T00:00:00.000Z",
+  year: "%Y-01-01T00:00:00.000Z"
+};
+const COLUMN_TYPES = {
+  text: "TEXT",
+  integer: "INTEGER",
+  bigint: "INTEGER",
+  real: "REAL",
+  boolean: "INTEGER",
+  timestamp: "TEXT",
+  json: "TEXT",
+  uuid: "TEXT",
+  blob: "BLOB"
+};
+class SqliteDialect {
+  constructor() {
+    this.name = "sqlite";
+  }
+  insertOrIgnore(table, columns, placeholders) {
+    return `INSERT OR IGNORE INTO ${table} (${columns.join(", ")}) VALUES (${placeholders.join(", ")})`;
+  }
+  insertOrReplace(table, columns, placeholders, primaryKey) {
+    return this.upsert(table, columns, placeholders, [primaryKey ?? columns[0]]);
+  }
+  upsert(table, columns, placeholders, conflictColumns, updateColumns) {
+    const updates = (0, import_shared.upsertUpdateColumns)(columns, conflictColumns, updateColumns);
+    const action = updates.length ? `DO UPDATE SET ${updates.map((column) => `${column} = excluded.${column}`).join(", ")}` : "DO NOTHING";
+    return `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders.join(", ")}) ON CONFLICT (${conflictColumns.join(", ")}) ${action}`;
+  }
+  jsonExtract(column, jsonPath) {
+    return `json_extract(${column}, '${jsonPath}')`;
+  }
+  jsonExtractAs(column, jsonPath, type) {
+    (0, import_shared.checkChoice)("jsonExtractAs type", type, ["text", "integer", "real", "json"]);
+    const path = `$${(0, import_shared.parseJsonPath)(jsonPath).map((step) => typeof step === "number" ? `[${step}]` : `.${step}`).join("")}`;
+    const value = `json_extract(${column}, '${path}')`;
+    if (type === "json")
+      return value;
+    return `CAST(${value} AS ${type === "text" ? "TEXT" : type === "integer" ? "INTEGER" : "REAL"})`;
+  }
+  jsonArrayContains(jsonArray, valueExpr) {
+    return `EXISTS (SELECT 1 FROM json_each(${jsonArray}) WHERE CAST(json_each.value AS TEXT) = CAST(${valueExpr} AS TEXT))`;
+  }
+  ifnull(expr, fallback) {
+    return `ifnull(${expr}, ${fallback})`;
+  }
+  autoIncrementPrimaryKey() {
+    return "INTEGER PRIMARY KEY AUTOINCREMENT";
+  }
+  columnType(kind) {
+    (0, import_shared.checkChoice)("columnType kind", kind, Object.keys(COLUMN_TYPES));
+    return COLUMN_TYPES[kind];
+  }
+  pragma(key, value) {
+    return `PRAGMA ${key} = ${value}`;
+  }
+  placeholder(_index) {
+    return "?";
+  }
+  now() {
+    return `strftime('${ISO_FORMAT}', 'now')`;
+  }
+  cast(expr, type) {
+    (0, import_shared.checkChoice)("cast type", type, ["text", "integer", "real", "timestamp"]);
+    if (type === "timestamp")
+      return `strftime('${ISO_FORMAT}', ${expr})`;
+    return `CAST(${expr} AS ${type === "text" ? "TEXT" : type === "integer" ? "INTEGER" : "REAL"})`;
+  }
+  addInterval(expr, amount, unit) {
+    const seconds = (0, import_shared.intervalSeconds)(amount, unit);
+    return `strftime('${ISO_FORMAT}', ${expr}, '${seconds >= 0 ? "+" : ""}${seconds} seconds')`;
+  }
+  dateBucket(unit, expr) {
+    return `strftime('${BUCKET_FORMATS[(0, import_shared.checkDateBucketUnit)(unit)]}', ${expr})`;
+  }
+  ilike(expr, pattern) {
+    return `${expr} LIKE ${pattern}`;
+  }
+  inList(expr, items) {
+    return items.length ? `${expr} IN (${items.join(", ")})` : "(1 = 0)";
+  }
+  inArray(expr, arrayParam) {
+    return `${expr} IN (SELECT value FROM json_each(${arrayParam}))`;
+  }
+  rowLock(mode, wait = "wait") {
+    (0, import_shared.checkChoice)("rowLock mode", mode, ["update", "share"]);
+    (0, import_shared.checkChoice)("rowLock wait", wait, ["wait", "skipLocked", "noWait"]);
+    return "";
+  }
+  advisoryTransactionLock(_keyExpr) {
+    return null;
+  }
+  greatest(...exprs) {
+    return nullSkippingExtreme("max", exprs);
+  }
+  least(...exprs) {
+    return nullSkippingExtreme("min", exprs);
+  }
+  uuid() {
+    return "lower(hex(randomblob(4)) || '-' || hex(randomblob(2)) || '-4' || substr(hex(randomblob(2)), 2) || '-' || substr('89ab', 1 + (random() & 3), 1) || substr(hex(randomblob(2)), 2) || '-' || hex(randomblob(6)))";
+  }
+}
+const nullSkippingExtreme = (fn, exprs) => {
+  if (exprs.length === 0)
+    throw new Error(`${fn === "max" ? "greatest" : "least"} needs at least one expression.`);
+  if (exprs.length === 1)
+    return `(${exprs[0]})`;
+  const coalesced = exprs.map((expr, index) => `coalesce(${[expr, ...exprs.filter((_, other) => other !== index)].join(", ")})`);
+  return `${fn}(${coalesced.join(", ")})`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SqliteDialect
+});

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

@@ -0,0 +1,17 @@
+import type { DateBucketUnit, IntervalUnit } from '../core/contracts/dialect.js';
+/** `amount` units as a number of seconds, after checking both. */
+export declare const intervalSeconds: (amount: number, unit: IntervalUnit) => number;
+/** Checks a dateBucket unit. */
+export declare const checkDateBucketUnit: (unit: DateBucketUnit) => DateBucketUnit;
+/** One step of a JSON path: an object key or an array index. */
+export type JsonPathStep = string | number;
+/**
+ * Splits a JSON path of the form `$.key`, `$.key.key` or `$.key[0]` into its
+ * steps. Anything else is refused, so a path never carries SQL.
+ */
+export declare const parseJsonPath: (jsonPath: string) => JsonPathStep[];
+/** Checks one of a fixed set of option values. */
+export declare const checkChoice: <T extends string>(what: string, value: T, allowed: readonly T[]) => T;
+/** The columns an upsert updates: those given, or every column outside the conflict target. */
+export declare const upsertUpdateColumns: (columns: string[], conflictColumns: string[], updateColumns?: string[]) => string[];
+//# sourceMappingURL=shared.d.ts.map

package/dist/cjs/dialects/shared.js

@@ -0,0 +1,90 @@
+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 shared_exports = {};
+__export(shared_exports, {
+  checkChoice: () => checkChoice,
+  checkDateBucketUnit: () => checkDateBucketUnit,
+  intervalSeconds: () => intervalSeconds,
+  parseJsonPath: () => parseJsonPath,
+  upsertUpdateColumns: () => upsertUpdateColumns
+});
+module.exports = __toCommonJS(shared_exports);
+const SECONDS_PER_UNIT = /* @__PURE__ */ new Map([
+  ["seconds", 1],
+  ["minutes", 60],
+  ["hours", 3600],
+  ["days", 86400]
+]);
+const intervalSeconds = (amount, unit) => {
+  if (typeof amount !== "number" || !Number.isFinite(amount)) {
+    throw new Error(`addInterval amount must be a finite number; got ${String(amount)}.`);
+  }
+  const perUnit = SECONDS_PER_UNIT.get(unit);
+  if (perUnit === void 0) {
+    throw new Error(`addInterval unit must be 'seconds', 'minutes', 'hours' or 'days'; got ${JSON.stringify(unit)}.`);
+  }
+  return amount * perUnit;
+};
+const DATE_BUCKET_UNITS = /* @__PURE__ */ new Set(["minute", "hour", "day", "month", "year"]);
+const checkDateBucketUnit = (unit) => {
+  if (!DATE_BUCKET_UNITS.has(unit)) {
+    throw new Error(`dateBucket unit must be 'minute', 'hour', 'day', 'month' or 'year'; got ${JSON.stringify(unit)}.`);
+  }
+  return unit;
+};
+const PATH_STEP = /\.([A-Za-z_][A-Za-z0-9_]*)|\[(\d+)\]/y;
+const parseJsonPath = (jsonPath) => {
+  const refuse = () => {
+    throw new Error(`Unsupported JSON path ${JSON.stringify(jsonPath)}: write $.key, $.key.key or $.key[0].`);
+  };
+  if (typeof jsonPath !== "string" || !jsonPath.startsWith("$"))
+    refuse();
+  const steps = [];
+  let index = 1;
+  while (index < jsonPath.length) {
+    PATH_STEP.lastIndex = index;
+    const match = PATH_STEP.exec(jsonPath);
+    if (!match)
+      refuse();
+    steps.push(match[1] !== void 0 ? match[1] : Number(match[2]));
+    index = PATH_STEP.lastIndex;
+  }
+  if (steps.length === 0)
+    refuse();
+  return steps;
+};
+const checkChoice = (what, value, allowed) => {
+  if (!allowed.includes(value)) {
+    throw new Error(`${what} must be ${allowed.map((option) => `'${option}'`).join(", ")}; got ${JSON.stringify(value)}.`);
+  }
+  return value;
+};
+const upsertUpdateColumns = (columns, conflictColumns, updateColumns) => {
+  if (conflictColumns.length === 0) {
+    throw new Error("upsert needs at least one conflict column.");
+  }
+  return updateColumns ?? columns.filter((column) => !conflictColumns.includes(column));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkChoice,
+  checkDateBucketUnit,
+  intervalSeconds,
+  parseJsonPath,
+  upsertUpdateColumns
+});

package/dist/cjs/exporters/PostgresExporter.d.ts

@@ -0,0 +1,14 @@
+import type { IDatabaseExporter } from '../core/contracts/exporter.js';
+/**
+ * PostgreSQL database exporter using `pg_dump`.
+ *
+ * Requires a valid connection string and `pg_dump` to be available on
+ * the system PATH. Supports both file-based and byte-array exports.
+ */
+export declare class PostgresExporter implements IDatabaseExporter {
+    private readonly connectionString?;
+    constructor(connectionString?: string | undefined);
+    exportToFile(outputPath: string): Promise<void>;
+    exportToBytes(): Promise<Uint8Array>;
+}
+//# sourceMappingURL=PostgresExporter.d.ts.map

package/dist/cjs/exporters/PostgresExporter.js

@@ -0,0 +1,61 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PostgresExporter_exports = {};
+__export(PostgresExporter_exports, {
+  PostgresExporter: () => PostgresExporter
+});
+module.exports = __toCommonJS(PostgresExporter_exports);
+class PostgresExporter {
+  constructor(connectionString) {
+    this.connectionString = connectionString;
+  }
+  async exportToFile(outputPath) {
+    if (!this.connectionString) {
+      throw new Error("PostgresExporter requires a connection string for pg_dump.");
+    }
+    const { execSync } = await Promise.resolve().then(() => __toESM(require("node:child_process")));
+    execSync(`pg_dump "${this.connectionString}" --file="${outputPath}" --format=custom`, {
+      stdio: "pipe"
+    });
+  }
+  async exportToBytes() {
+    if (!this.connectionString) {
+      throw new Error("PostgresExporter requires a connection string for pg_dump.");
+    }
+    const { execSync } = await Promise.resolve().then(() => __toESM(require("node:child_process")));
+    const buf = execSync(`pg_dump "${this.connectionString}" --format=custom`, {
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: 256 * 1024 * 1024
+    });
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresExporter
+});

package/dist/cjs/exporters/SqliteFileExporter.d.ts

@@ -0,0 +1,16 @@
+import type { StorageAdapter } from '../core/contracts/index.js';
+import type { IDatabaseExporter } from '../core/contracts/exporter.js';
+/**
+ * SQLite database exporter.
+ *
+ * Uses `VACUUM INTO` for file-based exports (better-sqlite3) and delegates
+ * to the adapter's `exportDatabase()` method for in-memory exports (sql.js,
+ * IndexedDB adapters).
+ */
+export declare class SqliteFileExporter implements IDatabaseExporter {
+    private readonly adapter;
+    constructor(adapter: StorageAdapter);
+    exportToFile(outputPath: string): Promise<void>;
+    exportToBytes(): Promise<Uint8Array>;
+}
+//# sourceMappingURL=SqliteFileExporter.d.ts.map

package/dist/cjs/exporters/SqliteFileExporter.js

@@ -0,0 +1,43 @@
+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 SqliteFileExporter_exports = {};
+__export(SqliteFileExporter_exports, {
+  SqliteFileExporter: () => SqliteFileExporter
+});
+module.exports = __toCommonJS(SqliteFileExporter_exports);
+class SqliteFileExporter {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async exportToFile(outputPath) {
+    const escaped = outputPath.replace(/'/g, "''");
+    await this.adapter.exec(`VACUUM INTO '${escaped}'`);
+  }
+  async exportToBytes() {
+    const exportable = this.adapter;
+    if (typeof exportable.exportDatabase === "function") {
+      const result = exportable.exportDatabase();
+      return result instanceof Promise ? result : result;
+    }
+    throw new Error(`SqliteFileExporter.exportToBytes() is not supported for adapter "${this.adapter.kind}". Use exportToFile() instead, or use an adapter that supports exportDatabase() (sql.js, IndexedDB).`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SqliteFileExporter
+});

package/dist/cjs/features/auth/authJsAdapter.d.ts

@@ -0,0 +1,110 @@
+/**
+ * An Auth.js database adapter over StorageAdapter: users, accounts, sessions
+ * and verification tokens kept through this library on PostgreSQL and SQLite
+ * alike, so a product's own Auth.js (NextAuth v5, `@auth/core`) stores its
+ * auth data where the rest of its data lives.
+ *
+ * The object `createAuthJsAdapter()` returns has the shape of `Adapter` from
+ * `@auth/core/adapters`, without a dependency on it: pass it as `adapter` to
+ * `NextAuth()` or `Auth()`. WebAuthn authenticators are not stored.
+ *
+ * @module
+ */
+import type { StorageAdapter } from '../../core/contracts/index.js';
+/** A user as Auth.js reads it (`AdapterUser`). */
+export interface AuthJsUser {
+    id: string;
+    email: string;
+    emailVerified: Date | null;
+    name?: string | null;
+    image?: string | null;
+}
+/**
+ * An account as Auth.js reads it (`AdapterAccount`). A type, not an
+ * interface, so it fits Auth.js's account, which allows more token fields.
+ * Fields the provider did not give are left out.
+ */
+export type AuthJsAccount = {
+    userId: string;
+    type: 'oauth' | 'oidc' | 'email' | 'webauthn';
+    provider: string;
+    providerAccountId: string;
+    refresh_token?: string;
+    access_token?: string;
+    expires_at?: number;
+    token_type?: Lowercase<string>;
+    scope?: string;
+    id_token?: string;
+    session_state?: string;
+};
+/** A session as Auth.js reads it (`AdapterSession`). */
+export interface AuthJsSession {
+    sessionToken: string;
+    userId: string;
+    expires: Date;
+}
+/** A verification token as Auth.js reads it (`VerificationToken`). */
+export interface AuthJsVerificationToken {
+    identifier: string;
+    token: string;
+    expires: Date;
+}
+/** The methods of Auth.js's `Adapter` this adapter implements. */
+export interface AuthJsAdapter {
+    createUser(user: Omit<AuthJsUser, 'id'> & {
+        id?: string;
+    }): Promise<AuthJsUser>;
+    getUser(id: string): Promise<AuthJsUser | null>;
+    getUserByEmail(email: string): Promise<AuthJsUser | null>;
+    getUserByAccount(account: Pick<AuthJsAccount, 'provider' | 'providerAccountId'>): Promise<AuthJsUser | null>;
+    updateUser(user: Partial<AuthJsUser> & Pick<AuthJsUser, 'id'>): Promise<AuthJsUser>;
+    deleteUser(userId: string): Promise<AuthJsUser | null>;
+    linkAccount(account: AuthJsAccount): Promise<AuthJsAccount>;
+    unlinkAccount(account: Pick<AuthJsAccount, 'provider' | 'providerAccountId'>): Promise<void>;
+    getAccount(providerAccountId: string, provider: string): Promise<AuthJsAccount | null>;
+    createSession(session: AuthJsSession): Promise<AuthJsSession>;
+    getSessionAndUser(sessionToken: string): Promise<{
+        session: AuthJsSession;
+        user: AuthJsUser;
+    } | null>;
+    updateSession(session: Partial<AuthJsSession> & Pick<AuthJsSession, 'sessionToken'>): Promise<AuthJsSession | null>;
+    deleteSession(sessionToken: string): Promise<void>;
+    createVerificationToken(token: AuthJsVerificationToken): Promise<AuthJsVerificationToken>;
+    useVerificationToken(params: {
+        identifier: string;
+        token: string;
+    }): Promise<AuthJsVerificationToken | null>;
+}
+/** Where the adapter keeps its tables, and how it makes ids. */
+export interface AuthJsAdapterOptions {
+    /** Put before each table name: `<prefix>users`, `<prefix>accounts`, `<prefix>sessions`, `<prefix>verification_tokens`. Default `auth_`. */
+    tablePrefix?: string;
+    /** Makes a user or account id when Auth.js passes none. Default: `crypto.randomUUID()`. */
+    generateId?: () => string;
+}
+/**
+ * The statements that create the adapter's tables and indexes on `db`'s
+ * engine, each `IF NOT EXISTS`, for a migration file or for
+ * ensureAuthJsTables.
+ */
+export declare function authJsTablesSql(db: StorageAdapter, options?: AuthJsAdapterOptions): string[];
+/** Creates the adapter's tables and indexes on `db` when they are missing. */
+export declare function ensureAuthJsTables(db: StorageAdapter, options?: AuthJsAdapterOptions): Promise<void>;
+/**
+ * An Auth.js database adapter that keeps users, accounts, sessions and
+ * verification tokens in `db`, on PostgreSQL or SQLite. Create the tables
+ * first with ensureAuthJsTables (or authJsTablesSql in a migration).
+ *
+ * @example
+ * ```typescript
+ * import NextAuth from 'next-auth';
+ * import { createDatabase } from '@framers/sql-storage-adapter';
+ * import { createAuthJsAdapter, ensureAuthJsTables } from '@framers/sql-storage-adapter/authjs';
+ *
+ * const db = await createDatabase({ url: process.env.DATABASE_URL, strict: true });
+ * await ensureAuthJsTables(db);
+ * export const { handlers, auth } = NextAuth({ adapter: createAuthJsAdapter(db), providers: [] });
+ * ```
+ */
+export declare function createAuthJsAdapter(db: StorageAdapter, options?: AuthJsAdapterOptions): AuthJsAdapter;
+//# sourceMappingURL=authJsAdapter.d.ts.map