tina4-nodejs 3.13.92 → 3.13.95

package/types/orm/src/databaseResult.d.ts

@@ -0,0 +1,109 @@
+import type { DatabaseAdapter } from "./types.js";
+/** Column metadata returned by columnInfo(). */
+export interface ColumnInfoResult {
+    name: string;
+    type: string;
+    size: number | null;
+    decimals: number | null;
+    nullable: boolean;
+    primary_key: boolean;
+}
+/**
+ * DatabaseResult — wraps fetched rows with convenience methods.
+ *
+ * Mirrors Python's `DatabaseResult` dataclass from tina4_python.database.adapter.
+ * Provides iteration, JSON/CSV export, pagination metadata, and array-like access.
+ */
+export declare class DatabaseResult implements Iterable<Record<string, unknown>> {
+    readonly records: Record<string, unknown>[];
+    readonly columns: string[];
+    readonly count: number;
+    readonly limit: number;
+    readonly offset: number;
+    private readonly _adapter?;
+    private readonly _sql?;
+    private _columnInfoCache?;
+    [index: number]: Record<string, unknown> | undefined;
+    constructor(records?: Record<string, unknown>[], columns?: string[], count?: number, limit?: number, offset?: number, adapter?: DatabaseAdapter, sql?: string);
+    /** JSON string of records. */
+    toJson(): string;
+    /** CSV with header row. */
+    toCsv(): string;
+    /** Same as records — plain array of row objects. */
+    toArray(): Record<string, unknown>[];
+    /** Pagination envelope — accepts either (page, perPage) or (offset, limit) style.
+     *
+     * When called with two arguments both >= 0 and the first >= the second
+     * (i.e. offset-style), pass `{ offset, limit }` as the first argument.
+     * The simplest way is to always use the default (page, perPage) form and
+     * let the autoCRUD layer supply offset/limit from the query string.
+     *
+     * Returns a superset of keys for backwards-compatibility across all clients.
+     */
+    /**
+     * Describe the page this result actually IS. Takes no arguments.
+     *
+     * MEASURED 2026-08-05 on a real 250-row table read with limit=20 offset=40
+     * (page 3 of 13): this reported page 1 of 2 and returned 10 of the 20 rows.
+     * It ignored the query entirely - defaulting page to 1 and perPage to 10 -
+     * then re-sliced the rows it was handed, which were already just that page.
+     * So a caller who paginated correctly at the SQL level had the answer
+     * silently re-paginated underneath them, with a page number that was simply
+     * wrong.
+     *
+     * WITH page/perPage it slices this result in memory, the behaviour GitHub
+     * issue #106 asked for. Valid ONLY when the result holds the WHOLE set
+     * (records.length >= count). A PARTIAL result cannot be sliced by page number
+     * without lying: MEASURED on 100,000 rows read under the default cap of 100,
+     * pages 1-5 of 20 were right and every page from 6 onward came back EMPTY
+     * while totalPages reported 5,000.
+     *
+     * `total` is `count`, and `count` is now the TRUE total for the filter in
+     * all four frameworks - Database.fetch runs a COUNT probe whenever it applied
+     * a limit. It used to be ROWS RETURNED here and in Ruby while Python and PHP
+     * probed, so one query answered 20 in two frameworks and 250 in the other
+     * two.
+     */
+    toPaginate(page?: number, perPage?: number): {
+        records: Record<string, unknown>[];
+        data: Record<string, unknown>[];
+        count: number;
+        total: number;
+        limit: number;
+        offset: number;
+        page: number;
+        per_page: number;
+        perPage: number;
+        totalPages: number;
+        total_pages: number;
+        has_next: boolean;
+        has_prev: boolean;
+    };
+    /** Iterable — for (const row of result) */
+    [Symbol.iterator](): Iterator<Record<string, unknown>>;
+    /** Total count — cross-framework parity with Python/Ruby. */
+    size(): number;
+    /** Number of records in this page. */
+    get length(): number;
+    /** Array-like indexed access with negative index support. */
+    at(index: number): Record<string, unknown> | undefined;
+    /** JSON.stringify support — serialises as the records array. */
+    toJSON(): Record<string, unknown>[];
+    /**
+     * Return column metadata for the query's table.
+     *
+     * Lazy — only queries the database when explicitly called. Caches the
+     * result so subsequent calls return immediately without re-querying.
+     */
+    columnInfo(): ColumnInfoResult[];
+    /** Extract table name from a SQL query using simple regex. */
+    private _extractTableFromSql;
+    /** Query the database adapter for column metadata. */
+    private _queryColumnMetadata;
+    /** Normalize adapter column info to standard format. */
+    private _normalizeColumns;
+    /** Parse size and decimals from a type string like VARCHAR(255) or NUMERIC(10,2). */
+    private _parseTypeSize;
+    /** Derive basic column info from record keys when no adapter is available. */
+    private _fallbackColumnInfo;
+}

package/types/orm/src/databaseUrl.d.ts

@@ -0,0 +1,125 @@
+/**
+ * A parsed database connection URL, as a VALUE.
+ *
+ * Feature 5 of the feature audit. This used to be `parseDatabaseUrl()`, a single
+ * function with a cyclomatic complexity of 43 - the worst function measured
+ * anywhere in the audit - whose entire job is string-to-struct. It is now one
+ * small parser per engine, each well under the threshold, behind a value type
+ * with the same surface as PHP's `DatabaseUrl` (the reference for this row).
+ *
+ * Core Principle 6 says a connection string must mean literally the same thing
+ * in every framework. `test/fixtures/database_url_corpus.json` is the answer
+ * key, byte-identical in all four.
+ */
+import { inspect } from "node:util";
+/** The canonical engine names. Aliases resolve to these ONCE, at parse. */
+export type DatabaseEngine = "sqlite" | "postgres" | "mysql" | "mssql" | "firebird" | "mongodb" | "odbc";
+/**
+ * Remove every credential from an arbitrary connection string.
+ *
+ * THE single redaction primitive. It works on a RAW string - valid or
+ * malformed, a URL or an ODBC DSN - so the error paths can use it too, and it
+ * is what `toSafeString()` calls for the odbc form rather than hand-rolling a
+ * second, weaker rule.
+ *
+ * It cannot be complete on a string with no recognisable credential structure
+ * (`notaurl-with-hunter2` has nothing to key off), which is exactly why the
+ * invalid-URL error reports the scheme and host instead of any form of the
+ * input. Redaction is for strings we can parse enough to redact.
+ */
+export declare function redactCredentials(raw: string): string;
+/**
+ * DISPLAY REDACTS, FIDELITY DOES NOT. JSON.stringify, util.inspect, String() and
+ * toSafeString() replace the password with the redaction marker, so a log line, a
+ * stack or a status payload is safe. structuredClone deliberately does not: its
+ * contract is a faithful structural copy, and a masked clone would produce an
+ * object whose password is the literal "***".
+ *
+ * The consequence: DO NOT PERSIST THIS OBJECT. A DatabaseUrl structured-cloned
+ * onto a worker thread, into a cache or into a queue payload carries a cleartext
+ * credential across that boundary. Use toSafeString() instead.
+ * test/databaseUrlRedaction.test.ts fails the build if framework code ever does.
+ */
+export declare class DatabaseUrl {
+    readonly engine: DatabaseEngine;
+    /** Null for sqlite and odbc - a file or a DSN string has no host. */
+    readonly host: string | null;
+    /** Null for sqlite and odbc. Otherwise always set: the engine default applies. */
+    readonly port: number | null;
+    readonly database: string;
+    /** Null when absent, never an empty string - absent and blank differ. */
+    readonly username: string | null;
+    readonly password: string | null;
+    /** ODBC only: the raw connection string handed to odbc.connect(). */
+    readonly connectionString: string | null;
+    constructor(url: string, username?: string, password?: string);
+    static fromEnv(key?: string): DatabaseUrl | null;
+    /**
+     * Connection target for the adapter. sqlite and odbc are the whole value.
+     *
+     * NOT SAFE TO LOG. For every network engine this is credential-free
+     * (host:port/database), which makes it look loggable - but the odbc branch
+     * returns the connection string VERBATIM, `PWD=` included, because that is
+     * what the driver has to receive. Log `toSafeString()`; never this.
+     */
+    dsn(): string;
+    /**
+     * The URL with the password replaced by ***.
+     *
+     * The ONLY form allowed in a log line or an error message: a connection URL in
+     * a log is a credential leak. Node had no such method at all before this,
+     * which meant every call site that wanted to log a connection target had to
+     * redact it by hand. It round-trips, so it stays readable as well as safe.
+     */
+    toSafeString(): string;
+    /**
+     * What `JSON.stringify(url)` emits.
+     *
+     * Without it, stringifying the value - directly, or as one field of a config
+     * object being logged - emitted `"password":"<the real password>"`, measured
+     * on this class. Python guards the same exposure with `__repr__` and Ruby
+     * with `#inspect`; JSON is the shape Node actually serialises into a log
+     * line, so it needs the guard too.
+     *
+     * Structure is preserved so the dump is still worth having: only the secret
+     * is masked. `null` stays `null` - an ABSENT password and a masked one are
+     * different facts, and flattening them would hide exactly the confusion C7
+     * is about.
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * What `console.log(url)` / `util.inspect(url)` print.
+     *
+     * Node's equivalent of Python's `__repr__` and Ruby's `#inspect`, and the
+     * same rendering they produce - `DatabaseUrl('postgres://user:***@h:5432/db')`
+     * (tina4-python/tina4_python/database/database_url.py:153). Without it,
+     * `console.log(url)` printed the default field dump, password included.
+     */
+    [inspect.custom](): string;
+    private static parse;
+    /**
+     * sqlite is parsed on the RAW string. The URL class collapses `sqlite:/x` and
+     * `sqlite:///x`, losing the difference between a one-slash ABSOLUTE path and
+     * the documented three-slash RELATIVE form.
+     *
+     *   sqlite:///app.db        -> app.db        (three slashes = relative to cwd)
+     *   sqlite:////abs/app.db   -> /abs/app.db   (four slashes = absolute)
+     *   sqlite:/abs/app.db      -> /abs/app.db   (one slash = a real absolute path)
+     *   sqlite:app.db           -> app.db
+     */
+    private static parseSqlite;
+    /**
+     * mssql and firebird: the URL class does not know these schemes, so they are
+     * matched directly.
+     *
+     * The captured path keeps its own leading slash when the URL had two, which is
+     * how the documented absolute Firebird form survives. The old code did
+     * `"/" + match[5]`, ADDING a slash - so an absolute path came back with two
+     * and a relative path was silently made absolute. Verified against live
+     * Firebird 5.0.4: the driver takes one or two leading slashes and rejects a
+     * relative path outright.
+     */
+    private static parseRegexForm;
+    /** postgres / mysql / mongodb, via the URL class. */
+    private static parseStandard;
+}

package/types/orm/src/docstore.d.ts

@@ -0,0 +1,241 @@
+/**
+ * Tina4 DocStore - pymongo-style document storage with a zero-config SQLite (JSON1) fallback.
+ *
+ * A document store with the everyday MongoDB driver collection API, backed by
+ * SQLite's JSON1 extension when no MongoDB server is configured.
+ *
+ *     import { getCollection, ObjectId } from "@tina4/orm";
+ *
+ *     const orders = await getCollection("orders");    // SqliteCollection when no Mongo configured
+ *     const { insertedId } = await orders.insertOne({ customer_id: 1, total: 9.99 });
+ *     for (const o of await orders.find({ customer_id: { $in: [1, 2] } }).sort("created_at", -1).limit(10).toArray()) {
+ *       // ...
+ *     }
+ *     await orders.updateOne({ _id: insertedId }, { $set: { status: "shipped" } });
+ *
+ * `getCollection(name)` returns a real MongoDB driver `Collection` when a Mongo
+ * URI is configured (TINA4_MONGO_URI, else TINA4_SESSION_MONGO_URI - the same
+ * names the queue/session Mongo backends read), and otherwise a SqliteCollection
+ * backed by a local SQLite file. This mirrors the file-based fallbacks the queue,
+ * cache, and session subsystems already provide: an app that talks to Mongo in
+ * production runs serverless in local dev with no code change - only the backend
+ * differs.
+ *
+ * A configured URI with NO driver installed throws `DocStoreDriverMissing`
+ * (ADR-0033). It does NOT quietly use the local SQLite store, and it no longer
+ * surfaces a bare ERR_MODULE_NOT_FOUND that names an npm package rather than
+ * the framework decision that led there.
+ *
+ * Design (the SQLite backend):
+ *   - Each collection is a table `(_id TEXT PRIMARY KEY, doc TEXT)`; `doc` is JSON.
+ *   - Query filters are pushed down to SQL over `json_extract(doc, '$.field')`
+ *     (lazy, not a full in-memory scan), supporting equality, $in/$nin,
+ *     $gt/$gte/$lt/$lte, $ne, $exists, $regex, and implicit-AND / $or / $and.
+ *   - Updates: $set, $unset, $inc, and full-document replace.
+ *   - Cursors: sort / limit / skip / projection.
+ *   - IDs are a built-in 12-byte ObjectId (zero-dependency; interchangeable with
+ *     the driver's ObjectId as a 24-hex string).
+ *
+ * Type round-trip is by value, not by wrapper object, so json_extract stays
+ * queryable and sortable: a Date is stored as an ISO-8601 UTC string and an
+ * ObjectId as its 24-hex string, and reads rehydrate a strict-ISO string back to
+ * a Date and a 24-hex string back to an ObjectId. That keeps range queries and
+ * sorts working on date and id fields - the trade-off (a plain 24-hex / ISO
+ * string becomes an ObjectId / Date on read) is acceptable for the local dev store.
+ *
+ * Deliberate non-goals: aggregation pipeline, $elemMatch, geo. This is the
+ * everyday CRUD + filter subset, not full Mongo parity.
+ */
+import { DatabaseSync } from "node:sqlite";
+/** Raised when a value cannot be parsed as an ObjectId. */
+export declare class InvalidId extends Error {
+    constructor(message: string);
+}
+/**
+ * A 12-byte MongoDB-style ObjectId, with no external dependency.
+ *
+ * Layout: 4-byte big-endian seconds since epoch, 5-byte per-process random,
+ * 3-byte big-endian counter. Renders as a 24-char hex string, so it is
+ * interchangeable with the driver's ObjectId wherever the string form is used.
+ */
+export declare class ObjectId {
+    private static _counter;
+    private static _process;
+    private readonly _bytes;
+    constructor(oid?: ObjectId | Buffer | Uint8Array | string | null);
+    private static _generate;
+    static isValid(value: unknown): boolean;
+    get binary(): Buffer;
+    /** The timestamp embedded in the id (the first 4 bytes), as a Date. */
+    get generationTime(): Date;
+    toString(): string;
+    toJSON(): string;
+    equals(other: unknown): boolean;
+}
+/** Value -> JSON-serialisable, sortable scalar form (for storage/queries). */
+export declare function encodeValue(value: unknown): unknown;
+/** Stored JSON value -> rich value, rehydrating ObjectId (24-hex) and Date (ISO). */
+export declare function decodeValue(value: unknown): unknown;
+interface CompiledFilter {
+    where: string;
+    params: unknown[];
+}
+/**
+ * Compile a Mongo-style filter object into { where, params }.
+ *
+ * Returns { where: "1=1", params: [] } for an empty filter. Supports implicit
+ * AND across keys, $or / $and, and the per-field operator set.
+ */
+export declare function compileFilter(query?: Record<string, unknown> | null): CompiledFilter;
+export interface InsertOneResult {
+    acknowledged: boolean;
+    insertedId: unknown;
+}
+export interface InsertManyResult {
+    acknowledged: boolean;
+    insertedIds: unknown[];
+}
+export interface UpdateResult {
+    acknowledged: boolean;
+    matchedCount: number;
+    modifiedCount: number;
+    upsertedId: unknown | null;
+}
+export interface DeleteResult {
+    acknowledged: boolean;
+    deletedCount: number;
+}
+/** Lazy result cursor. Builds and runs SQL only when materialised (toArray). */
+/** The three sort spellings a real FindCursor accepts. */
+export type SortSpec = string | [string, number][] | Record<string, number> | Map<string, number>;
+/**
+ * Normalise the driver's three sort spellings to a list of [key, direction].
+ *
+ * ADR-0036. A real `FindCursor.sort()` accepts a key plus a direction, a list
+ * of `[key, direction]` pairs, OR an object/Map - and the driver is the shape
+ * this fallback imitates (ADR-0025). The object form used to throw
+ * `TypeError: keyOrList is not iterable` here. Measured 2026-08-04 against a
+ * real MongoDB: the object spelling worked on the driver and threw on the
+ * fallback, in three of the four frameworks.
+ */
+export declare function sortSpec(keyOrList: SortSpec, direction?: number): [string, number][];
+export declare class Cursor {
+    #private;
+    /**
+     * The cursor receives WHAT IT NEEDS, not the collection it came from.
+     *
+     * It used to hold the collection and reach back for `connection`, `quoted` and
+     * `load` - which is the only reason those three were public. ADR-0025
+     * corollary 1: anything the fallback needs internally is private, and a real
+     * FindCursor exposes none of them. Handing over the two values and calling the
+     * module-level loader removes the back-reference AND the public surface.
+     */
+    constructor(conn: DatabaseSync, quoted: string, where: string, params: unknown[], projection?: Record<string, unknown> | null);
+    sort(keyOrList: SortSpec, direction?: number): this;
+    limit(n: number): this;
+    skip(n: number): this;
+    /**
+     * Materialise the cursor into an array of decoded documents.
+     *
+     * ASYNC because the driver's FindCursor.toArray() is async (ADR-0025 clause
+     * 3). The work underneath is synchronous - node:sqlite has no async API - but
+     * the SHAPE is what a call site sees, and a shape that changes with the
+     * provider is the defect this fixes.
+     */
+    toArray(): Promise<Record<string, unknown>[]>;
+    /**
+     * Async iteration, matching the driver.
+     *
+     * NOTE: there is deliberately no [Symbol.iterator] here. A real FindCursor
+     * has ONLY Symbol.asyncIterator, so `for (const doc of cursor)` is a
+     * fallback-only spelling - it works locally and throws "is not iterable" the
+     * moment TINA4_MONGO_URI is set. Use `for await (const doc of cursor)`.
+     *
+     * toList() is gone for the same reason: the driver's FindCursor has no such
+     * method.
+     *
+     * ADR-0035 restored the uniform spellings in ruby and php through a
+     * delegator, and deliberately did NOT do so here. A delegator can only supply
+     * a method that is POSSIBLE on the real provider, and a synchronous iterator
+     * is not: a FindCursor is async-only. Adding one back on the fallback alone
+     * would recreate ADR-0025's worst measured defect - identical source changing
+     * TYPE, with a truthy Promise passing `if (doc)` for a document that does not
+     * exist. That is ADR-0025 corollary 3, which ADR-0035 keeps.
+     */
+    [Symbol.asyncIterator](): AsyncIterator<Record<string, unknown>>;
+}
+/** A SQLite-backed collection exposing the everyday MongoDB driver API. */
+export declare class SqliteCollection {
+    #private;
+    constructor(conn: DatabaseSync, name: string);
+    insertOne(document: Record<string, unknown>): Promise<InsertOneResult>;
+    insertMany(documents: Record<string, unknown>[]): Promise<InsertManyResult>;
+    find(filter?: Record<string, unknown> | null, projection?: Record<string, unknown> | null): Cursor;
+    findOne(filter?: Record<string, unknown> | null, projection?: Record<string, unknown> | null): Promise<Record<string, unknown> | null>;
+    countDocuments(filter?: Record<string, unknown> | null): Promise<number>;
+    estimatedDocumentCount(): Promise<number>;
+    distinct(key: string, filter?: Record<string, unknown> | null): Promise<unknown[]>;
+    updateOne(filter: Record<string, unknown> | null | undefined, update: Record<string, unknown>, options?: {
+        upsert?: boolean;
+    }): Promise<UpdateResult>;
+    updateMany(filter: Record<string, unknown> | null | undefined, update: Record<string, unknown>, options?: {
+        upsert?: boolean;
+    }): Promise<UpdateResult>;
+    replaceOne(filter: Record<string, unknown> | null | undefined, replacement: Record<string, unknown>, options?: {
+        upsert?: boolean;
+    }): Promise<UpdateResult>;
+    deleteOne(filter?: Record<string, unknown> | null): Promise<DeleteResult>;
+    deleteMany(filter?: Record<string, unknown> | null): Promise<DeleteResult>;
+    drop(): Promise<void>;
+}
+/** A SQLite-backed document database (a file of collection tables). */
+export declare class SqliteDatabase {
+    readonly path: string;
+    private readonly conn;
+    private readonly collections;
+    constructor(path?: string);
+    getCollection(name: string): SqliteCollection;
+    listCollectionNames(): string[];
+    close(): void;
+}
+/**
+ * A Mongo URI is configured but the MongoDB driver is not installed.
+ *
+ * ADR-0024 rule 3, settled for DocStore by ADR-0033: a provider that cannot
+ * honour an operation must RAISE, naming the provider and what is missing.
+ * Node already threw here, but with a bare ERR_MODULE_NOT_FOUND that named an
+ * npm package and not the framework decision that led there - so the outcome
+ * was loud but undocumented, and different from the other three frameworks.
+ */
+export declare class DocStoreDriverMissing extends Error {
+    constructor(message: string);
+}
+/** True when no Mongo is configured, so the SQLite fallback is in effect. */
+export declare function isServerless(): boolean;
+/**
+ * Return a collection for `name`.
+ *
+ * A real MongoDB driver `Collection` when a Mongo URI is configured (and the
+ * `mongodb` driver is installed); otherwise a `SqliteCollection` backed by the
+ * local SQLite file. Same call sites either way - only the backend differs.
+ *
+ * ALWAYS async, on BOTH providers (ADR-0025 clause 3).
+ *
+ * It used to return a SqliteCollection SYNCHRONOUSLY in serverless mode and a
+ * Promise on the real-Mongo path. That made identical source change TYPE when
+ * TINA4_MONGO_URI was set, and a Promise is always truthy - so un-awaited code
+ * read a real document locally and a thenable in production, and `if (doc)`
+ * succeeded for a document that did not exist. The driver cannot become sync,
+ * so the fallback becomes async.
+ */
+export declare function getCollection(name: string): Promise<SqliteCollection | unknown>;
+/**
+ * Close every DocStore connection: the SQLite store and all Mongo clients.
+ *
+ * A pooled client keeps the event loop alive, so a script or test that touches
+ * the real provider needs a way to let the process end on its own.
+ */
+export declare function closeDocStore(): Promise<void>;
+/** Drop the cached default SQLite store (test helper). */
+export declare function resetDefaultStore(): void;
+export {};

package/types/orm/src/fakeData.d.ts

@@ -0,0 +1,22 @@
+import { FakeData as CoreFakeData } from "../../core/src/fakeData.js";
+import type { FieldDefinition } from "./types.js";
+/**
+ * ORM-aware FakeData — wraps the core FakeData and adds forField()
+ * which generates appropriate fake data based on an ORM FieldDefinition.
+ */
+export declare class FakeData extends CoreFakeData {
+    constructor(seed?: number);
+    /**
+     * Generate a Date object within a year range.
+     * Matches the Python API's datetime() method.
+     */
+    datetime(startYear?: number, endYear?: number): Date;
+    /**
+     * Generate a fake value appropriate for an ORM field definition.
+     * Respects min/max, minLength/maxLength, and type constraints.
+     *
+     * @param fieldDef - An ORM FieldDefinition object
+     * @param columnName - Optional column name for heuristic matching (e.g. "email", "phone")
+     */
+    forField(fieldDef: FieldDefinition, columnName?: string): unknown;
+}

package/types/orm/src/index.d.ts

@@ -0,0 +1,43 @@
+export type { FieldType, FieldDefinition, ModelDefinition, DatabaseAdapter, DatabaseResult as DatabaseWriteResult, ColumnInfo, QueryOptions, RelationshipDefinition, PaginatedResult, } from "./types.js";
+export { FetchResult } from "./types.js";
+export { DatabaseResult } from "./databaseResult.js";
+export type { ColumnInfoResult } from "./databaseResult.js";
+export { Database, initDatabase, getAdapter, setAdapter, bindDatabase, createAdapterFromUrl, closeDatabase, parseDatabaseUrl, setNamedAdapter, getNamedAdapter, resolveDbPool, stripTrailingSemicolons, wrapWithCache, resetRequestCaches } from "./database.js";
+export { adapterFetch, adapterQuery, adapterFetchOne, adapterExecute, adapterStartTransaction, adapterCommit, adapterRollback, adapterTableExists, adapterTables, adapterColumns, adapterCreateTable, extractLastInsertId, } from "./database.js";
+export type { DatabaseConfig } from "./database.js";
+export { DatabaseUrl, redactCredentials } from "./databaseUrl.js";
+export type { DatabaseEngine } from "./databaseUrl.js";
+export { discoverModels } from "./model.js";
+export type { DiscoveredModel } from "./model.js";
+export { syncModels, ensureMigrationTable, getNextBatch, isMigrationApplied, recordMigration, applyMigration, rollback, getAppliedMigrations, getLastBatchMigrations, removeMigrationRecord, migrate, createMigration, status, Migration, splitStatements, parseSetTerm, normalizeQuotes, sortMigrationFiles, shouldSkipCreateTable, } from "./migration.js";
+export type { MigrationResult, MigrationStatus } from "./migration.js";
+export { AutoCrud, generateCrudRoutes, crudEligibleModels } from "./autoCrud.js";
+export type { AutoCrudOptions } from "./autoCrud.js";
+export { buildQuery, parseQueryString } from "./query.js";
+export { validate } from "./validation.js";
+export type { ValidationError } from "./validation.js";
+export { BaseModel, snakeToCamel, camelToSnake } from "./baseModel.js";
+export { QueryBuilder } from "./queryBuilder.js";
+export { SQLTranslator, QueryCache } from "./sqlTranslator.js";
+export { DEFAULT_DATABASE_CONNECT_TIMEOUT_SECONDS, CONNECT_TIMEOUT_TOLERANCE_MS, connectTimeoutMillis, driverConnectTimeoutMillis, connectTarget, withConnectTimeout, } from "./connectTimeout.js";
+export { CachedDatabaseAdapter } from "./cachedDatabase.js";
+export type { CachedAdapterOptions } from "./cachedDatabase.js";
+export { FakeData } from "./fakeData.js";
+export { seedTable, seedOrm, seedModels, autoFieldMap } from "./seeder.js";
+export type { SeedSummary, SeedOptions } from "./seeder.js";
+export { ObjectId, InvalidId, DocStoreDriverMissing, SqliteDatabase, SqliteCollection, Cursor, getCollection, isServerless, resetDefaultStore, closeDocStore, encodeValue, decodeValue, compileFilter, } from "./docstore.js";
+export type { InsertOneResult, InsertManyResult, UpdateResult, DeleteResult, } from "./docstore.js";
+export { SQLiteAdapter } from "./adapters/sqlite.js";
+export { PostgresAdapter } from "./adapters/postgres.js";
+export type { PostgresConfig } from "./adapters/postgres.js";
+export { MysqlAdapter } from "./adapters/mysql.js";
+export type { MysqlConfig } from "./adapters/mysql.js";
+export { MssqlAdapter } from "./adapters/mssql.js";
+export type { MssqlConfig } from "./adapters/mssql.js";
+export { FirebirdAdapter, normalizeFirebirdDbIdentifier, resolveFirebirdCharset } from "./adapters/firebird.js";
+export type { FirebirdConfig } from "./adapters/firebird.js";
+export { MongodbAdapter } from "./adapters/mongodb.js";
+export type { MongoConfig } from "./adapters/mongodb.js";
+export { OdbcAdapter } from "./adapters/odbc.js";
+export type { OdbcConfig } from "./adapters/odbc.js";
+export { realtime, iceServers, type RealtimeOptions, LocalStorage, S3Storage, selectStorage, storageKey, type StorageBackend, Workspace as RealtimeWorkspace, Channel as RealtimeChannel, ChannelMember as RealtimeChannelMember, Message as RealtimeMessage, Attachment as RealtimeAttachment, } from "./realtime/index.js";