kysely 0.12.0 → 0.12.1

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

@@ -63,16 +63,124 @@ export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 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;
@@ -84,16 +192,124 @@ export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps
 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

@@ -128,16 +128,124 @@ 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 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/esm/dialect/dialect-adapter-base.d.ts

@@ -7,8 +7,44 @@ import { DialectAdapter } from './dialect-adapter.js';
  * they are added and there will be less breaking changes.
  */
 export declare abstract class DialectAdapterBase implements DialectAdapter {
+    /**
+     * Whether or not this dialect supports transactional DDL.
+     *
+     * If this is true, migrations are executed inside a transaction.
+     */
     get supportsTransactionalDdl(): boolean;
+    /**
+     * Whether or not this dialect supports the `returning` in inserts
+     * updates and deletes.
+     */
     get supportsReturning(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration processes to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
+     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
+     * has two columns `id` and `is_locked` and there's only one row in the
+     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
+     * Kysely takes care of creating the lock table and inserting the one single
+     * row to it before this method is executed.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
     abstract acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
     abstract releaseMigrationLock(db: Kysely<any>): Promise<void>;
 }

package/dist/esm/dialect/mysql/mysql-adapter.d.ts

@@ -1,8 +1,44 @@
 import { Kysely } from '../../kysely.js';
 import { DialectAdapter } from '../dialect-adapter.js';
 export declare class MysqlAdapter implements DialectAdapter {
+    /**
+     * Whether or not this dialect supports transactional DDL.
+     *
+     * If this is true, migrations are executed inside a transaction.
+     */
     get supportsTransactionalDdl(): boolean;
+    /**
+     * Whether or not this dialect supports the `returning` in inserts
+     * updates and deletes.
+     */
     get supportsReturning(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration processes to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
+     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
+     * has two columns `id` and `is_locked` and there's only one row in the
+     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
+     * Kysely takes care of creating the lock table and inserting the one single
+     * row to it before this method is executed.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
     acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
     releaseMigrationLock(db: Kysely<any>): Promise<void>;
 }

package/dist/esm/dialect/mysql/mysql-dialect.d.ts

@@ -15,9 +15,25 @@ import { DatabaseConnection } from '../../driver/database-connection.js';
 export declare class MysqlDialect implements Dialect {
     #private;
     constructor(config: MysqlDialectConfig);
+    /**
+     * Creates a driver for the dialect.
+     */
     createDriver(): Driver;
+    /**
+     * Creates a query compiler for the dialect.
+     */
     createQueryCompiler(): QueryCompiler;
+    /**
+     * Creates an adapter for the dialect.
+     */
     createAdapter(): DialectAdapter;
+    /**
+     * Creates a database introspector that can be used to get the database metadata
+     * such as the tables and columns that exist in the database.
+     *
+     * `db` never has any plugins installed. It's created using
+     * {@link Kysely.withoutPlugins}.
+     */
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
 /**

package/dist/esm/dialect/mysql/mysql-driver.d.ts

@@ -4,11 +4,40 @@ import { MysqlDialectConfig } from './mysql-dialect.js';
 export declare class MysqlDriver implements Driver {
     #private;
     constructor(config: MysqlDialectConfig);
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     *
+     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
+     * should be imported inside this function, not at the top of the driver file! This is
+     * important so that Kysely is usable without installing all database driver libraries
+     * it supports.
+     */
     init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
     acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
     beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
     commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
     releaseConnection(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
     destroy(): Promise<void>;
 }

package/dist/esm/dialect/mysql/mysql-introspector.d.ts

@@ -3,5 +3,8 @@ import { Kysely } from '../../kysely.js';
 export declare class MysqlIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
+    /**
+     * Get the database metadata such as the names of the tables and columns.
+     */
     getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
 }

package/dist/esm/dialect/postgres/postgres-adapter.d.ts

@@ -1,8 +1,44 @@
 import { Kysely } from '../../kysely.js';
 import { DialectAdapter } from '../dialect-adapter.js';
 export declare class PostgresAdapter implements DialectAdapter {
+    /**
+     * Whether or not this dialect supports transactional DDL.
+     *
+     * If this is true, migrations are executed inside a transaction.
+     */
     get supportsTransactionalDdl(): boolean;
+    /**
+     * Whether or not this dialect supports the `returning` in inserts
+     * updates and deletes.
+     */
     get supportsReturning(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration processes to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
+     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
+     * has two columns `id` and `is_locked` and there's only one row in the
+     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
+     * Kysely takes care of creating the lock table and inserting the one single
+     * row to it before this method is executed.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
     acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
     releaseMigrationLock(): Promise<void>;
 }

package/dist/esm/dialect/postgres/postgres-dialect.d.ts

@@ -21,9 +21,25 @@ import { DatabaseConnection } from '../../driver/database-connection.js';
 export declare class PostgresDialect implements Dialect {
     #private;
     constructor(config: PostgresDialectConfig);
+    /**
+     * Creates a driver for the dialect.
+     */
     createDriver(): Driver;
+    /**
+     * Creates a query compiler for the dialect.
+     */
     createQueryCompiler(): QueryCompiler;
+    /**
+     * Creates an adapter for the dialect.
+     */
     createAdapter(): DialectAdapter;
+    /**
+     * Creates a database introspector that can be used to get the database metadata
+     * such as the tables and columns that exist in the database.
+     *
+     * `db` never has any plugins installed. It's created using
+     * {@link Kysely.withoutPlugins}.
+     */
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
 /**

package/dist/esm/dialect/postgres/postgres-driver.d.ts

@@ -4,11 +4,40 @@ import { PostgresDialectConfig } from './postgres-dialect.js';
 export declare class PostgresDriver implements Driver {
     #private;
     constructor(config: PostgresDialectConfig);
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     *
+     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
+     * should be imported inside this function, not at the top of the driver file! This is
+     * important so that Kysely is usable without installing all database driver libraries
+     * it supports.
+     */
     init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
     acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
     beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
     commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
     releaseConnection(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
     destroy(): Promise<void>;
 }

package/dist/esm/dialect/postgres/postgres-introspector.d.ts

@@ -3,5 +3,8 @@ import { Kysely } from '../../kysely.js';
 export declare class PostgresIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
+    /**
+     * Get the database metadata such as the names of the tables and columns.
+     */
     getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
 }