kysely 0.16.2 → 0.16.6

package/dist/cjs/parser/reference-parser.d.ts

@@ -2,7 +2,6 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
@@ -13,8 +12,8 @@ import { SelectType } from '../util/column-type.js';
 export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any> | ComplexExpression<DB, TB>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
-export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
-declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : PrimitiveValue;
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : unknown;
+declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : unknown;
 export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(ctx: ParseContext, exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;

package/dist/cjs/parser/value-parser.d.ts

@@ -1,11 +1,10 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { ParseContext } from './parse-context.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { ComplexExpression } from './complex-expression-parser.js';
 export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
-export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, PrimitiveValue>): ValueExpressionNode;
-export declare function parseValueExpression(ctx: ParseContext, exp: ValueExpression<any, any, PrimitiveValue>): ValueNode | SelectQueryNode | RawNode;
+export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
+export declare function parseValueExpression(ctx: ParseContext, exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;

package/dist/cjs/parser/value-parser.js

@@ -16,16 +16,15 @@ function parseValueExpressionOrList(ctx, arg) {
 }
 exports.parseValueExpressionOrList = parseValueExpressionOrList;
 function parseValueExpression(ctx, exp) {
-    if ((0, object_utils_js_1.isPrimitive)(exp)) {
-        return value_node_js_1.ValueNode.create(exp);
+    if ((0, complex_expression_parser_js_1.isComplexExpression)(exp)) {
+        return (0, complex_expression_parser_js_1.parseComplexExpression)(ctx, exp);
     }
-    return (0, complex_expression_parser_js_1.parseComplexExpression)(ctx, exp);
+    return value_node_js_1.ValueNode.create(exp);
 }
 exports.parseValueExpression = parseValueExpression;
 function parseValueExpressionList(ctx, arg) {
-    if (arg.every(object_utils_js_1.isPrimitive)) {
-        // Optimization for large lists of primitive values.
-        return primitive_value_list_node_js_1.PrimitiveValueListNode.create(arg);
+    if (arg.some(complex_expression_parser_js_1.isComplexExpression)) {
+        return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
     }
-    return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
+    return primitive_value_list_node_js_1.PrimitiveValueListNode.create(arg);
 }

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 { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { RawBuilder } from '../raw-builder/raw-builder.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 raw_builder_js_1 = require("../raw-builder/raw-builder.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 raw_builder_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-compiler/default-query-compiler.d.ts

@@ -44,7 +44,6 @@ import { ValueNode } from '../operation-node/value-node.js';
 import { WhereNode } from '../operation-node/where-node.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { WithNode } from '../operation-node/with-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { CompiledQuery } from './compiled-query.js';
 import { RootOperationNode, QueryCompiler } from './query-compiler.js';
 import { HavingNode } from '../operation-node/having-node.js';
@@ -150,5 +149,5 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected getRightIdentifierWrapper(): string;
     protected getCurrentParameterPlaceholder(): string;
     protected addParameter(parameter: unknown): void;
-    protected appendImmediateValue(value: PrimitiveValue): void;
+    protected appendImmediateValue(value: unknown): void;
 }

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/schema/alter-table-builder.d.ts

@@ -5,13 +5,13 @@ import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionBuilder, ColumnDefinitionBuilderInterface } from './column-definition-builder.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { QueryId } from '../util/query-id.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { DataTypeExpression } from '../parser/data-type-parser.js';
 import { ForeignKeyConstraintBuilder, ForeignKeyConstraintBuilderInterface } from './foreign-key-constraint-builder.js';
+import { DefaultValueExpression } from '../parser/default-value-parser.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -43,7 +43,7 @@ export declare class AlterColumnBuilder {
     #private;
     constructor(props: AlterColumnBuilderProps);
     setDataType(dataType: ColumnDataType): AlterTableExecutor;
-    setDefault(value: PrimitiveValue | AnyRawBuilder): AlterTableExecutor;
+    setDefault(value: DefaultValueExpression): AlterTableExecutor;
     dropDefault(): AlterTableExecutor;
     setNotNull(): AlterTableExecutor;
     dropNotNull(): AlterTableExecutor;
@@ -141,8 +141,21 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
+    defaultTo(value: DefaultValueExpression): AlterTableAddColumnBuilder;
     /**
      * Adds a check constraint for the column.
      *
@@ -286,8 +299,21 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
+    defaultTo(value: DefaultValueExpression): AlterTableModifyColumnBuilder;
     /**
      * Adds a check constraint for the column.
      *

package/dist/cjs/schema/alter-table-builder.js

@@ -8,10 +8,8 @@ const column_definition_node_js_1 = require("../operation-node/column-definition
 const data_type_node_js_1 = require("../operation-node/data-type-node.js");
 const drop_column_node_js_1 = require("../operation-node/drop-column-node.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const rename_column_node_js_1 = require("../operation-node/rename-column-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
-const value_node_js_1 = require("../operation-node/value-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const column_definition_builder_js_1 = require("./column-definition-builder.js");
@@ -23,6 +21,7 @@ const unique_constraint_node_js_1 = require("../operation-node/unique-constraint
 const check_constraint_node_js_1 = require("../operation-node/check-constraint-node.js");
 const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-constraint-node.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
+const default_value_parser_js_1 = require("../parser/default-value-parser.js");
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -130,9 +129,7 @@ class AlterColumnBuilder {
             ...this.#props,
             alterTableNode: alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
                 alterColumn: alter_column_node_js_1.AlterColumnNode.cloneWith(this.#props.alterColumnNode, {
-                    setDefault: (0, operation_node_source_js_1.isOperationNodeSource)(value)
-                        ? value.toOperationNode()
-                        : value_node_js_1.ValueNode.createImmediate(value),
+                    setDefault: (0, default_value_parser_js_1.parseDefaultValueExpression)(value),
                 }),
             }),
         });

package/dist/cjs/schema/column-definition-builder.d.ts

@@ -1,6 +1,5 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { OnModifyForeignAction } from '../operation-node/references-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { DefaultValueExpression } from '../parser/default-value-parser.js';
@@ -83,8 +82,21 @@ export interface ColumnDefinitionBuilderInterface {
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): ColumnDefinitionBuilderInterface;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilderInterface;
     /**
      * Adds a check constraint for the column.
      *
@@ -222,6 +234,19 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
     defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
     /**

package/dist/cjs/util/log.d.ts

@@ -17,6 +17,7 @@ export declare type LogConfig = ReadonlyArray<LogLevel> | Logger;
 export declare class Log {
     #private;
     constructor(config: LogConfig);
+    isLevelEnabled(level: LogLevel): boolean;
     query(getEvent: () => QueryLogEvent): void;
     error(getEvent: () => ErrorLogEvent): void;
 }

package/dist/cjs/util/log.js

@@ -22,6 +22,9 @@ class Log {
             });
         }
     }
+    isLevelEnabled(level) {
+        return this.#levels[level];
+    }
     query(getEvent) {
         if (this.#levels.query) {
             this.#logger(getEvent());

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

@@ -1,14 +1,13 @@
-/// <reference types="node" />
-export declare type PrimitiveValue = string | number | boolean | null | Date | Buffer | BigInt;
-export declare function isEmpty(obj: ArrayLike<unknown> | string | object | Buffer): boolean;
+export declare function isEmpty(obj: ArrayLike<unknown> | string | object): boolean;
 export declare function isString(obj: unknown): obj is string;
 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 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 isBuffer(obj: unknown): obj is {
+    length: number;
+};
 export declare function isFunction(obj: unknown): obj is Function;
 export declare function isObject(obj: unknown): obj is Record<string, unknown>;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;

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

@@ -1,6 +1,6 @@
 "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.isBuffer = exports.isBigInt = 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.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) || isBuffer(obj)) {
         return obj.length === 0;
@@ -35,20 +35,12 @@ function isBigInt(obj) {
     return typeof obj === 'bigint';
 }
 exports.isBigInt = isBigInt;
+// Don't change the returnd type to `obj is Buffer` to not create a
+// hard dependency to node.
 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) ||
-        isBigInt(obj) ||
-        isBuffer(obj));
-}
-exports.isPrimitive = isPrimitive;
 function isFunction(obj) {
     return typeof obj === 'function';
 }

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;