kysely 0.12.0 → 0.14.0

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

@@ -66,6 +66,12 @@ export interface ColumnDefinitionBuilderInterface {
      * Adds a `not null` constraint for the column.
      */
     notNull(): ColumnDefinitionBuilderInterface;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a default value constraint for the column.
      *
@@ -87,11 +93,13 @@ export interface ColumnDefinitionBuilderInterface {
      * ```ts
      * db.schema
      *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .addColumn('number_of_legs', 'integer', (col) =>
+     *     col.check(db.raw('number_of_legs < 5'))
+     *   )
      *   .execute()
      * ```
      */
-    check(sql: string): ColumnDefinitionBuilderInterface;
+    check(expression: AnyRawBuilder): ColumnDefinitionBuilderInterface;
     /**
      * Makes the column a generated column using a `generated always as` statement.
      *
@@ -101,12 +109,20 @@ export interface ColumnDefinitionBuilderInterface {
      * db.schema
      *   .createTable('person')
      *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
      *   )
      *   .execute()
      * ```
      */
-    generatedAlwaysAs(sql: string): ColumnDefinitionBuilderInterface;
+    generatedAlwaysAs(expression: AnyRawBuilder): ColumnDefinitionBuilderInterface;
+    /**
+     * Adds the `generated always as identity` specifier on supported dialects.
+     */
+    generatedAlwaysAsIdentity(): ColumnDefinitionBuilderInterface;
+    /**
+     * Adds the `generated by default as identity` specifier on supported dialects.
+     */
+    generatedByDefaultAsIdentity(): ColumnDefinitionBuilderInterface;
     /**
      * Makes a generated column stored instead of virtual. This method can only
      * be used with {@link generatedAlwaysAs}
@@ -128,16 +144,140 @@ export interface ColumnDefinitionBuilderInterface {
 export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource {
     #private;
     constructor(node: ColumnDefinitionNode);
+    /**
+     * Adds `auto_increment` or `autoincrement` to the column definition
+     * depending on the dialect.
+     *
+     * Some dialects like PostgreSQL don't support this. On PostgreSQL
+     * you can use the `serial` or `bigserial` data type instead.
+     */
     autoIncrement(): ColumnDefinitionBuilder;
+    /**
+     * Makes the column the primary key.
+     *
+     * If you want to specify a composite primary key use the
+     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     */
     primaryKey(): ColumnDefinitionBuilder;
+    /**
+     * Adds a foreign key constraint for the column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id')
+     * ```
+     */
     references(ref: string): ColumnDefinitionBuilder;
+    /**
+     * Adds an `on delete` constraint for the foreign key column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
+     */
     onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilder;
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
+     */
     onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilder;
+    /**
+     * Adds a unique constraint for the column.
+     */
     unique(): ColumnDefinitionBuilder;
+    /**
+     * Adds a `not null` constraint for the column.
+     */
     notNull(): ColumnDefinitionBuilder;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): ColumnDefinitionBuilder;
+    /**
+     * Adds a default value constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
+     *   .execute()
+     * ```
+     */
     defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
-    check(sql: string): ColumnDefinitionBuilder;
-    generatedAlwaysAs(sql: string): ColumnDefinitionBuilder;
+    /**
+     * Adds a check constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) =>
+     *     col.check(db.raw('number_of_legs < 5'))
+     *   )
+     *   .execute()
+     * ```
+     */
+    check(expression: AnyRawBuilder): ColumnDefinitionBuilder;
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
+     *   )
+     *   .execute()
+     * ```
+     */
+    generatedAlwaysAs(expression: AnyRawBuilder): ColumnDefinitionBuilder;
+    /**
+     * Adds the `generated always as identity` specifier on supported dialects.
+     */
+    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder;
+    /**
+     * Adds the `generated by default as identity` specifier on supported dialects.
+     */
+    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder;
+    /**
+     * Makes a generated column stored instead of virtual. This method can only
+     * be used with {@link generatedAlwaysAs}
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
     stored(): ColumnDefinitionBuilder;
     toOperationNode(): ColumnDefinitionNode;
 }

package/dist/esm/schema/column-definition-builder.js

@@ -6,7 +6,7 @@ import { parseStringReference } from '../parser/reference-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
-import { GeneratedAlwaysAsNode } from '../operation-node/generated-always-as-node.js';
+import { GeneratedNode } from '../operation-node/generated-node.js';
 import { DefaultValueNode } from '../operation-node/default-value-node.js';
 export class ColumnDefinitionBuilder {
     #node;
@@ -50,29 +50,42 @@ export class ColumnDefinitionBuilder {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { unique: true }));
     }
     notNull() {
-        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { nullable: false }));
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { notNull: true }));
+    }
+    unsigned() {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { unsigned: true }));
     }
     defaultTo(value) {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
             defaultTo: DefaultValueNode.create(parseDefaultValueExpression(value)),
         }));
     }
-    check(sql) {
+    check(expression) {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
+            check: CheckConstraintNode.create(expression.toOperationNode()),
+        }));
+    }
+    generatedAlwaysAs(expression) {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
+            generated: GeneratedNode.createWithExpression(expression.toOperationNode()),
+        }));
+    }
+    generatedAlwaysAsIdentity() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            check: CheckConstraintNode.create(sql),
+            generated: GeneratedNode.create({ identity: true, always: true }),
         }));
     }
-    generatedAlwaysAs(sql) {
+    generatedByDefaultAsIdentity() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            generatedAlwaysAs: GeneratedAlwaysAsNode.create(sql),
+            generated: GeneratedNode.create({ identity: true, byDefault: true }),
         }));
     }
     stored() {
-        if (!this.#node.generatedAlwaysAs) {
+        if (!this.#node.generated) {
             throw new Error('stored() can only be called after generatedAlwaysAs');
         }
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            generatedAlwaysAs: GeneratedAlwaysAsNode.cloneWith(this.#node.generatedAlwaysAs, {
+            generated: GeneratedNode.cloneWith(this.#node.generated, {
                 stored: true,
             }),
         }));

package/dist/esm/schema/create-index-builder.d.ts

@@ -4,6 +4,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 export declare class CreateIndexBuilder implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateIndexBuilderProps);
@@ -36,11 +37,11 @@ export declare class CreateIndexBuilder implements OperationNodeSource, Compilab
      * await db.schema
      *   .createIndex('person_first_name_index')
      *   .on('person')
-     *   .expression('first_name COLLATE "fi_FI"')
+     *   .expression(db.raw('first_name COLLATE "fi_FI"'))
      *   .execute()
      * ```
      */
-    expression(expression: string): CreateIndexBuilder;
+    expression(expression: AnyRawBuilder): CreateIndexBuilder;
     /**
      * Specifies the index type.
      */

package/dist/esm/schema/create-index-builder.js

@@ -67,7 +67,7 @@ export class CreateIndexBuilder {
      * await db.schema
      *   .createIndex('person_first_name_index')
      *   .on('person')
-     *   .expression('first_name COLLATE "fi_FI"')
+     *   .expression(db.raw('first_name COLLATE "fi_FI"'))
      *   .execute()
      * ```
      */
@@ -75,7 +75,7 @@ export class CreateIndexBuilder {
         return new CreateIndexBuilder({
             ...this.#props,
             createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
-                expression: RawNode.createWithSql(expression),
+                expression: expression.toOperationNode(),
             }),
         });
     }

package/dist/esm/schema/create-table-builder.d.ts

@@ -7,6 +7,7 @@ import { ColumnDefinitionBuilder } from './column-definition-builder.js';
 import { QueryId } from '../util/query-id.js';
 import { ForeignKeyConstraintBuilder } from './foreign-key-constraint-builder.js';
 import { DataTypeExpression } from '../parser/data-type-parser.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 /**
  * This builder can be used to create a `create table` query.
  */
@@ -110,10 +111,10 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ### Examples
      *
      * ```ts
-     * addCheckConstraint('check_legs', 'number_of_legs < 5')
+     * addCheckConstraint('check_legs', db.raw('number_of_legs < 5'))
      * ```
      */
-    addCheckConstraint(constraintName: string, checkExpression: string): CreateTableBuilder<TB, C>;
+    addCheckConstraint(constraintName: string, checkExpression: AnyRawBuilder): CreateTableBuilder<TB, C>;
     /**
      * Adds a foreign key constraint.
      *

package/dist/esm/schema/create-table-builder.js

@@ -153,13 +153,13 @@ export class CreateTableBuilder {
      * ### Examples
      *
      * ```ts
-     * addCheckConstraint('check_legs', 'number_of_legs < 5')
+     * addCheckConstraint('check_legs', db.raw('number_of_legs < 5'))
      * ```
      */
     addCheckConstraint(constraintName, checkExpression) {
         return new CreateTableBuilder({
             ...this.#props,
-            createTableNode: CreateTableNode.cloneWithConstraint(this.#props.createTableNode, CheckConstraintNode.create(checkExpression, constraintName)),
+            createTableNode: CreateTableNode.cloneWithConstraint(this.#props.createTableNode, CheckConstraintNode.create(checkExpression.toOperationNode(), constraintName)),
         });
     }
     /**

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "kysely",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
     "url": "git://github.com/koskimas/kysely.git"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=14.0.0"
   },
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -20,16 +20,18 @@
   "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 test:build && npm run test:integration && npm run test:typings && npm run test:esmimports",
+    "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",
     "test:typings": "tsd test/typings",
-    "test:esmimports": "node check-esm-imports.js",
+    "test:esmimports": "node scripts/check-esm-imports.js",
     "prettier": "prettier --write src/**/*.ts test/**/*.ts",
-    "build": "npm run clean && npm run build:esm && npm run build:cjs && ./module-fixup.sh",
+    "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",
     "build:cjs": "tsc -p tsconfig-cjs.json",
     "docs:build": "typedoc --excludePrivate --excludeInternal --customCss ./docs-theme.css src/index.ts && npm run docs:postprocess",
-    "docs:postprocess": "node post-process-docs.js",
+    "docs:postprocess": "node scripts/post-process-docs.js",
+    "script:module-fixup": "node scripts/module-fixup.js",
+    "script:copy-interface-doc": "node scripts/copy-interface-documentation.js",
     "prepublishOnly": "npm run build"
   },
   "author": "Sami Koskimäki <sami@jakso.me>",

package/dist/cjs/operation-node/generated-always-as-node.d.ts

@@ -1,16 +0,0 @@
-import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-export declare type GeneratedAlwaysAsNodeParams = Omit<GeneratedAlwaysAsNode, 'kind' | 'expression'>;
-export interface GeneratedAlwaysAsNode extends OperationNode {
-    readonly kind: 'GeneratedAlwaysAsNode';
-    readonly expression: RawNode;
-    readonly stored?: boolean;
-}
-/**
- * @internal
- */
-export declare const GeneratedAlwaysAsNode: Readonly<{
-    is(node: OperationNode): node is GeneratedAlwaysAsNode;
-    create(expression: string): GeneratedAlwaysAsNode;
-    cloneWith(node: GeneratedAlwaysAsNode, params: GeneratedAlwaysAsNodeParams): GeneratedAlwaysAsNode;
-}>;

package/dist/cjs/operation-node/generated-always-as-node.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeneratedAlwaysAsNode = void 0;
-const object_utils_js_1 = require("../util/object-utils.js");
-const raw_node_js_1 = require("./raw-node.js");
-/**
- * @internal
- */
-exports.GeneratedAlwaysAsNode = (0, object_utils_js_1.freeze)({
-    is(node) {
-        return node.kind === 'GeneratedAlwaysAsNode';
-    },
-    create(expression) {
-        return (0, object_utils_js_1.freeze)({
-            kind: 'GeneratedAlwaysAsNode',
-            expression: raw_node_js_1.RawNode.createWithSql(expression),
-        });
-    },
-    cloneWith(node, params) {
-        return (0, object_utils_js_1.freeze)({
-            ...node,
-            ...params,
-        });
-    },
-});

package/dist/cjs/parser/on-conflict-parser.d.ts

@@ -1,10 +0,0 @@
-import { OnConflictNode } from '../operation-node/on-conflict-node.js';
-import { AnyColumn } from '../util/type-utils.js';
-import { ParseContext } from './parse-context.js';
-import { MutationObject } from './update-set-parser.js';
-export declare type OnConflictConstraintTarget = {
-    constraint: string;
-};
-export declare type OnConflictTargetExpression<DB, TB extends keyof DB> = AnyColumn<DB, TB> | ReadonlyArray<AnyColumn<DB, TB>> | OnConflictConstraintTarget;
-export declare function parseOnConflictDoNothing(target: OnConflictTargetExpression<any, any>): OnConflictNode;
-export declare function parseOnConflictUpdate(ctx: ParseContext, target: OnConflictTargetExpression<any, any>, updates: MutationObject<any, any>): OnConflictNode;

package/dist/cjs/parser/on-conflict-parser.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOnConflictUpdate = exports.parseOnConflictDoNothing = void 0;
-const identifier_node_js_1 = require("../operation-node/identifier-node.js");
-const on_conflict_node_js_1 = require("../operation-node/on-conflict-node.js");
-const object_utils_js_1 = require("../util/object-utils.js");
-const reference_parser_js_1 = require("./reference-parser.js");
-const update_set_parser_js_1 = require("./update-set-parser.js");
-function parseOnConflictDoNothing(target) {
-    return on_conflict_node_js_1.OnConflictNode.create({
-        ...parseConflictTarget(target),
-        doNothing: true,
-    });
-}
-exports.parseOnConflictDoNothing = parseOnConflictDoNothing;
-function parseOnConflictUpdate(ctx, target, updates) {
-    return on_conflict_node_js_1.OnConflictNode.create({
-        ...parseConflictTarget(target),
-        updates: (0, update_set_parser_js_1.parseUpdateObject)(ctx, updates),
-    });
-}
-exports.parseOnConflictUpdate = parseOnConflictUpdate;
-function parseConflictTarget(target) {
-    if ((0, object_utils_js_1.isString)(target) || (0, object_utils_js_1.isReadonlyArray)(target)) {
-        return {
-            columns: (0, object_utils_js_1.asReadonlyArray)(target).map(reference_parser_js_1.parseColumnName),
-        };
-    }
-    if ((0, object_utils_js_1.isObject)(target) && !(0, object_utils_js_1.isReadonlyArray)(target)) {
-        return {
-            constraint: identifier_node_js_1.IdentifierNode.create(target.constraint),
-        };
-    }
-    throw new Error(`invalid on conflict target ${JSON.stringify(target)}`);
-}

package/dist/esm/operation-node/generated-always-as-node.d.ts

@@ -1,16 +0,0 @@
-import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-export declare type GeneratedAlwaysAsNodeParams = Omit<GeneratedAlwaysAsNode, 'kind' | 'expression'>;
-export interface GeneratedAlwaysAsNode extends OperationNode {
-    readonly kind: 'GeneratedAlwaysAsNode';
-    readonly expression: RawNode;
-    readonly stored?: boolean;
-}
-/**
- * @internal
- */
-export declare const GeneratedAlwaysAsNode: Readonly<{
-    is(node: OperationNode): node is GeneratedAlwaysAsNode;
-    create(expression: string): GeneratedAlwaysAsNode;
-    cloneWith(node: GeneratedAlwaysAsNode, params: GeneratedAlwaysAsNodeParams): GeneratedAlwaysAsNode;
-}>;

package/dist/esm/operation-node/generated-always-as-node.js

@@ -1,22 +0,0 @@
-import { freeze } from '../util/object-utils.js';
-import { RawNode } from './raw-node.js';
-/**
- * @internal
- */
-export const GeneratedAlwaysAsNode = freeze({
-    is(node) {
-        return node.kind === 'GeneratedAlwaysAsNode';
-    },
-    create(expression) {
-        return freeze({
-            kind: 'GeneratedAlwaysAsNode',
-            expression: RawNode.createWithSql(expression),
-        });
-    },
-    cloneWith(node, params) {
-        return freeze({
-            ...node,
-            ...params,
-        });
-    },
-});

package/dist/esm/parser/on-conflict-parser.d.ts

@@ -1,10 +0,0 @@
-import { OnConflictNode } from '../operation-node/on-conflict-node.js';
-import { AnyColumn } from '../util/type-utils.js';
-import { ParseContext } from './parse-context.js';
-import { MutationObject } from './update-set-parser.js';
-export declare type OnConflictConstraintTarget = {
-    constraint: string;
-};
-export declare type OnConflictTargetExpression<DB, TB extends keyof DB> = AnyColumn<DB, TB> | ReadonlyArray<AnyColumn<DB, TB>> | OnConflictConstraintTarget;
-export declare function parseOnConflictDoNothing(target: OnConflictTargetExpression<any, any>): OnConflictNode;
-export declare function parseOnConflictUpdate(ctx: ParseContext, target: OnConflictTargetExpression<any, any>, updates: MutationObject<any, any>): OnConflictNode;

package/dist/esm/parser/on-conflict-parser.js

@@ -1,30 +0,0 @@
-import { IdentifierNode } from '../operation-node/identifier-node.js';
-import { OnConflictNode } from '../operation-node/on-conflict-node.js';
-import { asReadonlyArray, isObject, isReadonlyArray, isString, } from '../util/object-utils.js';
-import { parseColumnName } from './reference-parser.js';
-import { parseUpdateObject } from './update-set-parser.js';
-export function parseOnConflictDoNothing(target) {
-    return OnConflictNode.create({
-        ...parseConflictTarget(target),
-        doNothing: true,
-    });
-}
-export function parseOnConflictUpdate(ctx, target, updates) {
-    return OnConflictNode.create({
-        ...parseConflictTarget(target),
-        updates: parseUpdateObject(ctx, updates),
-    });
-}
-function parseConflictTarget(target) {
-    if (isString(target) || isReadonlyArray(target)) {
-        return {
-            columns: asReadonlyArray(target).map(parseColumnName),
-        };
-    }
-    if (isObject(target) && !isReadonlyArray(target)) {
-        return {
-            constraint: IdentifierNode.create(target.constraint),
-        };
-    }
-    throw new Error(`invalid on conflict target ${JSON.stringify(target)}`);
-}