kysely 0.16.3 → 0.16.7

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

@@ -162,7 +162,7 @@ export declare class QueryCreator<DB> {
     /**
      * Creates a delete query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify
      * a where clause for the delete operation.
      *
      * The return value of the query is an instance of {@link DeleteResult}.
@@ -182,7 +182,7 @@ export declare class QueryCreator<DB> {
     /**
      * Creates an update query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link UpdateQueryBuilder.where} method for examples on how to specify
      * a where clause for the update operation.
      *
      * See the {@link UpdateQueryBuilder.set} method for examples on how to

package/dist/esm/query-creator.js

@@ -76,7 +76,7 @@ export class QueryCreator {
     /**
      * Creates a delete query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify
      * a where clause for the delete operation.
      *
      * The return value of the query is an instance of {@link DeleteResult}.
@@ -103,7 +103,7 @@ export class QueryCreator {
     /**
      * Creates an update query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link UpdateQueryBuilder.where} method for examples on how to specify
      * a where clause for the update operation.
      *
      * See the {@link UpdateQueryBuilder.set} method for examples on how to

package/dist/esm/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/esm/schema/alter-table-builder.js

@@ -6,10 +6,8 @@ import { ColumnDefinitionNode } from '../operation-node/column-definition-node.j
 import { DataTypeNode, } from '../operation-node/data-type-node.js';
 import { DropColumnNode } from '../operation-node/drop-column-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
-import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
 import { RenameColumnNode } from '../operation-node/rename-column-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { ValueNode } from '../operation-node/value-node.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionBuilder, } from './column-definition-builder.js';
@@ -21,6 +19,7 @@ import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.j
 import { CheckConstraintNode } from '../operation-node/check-constraint-node.js';
 import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
+import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -127,9 +126,7 @@ export class AlterColumnBuilder {
             ...this.#props,
             alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
                 alterColumn: AlterColumnNode.cloneWith(this.#props.alterColumnNode, {
-                    setDefault: isOperationNodeSource(value)
-                        ? value.toOperationNode()
-                        : ValueNode.createImmediate(value),
+                    setDefault: parseDefaultValueExpression(value),
                 }),
             }),
         });

package/dist/esm/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/esm/schema/create-view-builder.js

@@ -3,7 +3,7 @@ import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { parseColumnName } from '../parser/reference-parser.js';
-import { ImmediateValuePlugin } from '../plugin/immediate-value.ts/immediate-value-plugin.js';
+import { ImmediateValuePlugin } from '../plugin/immediate-value/immediate-value-plugin.js';
 export class CreateViewBuilder {
     #props;
     constructor(props) {

package/dist/esm/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/esm/util/log.js

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

package/dist/esm/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;
@@ -17,3 +16,4 @@ export declare function asArray<T>(arg: T | T[]): T[];
 export declare function asReadonlyArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T>;
 export declare function isReadonlyArray(arg: unknown): arg is ReadonlyArray<unknown>;
 export declare function noop<T>(obj: T): T;
+export declare function compare(obj1: unknown, obj2: unknown): boolean;

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

@@ -26,18 +26,11 @@ export function isDate(obj) {
 export function isBigInt(obj) {
     return typeof obj === 'bigint';
 }
+// Don't change the returnd type to `obj is Buffer` to not create a
+// hard dependency to node.
 export function isBuffer(obj) {
     return typeof Buffer !== 'undefined' && Buffer.isBuffer(obj);
 }
-export function isPrimitive(obj) {
-    return (isString(obj) ||
-        isNumber(obj) ||
-        isBoolean(obj) ||
-        isNull(obj) ||
-        isDate(obj) ||
-        isBigInt(obj) ||
-        isBuffer(obj));
-}
 export function isFunction(obj) {
     return typeof obj === 'function';
 }
@@ -72,3 +65,51 @@ export function isReadonlyArray(arg) {
 export function noop(obj) {
     return obj;
 }
+export function compare(obj1, obj2) {
+    if (isReadonlyArray(obj1) && isReadonlyArray(obj2)) {
+        return compareArrays(obj1, obj2);
+    }
+    else if (isObject(obj1) && isObject(obj2)) {
+        return compareObjects(obj1, obj2);
+    }
+    return obj1 === obj2;
+}
+function compareArrays(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    for (let i = 0; i < arr1.length; ++i) {
+        if (!compare(arr1[i], arr2[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function compareObjects(obj1, obj2) {
+    if (isBuffer(obj1) && isBuffer(obj2)) {
+        return compareBuffers(obj1, obj2);
+    }
+    else if (isDate(obj1) && isDate(obj2)) {
+        return compareDates(obj1, obj2);
+    }
+    return compareGenericObjects(obj1, obj2);
+}
+function compareBuffers(buf1, buf2) {
+    return Buffer.compare(buf1, buf2) === 0;
+}
+function compareDates(date1, date2) {
+    return date1.getTime() === date2.getTime();
+}
+function compareGenericObjects(obj1, obj2) {
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (!compare(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/esm/util/type-utils.d.ts

@@ -111,3 +111,24 @@ export declare type UnknownRow = Record<string, unknown>;
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
+/**
+ * Takes all properties from T1 and merges all properties from T2
+ * that don't exist in T1 as optional properties.
+ *
+ * Example:
+ *
+ * interface Person {
+ *   name: string
+ *   age: number
+ * }
+ *
+ * interface Pet {
+ *   name: string
+ *   species: 'cat' | 'dog'
+ * }
+ *
+ * type Merged = MergePartial<Person, Pet>
+ *
+ * // { name: string, age: number, species?: 'cat' | 'dog' }
+ */
+export declare type MergePartial<T1, T2> = T1 & Partial<Omit<T2, keyof T1>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.16.3",
+  "version": "0.16.7",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -20,12 +20,16 @@
     "./dist/esm/index-nodeless.js": "./dist/esm/index-nodeless.js"
   },
   "scripts": {
-    "test:build": "rm -rf test/dist && tsc -p test",
-    "clean": "rm -rf dist && rm -rf test/dist",
-    "test": "npm run clean && npm run build:cjs && npm run script:copy-interface-doc && npm run test:build && npm run test:integration && npm run test:typings && npm run test:esmimports",
-    "test:integration": "mocha --timeout 15000 test/dist/**/*.test.js",
+    "clean": "rm -rf dist && rm -rf test/node/dist && rm -rf test/browser/bundle.js",
+    "test": "npm run clean && npm run build:cjs && npm run script:copy-interface-doc && npm run test:node:build && npm run test:node && npm run test:typings && npm run test:esmimports",
+    "test:node:build": "rm -rf test/node/dist && tsc -p test/node",
+    "test:node": "mocha --timeout 15000 test/node/dist/**/*.test.js",
+    "test:browser:build": "rm -rf test/browser/bundle.js && esbuild test/browser/main.ts --bundle --outfile=test/browser/bundle.js",
+    "test:browser": "npm run build && npm run test:browser:build && node test/browser/test.js",
+    "test:deno": "npm run build && deno run test/deno/local.test.ts && deno run test/deno/cdn.test.ts",
     "test:typings": "tsd test/typings",
     "test:esmimports": "node scripts/check-esm-imports.js",
+    "test:esbuild": "esbuild --bundle --platform=node --external:pg-native dist/esm/index.js --outfile=/dev/null",
     "prettier": "prettier --write src/**/*.ts test/**/*.ts",
     "build": "npm run clean && npm run build:esm && npm run build:cjs && npm run script:module-fixup && npm run script:copy-interface-doc",
     "build:esm": "tsc -p tsconfig.json && npm run script:add-deno-type-references",
@@ -51,9 +55,11 @@
     "better-sqlite3": "^7.4.5",
     "chai": "^4.3.4",
     "chai-subset": "^1.6.0",
+    "esbuild": "^0.14.11",
     "mocha": "^9.1.3",
     "mysql2": "^2.3.3",
     "pg": "^8.7.1",
+    "playwright": "^1.17.2",
     "prettier": "^2.5.1",
     "tsd": "^0.19.0",
     "typedoc": "^0.22.10",

package/.prettierignore

@@ -1 +0,0 @@
-*.md

package/dist/cjs/util/dynamic-import.d.ts

@@ -1,2 +0,0 @@
-export declare function importFunction<T extends Function>(modulePath: string): Promise<T>;
-export declare function importNamedFunction<T extends Function>(modulePath: string, exportName: string): Promise<T>;

package/dist/cjs/util/dynamic-import.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.importNamedFunction = exports.importFunction = void 0;
-const object_utils_js_1 = require("./object-utils.js");
-async function importFunction(modulePath) {
-    const module = await Promise.resolve().then(() => require(modulePath));
-    const errorMessage = `module "${modulePath}" doesn't export a function`;
-    if ((0, object_utils_js_1.isFunction)(module)) {
-        return module;
-    }
-    else if ((0, object_utils_js_1.isObject)(module) && (0, object_utils_js_1.isFunction)(module.default)) {
-        return module.default;
-    }
-    throw new Error(errorMessage);
-}
-exports.importFunction = importFunction;
-async function importNamedFunction(modulePath, exportName) {
-    const module = await Promise.resolve().then(() => require(modulePath));
-    const errorMessage = `no function export named "${exportName}" found in module "${modulePath}"`;
-    if (!(0, object_utils_js_1.isObject)(module)) {
-        throw new Error(errorMessage);
-    }
-    if ((0, object_utils_js_1.isFunction)(module[exportName])) {
-        return module[exportName];
-    }
-    else if ((0, object_utils_js_1.isObject)(module.default) &&
-        (0, object_utils_js_1.isFunction)(module.default[exportName])) {
-        return module.default[exportName];
-    }
-    throw new Error(errorMessage);
-}
-exports.importNamedFunction = importNamedFunction;

package/dist/esm/util/dynamic-import.d.ts

@@ -1,2 +0,0 @@
-export declare function importFunction<T extends Function>(modulePath: string): Promise<T>;
-export declare function importNamedFunction<T extends Function>(modulePath: string, exportName: string): Promise<T>;

package/dist/esm/util/dynamic-import.js

@@ -1,28 +0,0 @@
-/// <reference types="./dynamic-import.d.ts" />
-import { isFunction, isObject } from './object-utils.js';
-export async function importFunction(modulePath) {
-    const module = await import(modulePath);
-    const errorMessage = `module "${modulePath}" doesn't export a function`;
-    if (isFunction(module)) {
-        return module;
-    }
-    else if (isObject(module) && isFunction(module.default)) {
-        return module.default;
-    }
-    throw new Error(errorMessage);
-}
-export async function importNamedFunction(modulePath, exportName) {
-    const module = await import(modulePath);
-    const errorMessage = `no function export named "${exportName}" found in module "${modulePath}"`;
-    if (!isObject(module)) {
-        throw new Error(errorMessage);
-    }
-    if (isFunction(module[exportName])) {
-        return module[exportName];
-    }
-    else if (isObject(module.default) &&
-        isFunction(module.default[exportName])) {
-        return module.default[exportName];
-    }
-    throw new Error(errorMessage);
-}