kysely 0.16.3 → 0.16.7

package/dist/cjs/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/cjs/dialect/postgres/postgres-dialect-config.js

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

package/dist/cjs/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/cjs/dialect/postgres/postgres-dialect.js

@@ -5,6 +5,7 @@ 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");
+const object_utils_js_1 = require("../../util/object-utils.js");
 /**
  * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
  *
@@ -18,7 +19,7 @@ const postgres_adapter_js_1 = require("./postgres-adapter.js");
 class PostgresDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = (0, object_utils_js_1.freeze)({ ...config });
     }
     createDriver() {
         return new postgres_driver_js_1.PostgresDriver(this.#config);

package/dist/cjs/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/cjs/dialect/postgres/postgres-driver.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresDriver = 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 PostgresDriver {
     #config;
     #connections = new WeakMap();
     #pool = null;
     constructor(config) {
-        this.#config = config;
+        this.#config = (0, object_utils_js_1.freeze)({ ...config });
     }
     async init() {
         // Import the `pg` module here instead at the top of the file
@@ -66,7 +66,16 @@ class PostgresDriver {
 exports.PostgresDriver = PostgresDriver;
 async function importPgPool() {
     try {
-        return await (0, dynamic_import_js_1.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 Promise.resolve().then(() => require('pg'));
+        if ((0, object_utils_js_1.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/cjs/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/cjs/dialect/sqlite/sqlite-dialect-config.js

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

package/dist/cjs/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/cjs/dialect/sqlite/sqlite-dialect.js

@@ -5,6 +5,7 @@ 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.
  *
@@ -15,7 +16,7 @@ const sqlite_adapter_js_1 = require("./sqlite-adapter.js");
 class SqliteDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = (0, object_utils_js_1.freeze)({ ...config });
     }
     createDriver() {
         return new sqlite_driver_js_1.SqliteDriver(this.#config);

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

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

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

@@ -2,7 +2,6 @@
 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;
@@ -10,7 +9,7 @@ class SqliteDriver {
     #db;
     #connection;
     constructor(config) {
-        this.#config = config;
+        this.#config = (0, object_utils_js_1.freeze)({ ...config });
     }
     async init() {
         // Import the `better-sqlite3` module here instead at the top of the file
@@ -63,7 +62,16 @@ class SqliteDriver {
 exports.SqliteDriver = SqliteDriver;
 async function importBetterSqlite3Database() {
     try {
-        return await (0, dynamic_import_js_1.importFunction)('better-sqlite3');
+        // 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 sqliteModule = await Promise.resolve().then(() => require('better-sqlite3'));
+        if ((0, object_utils_js_1.isFunction)(sqliteModule)) {
+            return sqliteModule;
+        }
+        else {
+            return sqliteModule.default;
+        }
     }
     catch (error) {
         throw new Error('SQLite client not installed. Please run `npm install better-sqlite3`');

package/dist/cjs/driver/dummy-driver.d.ts

@@ -0,0 +1,68 @@
+import { DatabaseConnection } from './database-connection.js';
+import { Driver } from './driver.js';
+/**
+ * A driver that does absolutely nothing.
+ *
+ * You can use this to create Kysely instances solely for building queries
+ *
+ * ### Examples
+ *
+ * This example creates a Kysely instance for building postgres queries:
+ *
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: {
+ *     createAdapter() {
+ *       return new PostgresAdapter()
+ *     },
+ *     createDriver() {
+ *       return new DummyDriver()
+ *     },
+ *     createIntrospector(db: Kysely<any>) {
+ *       return new PostgresIntrospector(db)
+ *     },
+ *     createQueryCompiler() {
+ *       return new PostgresQueryCompiler()
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export declare class DummyDriver implements Driver {
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     *
+     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
+     * should be imported inside this function, not at the top of the driver file! This is
+     * important so that Kysely is usable without installing all database driver libraries
+     * it supports.
+     */
+    init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+}

package/dist/cjs/driver/dummy-driver.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyDriver = void 0;
+/**
+ * A driver that does absolutely nothing.
+ *
+ * You can use this to create Kysely instances solely for building queries
+ *
+ * ### Examples
+ *
+ * This example creates a Kysely instance for building postgres queries:
+ *
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: {
+ *     createAdapter() {
+ *       return new PostgresAdapter()
+ *     },
+ *     createDriver() {
+ *       return new DummyDriver()
+ *     },
+ *     createIntrospector(db: Kysely<any>) {
+ *       return new PostgresIntrospector(db)
+ *     },
+ *     createQueryCompiler() {
+ *       return new PostgresQueryCompiler()
+ *     },
+ *   },
+ * })
+ * ```
+ */
+class DummyDriver {
+    async init() {
+        // Nothing to do here.
+    }
+    async acquireConnection() {
+        return new DummyConnection();
+    }
+    async beginTransaction() {
+        // Nothing to do here.
+    }
+    async commitTransaction() {
+        // Nothing to do here.
+    }
+    async rollbackTransaction() {
+        // Nothing to do here.
+    }
+    async releaseConnection() {
+        // Nothing to do here.
+    }
+    async destroy() {
+        // Nothing to do here.
+    }
+}
+exports.DummyDriver = DummyDriver;
+class DummyConnection {
+    async executeQuery() {
+        return {
+            rows: [],
+        };
+    }
+}

package/dist/cjs/driver/runtime-driver.d.ts

@@ -28,7 +28,7 @@ export declare class RuntimeDriver implements Driver {
     /**
      * Releases a connection back to the pool.
      */
-    releaseConnection(runtimeConnection: DatabaseConnection): Promise<void>;
+    releaseConnection(connection: DatabaseConnection): Promise<void>;
     /**
      * Begins a transaction.
      */