kysely 0.16.1 → 0.16.5

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

@@ -4,7 +4,7 @@ import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
-import { DatabaseConnection } from '../../driver/database-connection.js';
+import { MysqlDialectConfig } from './mysql-dialect-config.js';
 /**
  * MySQL dialect that uses the [mysql2](https://github.com/sidorares/node-mysql2#readme) library.
  *
@@ -36,207 +36,3 @@ export declare class MysqlDialect implements Dialect {
      */
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
-/**
- * Config for the MySQL dialect.
- *
- * This interface is equal to `mysql2` library's pool config.
- *
- * https://github.com/sidorares/node-mysql2#using-connection-pools
- */
-export interface MysqlDialectConfig {
-    /**
-     * The MySQL user to authenticate as
-     */
-    user?: string;
-    /**
-     * The password of that MySQL user
-     */
-    password?: string;
-    /**
-     * Name of the database to use for this connection
-     */
-    database?: string;
-    /**
-     * The charset for the connection. This is called 'collation' in the SQL-level of MySQL (like utf8_general_ci).
-     * If a SQL-level charset is specified (like utf8mb4) then the default collation for that charset is used.
-     * (Default: 'UTF8_GENERAL_CI')
-     */
-    charset?: string;
-    /**
-     * The hostname of the database you are connecting to. (Default: localhost)
-     */
-    host?: string;
-    /**
-     * The port number to connect to. (Default: 3306)
-     */
-    port?: number;
-    /**
-     * The source IP address to use for TCP connection
-     */
-    localAddress?: string;
-    /**
-     * The path to a unix domain socket to connect to. When used host and port are ignored
-     */
-    socketPath?: string;
-    /**
-     * The timezone used to store local dates. (Default: 'local')
-     */
-    timezone?: string | 'local';
-    /**
-     * The milliseconds before a timeout occurs during the initial connection to the MySQL server. (Default: 10 seconds)
-     */
-    connectTimeout?: number;
-    /**
-     * Stringify objects instead of converting to values. (Default: 'false')
-     */
-    stringifyObjects?: boolean;
-    /**
-     * Allow connecting to MySQL instances that ask for the old (insecure) authentication method. (Default: false)
-     */
-    insecureAuth?: boolean;
-    /**
-     * Determines if column values should be converted to native JavaScript types. It is not recommended (and may go away / change in the future)
-     * to disable type casting, but you can currently do so on either the connection or query level. (Default: true)
-     *
-     * You can also specify a function (field: any, next: () => void) => {} to do the type casting yourself.
-     *
-     * WARNING: YOU MUST INVOKE the parser using one of these three field functions in your custom typeCast callback. They can only be called once.
-     *
-     * field.string()
-     * field.buffer()
-     * field.geometry()
-     *
-     * are aliases for
-     *
-     * parser.parseLengthCodedString()
-     * parser.parseLengthCodedBuffer()
-     * parser.parseGeometryValue()
-     *
-     * You can find which field function you need to use by looking at: RowDataPacket.prototype._typeCast
-     */
-    typeCast?: boolean | ((field: any, next: () => void) => any);
-    /**
-     * A custom query format function
-     */
-    queryFormat?: (query: string, values: any) => void;
-    /**
-     * When dealing with big numbers (BIGINT and DECIMAL columns) in the database, you should enable this option
-     * (Default: false)
-     */
-    supportBigNumbers?: boolean;
-    /**
-     * Enabling both supportBigNumbers and bigNumberStrings forces big numbers (BIGINT and DECIMAL columns) to be
-     * always returned as JavaScript String objects (Default: false). Enabling supportBigNumbers but leaving
-     * bigNumberStrings disabled will return big numbers as String objects only when they cannot be accurately
-     * represented with [JavaScript Number objects] (http://ecma262-5.com/ELS5_HTML.htm#Section_8.5)
-     * (which happens when they exceed the [-2^53, +2^53] range), otherwise they will be returned as Number objects.
-     * This option is ignored if supportBigNumbers is disabled.
-     */
-    bigNumberStrings?: boolean;
-    /**
-     * Force date types (TIMESTAMP, DATETIME, DATE) to be returned as strings rather then inflated into JavaScript Date
-     * objects. Can be true/false or an array of type names to keep as strings.
-     *
-     * (Default: false)
-     */
-    dateStrings?: boolean | Array<'TIMESTAMP' | 'DATETIME' | 'DATE'>;
-    /**
-     * This will print all incoming and outgoing packets on stdout.
-     * You can also restrict debugging to packet types by passing an array of types (strings) to debug;
-     *
-     * (Default: false)
-     */
-    debug?: any;
-    /**
-     * Generates stack traces on Error to include call site of library entrance ('long stack traces'). Slight
-     * performance penalty for most calls. (Default: true)
-     */
-    trace?: boolean;
-    /**
-     * Allow multiple MySQL statements per query. Be careful with this, it exposes you to SQL injection attacks. (Default: false)
-     */
-    multipleStatements?: boolean;
-    /**
-     * List of connection flags to use other than the default ones. It is also possible to blacklist default ones
-     */
-    flags?: Array<string>;
-    /**
-     * object with ssl parameters or a string containing name of ssl profile
-     */
-    ssl?: string | MysqlSslOptions;
-    /**
-     * Return each row as an array, not as an object.
-     * This is useful when you have duplicate column names.
-     * This can also be set in the `QueryOption` object to be applied per-query.
-     */
-    rowsAsArray?: boolean;
-    /**
-     * The milliseconds before a timeout occurs during the connection acquisition. This is slightly different from connectTimeout,
-     * because acquiring a pool connection does not always involve making a connection. (Default: 10 seconds)
-     */
-    acquireTimeout?: number;
-    /**
-     * Determines the pool's action when no connections are available and the limit has been reached. If true, the pool will queue
-     * the connection request and call it when one becomes available. If false, the pool will immediately call back with an error.
-     * (Default: true)
-     */
-    waitForConnections?: boolean;
-    /**
-     * The maximum number of connections to create at once. (Default: 10)
-     */
-    connectionLimit?: number;
-    /**
-     * The maximum number of connection requests the pool will queue before returning an error from getConnection. If set to 0, there
-     * is no limit to the number of queued connection requests. (Default: 0)
-     */
-    queueLimit?: number;
-    /**
-     * Enable keep-alive on the socket.  It's disabled by default, but the
-     * user can enable it and supply an initial delay.
-     */
-    enableKeepAlive?: true;
-    /**
-     * If keep-alive is enabled users can supply an initial delay.
-     */
-    keepAliveInitialDelay?: number;
-    /**
-     * Called once for each created connection.
-     *
-     * This is a Kysely specific feature and does not come from the `mysql2` module.
-     */
-    onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
-}
-export interface MysqlSslOptions {
-    /**
-     * A string or buffer holding the PFX or PKCS12 encoded private key, certificate and CA certificates
-     */
-    pfx?: string;
-    /**
-     * A string holding the PEM encoded private key
-     */
-    key?: string;
-    /**
-     * A string of passphrase for the private key or pfx
-     */
-    passphrase?: string;
-    /**
-     * A string holding the PEM encoded certificate
-     */
-    cert?: string;
-    /**
-     * Either a string or list of strings of PEM encoded CA certificates to trust.
-     */
-    ca?: string | string[];
-    /**
-     * Either a string or list of strings of PEM encoded CRLs (Certificate Revocation List)
-     */
-    crl?: string | string[];
-    /**
-     * A string describing the ciphers to use or exclude
-     */
-    ciphers?: string;
-    /**
-     * You can also connect to a MySQL server without properly providing the appropriate CA to trust. You should not do this.
-     */
-    rejectUnauthorized?: boolean;
-}

package/dist/esm/dialect/mysql/mysql-dialect.js

@@ -1,3 +1,4 @@
+/// <reference types="./mysql-dialect.d.ts" />
 import { MysqlDriver } from './mysql-driver.js';
 import { MysqlQueryCompiler } from './mysql-query-compiler.js';
 import { MysqlIntrospector } from './mysql-introspector.js';

package/dist/esm/dialect/mysql/mysql-driver.d.ts

@@ -1,6 +1,6 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
-import { MysqlDialectConfig } from './mysql-dialect.js';
+import { MysqlDialectConfig } from './mysql-dialect-config.js';
 export declare class MysqlDriver implements Driver {
     #private;
     constructor(config: MysqlDialectConfig);

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

@@ -1,6 +1,6 @@
+/// <reference types="./mysql-driver.d.ts" />
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { importNamedFunction } from '../../util/dynamic-import.js';
-import { isObject } from '../../util/object-utils.js';
+import { isFunction, isObject } from '../../util/object-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class MysqlDriver {
     #config;
@@ -79,7 +79,16 @@ export class MysqlDriver {
 }
 async function importMysqlPoolFactory() {
     try {
-        return await importNamedFunction('mysql2', 'createPool');
+        // The imported module name must be a string literal to make
+        // some bundlers work. So don't move this code behind a helper
+        // for example.
+        const mysqlModule = await import('mysql2');
+        if (isFunction(mysqlModule.createPool)) {
+            return mysqlModule.createPool;
+        }
+        else {
+            return mysqlModule.default.createPool;
+        }
     }
     catch (error) {
         throw new Error('MySQL client not installed. Please run `npm install mysql2`');

package/dist/esm/dialect/mysql/mysql-introspector.js

@@ -1,3 +1,4 @@
+/// <reference types="./mysql-introspector.d.ts" />
 import { MIGRATION_LOCK_TABLE, MIGRATION_TABLE, } from '../../migration/migrator.js';
 import { freeze } from '../../util/object-utils.js';
 export class MysqlIntrospector {

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

@@ -1,3 +1,4 @@
+/// <reference types="./mysql-query-compiler.d.ts" />
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export class MysqlQueryCompiler extends DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {

package/dist/esm/dialect/postgres/postgres-adapter.js

@@ -1,3 +1,4 @@
+/// <reference types="./postgres-adapter.d.ts" />
 import { DialectAdapterBase } from '../dialect-adapter-base.js';
 // Random id for our transaction lock.
 const LOCK_ID = '3853314791062309107';

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

@@ -0,0 +1,103 @@
+/// <reference types="node" />
+import * as stream from 'stream';
+import { ConnectionOptions } from 'tls';
+import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * Config for the PostgreSQL dialect.
+ *
+ * This interface is equal to `pg` library's `Pool` config:
+ *
+ * https://node-postgres.com/api/pool
+ * https://node-postgres.com/api/client
+ */
+export interface PostgresDialectConfig {
+    /**
+     * defaults process.env.PGUSER || process.env.USER.
+     */
+    user?: string;
+    /**
+     * default process.env.PGDATABASE || process.env.USER
+     */
+    database?: string;
+    /**
+     * default process.env.PGPASSWORD
+     */
+    password?: string | (() => string | Promise<string>);
+    /**
+     * default process.env.PGPORT
+     */
+    port?: number;
+    /**
+     * default process.env.PGHOST
+     */
+    host?: string;
+    /**
+     * e.g. postgres:*user:password@host:5432/database
+     */
+    connectionString?: string;
+    /**
+     * passed directly to node.TLSSocket, supports all tls.connect options
+     */
+    ssl?: boolean | ConnectionOptions;
+    /**
+     * Number of milliseconds to wait before timing out when connecting a new client
+     * by default this is 0 which means no timeout.
+     */
+    connectionTimeoutMillis?: number;
+    /**
+     * Maximum number of clients the pool should contain. by default this is set to 10.
+     */
+    max?: number;
+    /**
+     * Minimum number of clients the pool should contain
+     */
+    min?: number;
+    /**
+     * Number of milliseconds a client must sit idle in the pool and not be checked out
+     * before it is disconnected from the backend and discarded.
+     *
+     * default is 10000 (10 seconds) - set to 0 to disable auto-disconnection of idle clients.
+     */
+    idleTimeoutMillis?: number;
+    /**
+     * Default behavior is the pool will keep clients open & connected to the backend
+     * until idleTimeoutMillis expire for each client and node will maintain a ref
+     * to the socket on the client, keeping the event loop alive until all clients are closed
+     * after being idle or the pool is manually shutdown with `pool.end()`.
+     *
+     * 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 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;
+    log?: (...messages: any[]) => void;
+    /**
+     * Number of milliseconds before a statement in query will time out, default is no timeout.
+     */
+    statement_timeout?: false | number;
+    /**
+     * Number of milliseconds before terminating any session with an open idle transaction.
+     * Default is no timeout.
+     */
+    idle_in_transaction_session_timeout?: number;
+    /**
+     * Number of milliseconds before a query call will timeout, default is no timeout.
+     */
+    query_timeout?: number;
+    /**
+     * The name of the application that created this Client instance.
+     */
+    application_name?: string;
+    /**
+     * Called once for each created connection.
+     *
+     * This is a Kysely specific feature and does not come from the `pg` module.
+     */
+    onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
+    keepAlive?: boolean;
+    keepAliveInitialDelayMillis?: number;
+    types?: any;
+    stream?: stream.Duplex;
+    parseInputDatesAsUTC?: boolean;
+}

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

@@ -0,0 +1,2 @@
+/// <reference types="./postgres-dialect-config.d.ts" />
+export {};

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

@@ -1,13 +1,10 @@
-/// <reference types="node" />
-import * as stream from 'stream';
-import { ConnectionOptions } from 'tls';
 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 '../database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
-import { DatabaseConnection } from '../../driver/database-connection.js';
+import { PostgresDialectConfig } from './postgres-dialect-config.js';
 /**
  * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
  *
@@ -42,102 +39,3 @@ export declare class PostgresDialect implements Dialect {
      */
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
-/**
- * Config for the PostgreSQL dialect.
- *
- * This interface is equal to `pg` library's `Pool` config:
- *
- * https://node-postgres.com/api/pool
- * https://node-postgres.com/api/client
- */
-export interface PostgresDialectConfig {
-    /**
-     * defaults process.env.PGUSER || process.env.USER.
-     */
-    user?: string;
-    /**
-     * default process.env.PGDATABASE || process.env.USER
-     */
-    database?: string;
-    /**
-     * default process.env.PGPASSWORD
-     */
-    password?: string | (() => string | Promise<string>);
-    /**
-     * default process.env.PGPORT
-     */
-    port?: number;
-    /**
-     * default process.env.PGHOST
-     */
-    host?: string;
-    /**
-     * e.g. postgres:*user:password@host:5432/database
-     */
-    connectionString?: string;
-    /**
-     * passed directly to node.TLSSocket, supports all tls.connect options
-     */
-    ssl?: boolean | ConnectionOptions;
-    /**
-     * Number of milliseconds to wait before timing out when connecting a new client
-     * by default this is 0 which means no timeout.
-     */
-    connectionTimeoutMillis?: number;
-    /**
-     * Maximum number of clients the pool should contain. by default this is set to 10.
-     */
-    max?: number;
-    /**
-     * Minimum number of clients the pool should contain
-     */
-    min?: number;
-    /**
-     * Number of milliseconds a client must sit idle in the pool and not be checked out
-     * before it is disconnected from the backend and discarded.
-     *
-     * default is 10000 (10 seconds) - set to 0 to disable auto-disconnection of idle clients.
-     */
-    idleTimeoutMillis?: number;
-    /**
-     * Default behavior is the pool will keep clients open & connected to the backend
-     * until idleTimeoutMillis expire for each client and node will maintain a ref
-     * to the socket on the client, keeping the event loop alive until all clients are closed
-     * after being idle or the pool is manually shutdown with `pool.end()`.
-     *
-     * 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 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;
-    log?: (...messages: any[]) => void;
-    /**
-     * Number of milliseconds before a statement in query will time out, default is no timeout.
-     */
-    statement_timeout?: false | number;
-    /**
-     * Number of milliseconds before terminating any session with an open idle transaction.
-     * Default is no timeout.
-     */
-    idle_in_transaction_session_timeout?: number;
-    /**
-     * Number of milliseconds before a query call will timeout, default is no timeout.
-     */
-    query_timeout?: number;
-    /**
-     * The name of the application that created this Client instance.
-     */
-    application_name?: string;
-    /**
-     * Called once for each created connection.
-     *
-     * This is a Kysely specific feature and does not come from the `pg` module.
-     */
-    onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
-    keepAlive?: boolean;
-    keepAliveInitialDelayMillis?: number;
-    types?: any;
-    stream?: stream.Duplex;
-    parseInputDatesAsUTC?: boolean;
-}

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

@@ -1,3 +1,4 @@
+/// <reference types="./postgres-dialect.d.ts" />
 import { PostgresDriver } from './postgres-driver.js';
 import { PostgresIntrospector } from './postgres-introspector.js';
 import { PostgresQueryCompiler } from './postgres-query-compiler.js';

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

@@ -1,6 +1,6 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
-import { PostgresDialectConfig } from './postgres-dialect.js';
+import { PostgresDialectConfig } from './postgres-dialect-config.js';
 export declare class PostgresDriver implements Driver {
     #private;
     constructor(config: PostgresDialectConfig);

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

@@ -1,5 +1,6 @@
+/// <reference types="./postgres-driver.d.ts" />
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { importNamedFunction } from '../../util/dynamic-import.js';
+import { isFunction } from '../../util/object-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class PostgresDriver {
     #config;
@@ -62,7 +63,16 @@ export class PostgresDriver {
 }
 async function importPgPool() {
     try {
-        return await importNamedFunction('pg', 'Pool');
+        // The imported module name must be a string literal to make
+        // some bundlers work. So don't move this code behind a helper
+        // for example.
+        const pgModule = await import('pg');
+        if (isFunction(pgModule.Pool)) {
+            return pgModule.Pool;
+        }
+        else {
+            return pgModule.default.Pool;
+        }
     }
     catch (error) {
         throw new Error('Postgres client not installed. Please run `npm install pg`');

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

@@ -1,3 +1,4 @@
+/// <reference types="./postgres-introspector.d.ts" />
 import { MIGRATION_LOCK_TABLE, MIGRATION_TABLE, } from '../../migration/migrator.js';
 import { freeze } from '../../util/object-utils.js';
 export class PostgresIntrospector {

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

@@ -1,3 +1,4 @@
+/// <reference types="./postgres-query-compiler.d.ts" />
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export class PostgresQueryCompiler extends DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {

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

@@ -1,3 +1,4 @@
+/// <reference types="./sqlite-adapter.d.ts" />
 export class SqliteAdapter {
     get supportsTransactionalDdl() {
         return false;

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

@@ -0,0 +1,43 @@
+import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * 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/esm/dialect/sqlite/sqlite-dialect-config.js

@@ -0,0 +1,2 @@
+/// <reference types="./sqlite-dialect-config.d.ts" />
+export {};

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

@@ -4,7 +4,7 @@ import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
-import { DatabaseConnection } from '../../driver/database-connection.js';
+import { SqliteDialectConfig } from './sqlite-dialect-config.js';
 /**
  * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
  *
@@ -36,45 +36,3 @@ export declare class SqliteDialect implements Dialect {
      */
     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/esm/dialect/sqlite/sqlite-dialect.js

@@ -1,3 +1,4 @@
+/// <reference types="./sqlite-dialect.d.ts" />
 import { SqliteDriver } from './sqlite-driver.js';
 import { SqliteQueryCompiler } from './sqlite-query-compiler.js';
 import { SqliteIntrospector } from './sqlite-introspector.js';