kysely 0.10.1 → 0.11.3

package/README.md

@@ -39,14 +39,17 @@ using Kysely and can't find something you'd want to use, please open an issue or
 
 # Installation
 
-Kysely currently works on PostgreSQL and MySQL. You can install it using
+Kysely currently works on PostgreSQL, MySQL and SQLite. You can install it using
 
 ```
-# postgres
+# PostgreSQL
 npm install kysely pg
 
-# mysql
+# MySQL
 npm install kysely mysql2
+
+# SQLite
+npm install kysely better-sqlite3
 ```
 
 More dialects will be added soon. Kysely also has a simple interface
@@ -94,6 +97,7 @@ interface Database {
 
 // You'd create one of these when you start your app.
 const db = new Kysely<Database>({
+  // Use MysqlDialect for MySQL and SqliteDialect for SQLite.
   dialect: new PostgresDialect({
     host: 'localhost',
     database: 'kysely_test',

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

@@ -24,7 +24,7 @@ export interface DialectAdapter {
      * it's not possible for two migration processes to run in parallel.
      *
      * Most dialects have explicit locks that can be used, like advisory locks
-     * in postgres and the get_lock function in mysql.
+     * in PostgreSQL and the get_lock function in MySQL.
      *
      * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
      * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
@@ -44,7 +44,8 @@ export interface DialectAdapter {
      *
      * 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.
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
      */
     releaseMigrationLock(db: Kysely<any>): Promise<void>;
 }

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

@@ -16,7 +16,7 @@ class MysqlAdapter {
         // released when the connection is destroyed (session ends) or when the lock
         // is released using `release_lock`. This way we know that the lock is either
         // released by us after successfull or failed migrations OR it's released by
-        // mysql if the process gets killed for some reason.
+        // MySQL if the process gets killed for some reason.
         await db
             .raw(`select get_lock('${LOCK_ID}', ${LOCK_TIMEOUT_SECONDS})`)
             .execute();

package/dist/cjs/dialect/mysql/mysql-dialect.d.ts

@@ -21,7 +21,7 @@ export declare class MysqlDialect implements Dialect {
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
 /**
- * Config for the mysql dialect.
+ * Config for the MySQL dialect.
  *
  * This interface is equal to `mysql2` library's pool config.
  *
@@ -137,7 +137,7 @@ export interface MysqlDialectConfig {
      */
     trace?: boolean;
     /**
-     * Allow multiple mysql statements per query. Be careful with this, it exposes you to SQL injection attacks. (Default: false)
+     * Allow multiple MySQL statements per query. Be careful with this, it exposes you to SQL injection attacks. (Default: false)
      */
     multipleStatements?: boolean;
     /**
@@ -186,7 +186,7 @@ export interface MysqlDialectConfig {
     /**
      * Called once for each created connection.
      *
-     * This is a Kysely specific feature and does not come from the `pg` module.
+     * This is a Kysely specific feature and does not come from the `mysql2` module.
      */
     onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
 }

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlDriver = void 0;
+const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
+const dynamic_import_js_1 = require("../../util/dynamic-import.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
 const PRIVATE_RELEASE_METHOD = Symbol();
 class MysqlDriver {
@@ -50,19 +52,16 @@ class MysqlDriver {
     }
     async beginTransaction(connection, settings) {
         if (settings.isolationLevel) {
-            // On mysql this sets the isolation level of the next transaction.
-            await connection.executeQuery({
-                sql: `set transaction isolation level ${settings.isolationLevel}`,
-                parameters: [],
-            });
+            // On MySQL this sets the isolation level of the next transaction.
+            await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw(`set transaction isolation level ${settings.isolationLevel}`));
         }
-        await connection.executeQuery({ sql: 'begin', parameters: [] });
+        await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('begin'));
     }
     async commitTransaction(connection) {
-        await connection.executeQuery({ sql: 'commit', parameters: [] });
+        await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('commit'));
     }
     async rollbackTransaction(connection) {
-        await connection.executeQuery({ sql: 'rollback', parameters: [] });
+        await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('rollback'));
     }
     async releaseConnection(connection) {
         const mysqlConnection = connection;
@@ -84,19 +83,10 @@ class MysqlDriver {
 exports.MysqlDriver = MysqlDriver;
 async function importMysqlPoolFactory() {
     try {
-        // For this to work with both esm and cjs modules we need
-        // this hacky crap here.
-        const mysql = (await Promise.resolve().then(() => require('mysql2')));
-        if ((0, object_utils_js_1.isFunction)(mysql.createPool)) {
-            return mysql.createPool;
-        }
-        else {
-            // With esm the imported module doesn't match the typings.
-            return mysql.default.createPool;
-        }
+        return await (0, dynamic_import_js_1.importNamedFunction)('mysql2', 'createPool');
     }
     catch (error) {
-        throw new Error('Mysql client not installed. Please run `npm install mysql2`');
+        throw new Error('MySQL client not installed. Please run `npm install mysql2`');
     }
 }
 class MysqlConnection {
@@ -106,19 +96,19 @@ class MysqlConnection {
     }
     async executeQuery(compiledQuery) {
         const result = await this.#executeQuery(compiledQuery);
-        if ((0, object_utils_js_1.isObject)(result) && 'insertId' in result && 'affectedRows' in result) {
-            if ((0, object_utils_js_1.isNumber)(result.insertId) && result.insertId > 0) {
-                return {
-                    insertedPrimaryKey: result.insertId,
-                    rows: [],
-                };
-            }
-            else if ((0, object_utils_js_1.isNumber)(result.affectedRows)) {
-                return {
-                    numUpdatedOrDeletedRows: result.affectedRows,
-                    rows: [],
-                };
-            }
+        if (isOkPacket(result)) {
+            const { insertId, affectedRows } = result;
+            return {
+                insertId: insertId !== undefined &&
+                    insertId !== null &&
+                    insertId.toString() !== '0'
+                    ? BigInt(insertId)
+                    : undefined,
+                numUpdatedOrDeletedRows: affectedRows !== undefined && insertId !== null
+                    ? BigInt(affectedRows)
+                    : undefined,
+                rows: [],
+            };
         }
         else if (Array.isArray(result)) {
             return {
@@ -145,3 +135,6 @@ class MysqlConnection {
         this.#rawConnection.release();
     }
 }
+function isOkPacket(obj) {
+    return (0, object_utils_js_1.isObject)(obj) && 'insertId' in obj && 'affectedRows' in obj;
+}

package/dist/cjs/dialect/mysql/mysql-query-compiler.d.ts

@@ -1,7 +1,5 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
-    protected visitReturning(): void;
-    protected getSql(): string;
     protected getCurrentParameterPlaceholder(): string;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;

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

@@ -3,12 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlQueryCompiler = void 0;
 const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
 class MysqlQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
-    visitReturning() {
-        // Do nothing.
-    }
-    getSql() {
-        return super.getSql().trimEnd();
-    }
     getCurrentParameterPlaceholder() {
         return '?';
     }

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

@@ -27,7 +27,7 @@ export declare class PostgresDialect implements Dialect {
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
 /**
- * Config for the postgres dialect.
+ * Config for the PostgreSQL dialect.
  *
  * This interface is equal to `pg` library's `Pool` config:
  *
@@ -91,7 +91,7 @@ export interface PostgresDialectConfig {
      *
      * Setting `allowExitOnIdle: true` in the config will allow the node event loop to exit
      * as soon as all clients in the pool are idle, even if their socket is still open
-     * to the postgres server.  This can be handy in scripts & tests
+     * to the PostgreSQL server.  This can be handy in scripts & tests
      * where you don't want to wait for your clients to go idle before your process exits.
      */
     allowExitOnIdle?: boolean;

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresDriver = void 0;
-const object_utils_js_1 = require("../../util/object-utils.js");
+const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
+const dynamic_import_js_1 = require("../../util/dynamic-import.js");
 const PRIVATE_RELEASE_METHOD = Symbol();
 class PostgresDriver {
     #config;
@@ -38,20 +39,17 @@ class PostgresDriver {
     }
     async beginTransaction(connection, settings) {
         if (settings.isolationLevel) {
-            await connection.executeQuery({
-                sql: `start transaction isolation level ${settings.isolationLevel}`,
-                parameters: [],
-            });
+            await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw(`start transaction isolation level ${settings.isolationLevel}`));
         }
         else {
-            await connection.executeQuery({ sql: 'begin', parameters: [] });
+            await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('begin'));
         }
     }
     async commitTransaction(connection) {
-        await connection.executeQuery({ sql: 'commit', parameters: [] });
+        await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('commit'));
     }
     async rollbackTransaction(connection) {
-        await connection.executeQuery({ sql: 'rollback', parameters: [] });
+        await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('rollback'));
     }
     async releaseConnection(connection) {
         const pgConnection = connection;
@@ -68,16 +66,7 @@ class PostgresDriver {
 exports.PostgresDriver = PostgresDriver;
 async function importPgPool() {
     try {
-        // For this to work with both esm and cjs modules we need
-        // this hacky crap here.
-        const pg = (await Promise.resolve().then(() => require('pg')));
-        if ((0, object_utils_js_1.isFunction)(pg.Pool)) {
-            return pg.Pool;
-        }
-        else {
-            // With esm the imported module doesn't match the typings.
-            return pg.default.Pool;
-        }
+        return await (0, dynamic_import_js_1.importNamedFunction)('pg', 'Pool');
     }
     catch (error) {
         throw new Error('Postgres client not installed. Please run `npm install pg`');
@@ -94,7 +83,7 @@ class PostgresConnection {
         ]);
         if (result.command === 'UPDATE' || result.command === 'DELETE') {
             return {
-                numUpdatedOrDeletedRows: result.rowCount,
+                numUpdatedOrDeletedRows: BigInt(result.rowCount),
                 rows: result.rows ?? [],
             };
         }

package/dist/cjs/dialect/postgres/postgres-query-compiler.d.ts

@@ -1,3 +1,6 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class PostgresQueryCompiler extends DefaultQueryCompiler {
+    protected getCurrentParameterPlaceholder(): string;
+    protected getLeftIdentifierWrapper(): string;
+    protected getRightIdentifierWrapper(): string;
 }

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

@@ -2,7 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresQueryCompiler = void 0;
 const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
-// The default query compiler is for PostgreSQL.
 class PostgresQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
+    getCurrentParameterPlaceholder() {
+        return '$' + this.numParameters;
+    }
+    getLeftIdentifierWrapper() {
+        return '"';
+    }
+    getRightIdentifierWrapper() {
+        return '"';
+    }
 }
 exports.PostgresQueryCompiler = PostgresQueryCompiler;

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

@@ -0,0 +1,7 @@
+import { DialectAdapter } from '../dialect-adapter.js';
+export declare class SqliteAdapter implements DialectAdapter {
+    get supportsTransactionalDdl(): boolean;
+    get supportsReturning(): boolean;
+    acquireMigrationLock(): Promise<void>;
+    releaseMigrationLock(): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteAdapter = void 0;
+class SqliteAdapter {
+    get supportsTransactionalDdl() {
+        return false;
+    }
+    get supportsReturning() {
+        return false;
+    }
+    async acquireMigrationLock() {
+        // Nothing to do here.
+    }
+    async releaseMigrationLock() {
+        // Nothing to do here.
+    }
+}
+exports.SqliteAdapter = SqliteAdapter;

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

@@ -0,0 +1,64 @@
+import { Driver } from '../../driver/driver.js';
+import { Kysely } from '../../kysely.js';
+import { QueryCompiler } from '../../query-compiler/query-compiler.js';
+import { Dialect } from '../dialect.js';
+import { DatabaseIntrospector } from '../../introspection/database-introspector.js';
+import { DialectAdapter } from '../dialect-adapter.js';
+import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
+ *
+ * The {@link SqliteDialectConfig | configuration} is used to construct an instance of
+ * [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
+ * class. The configuration values are passed directly to the `Database` constructor.
+ */
+export declare class SqliteDialect implements Dialect {
+    #private;
+    constructor(config: SqliteDialectConfig);
+    createDriver(): Driver;
+    createQueryCompiler(): QueryCompiler;
+    createAdapter(): DialectAdapter;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+}
+/**
+ * Config for the SQLite dialect.
+ *
+ * This interface is equal to `better-sqlite3` library's `Databse` class's constructor parameters.
+ *
+ * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
+ */
+export interface SqliteDialectConfig {
+    /**
+     * The database file path.
+     *
+     * This is passed as the first argument for the [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
+     * class constructor.
+     */
+    databasePath: string;
+    /**
+     * Open the database connection in readonly mode (default: false)
+     */
+    readonly?: boolean;
+    /**
+     * If the database does not exist, an Error will be thrown instead of creating a new file.
+     * This option is ignored for in-memory, temporary, or readonly database connections
+     * (default: false)
+     */
+    fileMustExist?: boolean;
+    /**
+     * The number of milliseconds to wait when executing queries on a locked database,
+     * before throwing a SQLITE_BUSY error (default: 5000)
+     */
+    timeout?: number;
+    /**
+     * Provide a function that gets called with every SQL string executed by the database connection
+     * (default: null)
+     */
+    verbose?: (sql: string) => void;
+    /**
+     * 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>;
+}

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

@@ -0,0 +1,33 @@
+"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");
+/**
+ * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
+ *
+ * The {@link SqliteDialectConfig | configuration} is used to construct an instance of
+ * [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
+ * class. The configuration values are passed directly to the `Database` constructor.
+ */
+class SqliteDialect {
+    #config;
+    constructor(config) {
+        this.#config = 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;

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

@@ -0,0 +1,14 @@
+import { DatabaseConnection } from '../../driver/database-connection.js';
+import { Driver } from '../../driver/driver.js';
+import { SqliteDialectConfig } from './sqlite-dialect.js';
+export declare class SqliteDriver implements Driver {
+    #private;
+    constructor(config: SqliteDialectConfig);
+    init(): Promise<void>;
+    acquireConnection(): Promise<DatabaseConnection>;
+    beginTransaction(connection: DatabaseConnection): Promise<void>;
+    commitTransaction(connection: DatabaseConnection): Promise<void>;
+    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    releaseConnection(): Promise<void>;
+    destroy(): Promise<void>;
+}

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

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteDriver = void 0;
+const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
+const dynamic_import_js_1 = require("../../util/dynamic-import.js");
+const object_utils_js_1 = require("../../util/object-utils.js");
+class SqliteDriver {
+    #config;
+    #connectionMutex = new ConnectionMutex();
+    #db;
+    #connection;
+    constructor(config) {
+        this.#config = config;
+    }
+    async init() {
+        // Import the `better-sqlite3` module here instead at the top of the file
+        // so that this file can be loaded by node without `better-sqlite3` driver
+        // installed. As you can see, there IS an import from `better-sqlite3` at
+        // the top level too, but that's only for types. It doesn't get compiled
+        // into javascript. You can check the built javascript code.
+        const DatabaseConstructor = await importBetterSqlite3Database();
+        const options = {};
+        if ((0, object_utils_js_1.isBoolean)(this.#config.readonly)) {
+            options.readonly = this.#config.readonly;
+        }
+        if ((0, object_utils_js_1.isBoolean)(this.#config.fileMustExist)) {
+            options.fileMustExist = this.#config.fileMustExist;
+        }
+        if ((0, object_utils_js_1.isNumber)(this.#config.timeout)) {
+            options.timeout = this.#config.timeout;
+        }
+        if ((0, object_utils_js_1.isFunction)(this.#config.verbose)) {
+            options.verbose = this.#config.verbose;
+        }
+        this.#db = new DatabaseConstructor(this.#config.databasePath, options);
+        this.#connection = new SqliteConnection(this.#db);
+        if (this.#config.onCreateConnection) {
+            await this.#config.onCreateConnection(this.#connection);
+        }
+    }
+    async acquireConnection() {
+        // SQLite only has one single connection. We use a mutex here to wait
+        // until the single connection has been released.
+        await this.#connectionMutex.lock();
+        return this.#connection;
+    }
+    async beginTransaction(connection) {
+        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 releaseConnection() {
+        this.#connectionMutex.unlock();
+    }
+    async destroy() {
+        this.#db?.close();
+    }
+}
+exports.SqliteDriver = SqliteDriver;
+async function importBetterSqlite3Database() {
+    try {
+        return await (0, dynamic_import_js_1.importFunction)('better-sqlite3');
+    }
+    catch (error) {
+        throw new Error('SQLite client not installed. Please run `npm install better-sqlite3`');
+    }
+}
+class SqliteConnection {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    executeQuery(compiledQuery) {
+        const { sql, parameters } = compiledQuery;
+        const stmt = this.#db.prepare(sql);
+        if (stmt.reader) {
+            return Promise.resolve({
+                rows: stmt.all(parameters),
+            });
+        }
+        else {
+            const { changes, lastInsertRowid } = stmt.run(parameters);
+            return Promise.resolve({
+                numUpdatedOrDeletedRows: changes !== undefined && changes !== null
+                    ? BigInt(changes)
+                    : undefined,
+                insertId: lastInsertRowid !== undefined && lastInsertRowid !== null
+                    ? BigInt(lastInsertRowid)
+                    : undefined,
+                rows: [],
+            });
+        }
+    }
+}
+class ConnectionMutex {
+    #promise;
+    #resolve;
+    async lock() {
+        while (this.#promise) {
+            await this.#promise;
+        }
+        this.#promise = new Promise((resolve) => {
+            this.#resolve = resolve;
+        });
+    }
+    unlock() {
+        const resolve = this.#resolve;
+        this.#promise = undefined;
+        this.#resolve = undefined;
+        resolve?.();
+    }
+}

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

@@ -0,0 +1,7 @@
+import { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions } from '../../introspection/database-introspector.js';
+import { Kysely } from '../../kysely.js';
+export declare class SqliteIntrospector implements DatabaseIntrospector {
+    #private;
+    constructor(db: Kysely<any>);
+    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteIntrospector = void 0;
+const migration_js_1 = require("../../migration/migration.js");
+class SqliteIntrospector {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    async getMetadata(options = { withInternalKyselyTables: false }) {
+        let query = this.#db
+            .selectFrom('sqlite_schema')
+            .where('type', '=', 'table')
+            .where('name', 'not like', 'sqlite_%')
+            .select('name')
+            .castTo();
+        if (!options.withInternalKyselyTables) {
+            query = query
+                .where('name', '!=', migration_js_1.MIGRATION_TABLE)
+                .where('name', '!=', migration_js_1.MIGRATION_LOCK_TABLE);
+        }
+        const tables = await query.execute();
+        return {
+            tables: await Promise.all(tables.map(({ name }) => this.#getTableMetadata(name))),
+        };
+    }
+    async #getTableMetadata(table) {
+        const db = this.#db;
+        const columns = await db
+            .selectFrom(db.raw(`PRAGMA_TABLE_INFO(?)`, [table]).as('table_info'))
+            .select(['name', 'type', 'notnull'])
+            .castTo()
+            .execute();
+        return {
+            name: table,
+            columns: columns.map((col) => ({
+                name: col.name,
+                dataType: col.type,
+                isNullable: !col.notnull,
+            })),
+        };
+    }
+}
+exports.SqliteIntrospector = SqliteIntrospector;

package/dist/cjs/dialect/sqlite/sqlite-query-compiler.d.ts

@@ -0,0 +1,7 @@
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+export declare class SqliteQueryCompiler extends DefaultQueryCompiler {
+    protected getCurrentParameterPlaceholder(): string;
+    protected getLeftIdentifierWrapper(): string;
+    protected getRightIdentifierWrapper(): string;
+    protected getAutoIncrement(): string;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteQueryCompiler = void 0;
+const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
+class SqliteQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
+    getCurrentParameterPlaceholder() {
+        return '?';
+    }
+    getLeftIdentifierWrapper() {
+        return '"';
+    }
+    getRightIdentifierWrapper() {
+        return '"';
+    }
+    getAutoIncrement() {
+        return 'autoincrement';
+    }
+}
+exports.SqliteQueryCompiler = SqliteQueryCompiler;