kysely 0.28.17 → 0.29.0

package/dist/cjs/dialect/postgres/postgres-dialect-config.d.ts

@@ -1,68 +0,0 @@
-import type { DatabaseConnection } from '../../driver/database-connection.js';
-/**
- * Config for the PostgreSQL dialect.
- */
-export interface PostgresDialectConfig {
-    /**
-     * A postgres Pool instance or a function that returns one.
-     *
-     * If a function is provided, it's called once when the first query is executed.
-     *
-     * https://node-postgres.com/apis/pool
-     */
-    pool: PostgresPool | (() => Promise<PostgresPool>);
-    /**
-     * https://github.com/brianc/node-postgres/tree/master/packages/pg-cursor
-     *
-     * ```ts
-     * import { PostgresDialect } from 'kysely'
-     * import { Pool } from 'pg'
-     * import Cursor from 'pg-cursor'
-     * // or import * as Cursor from 'pg-cursor'
-     *
-     * new PostgresDialect({
-     *  cursor: Cursor,
-     *  pool: new Pool('postgres://localhost:5432/mydb')
-     * })
-     * ```
-     */
-    cursor?: PostgresCursorConstructor;
-    /**
-     * Called once for each created connection.
-     */
-    onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
-    /**
-     * Called every time a connection is acquired from the pool.
-     */
-    onReserveConnection?: (connection: DatabaseConnection) => Promise<void>;
-}
-/**
- * This interface is the subset of pg driver's `Pool` class that
- * kysely needs.
- *
- * We don't use the type from `pg` here to not have a dependency to it.
- *
- * https://node-postgres.com/apis/pool
- */
-export interface PostgresPool {
-    connect(): Promise<PostgresPoolClient>;
-    end(): Promise<void>;
-}
-export interface PostgresPoolClient {
-    query<R>(sql: string, parameters: ReadonlyArray<unknown>): Promise<PostgresQueryResult<R>>;
-    query<R>(cursor: PostgresCursor<R>): PostgresCursor<R>;
-    release(): void;
-}
-export interface PostgresCursor<T> {
-    read(rowsCount: number): Promise<T[]>;
-    close(): Promise<void>;
-}
-export type PostgresCursorConstructor = new <T>(sql: string, parameters: unknown[]) => PostgresCursor<T>;
-export interface PostgresQueryResult<R> {
-    command: 'UPDATE' | 'DELETE' | 'INSERT' | 'SELECT' | 'MERGE';
-    rowCount: number;
-    rows: R[];
-}
-export interface PostgresStream<T> {
-    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
-}

package/dist/cjs/dialect/postgres/postgres-dialect-config.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/dialect/postgres/postgres-dialect.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresDialect = void 0;
-const postgres_driver_js_1 = require("./postgres-driver.js");
-const postgres_introspector_js_1 = require("./postgres-introspector.js");
-const postgres_query_compiler_js_1 = require("./postgres-query-compiler.js");
-const postgres_adapter_js_1 = require("./postgres-adapter.js");
-/**
- * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
- *
- * The constructor takes an instance of {@link PostgresDialectConfig}.
- *
- * ```ts
- * import { Pool } from 'pg'
- *
- * new PostgresDialect({
- *   pool: new Pool({
- *     database: 'some_db',
- *     host: 'localhost',
- *   })
- * })
- * ```
- *
- * If you want the pool to only be created once it's first used, `pool`
- * can be a function:
- *
- * ```ts
- * import { Pool } from 'pg'
- *
- * new PostgresDialect({
- *   pool: async () => new Pool({
- *     database: 'some_db',
- *     host: 'localhost',
- *   })
- * })
- * ```
- */
-class PostgresDialect {
-    #config;
-    constructor(config) {
-        this.#config = config;
-    }
-    createDriver() {
-        return new postgres_driver_js_1.PostgresDriver(this.#config);
-    }
-    createQueryCompiler() {
-        return new postgres_query_compiler_js_1.PostgresQueryCompiler();
-    }
-    createAdapter() {
-        return new postgres_adapter_js_1.PostgresAdapter();
-    }
-    createIntrospector(db) {
-        return new postgres_introspector_js_1.PostgresIntrospector(db);
-    }
-}
-exports.PostgresDialect = PostgresDialect;

package/dist/cjs/dialect/postgres/postgres-driver.d.ts

@@ -1,55 +0,0 @@
-import type { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
-import type { Driver, TransactionSettings } from '../../driver/driver.js';
-import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import type { QueryCompiler } from '../../query-compiler/query-compiler.js';
-import type { PostgresCursorConstructor, PostgresDialectConfig, PostgresPoolClient } from './postgres-dialect-config.js';
-declare const PRIVATE_RELEASE_METHOD: unique symbol;
-export declare class PostgresDriver implements Driver {
-    #private;
-    constructor(config: PostgresDialectConfig);
-    /**
-     * Initializes the driver.
-     *
-     * After calling this method the driver should be usable and `acquireConnection` etc.
-     * methods should be callable.
-     */
-    init(): Promise<void>;
-    /**
-     * Acquires a new connection from the pool.
-     */
-    acquireConnection(): Promise<DatabaseConnection>;
-    /**
-     * Begins a transaction.
-     */
-    beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
-    /**
-     * Commits a transaction.
-     */
-    commitTransaction(connection: DatabaseConnection): Promise<void>;
-    /**
-     * Rolls back a transaction.
-     */
-    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
-    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    /**
-     * Releases a connection back to the pool.
-     */
-    releaseConnection(connection: PostgresConnection): Promise<void>;
-    /**
-     * Destroys the driver and releases all resources.
-     */
-    destroy(): Promise<void>;
-}
-interface PostgresConnectionOptions {
-    cursor: PostgresCursorConstructor | null;
-}
-declare class PostgresConnection implements DatabaseConnection {
-    #private;
-    constructor(client: PostgresPoolClient, options: PostgresConnectionOptions);
-    executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
-    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
-    [PRIVATE_RELEASE_METHOD](): void;
-}
-export {};

package/dist/cjs/dialect/postgres/postgres-driver.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresDriver = void 0;
-const savepoint_parser_js_1 = require("../../parser/savepoint-parser.js");
-const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
-const object_utils_js_1 = require("../../util/object-utils.js");
-const query_id_js_1 = require("../../util/query-id.js");
-const stack_trace_utils_js_1 = require("../../util/stack-trace-utils.js");
-const PRIVATE_RELEASE_METHOD = Symbol();
-class PostgresDriver {
-    #config;
-    #connections = new WeakMap();
-    #pool;
-    constructor(config) {
-        this.#config = (0, object_utils_js_1.freeze)({ ...config });
-    }
-    async init() {
-        this.#pool = (0, object_utils_js_1.isFunction)(this.#config.pool)
-            ? await this.#config.pool()
-            : this.#config.pool;
-    }
-    async acquireConnection() {
-        const client = await this.#pool.connect();
-        let connection = this.#connections.get(client);
-        if (!connection) {
-            connection = new PostgresConnection(client, {
-                cursor: this.#config.cursor ?? null,
-            });
-            this.#connections.set(client, connection);
-            // The driver must take care of calling `onCreateConnection` when a new
-            // connection is created. The `pg` module doesn't provide an async hook
-            // for the connection creation. We need to call the method explicitly.
-            if (this.#config.onCreateConnection) {
-                await this.#config.onCreateConnection(connection);
-            }
-        }
-        if (this.#config.onReserveConnection) {
-            await this.#config.onReserveConnection(connection);
-        }
-        return connection;
-    }
-    async beginTransaction(connection, settings) {
-        if (settings.isolationLevel || settings.accessMode) {
-            let sql = 'start transaction';
-            if (settings.isolationLevel) {
-                sql += ` isolation level ${settings.isolationLevel}`;
-            }
-            if (settings.accessMode) {
-                sql += ` ${settings.accessMode}`;
-            }
-            await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw(sql));
-        }
-        else {
-            await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('begin'));
-        }
-    }
-    async commitTransaction(connection) {
-        await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('commit'));
-    }
-    async rollbackTransaction(connection) {
-        await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('rollback'));
-    }
-    async savepoint(connection, savepointName, compileQuery) {
-        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('savepoint', savepointName), (0, query_id_js_1.createQueryId)()));
-    }
-    async rollbackToSavepoint(connection, savepointName, compileQuery) {
-        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('rollback to', savepointName), (0, query_id_js_1.createQueryId)()));
-    }
-    async releaseSavepoint(connection, savepointName, compileQuery) {
-        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('release', savepointName), (0, query_id_js_1.createQueryId)()));
-    }
-    async releaseConnection(connection) {
-        connection[PRIVATE_RELEASE_METHOD]();
-    }
-    async destroy() {
-        if (this.#pool) {
-            const pool = this.#pool;
-            this.#pool = undefined;
-            await pool.end();
-        }
-    }
-}
-exports.PostgresDriver = PostgresDriver;
-class PostgresConnection {
-    #client;
-    #options;
-    constructor(client, options) {
-        this.#client = client;
-        this.#options = options;
-    }
-    async executeQuery(compiledQuery) {
-        try {
-            const { command, rowCount, rows } = await this.#client.query(compiledQuery.sql, [...compiledQuery.parameters]);
-            return {
-                numAffectedRows: command === 'INSERT' ||
-                    command === 'UPDATE' ||
-                    command === 'DELETE' ||
-                    command === 'MERGE'
-                    ? BigInt(rowCount)
-                    : undefined,
-                rows: rows ?? [],
-            };
-        }
-        catch (err) {
-            throw (0, stack_trace_utils_js_1.extendStackTrace)(err, new Error());
-        }
-    }
-    async *streamQuery(compiledQuery, chunkSize) {
-        if (!this.#options.cursor) {
-            throw new Error("'cursor' is not present in your postgres dialect config. It's required to make streaming work in postgres.");
-        }
-        if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
-            throw new Error('chunkSize must be a positive integer');
-        }
-        const cursor = this.#client.query(new this.#options.cursor(compiledQuery.sql, compiledQuery.parameters.slice()));
-        try {
-            while (true) {
-                const rows = await cursor.read(chunkSize);
-                if (rows.length === 0) {
-                    break;
-                }
-                yield {
-                    rows,
-                };
-            }
-        }
-        finally {
-            await cursor.close();
-        }
-    }
-    [PRIVATE_RELEASE_METHOD]() {
-        this.#client.release();
-    }
-}

package/dist/cjs/dialect/postgres/postgres-introspector.d.ts

@@ -1,20 +0,0 @@
-import type { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
-import type { Kysely } from '../../kysely.js';
-export declare class PostgresIntrospector implements DatabaseIntrospector {
-    #private;
-    constructor(db: Kysely<any>);
-    /**
-     * Get schema metadata.
-     */
-    getSchemas(): Promise<SchemaMetadata[]>;
-    /**
-     * Get tables and views metadata.
-     */
-    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
-    /**
-     * Get the database metadata such as table and column names.
-     *
-     * @deprecated Use getTables() instead.
-     */
-    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
-}

package/dist/cjs/dialect/postgres/postgres-introspector.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresIntrospector = void 0;
-const migrator_js_1 = require("../../migration/migrator.js");
-const object_utils_js_1 = require("../../util/object-utils.js");
-const sql_js_1 = require("../../raw-builder/sql.js");
-class PostgresIntrospector {
-    #db;
-    constructor(db) {
-        this.#db = db;
-    }
-    async getSchemas() {
-        let rawSchemas = await this.#db
-            .selectFrom('pg_catalog.pg_namespace')
-            .select('nspname')
-            .$castTo()
-            .execute();
-        return rawSchemas.map((it) => ({ name: it.nspname }));
-    }
-    async getTables(options = { withInternalKyselyTables: false }) {
-        let query = this.#db
-            // column
-            .selectFrom('pg_catalog.pg_attribute as a')
-            // table
-            .innerJoin('pg_catalog.pg_class as c', 'a.attrelid', 'c.oid')
-            // table schema
-            .innerJoin('pg_catalog.pg_namespace as ns', 'c.relnamespace', 'ns.oid')
-            // column data type
-            .innerJoin('pg_catalog.pg_type as typ', 'a.atttypid', 'typ.oid')
-            // column data type schema
-            .innerJoin('pg_catalog.pg_namespace as dtns', 'typ.typnamespace', 'dtns.oid')
-            .select([
-            'a.attname as column',
-            'a.attnotnull as not_null',
-            'a.atthasdef as has_default',
-            'c.relname as table',
-            'c.relkind as table_type',
-            'ns.nspname as schema',
-            'typ.typname as type',
-            'dtns.nspname as type_schema',
-            (0, sql_js_1.sql) `col_description(a.attrelid, a.attnum)`.as('column_description'),
-            (0, sql_js_1.sql) `pg_get_serial_sequence(quote_ident(ns.nspname) || '.' || quote_ident(c.relname), a.attname)`.as('auto_incrementing'),
-        ])
-            .where('c.relkind', 'in', [
-            'r' /*regular table*/,
-            'v' /*view*/,
-            'p' /*partitioned table*/,
-        ])
-            .where('ns.nspname', '!~', '^pg_')
-            .where('ns.nspname', '!=', 'information_schema')
-            // Filter out internal cockroachdb schema
-            .where('ns.nspname', '!=', 'crdb_internal')
-            // Only schemas where we are allowed access
-            .where((0, sql_js_1.sql) `has_schema_privilege(ns.nspname, 'USAGE')`)
-            // No system columns
-            .where('a.attnum', '>=', 0)
-            .where('a.attisdropped', '!=', true)
-            .orderBy('ns.nspname')
-            .orderBy('c.relname')
-            .orderBy('a.attnum')
-            .$castTo();
-        if (!options.withInternalKyselyTables) {
-            query = query
-                .where('c.relname', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
-                .where('c.relname', '!=', migrator_js_1.DEFAULT_MIGRATION_LOCK_TABLE);
-        }
-        const rawColumns = await query.execute();
-        return this.#parseTableMetadata(rawColumns);
-    }
-    async getMetadata(options) {
-        return {
-            tables: await this.getTables(options),
-        };
-    }
-    #parseTableMetadata(columns) {
-        const tableDictionary = new Map();
-        for (let i = 0, len = columns.length; i < len; i++) {
-            const column = columns[i];
-            const { schema, table } = column;
-            const tableKey = `schema:${schema};table:${table}`;
-            if (!tableDictionary.has(tableKey)) {
-                tableDictionary.set(tableKey, (0, object_utils_js_1.freeze)({
-                    columns: [],
-                    isView: column.table_type === 'v',
-                    name: table,
-                    schema,
-                }));
-            }
-            tableDictionary.get(tableKey).columns.push((0, object_utils_js_1.freeze)({
-                comment: column.column_description ?? undefined,
-                dataType: column.type,
-                dataTypeSchema: column.type_schema,
-                hasDefaultValue: column.has_default,
-                isAutoIncrementing: column.auto_incrementing !== null,
-                isNullable: !column.not_null,
-                name: column.column,
-            }));
-        }
-        return Array.from(tableDictionary.values());
-    }
-}
-exports.PostgresIntrospector = PostgresIntrospector;

package/dist/cjs/dialect/postgres/postgres-query-compiler.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresQueryCompiler = void 0;
-const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
-const ID_WRAP_REGEX = /"/g;
-class PostgresQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
-    sanitizeIdentifier(identifier) {
-        return identifier.replace(ID_WRAP_REGEX, '""');
-    }
-}
-exports.PostgresQueryCompiler = PostgresQueryCompiler;

package/dist/cjs/dialect/sqlite/sqlite-adapter.d.ts

@@ -1,80 +0,0 @@
-import type { Kysely } from '../../kysely.js';
-import { DialectAdapterBase } from '../dialect-adapter-base.js';
-import type { MigrationLockOptions } from '../dialect-adapter.js';
-export declare class SqliteAdapter extends DialectAdapterBase {
-    /**
-     * Whether or not this dialect supports transactional DDL.
-     *
-     * If this is true, migrations are executed inside a transaction.
-     */
-    get supportsTransactionalDdl(): boolean;
-    /**
-     * Whether or not this dialect supports the `returning` in inserts
-     * updates and deletes.
-     */
-    get supportsReturning(): boolean;
-    /**
-     * This method is used to acquire a lock for the migrations so that
-     * it's not possible for two migration operations to run in parallel.
-     *
-     * Most dialects have explicit locks that can be used, like advisory locks
-     * in PostgreSQL and the get_lock function in MySQL.
-     *
-     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
-     * created by Kysely can be used instead. You can access it through the `options` object.
-     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
-     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
-     * takes care of creating the lock table and inserting the one single row to it before this
-     * method is executed. If the dialect supports schemas and the user has specified a custom
-     * schema in their migration settings, the options object also contains the schema name in
-     * {@link MigrationLockOptions.lockTableSchema}.
-     *
-     * Here's an example of how you might implement this method for a dialect that doesn't
-     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
-     *
-     * ```ts
-     * import { DialectAdapterBase, type MigrationLockOptions, Kysely } from 'kysely'
-     *
-     * export class MyAdapter extends DialectAdapterBase {
-     *   override async acquireMigrationLock(
-     *     db: Kysely<any>,
-     *     options: MigrationLockOptions
-     *   ): Promise<void> {
-     *     const queryDb = options.lockTableSchema
-     *       ? db.withSchema(options.lockTableSchema)
-     *       : db
-     *
-     *     // Since our imaginary dialect supports transactional DDL and has
-     *     // row locks, we can simply take a row lock here and it will guarantee
-     *     // all subsequent calls to this method from other transactions will
-     *     // wait until this transaction finishes.
-     *     await queryDb
-     *       .selectFrom(options.lockTable)
-     *       .selectAll()
-     *       .where('id', '=', options.lockRowId)
-     *       .forUpdate()
-     *       .execute()
-     *   }
-     *
-     *   override async releaseMigrationLock() {
-     *     // noop
-     *   }
-     * }
-     * ```
-     *
-     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
-     * is a transaction inside which the migrations will be executed. Otherwise
-     * `db` is a single connection (session) that will be used to execute the
-     * migrations.
-     */
-    acquireMigrationLock(_db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
-    /**
-     * Releases the migration lock. See {@link acquireMigrationLock}.
-     *
-     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
-     * is a transaction inside which the migrations were executed. Otherwise `db`
-     * is a single connection (session) that was used to execute the migrations
-     * and the `acquireMigrationLock` call.
-     */
-    releaseMigrationLock(_db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
-}

package/dist/cjs/dialect/sqlite/sqlite-adapter.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqliteAdapter = void 0;
-const dialect_adapter_base_js_1 = require("../dialect-adapter-base.js");
-class SqliteAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
-    get supportsTransactionalDdl() {
-        return false;
-    }
-    get supportsReturning() {
-        return true;
-    }
-    async acquireMigrationLock(_db, _opt) {
-        // SQLite only has one connection that's reserved by the migration system
-        // for the whole time between acquireMigrationLock and releaseMigrationLock.
-        // We don't need to do anything here.
-    }
-    async releaseMigrationLock(_db, _opt) {
-        // SQLite only has one connection that's reserved by the migration system
-        // for the whole time between acquireMigrationLock and releaseMigrationLock.
-        // We don't need to do anything here.
-    }
-}
-exports.SqliteAdapter = SqliteAdapter;

package/dist/cjs/dialect/sqlite/sqlite-dialect-config.d.ts

@@ -1,41 +0,0 @@
-import type { DatabaseConnection } from '../../driver/database-connection.js';
-/**
- * Config for the SQLite dialect.
- */
-export interface SqliteDialectConfig {
-    /**
-     * An sqlite Database instance or a function that returns one.
-     *
-     * If a function is provided, it's called once when the first query is executed.
-     *
-     * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
-     */
-    database: SqliteDatabase | (() => Promise<SqliteDatabase>);
-    /**
-     * Called once when the first query is executed.
-     *
-     * This is a Kysely specific feature and does not come from the `better-sqlite3` module.
-     */
-    onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
-}
-/**
- * This interface is the subset of better-sqlite3 driver's `Database` class that
- * kysely needs.
- *
- * We don't use the type from `better-sqlite3` here to not have a dependency to it.
- *
- * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
- */
-export interface SqliteDatabase {
-    close(): void;
-    prepare(sql: string): SqliteStatement;
-}
-export interface SqliteStatement {
-    readonly reader: boolean;
-    all(parameters: ReadonlyArray<unknown>): unknown[];
-    run(parameters: ReadonlyArray<unknown>): {
-        changes: number | bigint;
-        lastInsertRowid: number | bigint;
-    };
-    iterate(parameters: ReadonlyArray<unknown>): IterableIterator<unknown>;
-}

package/dist/cjs/dialect/sqlite/sqlite-dialect-config.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/dialect/sqlite/sqlite-dialect.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqliteDialect = void 0;
-const sqlite_driver_js_1 = require("./sqlite-driver.js");
-const sqlite_query_compiler_js_1 = require("./sqlite-query-compiler.js");
-const sqlite_introspector_js_1 = require("./sqlite-introspector.js");
-const sqlite_adapter_js_1 = require("./sqlite-adapter.js");
-const object_utils_js_1 = require("../../util/object-utils.js");
-/**
- * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
- *
- * The constructor takes an instance of {@link SqliteDialectConfig}.
- *
- * ```ts
- * import Database from 'better-sqlite3'
- *
- * new SqliteDialect({
- *   database: new Database('db.sqlite')
- * })
- * ```
- *
- * If you want the pool to only be created once it's first used, `database`
- * can be a function:
- *
- * ```ts
- * import Database from 'better-sqlite3'
- *
- * new SqliteDialect({
- *   database: async () => new Database('db.sqlite')
- * })
- * ```
- */
-class SqliteDialect {
-    #config;
-    constructor(config) {
-        this.#config = (0, object_utils_js_1.freeze)({ ...config });
-    }
-    createDriver() {
-        return new sqlite_driver_js_1.SqliteDriver(this.#config);
-    }
-    createQueryCompiler() {
-        return new sqlite_query_compiler_js_1.SqliteQueryCompiler();
-    }
-    createAdapter() {
-        return new sqlite_adapter_js_1.SqliteAdapter();
-    }
-    createIntrospector(db) {
-        return new sqlite_introspector_js_1.SqliteIntrospector(db);
-    }
-}
-exports.SqliteDialect = SqliteDialect;