@framers/sql-storage-adapter 0.7.3 → 0.7.5

package/README.md

@@ -93,6 +93,7 @@ import { createStorageFeatures, runSchemaMigrations, isUniqueViolation } from '@
 | `./core` | Contracts and errors, dialects, full-text search, codecs, exporters, `createStorageFeatures`, the schema-migration runner, `isUniqueViolation`, the logger. No adapter |
 | `./postgres`, `./better-sqlite3`, `./sqljs`, `./indexeddb`, `./capacitor` | One adapter each |
 | `./backup` | S3-compatible backups (`@aws-sdk/client-s3`) |
+| `./authjs` | The Auth.js database adapter (also in `./core`) |
 | `./electron`, `./electron/renderer`, `./electron/preload` | The Electron adapters. `./electron/renderer` holds only what a window uses; `require('./electron/preload')` gives one bundled CommonJS file for a sandboxed preload |
 | `./sync`, `./kv`, `./types` | Cross-platform sync, the key-value store, the types |
 
@@ -381,6 +382,26 @@ const status = await schemaMigrationStatus(db, migrations);            // { appl
 - **Outside a transaction.** A file whose first line is `-- outside transaction` (`outsideTransactionMarker`) runs outside a transaction, for `CREATE INDEX CONCURRENTLY` or `VACUUM`. On PostgreSQL it runs under the session lock on one held connection (`withConnection`).
 - **Unknown rows.** `unknown: 'ignore'` lets a run go on past ledger rows the list lacks.
 
+### Auth.js
+
+`createAuthJsAdapter(db)` is an Auth.js database adapter. It keeps users, accounts, sessions and verification tokens in the product's own database through this library, on PostgreSQL or SQLite. Pass it to NextAuth v5 or `@auth/core`; it has the shape of `Adapter` from `@auth/core/adapters`, which CI checks, and needs no dependency on it.
+
+```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); // or put authJsTablesSql(db) in a migration
+export const { handlers, auth, signIn, signOut } = NextAuth({ adapter: createAuthJsAdapter(db), providers: [/* ... */] });
+```
+
+- **Tables.** They are `auth_users`, `auth_accounts`, `auth_sessions` and `auth_verification_tokens`; `tablePrefix` changes the `auth_`. Ids are text, from `crypto.randomUUID()` unless Auth.js passes one or `generateId` is given. Times are `timestamptz` on PostgreSQL and ISO 8601 text on SQLite, and Dates either way in JavaScript.
+- **Deletes.** `deleteUser` deletes the user's sessions and accounts first, in one transaction, so it holds on engines that leave foreign keys off.
+- **Verification tokens.** `useVerificationToken` deletes and returns the token in one statement (`DELETE ... RETURNING`), so a token works once.
+- **Passkeys.** WebAuthn authenticators are not stored.
+- **Tests.** Auth.js's own adapter test suite runs against it on PostgreSQL, better-sqlite3 and sql.js.
+
 ### Values
 
 On SQLite, values convert as they bind, positional and named alike:
@@ -709,30 +730,41 @@ const ddl = `CREATE TABLE notes (id ${d.columnType('uuid')} PRIMARY KEY DEFAULT
 - Column values follow each engine: a PostgreSQL `BOOLEAN` returns `true` and the SQLite `INTEGER` returns `1`, and a `TIMESTAMPTZ` returns a `Date` where SQLite returns text. `typeParsers` (see "Values") narrows the PostgreSQL side.
 - `pragma()` returns null on PostgreSQL and `advisoryTransactionLock()` returns null on SQLite: skip the statement when it is null.
 
-### IFullTextSearch — FTS5 & tsvector
+### IFullTextSearch — FTS5, FTS4 & tsvector
+
+`createStorageFeatures` gives each engine the full-text search it has:
+- FTS5 on better-sqlite3;
+- FTS4 on sql.js and IndexedDB, whose stock sql.js build compiles FTS3 and FTS4 and no FTS5;
+- a tsvector column with a GIN index on PostgreSQL, the Supabase adapter included.
+
+The same calls return the same rows on all three, and `tests/fts.parity.spec.ts` runs them on each.
 
 ```typescript
 const { fts } = features;
 
-// Create index: FTS5 virtual table (SQLite) or tsvector + GIN (Postgres)
-await adapter.exec(fts.createIndex({
+// FTS5 or FTS4 virtual table (SQLite), or a _tsv column with a GIN index (PostgreSQL)
+await db.exec(fts.createIndex({
   table: 'docs_fts',
   columns: ['title', 'body'],
   contentTable: 'documents',
   tokenizer: 'porter ascii',
+  weights: { title: 'A', body: 'C' },   // PostgreSQL ranks with them; SQLite ignores them
 }));
+await db.exec(fts.rebuildCommand('docs_fts'));
+
+// The best match first on every engine; a named placeholder binds once wherever it appears
+const rows = await db.all(
+  `SELECT t.id FROM ${fts.joinClause('documents', 't', 'docs_fts', 'docs_fts')}
+   WHERE ${fts.matchClause('docs_fts', '@q')} ORDER BY ${fts.relevanceOrder('docs_fts', '@q')}`,
+  { q: fts.sanitizeQuery(userText) },
+);
+```
 
-// Search query
-const sql = `
-  SELECT t.*
-  FROM ${fts.joinClause('documents', 't', 'fts', 'docs_fts')}
-  WHERE ${fts.matchClause('docs_fts', '?')}
-  ORDER BY ${fts.rankExpression('fts')}
-`;
+- **Ordering.** `relevanceOrder` orders best first everywhere. `rankExpression` keeps each engine's own direction: FTS5's `rank` is lower-better, FTS4's `length(offsets())` and PostgreSQL's `ts_rank` are higher-better.
+- **Queries.** `sanitizeQuery` turns text into its words, quoted and joined with OR, on every engine. PostgreSQL reads queries with `websearch_to_tsquery`: words are ANDed, and `or`, `-word` and quoted phrases work as in a search box.
+- **One index, many features objects.** On PostgreSQL, `createIndex` records each index's table, columns, language and weights for the whole process, so a features object made later syncs, rebuilds and queries an index another one created, and each index keeps its own language. Run `createIndex` (it is idempotent) in each process before `syncInsert` or `rebuildCommand`.
+- **Aliases.** On SQLite, alias the index as itself in `joinClause` (or pass the alias as `indexName` to `matchClause`), since a MATCH names the table as the query writes it.
 
-// Rebuild index
-await adapter.exec(fts.rebuildCommand('docs_fts'));
-```
 
 ### IBlobCodec — Cross-Platform Binary Encoding
 

package/dist/cjs/core/contracts/features.js

@@ -23,6 +23,7 @@ module.exports = __toCommonJS(features_exports);
 var import_SqliteDialect = require("../../dialects/SqliteDialect.js");
 var import_PostgresDialect = require("../../dialects/PostgresDialect.js");
 var import_SqliteFts5 = require("../../fts/SqliteFts5.js");
+var import_SqliteFts4 = require("../../fts/SqliteFts4.js");
 var import_PostgresFts = require("../../fts/PostgresFts.js");
 var import_NodeBlobCodec = require("../../codecs/NodeBlobCodec.js");
 var import_BrowserBlobCodec = require("../../codecs/BrowserBlobCodec.js");
@@ -45,12 +46,13 @@ function extractPostgresConnectionString(adapter) {
   return `postgresql://${auth}${host}:${port}/${options.database}${sslQuery}`;
 }
 function createStorageFeatures(adapter) {
-  const isPostgres = adapter.kind === "postgres";
+  const isPostgres = adapter.kind === "postgres" || adapter.kind === "supabase-postgres";
+  const hasFts5 = adapter.kind !== "sqljs" && adapter.kind !== "indexeddb";
   const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
   const postgresConnectionString = isPostgres ? extractPostgresConnectionString(adapter) : void 0;
   return {
     dialect: isPostgres ? new import_PostgresDialect.PostgresDialect() : new import_SqliteDialect.SqliteDialect(),
-    fts: isPostgres ? new import_PostgresFts.PostgresFts() : new import_SqliteFts5.SqliteFts5(),
+    fts: isPostgres ? new import_PostgresFts.PostgresFts() : hasFts5 ? new import_SqliteFts5.SqliteFts5() : new import_SqliteFts4.SqliteFts4(),
     blobCodec: isBrowser ? new import_BrowserBlobCodec.BrowserBlobCodec() : new import_NodeBlobCodec.NodeBlobCodec(),
     exporter: isPostgres ? new import_PostgresExporter.PostgresExporter(postgresConnectionString) : new import_SqliteFileExporter.SqliteFileExporter(adapter)
   };

package/dist/cjs/core/contracts/fts.d.ts

@@ -1,8 +1,9 @@
 /**
  * Full-text search abstraction.
  *
- * SQLite implementations use FTS5 virtual tables.
- * Postgres implementations use tsvector columns with GIN indexes.
+ * better-sqlite3 uses FTS5 virtual tables; sql.js and IndexedDB use FTS4, which
+ * their stock sql.js build has (it has no FTS5). Postgres implementations use
+ * tsvector columns with GIN indexes.
  * Methods return SQL strings — no database calls.
  */
 export interface IFullTextSearch {
@@ -13,25 +14,36 @@ export interface IFullTextSearch {
      * @param config.columns - Columns to index.
      * @param config.contentTable - Source table (for external-content FTS5).
      * @param config.tokenizer - Tokenizer config (e.g. 'porter ascii').
+     * @param config.weights - PostgreSQL: a weight per column (A highest, D lowest) for ranking. The SQLite engines rank without it.
      */
     createIndex(config: {
         table: string;
         columns: string[];
         contentTable?: string;
         tokenizer?: string;
+        weights?: Record<string, 'A' | 'B' | 'C' | 'D'>;
     }): string;
     /**
      * Generate a WHERE clause fragment for full-text matching.
      * SQLite: `memory_traces_fts MATCH ?`
-     * Postgres: `memory_traces._tsv @@ plainto_tsquery('english', $1)`
+     * Postgres: `_tsv @@ websearch_to_tsquery('english', $1)`, in the index's own language
      */
     matchClause(indexName: string, queryPlaceholder: string): string;
     /**
-     * Generate an ORDER BY rank expression.
-     * SQLite: `memory_traces_fts.rank`
-     * Postgres: `ts_rank(memory_traces._tsv, plainto_tsquery('english', $1))`
+     * A rank value, in each engine's own direction.
+     * SQLite FTS5: `memory_traces_fts.rank` (lower is better)
+     * SQLite FTS4: `length(offsets(memory_traces_fts))` (higher is better)
+     * Postgres: `ts_rank(_tsv, websearch_to_tsquery('english', $1))` (higher is better)
+     * Use relevanceOrder to order the same way on every engine.
      */
     rankExpression(indexName: string, queryPlaceholder?: string): string;
+    /**
+     * An ORDER BY fragment that puts the best match first on every engine.
+     * SQLite FTS5: `memory_traces_fts.rank`
+     * SQLite FTS4: `length(offsets(memory_traces_fts)) DESC`
+     * Postgres: `ts_rank(_tsv, websearch_to_tsquery('english', $1)) DESC`
+     */
+    relevanceOrder(indexName: string, queryPlaceholder?: string): string;
     /**
      * Generate the rebuild/reindex command.
      * SQLite: `INSERT INTO fts_table(fts_table) VALUES('rebuild')`
@@ -46,8 +58,8 @@ export interface IFullTextSearch {
     syncInsert(indexName: string, rowIdExpr: string, columns: string[]): string;
     /**
      * Sanitize natural-language input into a safe search query.
-     * SQLite: wraps words in quotes, strips FTS5 operators.
-     * Postgres: pass-through (plainto_tsquery handles it).
+     * Every engine: the words, quoted, joined with OR, with the operators of
+     * the query syntax stripped, so it matches the same rows everywhere.
      */
     sanitizeQuery(input: string): string;
     /**

package/dist/cjs/core/portable.d.ts

@@ -10,6 +10,7 @@ export * from '../types/index.js';
 export { SqliteDialect } from '../dialects/SqliteDialect.js';
 export { PostgresDialect } from '../dialects/PostgresDialect.js';
 export { SqliteFts5 } from '../fts/SqliteFts5.js';
+export { SqliteFts4 } from '../fts/SqliteFts4.js';
 export { PostgresFts } from '../fts/PostgresFts.js';
 export { NodeBlobCodec } from '../codecs/NodeBlobCodec.js';
 export { BrowserBlobCodec } from '../codecs/BrowserBlobCodec.js';
@@ -19,5 +20,6 @@ export { createStorageFeatures } from './contracts/features.js';
 export { isUniqueViolation } from '../shared/errors.js';
 export { setStorageLogger, getStorageLogger, type StorageLogger } from '../shared/logger.js';
 export * from '../features/migrations/schemaMigrations.js';
+export * from '../features/auth/authJsAdapter.js';
 export * from '../shared/parameterUtils.js';
 //# sourceMappingURL=portable.d.ts.map

package/dist/cjs/core/portable.js

@@ -25,6 +25,7 @@ __export(portable_exports, {
   PostgresFts: () => import_PostgresFts.PostgresFts,
   SqliteDialect: () => import_SqliteDialect.SqliteDialect,
   SqliteFileExporter: () => import_SqliteFileExporter.SqliteFileExporter,
+  SqliteFts4: () => import_SqliteFts4.SqliteFts4,
   SqliteFts5: () => import_SqliteFts5.SqliteFts5,
   createStorageFeatures: () => import_features.createStorageFeatures,
   getStorageLogger: () => import_logger.getStorageLogger,
@@ -36,6 +37,7 @@ __reExport(portable_exports, require("../types/index.js"), module.exports);
 var import_SqliteDialect = require("../dialects/SqliteDialect.js");
 var import_PostgresDialect = require("../dialects/PostgresDialect.js");
 var import_SqliteFts5 = require("../fts/SqliteFts5.js");
+var import_SqliteFts4 = require("../fts/SqliteFts4.js");
 var import_PostgresFts = require("../fts/PostgresFts.js");
 var import_NodeBlobCodec = require("../codecs/NodeBlobCodec.js");
 var import_BrowserBlobCodec = require("../codecs/BrowserBlobCodec.js");
@@ -45,6 +47,7 @@ var import_features = require("./contracts/features.js");
 var import_errors = require("../shared/errors.js");
 var import_logger = require("../shared/logger.js");
 __reExport(portable_exports, require("../features/migrations/schemaMigrations.js"), module.exports);
+__reExport(portable_exports, require("../features/auth/authJsAdapter.js"), module.exports);
 __reExport(portable_exports, require("../shared/parameterUtils.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -55,6 +58,7 @@ __reExport(portable_exports, require("../shared/parameterUtils.js"), module.expo
   PostgresFts,
   SqliteDialect,
   SqliteFileExporter,
+  SqliteFts4,
   SqliteFts5,
   createStorageFeatures,
   getStorageLogger,
@@ -62,5 +66,6 @@ __reExport(portable_exports, require("../shared/parameterUtils.js"), module.expo
   setStorageLogger,
   ...require("../types/index.js"),
   ...require("../features/migrations/schemaMigrations.js"),
+  ...require("../features/auth/authJsAdapter.js"),
   ...require("../shared/parameterUtils.js")
 });

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

package/dist/cjs/features/auth/authJsAdapter.js

@@ -0,0 +1,251 @@
+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 authJsAdapter_exports = {};
+__export(authJsAdapter_exports, {
+  authJsTablesSql: () => authJsTablesSql,
+  createAuthJsAdapter: () => createAuthJsAdapter,
+  ensureAuthJsTables: () => ensureAuthJsTables
+});
+module.exports = __toCommonJS(authJsAdapter_exports);
+var import_features = require("../../core/contracts/features.js");
+const PREFIX = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const tablesFor = (options) => {
+  const prefix = options.tablePrefix ?? "auth_";
+  if (!PREFIX.test(prefix)) {
+    throw new Error(`tablePrefix must be letters, digits and underscores, starting with a letter or an underscore; got ${JSON.stringify(prefix)}.`);
+  }
+  return {
+    users: `${prefix}users`,
+    accounts: `${prefix}accounts`,
+    sessions: `${prefix}sessions`,
+    verificationTokens: `${prefix}verification_tokens`
+  };
+};
+function authJsTablesSql(db, options = {}) {
+  const t = tablesFor(options);
+  const d = (0, import_features.createStorageFeatures)(db).dialect;
+  const timestamp = d.columnType("timestamp");
+  return [
+    `CREATE TABLE IF NOT EXISTS ${t.users} (id TEXT PRIMARY KEY, name TEXT, email TEXT UNIQUE, email_verified ${timestamp}, image TEXT)`,
+    `CREATE TABLE IF NOT EXISTS ${t.accounts} (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL REFERENCES ${t.users} (id) ON DELETE CASCADE,
+      type TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      provider_account_id TEXT NOT NULL,
+      refresh_token TEXT,
+      access_token TEXT,
+      expires_at ${d.columnType("bigint")},
+      token_type TEXT,
+      scope TEXT,
+      id_token TEXT,
+      session_state TEXT,
+      UNIQUE (provider, provider_account_id)
+    )`,
+    `CREATE TABLE IF NOT EXISTS ${t.sessions} (session_token TEXT PRIMARY KEY, user_id TEXT NOT NULL REFERENCES ${t.users} (id) ON DELETE CASCADE, expires ${timestamp} NOT NULL)`,
+    `CREATE TABLE IF NOT EXISTS ${t.verificationTokens} (identifier TEXT NOT NULL, token TEXT NOT NULL, expires ${timestamp} NOT NULL, PRIMARY KEY (identifier, token))`,
+    `CREATE INDEX IF NOT EXISTS ${t.accounts}_user_id ON ${t.accounts} (user_id)`,
+    `CREATE INDEX IF NOT EXISTS ${t.sessions}_user_id ON ${t.sessions} (user_id)`
+  ];
+}
+async function ensureAuthJsTables(db, options = {}) {
+  for (const statement of authJsTablesSql(db, options)) {
+    await db.exec(statement);
+  }
+}
+const toDate = (value) => value == null ? null : value instanceof Date ? value : new Date(String(value));
+const toUser = (row) => ({
+  id: String(row.id),
+  name: row.name ?? null,
+  email: row.email,
+  emailVerified: toDate(row.email_verified),
+  image: row.image ?? null
+});
+const toAccount = (row) => {
+  const account = {
+    userId: String(row.user_id),
+    type: row.type,
+    provider: row.provider,
+    providerAccountId: row.provider_account_id
+  };
+  for (const field of ["refresh_token", "access_token", "token_type", "scope", "id_token", "session_state"]) {
+    if (row[field] != null)
+      account[field] = String(row[field]);
+  }
+  if (row.expires_at != null)
+    account.expires_at = Number(row.expires_at);
+  return account;
+};
+const toSession = (row) => ({
+  sessionToken: row.session_token,
+  userId: String(row.user_id),
+  expires: toDate(row.expires)
+});
+const toVerificationToken = (row) => ({
+  identifier: row.identifier,
+  token: row.token,
+  expires: toDate(row.expires)
+});
+const defaultId = () => {
+  const random = globalThis.crypto?.randomUUID;
+  if (!random)
+    throw new Error("crypto.randomUUID() is not available; pass generateId.");
+  return random.call(globalThis.crypto);
+};
+function createAuthJsAdapter(db, options = {}) {
+  const t = tablesFor(options);
+  const generateId = options.generateId ?? defaultId;
+  const getUser = async (id) => {
+    const row = await db.get(`SELECT * FROM ${t.users} WHERE id = ?`, [id]);
+    return row ? toUser(row) : null;
+  };
+  const getSession = async (sessionToken) => {
+    const row = await db.get(`SELECT * FROM ${t.sessions} WHERE session_token = ?`, [sessionToken]);
+    return row ? toSession(row) : null;
+  };
+  return {
+    async createUser(user) {
+      const id = user.id ?? generateId();
+      await db.run(`INSERT INTO ${t.users} (id, name, email, email_verified, image) VALUES (?, ?, ?, ?, ?)`, [
+        id,
+        user.name ?? null,
+        user.email,
+        user.emailVerified ?? null,
+        user.image ?? null
+      ]);
+      return await getUser(id);
+    },
+    getUser,
+    async getUserByEmail(email) {
+      const row = await db.get(`SELECT * FROM ${t.users} WHERE email = ?`, [email]);
+      return row ? toUser(row) : null;
+    },
+    async getUserByAccount({ provider, providerAccountId }) {
+      const row = await db.get(`SELECT u.* FROM ${t.users} u JOIN ${t.accounts} a ON a.user_id = u.id WHERE a.provider = ? AND a.provider_account_id = ?`, [provider, providerAccountId]);
+      return row ? toUser(row) : null;
+    },
+    async updateUser(user) {
+      const fields = [];
+      if ("name" in user)
+        fields.push(["name", user.name ?? null]);
+      if ("email" in user)
+        fields.push(["email", user.email]);
+      if ("emailVerified" in user)
+        fields.push(["email_verified", user.emailVerified ?? null]);
+      if ("image" in user)
+        fields.push(["image", user.image ?? null]);
+      if (fields.length) {
+        await db.run(`UPDATE ${t.users} SET ${fields.map(([column]) => `${column} = ?`).join(", ")} WHERE id = ?`, [
+          ...fields.map(([, value]) => value),
+          user.id
+        ]);
+      }
+      const updated = await getUser(user.id);
+      if (!updated)
+        throw new Error(`No user with id ${JSON.stringify(user.id)} to update.`);
+      return updated;
+    },
+    async deleteUser(userId) {
+      return db.transaction(async (trx) => {
+        const row = await trx.get(`SELECT * FROM ${t.users} WHERE id = ?`, [userId]);
+        await trx.run(`DELETE FROM ${t.sessions} WHERE user_id = ?`, [userId]);
+        await trx.run(`DELETE FROM ${t.accounts} WHERE user_id = ?`, [userId]);
+        await trx.run(`DELETE FROM ${t.users} WHERE id = ?`, [userId]);
+        return row ? toUser(row) : null;
+      });
+    },
+    async linkAccount(account) {
+      await db.run(`INSERT INTO ${t.accounts} (id, user_id, type, provider, provider_account_id, refresh_token, access_token, expires_at, token_type, scope, id_token, session_state)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        generateId(),
+        account.userId,
+        account.type,
+        account.provider,
+        account.providerAccountId,
+        account.refresh_token ?? null,
+        account.access_token ?? null,
+        account.expires_at ?? null,
+        account.token_type ?? null,
+        account.scope ?? null,
+        account.id_token ?? null,
+        account.session_state ?? null
+      ]);
+      return account;
+    },
+    async unlinkAccount({ provider, providerAccountId }) {
+      await db.run(`DELETE FROM ${t.accounts} WHERE provider = ? AND provider_account_id = ?`, [provider, providerAccountId]);
+    },
+    async getAccount(providerAccountId, provider) {
+      const row = await db.get(`SELECT * FROM ${t.accounts} WHERE provider = ? AND provider_account_id = ?`, [
+        provider,
+        providerAccountId
+      ]);
+      return row ? toAccount(row) : null;
+    },
+    async createSession(session) {
+      await db.run(`INSERT INTO ${t.sessions} (session_token, user_id, expires) VALUES (?, ?, ?)`, [
+        session.sessionToken,
+        session.userId,
+        session.expires
+      ]);
+      return { sessionToken: session.sessionToken, userId: session.userId, expires: session.expires };
+    },
+    async getSessionAndUser(sessionToken) {
+      const session = await getSession(sessionToken);
+      if (!session)
+        return null;
+      const user = await getUser(session.userId);
+      return user ? { session, user } : null;
+    },
+    async updateSession(session) {
+      const fields = [];
+      if (session.expires !== void 0)
+        fields.push(["expires", session.expires]);
+      if (session.userId !== void 0)
+        fields.push(["user_id", session.userId]);
+      if (fields.length) {
+        await db.run(`UPDATE ${t.sessions} SET ${fields.map(([column]) => `${column} = ?`).join(", ")} WHERE session_token = ?`, [
+          ...fields.map(([, value]) => value),
+          session.sessionToken
+        ]);
+      }
+      return getSession(session.sessionToken);
+    },
+    async deleteSession(sessionToken) {
+      await db.run(`DELETE FROM ${t.sessions} WHERE session_token = ?`, [sessionToken]);
+    },
+    async createVerificationToken(token) {
+      await db.run(`INSERT INTO ${t.verificationTokens} (identifier, token, expires) VALUES (?, ?, ?)`, [
+        token.identifier,
+        token.token,
+        token.expires
+      ]);
+      return { identifier: token.identifier, token: token.token, expires: token.expires };
+    },
+    async useVerificationToken({ identifier, token }) {
+      const row = await db.get(`DELETE FROM ${t.verificationTokens} WHERE identifier = ? AND token = ? RETURNING identifier, token, expires`, [identifier, token]);
+      return row ? toVerificationToken(row) : null;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  authJsTablesSql,
+  createAuthJsAdapter,
+  ensureAuthJsTables
+});

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

@@ -1,29 +1,30 @@
 import type { IFullTextSearch } from '../core/contracts/fts.js';
+type Weight = 'A' | 'B' | 'C' | 'D';
 /**
  * Postgres full-text search using tsvector columns and GIN indexes.
  *
- * Unlike FTS5 (separate virtual table), Postgres stores the tsvector
- * as a column `_tsv` on the content table itself. The `createIndex()`
- * call adds the column, creates the GIN index, and backfills existing rows.
+ * Unlike FTS5 (separate virtual table), Postgres stores the tsvector as a
+ * column `_tsv` on the content table itself. The `createIndex()` call adds the
+ * column, creates the GIN index, and backfills existing rows. Queries go
+ * through `websearch_to_tsquery`, which reads raw user text without syntax
+ * errors: words are ANDed, and `or`, `-word` and quoted phrases work as in a
+ * web search box.
  */
 export declare class PostgresFts implements IFullTextSearch {
-    /** The content table is stored during createIndex for use by other methods. */
-    private _contentTable;
-    private _columns;
-    private _lang;
     createIndex(config: {
         table: string;
         columns: string[];
         contentTable?: string;
         tokenizer?: string;
+        weights?: Record<string, Weight>;
     }): 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;
+    matchClause(indexName: string, queryPlaceholder: string): string;
+    rankExpression(indexName: string, queryPlaceholder?: string): string;
+    relevanceOrder(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;
-    /** Map FTS5-style tokenizer strings to Postgres text search configurations. */
-    private _tokenizerToLang;
 }
+export {};
 //# sourceMappingURL=PostgresFts.d.ts.map