kysely 0.16.0 → 0.16.4

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-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,7 +2,7 @@
 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;
@@ -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-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;
@@ -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/index.d.ts

@@ -1,8 +1,11 @@
 export * from './index-nodeless.js';
 export * from './migration/file-migration-provider.js';
 export * from './dialect/sqlite/sqlite-dialect.js';
+export * from './dialect/sqlite/sqlite-dialect-config.js';
 export * from './dialect/sqlite/sqlite-driver.js';
 export * from './dialect/mysql/mysql-dialect.js';
+export * from './dialect/mysql/mysql-dialect-config.js';
 export * from './dialect/mysql/mysql-driver.js';
 export * from './dialect/postgres/postgres-driver.js';
+export * from './dialect/postgres/postgres-dialect-config.js';
 export * from './dialect/postgres/postgres-dialect.js';

package/dist/cjs/index.js

@@ -13,8 +13,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./index-nodeless.js"), exports);
 __exportStar(require("./migration/file-migration-provider.js"), exports);
 __exportStar(require("./dialect/sqlite/sqlite-dialect.js"), exports);
+__exportStar(require("./dialect/sqlite/sqlite-dialect-config.js"), exports);
 __exportStar(require("./dialect/sqlite/sqlite-driver.js"), exports);
 __exportStar(require("./dialect/mysql/mysql-dialect.js"), exports);
+__exportStar(require("./dialect/mysql/mysql-dialect-config.js"), exports);
 __exportStar(require("./dialect/mysql/mysql-driver.js"), exports);
 __exportStar(require("./dialect/postgres/postgres-driver.js"), exports);
+__exportStar(require("./dialect/postgres/postgres-dialect-config.js"), exports);
 __exportStar(require("./dialect/postgres/postgres-dialect.js"), exports);

package/dist/cjs/operation-node/constraint-node.d.ts

@@ -1,5 +1,5 @@
-import { CheckConstraintNode } from "./check-constraint-node";
-import { ForeignKeyConstraintNode } from "./foreign-key-constraint-node";
-import { PrimaryKeyConstraintNode } from "./primary-constraint-node";
-import { UniqueConstraintNode } from "./unique-constraint-node";
+import { CheckConstraintNode } from './check-constraint-node.js';
+import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
+import { PrimaryKeyConstraintNode } from './primary-constraint-node.js';
+import { UniqueConstraintNode } from './unique-constraint-node.js';
 export declare type ConstraintNode = PrimaryKeyConstraintNode | UniqueConstraintNode | CheckConstraintNode | ForeignKeyConstraintNode;

package/dist/cjs/plugin/camel-case/camel-case-plugin.js

@@ -111,5 +111,5 @@ class CamelCasePlugin {
 }
 exports.CamelCasePlugin = CamelCasePlugin;
 function canMap(obj) {
-    return (0, object_utils_js_1.isObject)(obj) && !(obj instanceof Date) && !Buffer.isBuffer(obj);
+    return (0, object_utils_js_1.isObject)(obj) && !(0, object_utils_js_1.isDate)(obj) && !(0, object_utils_js_1.isBuffer)(obj);
 }

package/dist/cjs/query-builder/expression-builder.d.ts

@@ -3,6 +3,8 @@ import { TableExpression, TableExpressionDatabase, TableExpressionTables } from
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
 import { ParseContext } from '../parser/parse-context.js';
 import { FunctionBuilder } from './function-builder.js';
+import { RawBuilder } from '../index-nodeless.js';
+import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
 export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
     constructor(props: ExpressionBuilderProps);
@@ -44,6 +46,8 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * The query builder returned by this method is typed in a way that you can refer to
      * all tables of the parent query in addition to the subquery's tables.
      *
+     * This method accepts all the same inputs as {@link QueryCreator.selectFrom}.
+     *
      * ### Examples
      *
      * This example shows that you can refer to both `pet.owner_id` and `person.id`
@@ -86,6 +90,44 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * See {@link QueryCreator.withSchema}
      */
     withSchema(schema: string): ExpressionBuilder<DB, TB>;
+    /**
+     * See {@link QueryCreator.raw}.
+     */
+    raw<T = unknown>(sql: string, parameters?: unknown[]): RawBuilder<T>;
+    /**
+     * This can be used to reference columns.
+     *
+     * ### Examples
+     *
+     * In the next example we use the `ref` method to reference
+     * columns of the virtual table `excluded` in a type-safe way
+     * to create an upsert operation:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
+     *
+     * In the next example we use `ref` in a raw expression. Unless you
+     * want to be as type-safe as possible, this is probably overkill:
+     *
+     * ```ts
+     * db.update('pet').set({
+     *   name: (eb) => eb.raw('concat(?, ?)', [
+     *     eb.ref('pet.name'),
+     *     suffix,
+     *   ])
+     * })
+     * ```
+     */
+    ref<RE extends StringReference<DB, TB>>(reference: RE): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
 }
 export interface ExpressionBuilderProps {
     readonly executor: NoopQueryExecutor;

package/dist/cjs/query-builder/expression-builder.js

@@ -8,6 +8,7 @@ const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugi
 const query_id_js_1 = require("../util/query-id.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const function_builder_js_1 = require("./function-builder.js");
+const index_nodeless_js_1 = require("../index-nodeless.js");
 class ExpressionBuilder {
     #props;
     constructor(props) {
@@ -64,5 +65,52 @@ class ExpressionBuilder {
             executor: this.#props.executor.withPluginAtFront(new with_schema_plugin_js_1.WithSchemaPlugin(schema)),
         });
     }
+    /**
+     * See {@link QueryCreator.raw}.
+     */
+    raw(sql, parameters) {
+        return new index_nodeless_js_1.RawBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#props.executor,
+            sql,
+            parameters,
+        });
+    }
+    /**
+     * This can be used to reference columns.
+     *
+     * ### Examples
+     *
+     * In the next example we use the `ref` method to reference
+     * columns of the virtual table `excluded` in a type-safe way
+     * to create an upsert operation:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
+     *
+     * In the next example we use `ref` in a raw expression. Unless you
+     * want to be as type-safe as possible, this is probably overkill:
+     *
+     * ```ts
+     * db.update('pet').set({
+     *   name: (eb) => eb.raw('concat(?, ?)', [
+     *     eb.ref('pet.name'),
+     *     suffix,
+     *   ])
+     * })
+     * ```
+     */
+    ref(reference) {
+        return this.raw('??', [reference]);
+    }
 }
 exports.ExpressionBuilder = ExpressionBuilder;

package/dist/cjs/query-builder/insert-query-builder.d.ts

@@ -342,6 +342,22 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * values ($1, $2)
      * on conflict ("name") do nothing
      * ```
+     *
+     * You can refer to the columns of the virtual `excluded` table
+     * in a type-safe way using a callback and the `ref` method of
+     * `ExpressionBuilder`:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
      */
     onConflict(callback: (builder: OnConflictBuilder<DB, TB>) => OnConflictDoNothingBuilder<DB, TB> | OnConflictUpdateBuilder<DB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**

package/dist/cjs/query-builder/insert-query-builder.js

@@ -248,6 +248,22 @@ class InsertQueryBuilder {
      * values ($1, $2)
      * on conflict ("name") do nothing
      * ```
+     *
+     * You can refer to the columns of the virtual `excluded` table
+     * in a type-safe way using a callback and the `ref` method of
+     * `ExpressionBuilder`:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
      */
     onConflict(callback) {
         return new InsertQueryBuilder({

package/dist/cjs/query-builder/on-conflict-builder.d.ts

@@ -377,14 +377,16 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * do update set "first_name" = $3
      * ```
      */
-    doUpdateSet(updates: MutationObject<DB, TB>): OnConflictUpdateBuilder<{
-        [K in keyof DB | 'excluded']: K extends keyof DB ? DB[K] : DB[TB];
-    }, TB | 'excluded'>;
+    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
 }
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;
     readonly parseContext: ParseContext;
 }
+export declare type OnConflictDatabase<DB, TB extends keyof DB> = {
+    [K in keyof DB | 'excluded']: K extends keyof DB ? DB[K] : DB[TB];
+};
+export declare type OnConflictTables<TB> = TB | 'excluded';
 export declare class OnConflictDoNothingBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
     #private;
     constructor(props: OnConflictBuilderProps);

package/dist/cjs/query-creator.d.ts

@@ -412,7 +412,7 @@ export declare class QueryCreator<DB> {
      * @param params - The parameters that will be bound to the `?` and `??` placeholders in
      *    the sql string.
      */
-    raw<T = unknown>(sql: string, parameters?: any[]): RawBuilder<T>;
+    raw<T = unknown>(sql: string, parameters?: unknown[]): RawBuilder<T>;
 }
 export interface QueryCreatorProps {
     readonly executor: QueryExecutor;

package/dist/cjs/util/object-utils.d.ts

@@ -6,8 +6,8 @@ export declare function isNumber(obj: unknown): obj is number;
 export declare function isBoolean(obj: unknown): obj is boolean;
 export declare function isNull(obj: unknown): obj is null;
 export declare function isDate(obj: unknown): obj is Date;
-export declare function isBuffer(obj: unknown): obj is Buffer;
 export declare function isBigInt(obj: unknown): obj is BigInt;
+export declare function isBuffer(obj: unknown): obj is Buffer;
 export declare function isPrimitive(obj: unknown): obj is PrimitiveValue;
 export declare function isFunction(obj: unknown): obj is Function;
 export declare function isObject(obj: unknown): obj is Record<string, unknown>;

package/dist/cjs/util/object-utils.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isPrimitive = exports.isBigInt = exports.isBuffer = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isEmpty = void 0;
+exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isPrimitive = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isEmpty = void 0;
 function isEmpty(obj) {
-    if (Array.isArray(obj) || isString(obj) || Buffer.isBuffer(obj)) {
+    if (Array.isArray(obj) || isString(obj) || isBuffer(obj)) {
         return obj.length === 0;
     }
     else if (obj) {
@@ -31,22 +31,22 @@ function isDate(obj) {
     return obj instanceof Date;
 }
 exports.isDate = isDate;
-function isBuffer(obj) {
-    return Buffer.isBuffer(obj);
-}
-exports.isBuffer = isBuffer;
 function isBigInt(obj) {
     return typeof obj === 'bigint';
 }
 exports.isBigInt = isBigInt;
+function isBuffer(obj) {
+    return typeof Buffer !== 'undefined' && Buffer.isBuffer(obj);
+}
+exports.isBuffer = isBuffer;
 function isPrimitive(obj) {
     return (isString(obj) ||
         isNumber(obj) ||
         isBoolean(obj) ||
         isNull(obj) ||
         isDate(obj) ||
-        isBuffer(obj) ||
-        isBigInt(obj));
+        isBigInt(obj) ||
+        isBuffer(obj));
 }
 exports.isPrimitive = isPrimitive;
 function isFunction(obj) {

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

@@ -1 +1,2 @@
+/// <reference types="./database-introspector.d.ts" />
 export {};

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

@@ -1,3 +1,4 @@
+/// <reference types="./dialect-adapter-base.d.ts" />
 /**
  * A basic implementation of `DialectAdapter` with sensible default values.
  * 3rd party dialects can extend this instead of implementing the `DialectAdapter`

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

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

package/dist/esm/dialect/dialect.js

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

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

@@ -1,3 +1,4 @@
+/// <reference types="./mysql-adapter.d.ts" />
 import { DialectAdapterBase } from '../dialect-adapter-base.js';
 const LOCK_ID = 'ea586330-2c93-47c8-908d-981d9d270f9d';
 const LOCK_TIMEOUT_SECONDS = 60 * 60;