kysely 0.9.9 → 0.11.1

package/dist/esm/query-creator.js

@@ -26,20 +26,17 @@ export class QueryCreator {
     /**
      * Creates an insert query.
      *
-     * The return value of this query is `number | undefined` because of the differences
-     * between database engines. Most engines (like Mysql) return the auto incrementing
-     * primary key (if it exists), but some (like postgres) return nothing by default.
-     * If you are running a database engine like `Mysql` that always returns the primary
-     * key, you can safely use `!` or the {@link QueryBuilder.castTo | castTo} method
-     * to cast away the `undefined` from the type.
+     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * the inserted row if the db returned one.
      *
      * See the {@link QueryBuilder.values | values} method for more info and examples. Also see
      * the {@link QueryBuilder.returning | returning} method for a way to return columns
-     * on supported databases like postgres.
+     * on supported databases like PostgreSQL.
      *
      * @example
      * ```ts
-     * const maybePrimaryKey: number | undefined = await db
+     * const result = await db
      *   .insertInto('person')
      *   .values({
      *     id: db.generated,
@@ -47,10 +44,12 @@ export class QueryCreator {
      *     last_name: 'Aniston'
      *   })
      *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
      * ```
      *
      * @example
-     * Some databases like postgres support the `returning` method:
+     * Some databases like PostgreSQL support the `returning` method:
      *
      * ```ts
      * const { id } = await db
@@ -76,14 +75,18 @@ export class QueryCreator {
      * Creates a delete query.
      *
      * See the {@link QueryBuilder.where} method for examples on how to specify
-     * a where clause for the delete operation .
+     * a where clause for the delete operation.
+     *
+     * The return value of the query is an instance of {@link DeleteResult}.
      *
      * @example
      * ```ts
-     * const numAffectedRows = await db
+     * const result = await db
      *   .deleteFrom('person')
      *   .where('person.id', '=', 1)
      *   .executeTakeFirst()
+     *
+     * console.log(result.numDeletedRows)
      * ```
      */
     deleteFrom(table) {
@@ -103,13 +106,17 @@ export class QueryCreator {
      * See the {@link QueryBuilder.set} method for examples on how to
      * specify the updates.
      *
+     * The return value of the query is an {@link UpdateResult}.
+     *
      * @example
      * ```ts
-     * const numAffectedRows = await db
+     * const result = await db
      *   .updateTable('person')
      *   .set({ first_name: 'Jennifer' })
      *   .where('person.id', '=', 1)
      *   .executeTakeFirst()
+     *
+     * console.log(result.numUpdatedRows)
      * ```
      */
     updateTable(table) {
@@ -167,7 +174,7 @@ export class QueryCreator {
      *  .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select * from "mammals"."pet"
@@ -187,7 +194,7 @@ export class QueryCreator {
      *  .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "p"."name" from "mammals"."pet" as "p"
@@ -237,7 +244,7 @@ export class QueryCreator {
      * console.log(person.name)
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select concat(first_name, ' ', last_name) as "name"
@@ -295,7 +302,7 @@ export class QueryCreator {
      * }
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select * from "person" where now() - birth_date > interval $1 year
@@ -309,7 +316,8 @@ export class QueryCreator {
      * Example of creating a completely raw query from scratch:
      *
      * ```ts
-     * const persons = await db.raw<Person>('select p.* from person p').execute()
+     * const result = await db.raw<Person>('select p.* from person p').execute()
+     * const persons = result.rows
      * ```
      *
      * For a raw query, you need to specify the type of the returned __row__. In

package/dist/esm/raw-builder/raw-builder.d.ts

@@ -41,5 +41,5 @@ export interface RawBuilderProps {
     readonly queryId: QueryId;
     readonly executor: QueryExecutor;
     readonly sql: string;
-    readonly parameters?: any;
+    readonly parameters?: ReadonlyArray<unknown>;
 }

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

@@ -63,7 +63,7 @@ export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder>, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableAddColumnBuilderProps);
-    increments(): AlterTableAddColumnBuilder;
+    autoIncrement(): AlterTableAddColumnBuilder;
     primaryKey(): AlterTableAddColumnBuilder;
     references(ref: string): AlterTableAddColumnBuilder;
     onDelete(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
@@ -72,6 +72,8 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
     notNull(): AlterTableAddColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
     check(sql: string): AlterTableAddColumnBuilder;
+    generatedAlwaysAs(sql: string): AlterTableAddColumnBuilder;
+    stored(): AlterTableAddColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
@@ -82,7 +84,7 @@ export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps
 export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableModifyColumnBuilder>, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableModifyColumnBuilderProps);
-    increments(): AlterTableModifyColumnBuilder;
+    autoIncrement(): AlterTableModifyColumnBuilder;
     primaryKey(): AlterTableModifyColumnBuilder;
     references(ref: string): AlterTableModifyColumnBuilder;
     onDelete(onDelete: OnModifyForeignAction): AlterTableModifyColumnBuilder;
@@ -91,6 +93,8 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
     notNull(): AlterTableModifyColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
     check(sql: string): AlterTableModifyColumnBuilder;
+    generatedAlwaysAs(sql: string): AlterTableModifyColumnBuilder;
+    stored(): AlterTableModifyColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

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

@@ -184,10 +184,10 @@ export class AlterTableAddColumnBuilder {
     constructor(props) {
         this.#props = freeze(props);
     }
-    increments() {
+    autoIncrement() {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
-            columnBuilder: this.#props.columnBuilder.increments(),
+            columnBuilder: this.#props.columnBuilder.autoIncrement(),
         });
     }
     primaryKey() {
@@ -238,6 +238,18 @@ export class AlterTableAddColumnBuilder {
             columnBuilder: this.#props.columnBuilder.check(sql),
         });
     }
+    generatedAlwaysAs(sql) {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+        });
+    }
+    stored() {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.stored(),
+        });
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(AlterTableNode.cloneWith(this.#props.alterTableNode, {
             addColumn: AddColumnNode.create(this.#props.columnBuilder.toOperationNode()),
@@ -255,10 +267,10 @@ export class AlterTableModifyColumnBuilder {
     constructor(props) {
         this.#props = freeze(props);
     }
-    increments() {
+    autoIncrement() {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,
-            columnBuilder: this.#props.columnBuilder.increments(),
+            columnBuilder: this.#props.columnBuilder.autoIncrement(),
         });
     }
     primaryKey() {
@@ -309,6 +321,18 @@ export class AlterTableModifyColumnBuilder {
             columnBuilder: this.#props.columnBuilder.check(sql),
         });
     }
+    generatedAlwaysAs(sql) {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+        });
+    }
+    stored() {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.stored(),
+        });
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(AlterTableNode.cloneWith(this.#props.alterTableNode, {
             modifyColumn: ModifyColumnNode.create(this.#props.columnBuilder.toOperationNode()),

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

@@ -12,7 +12,7 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * Some dialects like PostgreSQL don't support this. On PostgreSQL
      * you can use the `serial` or `bigserial` data type instead.
      */
-    increments(): R;
+    autoIncrement(): R;
     /**
      * Makes the column the primary key.
      *
@@ -40,10 +40,19 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * column definition (like MySQL 5) you need to call the table level
      * {@link TableBuilder.addForeignKeyConstraint} method instead.
      *
+     * @example
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
      */
     onDelete(onDelete: OnModifyForeignAction): R;
     /**
      * Adds an `on update` constraint for the foreign key column.
+     *
+     * @example
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
      */
     onUpdate(onUpdate: OnModifyForeignAction): R;
     /**
@@ -78,11 +87,41 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * ```
      */
     check(sql: string): R;
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * @example
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *   )
+     *   .execute()
+     * ```
+     */
+    generatedAlwaysAs(sql: string): R;
+    /**
+     * Makes a generated column stored instead of virtual. This method can only
+     * be used with {@link generatedAlwaysAs}
+     *
+     * @example
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
+    stored(): R;
 }
 export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface<ColumnDefinitionBuilder>, OperationNodeSource {
     #private;
     constructor(node: ColumnDefinitionNode);
-    increments(): ColumnDefinitionBuilder;
+    autoIncrement(): ColumnDefinitionBuilder;
     primaryKey(): ColumnDefinitionBuilder;
     references(ref: string): ColumnDefinitionBuilder;
     onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilder;
@@ -91,5 +130,7 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
     notNull(): ColumnDefinitionBuilder;
     defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
     check(sql: string): ColumnDefinitionBuilder;
+    generatedAlwaysAs(sql: string): ColumnDefinitionBuilder;
+    stored(): ColumnDefinitionBuilder;
     toOperationNode(): ColumnDefinitionNode;
 }

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

@@ -6,16 +6,18 @@ 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 { DefaultValueNode } from '../operation-node/default-value-node.js';
 export class ColumnDefinitionBuilder {
     #node;
     constructor(node) {
         this.#node = node;
     }
-    increments() {
-        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { isAutoIncrementing: true }));
+    autoIncrement() {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { autoIncrement: true }));
     }
     primaryKey() {
-        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { isPrimaryKey: true }));
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { primaryKey: true }));
     }
     references(ref) {
         const references = parseStringReference(ref);
@@ -45,14 +47,14 @@ export class ColumnDefinitionBuilder {
         }));
     }
     unique() {
-        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { isUnique: true }));
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { unique: true }));
     }
     notNull() {
-        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { isNullable: false }));
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { nullable: false }));
     }
     defaultTo(value) {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            defaultTo: parseDefaultValueExpression(value),
+            defaultTo: DefaultValueNode.create(parseDefaultValueExpression(value)),
         }));
     }
     check(sql) {
@@ -60,6 +62,21 @@ export class ColumnDefinitionBuilder {
             check: CheckConstraintNode.create(sql),
         }));
     }
+    generatedAlwaysAs(sql) {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
+            generatedAlwaysAs: GeneratedAlwaysAsNode.create(sql),
+        }));
+    }
+    stored() {
+        if (!this.#node.generatedAlwaysAs) {
+            throw new Error('stored() can only be called after generatedAlwaysAs');
+        }
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
+            generatedAlwaysAs: GeneratedAlwaysAsNode.cloneWith(this.#node.generatedAlwaysAs, {
+                stored: true,
+            }),
+        }));
+    }
     toOperationNode() {
         return this.#node;
     }

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

@@ -9,7 +9,7 @@ export class CreateSchemaBuilder {
     ifNotExists() {
         return new CreateSchemaBuilder({
             ...this.#props,
-            createSchemaNode: CreateSchemaNode.cloneWith(this.#props.createSchemaNode, { modifier: 'IfNotExists' }),
+            createSchemaNode: CreateSchemaNode.cloneWith(this.#props.createSchemaNode, { ifNotExists: true }),
         });
     }
     toOperationNode() {

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

@@ -26,9 +26,9 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'integer', (col) => col.increments().primaryKey()),
-     *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
+     *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
+     *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
      *   .addColumn('parent_id', 'integer', (col) =>
@@ -37,11 +37,10 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```
      *
      * With this method, it's once again good to remember that Kysely just builds the query
-     * that's as close to the structure of your builder method calls as possible, and doesn't
-     * provide the same API for all databses. For example, some databases like older MySQL
-     * don't support `references` statement in the column definition. Instead foreign key
-     * constraints need to be defined in at the level of the `create table` query. See
-     * the next example:
+     * and doesn't provide the same API for all databses. For example, some databases like
+     * older MySQL don't support `references` statement in the column definition. Instead
+     * foreign key constraints need to be defined in at the level of the `create table`
+     * query. See the next example:
      *
      * @example
      * ```ts

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

@@ -27,7 +27,7 @@ export class CreateTableBuilder {
     ifNotExists() {
         return new CreateTableBuilder({
             ...this.#props,
-            createTableNode: CreateTableNode.cloneWithModifier(this.#props.createTableNode, 'IfNotExists'),
+            createTableNode: CreateTableNode.cloneWithIfNotExists(this.#props.createTableNode, true),
         });
     }
     /**
@@ -37,9 +37,9 @@ export class CreateTableBuilder {
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'integer', (col) => col.increments().primaryKey()),
-     *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
+     *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
+     *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
      *   .addColumn('parent_id', 'integer', (col) =>
@@ -48,11 +48,10 @@ export class CreateTableBuilder {
      * ```
      *
      * With this method, it's once again good to remember that Kysely just builds the query
-     * that's as close to the structure of your builder method calls as possible, and doesn't
-     * provide the same API for all databses. For example, some databases like older MySQL
-     * don't support `references` statement in the column definition. Instead foreign key
-     * constraints need to be defined in at the level of the `create table` query. See
-     * the next example:
+     * and doesn't provide the same API for all databses. For example, some databases like
+     * older MySQL don't support `references` statement in the column definition. Instead
+     * foreign key constraints need to be defined in at the level of the `create table`
+     * query. See the next example:
      *
      * @example
      * ```ts

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

@@ -9,6 +9,11 @@ import { AnyRawBuilder } from '../util/type-utils.js';
 export declare class CreateViewBuilder implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateViewBuilderProps);
+    materialized(): CreateViewBuilder;
+    /**
+     * Only implemented on some dialects like SQLite. On most dialects, use {@link orReplace}.
+     */
+    ifNotExists(): CreateViewBuilder;
     orReplace(): CreateViewBuilder;
     columns(columns: string[]): CreateViewBuilder;
     as(query: AnyQueryBuilder | AnyRawBuilder): CreateViewBuilder;

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

@@ -20,11 +20,30 @@ export class CreateViewBuilder {
             executor: props.executor.withPlugin(new ImmediateValuePlugin()),
         });
     }
+    materialized() {
+        return new CreateViewBuilder({
+            ...this.#props,
+            createViewNode: CreateViewNode.cloneWith(this.#props.createViewNode, {
+                materialized: true,
+            }),
+        });
+    }
+    /**
+     * Only implemented on some dialects like SQLite. On most dialects, use {@link orReplace}.
+     */
+    ifNotExists() {
+        return new CreateViewBuilder({
+            ...this.#props,
+            createViewNode: CreateViewNode.cloneWith(this.#props.createViewNode, {
+                ifNotExists: true,
+            }),
+        });
+    }
     orReplace() {
         return new CreateViewBuilder({
             ...this.#props,
             createViewNode: CreateViewNode.cloneWith(this.#props.createViewNode, {
-                modifier: 'OrReplace',
+                orReplace: true,
             }),
         });
     }

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

@@ -23,7 +23,7 @@ export class DropIndexBuilder {
         return new DropIndexBuilder({
             ...this.#props,
             dropIndexNode: DropIndexNode.cloneWith(this.#props.dropIndexNode, {
-                modifier: 'IfExists',
+                ifExists: true,
             }),
         });
     }

package/dist/esm/schema/drop-schema-builder.js

@@ -9,7 +9,9 @@ export class DropSchemaBuilder {
     ifExists() {
         return new DropSchemaBuilder({
             ...this.#props,
-            dropSchemaNode: DropSchemaNode.cloneWithModifier(this.#props.dropSchemaNode, 'IfExists'),
+            dropSchemaNode: DropSchemaNode.cloneWith(this.#props.dropSchemaNode, {
+                ifExists: true,
+            }),
         });
     }
     toOperationNode() {

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

@@ -9,7 +9,9 @@ export class DropTableBuilder {
     ifExists() {
         return new DropTableBuilder({
             ...this.#props,
-            dropTableNode: DropTableNode.cloneWithModifier(this.#props.dropTableNode, 'IfExists'),
+            dropTableNode: DropTableNode.cloneWith(this.#props.dropTableNode, {
+                ifExists: true,
+            }),
         });
     }
     toOperationNode() {

package/dist/esm/schema/drop-view-builder.d.ts

@@ -7,6 +7,7 @@ import { DropViewNode } from '../operation-node/drop-view-node.js';
 export declare class DropViewBuilder implements OperationNodeSource, Compilable {
     #private;
     constructor(props: DropViewBuilderProps);
+    materialized(): DropViewBuilder;
     ifExists(): DropViewBuilder;
     toOperationNode(): DropViewNode;
     compile(): CompiledQuery;

package/dist/esm/schema/drop-view-builder.js

@@ -6,10 +6,20 @@ export class DropViewBuilder {
     constructor(props) {
         this.#props = freeze(props);
     }
+    materialized() {
+        return new DropViewBuilder({
+            ...this.#props,
+            dropViewNode: DropViewNode.cloneWith(this.#props.dropViewNode, {
+                materialized: true,
+            }),
+        });
+    }
     ifExists() {
         return new DropViewBuilder({
             ...this.#props,
-            dropViewNode: DropViewNode.cloneWithModifier(this.#props.dropViewNode, 'IfExists'),
+            dropViewNode: DropViewNode.cloneWith(this.#props.dropViewNode, {
+                ifExists: true,
+            }),
         });
     }
     toOperationNode() {

package/dist/esm/schema/schema.d.ts

@@ -24,7 +24,7 @@ export declare class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('first_name', 'varchar', col => col.notNull())
      *   .addColumn('last_name', 'varchar', col => col.notNull())
      *   .addColumn('gender', 'varchar')
@@ -40,7 +40,7 @@ export declare class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('pet')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('owner_id', 'integer', col => col
      *     .references('person.id')
      *     .onDelete('cascade')
@@ -57,7 +57,7 @@ export declare class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('pet')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('owner_id', 'integer')
      *   .addForeignKeyConstraint(
      *     'pet_owner_id_foreign', ['owner_id'], 'person', ['id'],

package/dist/esm/schema/schema.js

@@ -37,7 +37,7 @@ export class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('first_name', 'varchar', col => col.notNull())
      *   .addColumn('last_name', 'varchar', col => col.notNull())
      *   .addColumn('gender', 'varchar')
@@ -53,7 +53,7 @@ export class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('pet')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('owner_id', 'integer', col => col
      *     .references('person.id')
      *     .onDelete('cascade')
@@ -70,7 +70,7 @@ export class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('pet')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('owner_id', 'integer')
      *   .addForeignKeyConstraint(
      *     'pet_owner_id_foreign', ['owner_id'], 'person', ['id'],

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,27 @@
+import { isFunction, isObject } from './object-utils.js';
+export async function importFunction(modulePath) {
+    const module = await import(modulePath);
+    const errorMessage = `module "${modulePath}" doesn 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);
+}

package/dist/esm/util/performance-now.d.ts

@@ -0,0 +1 @@
+export declare function performanceNow(): number;