kysely 0.11.2 → 0.12.1

package/dist/cjs/schema/alter-table-builder.d.ts

@@ -60,19 +60,127 @@ export declare class AlterTableExecutor implements OperationNodeSource, Compilab
 }
 export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 }
-export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder>, OperationNodeSource, Compilable {
+export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableAddColumnBuilderProps);
+    /**
+     * 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(): AlterTableAddColumnBuilder;
+    /**
+     * Makes the column the primary key.
+     *
+     * If you want to specify a composite primary key use the
+     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     */
     primaryKey(): AlterTableAddColumnBuilder;
+    /**
+     * 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): AlterTableAddColumnBuilder;
+    /**
+     * 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): AlterTableAddColumnBuilder;
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
+     */
     onUpdate(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
+    /**
+     * Adds a unique constraint for the column.
+     */
     unique(): AlterTableAddColumnBuilder;
+    /**
+     * Adds a `not null` constraint for the column.
+     */
     notNull(): AlterTableAddColumnBuilder;
+    /**
+     * 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: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
+    /**
+     * Adds a check constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .execute()
+     * ```
+     */
     check(sql: string): AlterTableAddColumnBuilder;
+    /**
+     * 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("concat(first_name, ' ', last_name)")
+     *   )
+     *   .execute()
+     * ```
+     */
     generatedAlwaysAs(sql: string): AlterTableAddColumnBuilder;
+    /**
+     * 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(): AlterTableAddColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
@@ -81,19 +189,127 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
 export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps {
     readonly columnBuilder: ColumnDefinitionBuilder;
 }
-export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableModifyColumnBuilder>, OperationNodeSource, Compilable {
+export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableModifyColumnBuilderProps);
+    /**
+     * 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(): AlterTableModifyColumnBuilder;
+    /**
+     * Makes the column the primary key.
+     *
+     * If you want to specify a composite primary key use the
+     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     */
     primaryKey(): AlterTableModifyColumnBuilder;
+    /**
+     * 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): AlterTableModifyColumnBuilder;
+    /**
+     * 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): AlterTableModifyColumnBuilder;
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
+     */
     onUpdate(onUpdate: OnModifyForeignAction): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a unique constraint for the column.
+     */
     unique(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a `not null` constraint for the column.
+     */
     notNull(): AlterTableModifyColumnBuilder;
+    /**
+     * 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: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a check constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .execute()
+     * ```
+     */
     check(sql: string): AlterTableModifyColumnBuilder;
+    /**
+     * 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("concat(first_name, ' ', last_name)")
+     *   )
+     *   .execute()
+     * ```
+     */
     generatedAlwaysAs(sql: string): AlterTableModifyColumnBuilder;
+    /**
+     * 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(): AlterTableModifyColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;

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

@@ -4,7 +4,7 @@ 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';
-export interface ColumnDefinitionBuilderInterface<R> {
+export interface ColumnDefinitionBuilderInterface {
     /**
      * Adds `auto_increment` or `autoincrement` to the column definition
      * depending on the dialect.
@@ -12,14 +12,14 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * Some dialects like PostgreSQL don't support this. On PostgreSQL
      * you can use the `serial` or `bigserial` data type instead.
      */
-    autoIncrement(): R;
+    autoIncrement(): ColumnDefinitionBuilderInterface;
     /**
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
      * {@link TableBuilder.addPrimaryKeyConstraint} method.
      */
-    primaryKey(): R;
+    primaryKey(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a foreign key constraint for the column.
      *
@@ -27,12 +27,13 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * column definition (like MySQL 5) you need to call the table level
      * {@link TableBuilder.addForeignKeyConstraint} method instead.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * col.references('person.id')
      * ```
      */
-    references(ref: string): R;
+    references(ref: string): ColumnDefinitionBuilderInterface;
     /**
      * Adds an `on delete` constraint for the foreign key column.
      *
@@ -40,33 +41,36 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * column definition (like MySQL 5) you need to call the table level
      * {@link TableBuilder.addForeignKeyConstraint} method instead.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * col.references('person.id').onDelete('cascade')
      * ```
      */
-    onDelete(onDelete: OnModifyForeignAction): R;
+    onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilderInterface;
     /**
      * Adds an `on update` constraint for the foreign key column.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * col.references('person.id').onUpdate('cascade')
      * ```
      */
-    onUpdate(onUpdate: OnModifyForeignAction): R;
+    onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilderInterface;
     /**
      * Adds a unique constraint for the column.
      */
-    unique(): R;
+    unique(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a `not null` constraint for the column.
      */
-    notNull(): R;
+    notNull(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a default value constraint for the column.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('pet')
@@ -74,11 +78,12 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): R;
+    defaultTo(value: PrimitiveValue | AnyRawBuilder): ColumnDefinitionBuilderInterface;
     /**
      * Adds a check constraint for the column.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('pet')
@@ -86,11 +91,12 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    check(sql: string): R;
+    check(sql: string): ColumnDefinitionBuilderInterface;
     /**
      * Makes the column a generated column using a `generated always as` statement.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('person')
@@ -100,12 +106,13 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    generatedAlwaysAs(sql: string): R;
+    generatedAlwaysAs(sql: string): ColumnDefinitionBuilderInterface;
     /**
      * Makes a generated column stored instead of virtual. This method can only
      * be used with {@link generatedAlwaysAs}
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('person')
@@ -116,21 +123,129 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    stored(): R;
+    stored(): ColumnDefinitionBuilderInterface;
 }
-export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface<ColumnDefinitionBuilder>, OperationNodeSource {
+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 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;
+    /**
+     * Adds a check constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .execute()
+     * ```
+     */
     check(sql: string): 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("concat(first_name, ' ', last_name)")
+     *   )
+     *   .execute()
+     * ```
+     */
     generatedAlwaysAs(sql: string): 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/cjs/schema/create-index-builder.d.ts

@@ -30,7 +30,8 @@ export declare class CreateIndexBuilder implements OperationNodeSource, Compilab
     /**
      * Specifies an arbitrary expression for the index.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db.schema
      *   .createIndex('person_first_name_index')

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

@@ -64,7 +64,8 @@ class CreateIndexBuilder {
     /**
      * Specifies an arbitrary expression for the index.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db.schema
      *   .createIndex('person_first_name_index')

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

@@ -1,4 +1,4 @@
-import { CreateTableNode } from '../operation-node/create-table-node.js';
+import { CreateTableNode, OnCommitAction } from '../operation-node/create-table-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
@@ -13,6 +13,19 @@ import { DataTypeExpression } from '../parser/data-type-parser.js';
 export declare class CreateTableBuilder<TB extends string, C extends string = never> implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateTableBuilderProps);
+    /**
+     * Adds the "temporary" modifier.
+     *
+     * Use this to create a temporary table.
+     */
+    temporary(): CreateTableBuilder<TB, C>;
+    /**
+     * Adds an "on commit" statement.
+     *
+     * This can be used in conjunction with temporary tables on supported databases
+     * like PostgreSQL.
+     */
+    onCommit(onCommit: OnCommitAction): CreateTableBuilder<TB, C>;
     /**
      * Adds the "if not exists" modifier.
      *
@@ -22,7 +35,8 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
     /**
      * Adds a column to the table.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db.schema
      *   .createTable('person')
@@ -42,7 +56,6 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * foreign key constraints need to be defined in at the level of the `create table`
      * query. See the next example:
      *
-     * @example
      * ```ts
      *   .addColumn('parent_id', 'integer')
      *   .addForeignKeyConstraint(
@@ -55,7 +68,6 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * keyword and you need to define an autoincrementing column for example using
      * `serial`:
      *
-     * @example
      * ```ts
      * await db.schema
      *   .createTable('person')
@@ -69,7 +81,8 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * The constraint name can be anything you want, but it must be unique
      * across the whole database.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * addPrimaryKeyConstraint('primary_key', ['first_name', 'last_name'])
      * ```
@@ -81,7 +94,8 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * The constraint name can be anything you want, but it must be unique
      * across the whole database.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * addUniqueConstraint('first_name_last_name_unique', ['first_name', 'last_name'])
      * ```
@@ -93,7 +107,8 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * The constraint name can be anything you want, but it must be unique
      * across the whole database.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * addCheckConstraint('check_legs', 'number_of_legs < 5')
      * ```
@@ -105,7 +120,8 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * The constraint name can be anything you want, but it must be unique
      * across the whole database.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * addForeignKeyConstraint(
      *   'owner_id_foreign',
@@ -115,7 +131,8 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * )
      * ```
      *
-     * @example
+     * Add constraintfor multiple columns:
+     *
      * ```ts
      * addForeignKeyConstraint(
      *   'owner_id_foreign',