kysely 0.8.0 → 0.9.2

package/dist/esm/query-compiler/compiled-query.d.ts

@@ -1,4 +1,4 @@
 export interface CompiledQuery {
     readonly sql: string;
-    readonly bindings: ReadonlyArray<any>;
+    readonly parameters: ReadonlyArray<unknown>;
 }

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -62,7 +62,7 @@ import { ModifyColumnNode } from '../operation-node/modify-column-node.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
-    protected get numBindings(): number;
+    protected get numParameters(): number;
     compileQuery(node: RootOperationNode): CompiledQuery;
     protected getSql(): string;
     protected visitSelectQuery(node: SelectQueryNode): void;
@@ -92,6 +92,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitTable(node: TableNode): void;
     protected visitCreateTable(node: CreateTableNode): void;
     protected visitColumnDefinition(node: ColumnDefinitionNode): void;
+    protected getAutoIncrement(): string;
     protected visitReferences(node: ReferencesNode): void;
     protected visitDropTable(node: DropTableNode): void;
     protected visitDataType(node: DataTypeNode): void;
@@ -125,10 +126,10 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitAddConstraint(node: AddConstraintNode): void;
     protected visitDropConstraint(node: DropConstraintNode): void;
     protected append(str: string): void;
-    protected appendValue(value: PrimitiveValue): void;
+    protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected getCurrentParameterPlaceholder(): string;
-    protected addBinding(binding: any): void;
+    protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: PrimitiveValue): void;
 }

package/dist/esm/query-compiler/default-query-compiler.js

@@ -1,25 +1,24 @@
-import { DataTypeNode } from '../operation-node/data-type-node.js';
 import { OperationNodeVisitor } from '../operation-node/operation-node-visitor.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { getLast, freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
 export class DefaultQueryCompiler extends OperationNodeVisitor {
-    #sqlFragments = [];
-    #bindings = [];
-    get numBindings() {
-        return this.#bindings.length;
+    #sql = '';
+    #parameters = [];
+    get numParameters() {
+        return this.#parameters.length;
     }
     compileQuery(node) {
-        this.#sqlFragments = [];
-        this.#bindings = [];
+        this.#sql = '';
+        this.#parameters = [];
         this.visitNode(node);
         return freeze({
             sql: this.getSql(),
-            bindings: this.#bindings,
+            parameters: this.#parameters,
         });
     }
     getSql() {
-        return this.#sqlFragments.join('');
+        return this.#sql;
     }
     visitSelectQuery(node) {
         // This is a sub query if this is not the root node.
@@ -289,19 +288,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     visitColumnDefinition(node) {
         this.visitNode(node.column);
         this.append(' ');
-        if (node.isAutoIncrementing) {
-            // Postgres overrides the data type for autoincrementing columns.
-            if (DataTypeNode.is(node.dataType) &&
-                node.dataType.dataType === 'bigint') {
-                this.append('bigserial');
-            }
-            else {
-                this.append('serial');
-            }
-        }
-        else {
-            this.visitNode(node.dataType);
-        }
+        this.visitNode(node.dataType);
         if (node.defaultTo) {
             this.append(' default ');
             this.visitNode(node.defaultTo);
@@ -309,6 +296,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (!node.isNullable) {
             this.append(' not null');
         }
+        if (node.isAutoIncrementing) {
+            this.append(' ');
+            this.append(this.getAutoIncrement());
+        }
         if (node.isUnique) {
             this.append(' unique');
         }
@@ -324,6 +315,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.check);
         }
     }
+    getAutoIncrement() {
+        return 'auto_increment';
+    }
     visitReferences(node) {
         this.append('references ');
         this.visitNode(node.table);
@@ -634,10 +628,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node.constraintName);
     }
     append(str) {
-        this.#sqlFragments.push(str);
+        this.#sql += str;
     }
-    appendValue(value) {
-        this.addBinding(value);
+    appendValue(parameter) {
+        this.addParameter(parameter);
         this.append(this.getCurrentParameterPlaceholder());
     }
     getLeftIdentifierWrapper() {
@@ -647,10 +641,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         return '"';
     }
     getCurrentParameterPlaceholder() {
-        return '$' + this.numBindings;
+        return '$' + this.numParameters;
     }
-    addBinding(binding) {
-        this.#bindings.push(binding);
+    addParameter(parameter) {
+        this.#parameters.push(parameter);
     }
     appendImmediateValue(value) {
         if (isString(value)) {
@@ -678,7 +672,7 @@ const SELECT_MODIFIER_SQL = {
     ForNoKeyUpdate: 'for no key update',
     ForUpdate: 'for update',
     ForShare: 'for share',
-    NoWait: 'no wait',
+    NoWait: 'nowait',
     SkipLocked: 'skip locked',
 };
 const JOIN_TYPE_SQL = {

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

@@ -10,7 +10,7 @@ export declare class QueryCreator<DB> {
     #private;
     constructor(props: QueryCreatorProps);
     /**
-     * Creates a `select` query builder against the given table/tables.
+     * Creates a `select` query builder for the given table or tables.
      *
      * The tables passed to this method are built as the query's `from` clause.
      *
@@ -221,6 +221,9 @@ export declare class QueryCreator<DB> {
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.
      *
+     * This only affects the query created through the builder returned from
+     * this method and doesn't modify the `db` instance.
+     *
      * @example
      * ```
      * await db.withSchema('mammals')
@@ -261,10 +264,10 @@ export declare class QueryCreator<DB> {
      * Provides a way to pass arbitrary SQL into your query and executing completely
      * raw queries.
      *
-     * You can use strings `?` and `??` in the `sql` to bind parameters such as
+     * You can use the strings `?` and `??` in the `sql` to bind parameters such as
      * user input to the SQL. You should never EVER concatenate untrusted user
      * input to the SQL string to avoid injection vulnerabilities. Instead use `?`
-     * in place of the value and pass the actual value in the `params` list. See
+     * in place of a value and pass the actual value in the `parameters` list. See
      * the examples below.
      *
      * You should only use `raw` when there is no other way to get the job done. This is
@@ -276,11 +279,11 @@ export declare class QueryCreator<DB> {
      * Raw builder instances can be passed to pretty much anywhere: `select`, `where`,
      * `*Join`, `groupBy`, `orderBy` etc. Just try it. If the method accepts it, it works.
      *
-     * @param sql - The raw SQL. Special strings `?` and `??` can be used to provide
-     *    parameter bindings. `?` for values and `??` for identifiers such as column names
+     * @param sql - The raw SQL. Special strings `?` and `??` can be used as parameter
+     *    placeholders. `?` for values and `??` for identifiers such as column names
      *    or `column.table` references.
      *
-     * @param params - The parameters that will be bound to the `?` and `??` bindings in
+     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
      *    the sql string.
      *
      * @example
@@ -318,7 +321,7 @@ export declare class QueryCreator<DB> {
      *     the output type. In this case you need to use the `castTo` method on the query
      *     to specify a return type for the query.
      *
-     * We could've also used `??` bindings to provide `first_name` and `last_name` like
+     * We could've also used a `??` placeholder to provide `first_name` and `last_name` like
      * this:
      *
      * ```ts
@@ -333,9 +336,9 @@ export declare class QueryCreator<DB> {
      *
      * But it's often cleaner to just write the column names in the SQL. Again remember to
      * never concatenate column names or any other untrusted user input to the SQL string or you
-     * are going to create an injection vulnerability. All user input should go to the bindings
+     * are going to create an injection vulnerability. All user input should go to the parameters
      * array, never to the SQL string directly. But if the column names or values are trusted
-     * and known at compile time, there is no reason to use bindings.
+     * and known at compile time, there is no reason to use parameters.
      *
      * @example
      * Example of using `raw` in `where`:
@@ -361,7 +364,7 @@ export declare class QueryCreator<DB> {
      *
      * The function in the above example returns people that are older than the given number of
      * years. The number of years in this example is an untrusted user input, and therefore we use
-     * a `?` binding for it.
+     * a `?` placeholder for it.
      *
      * @example
      * Example of creating a completely raw query from scratch:
@@ -375,7 +378,7 @@ export declare class QueryCreator<DB> {
      * The result of `execute()` method is always an array. In this case the type of
      * the `persons` variable is `Person[]`.
      */
-    raw<T = unknown>(sql: string, params?: any[]): RawBuilder<T>;
+    raw<T = unknown>(sql: string, parameters?: any[]): RawBuilder<T>;
 }
 export interface QueryCreatorProps {
     readonly executor: QueryExecutor;

package/dist/esm/query-creator.js

@@ -155,6 +155,9 @@ export class QueryCreator {
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.
      *
+     * This only affects the query created through the builder returned from
+     * this method and doesn't modify the `db` instance.
+     *
      * @example
      * ```
      * await db.withSchema('mammals')
@@ -200,10 +203,10 @@ export class QueryCreator {
      * Provides a way to pass arbitrary SQL into your query and executing completely
      * raw queries.
      *
-     * You can use strings `?` and `??` in the `sql` to bind parameters such as
+     * You can use the strings `?` and `??` in the `sql` to bind parameters such as
      * user input to the SQL. You should never EVER concatenate untrusted user
      * input to the SQL string to avoid injection vulnerabilities. Instead use `?`
-     * in place of the value and pass the actual value in the `params` list. See
+     * in place of a value and pass the actual value in the `parameters` list. See
      * the examples below.
      *
      * You should only use `raw` when there is no other way to get the job done. This is
@@ -215,11 +218,11 @@ export class QueryCreator {
      * Raw builder instances can be passed to pretty much anywhere: `select`, `where`,
      * `*Join`, `groupBy`, `orderBy` etc. Just try it. If the method accepts it, it works.
      *
-     * @param sql - The raw SQL. Special strings `?` and `??` can be used to provide
-     *    parameter bindings. `?` for values and `??` for identifiers such as column names
+     * @param sql - The raw SQL. Special strings `?` and `??` can be used as parameter
+     *    placeholders. `?` for values and `??` for identifiers such as column names
      *    or `column.table` references.
      *
-     * @param params - The parameters that will be bound to the `?` and `??` bindings in
+     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
      *    the sql string.
      *
      * @example
@@ -257,7 +260,7 @@ export class QueryCreator {
      *     the output type. In this case you need to use the `castTo` method on the query
      *     to specify a return type for the query.
      *
-     * We could've also used `??` bindings to provide `first_name` and `last_name` like
+     * We could've also used a `??` placeholder to provide `first_name` and `last_name` like
      * this:
      *
      * ```ts
@@ -272,9 +275,9 @@ export class QueryCreator {
      *
      * But it's often cleaner to just write the column names in the SQL. Again remember to
      * never concatenate column names or any other untrusted user input to the SQL string or you
-     * are going to create an injection vulnerability. All user input should go to the bindings
+     * are going to create an injection vulnerability. All user input should go to the parameters
      * array, never to the SQL string directly. But if the column names or values are trusted
-     * and known at compile time, there is no reason to use bindings.
+     * and known at compile time, there is no reason to use parameters.
      *
      * @example
      * Example of using `raw` in `where`:
@@ -300,7 +303,7 @@ export class QueryCreator {
      *
      * The function in the above example returns people that are older than the given number of
      * years. The number of years in this example is an untrusted user input, and therefore we use
-     * a `?` binding for it.
+     * a `?` placeholder for it.
      *
      * @example
      * Example of creating a completely raw query from scratch:
@@ -314,12 +317,12 @@ export class QueryCreator {
      * The result of `execute()` method is always an array. In this case the type of
      * the `persons` variable is `Person[]`.
      */
-    raw(sql, params) {
+    raw(sql, parameters) {
         return new RawBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
             sql,
-            params,
+            parameters,
         });
     }
 }

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 params?: any;
+    readonly parameters?: any;
 }

package/dist/esm/raw-builder/raw-builder.js

@@ -25,24 +25,24 @@ export class RawBuilder {
         });
     }
     toOperationNode() {
-        const bindingRegex = /(\?\??)/g;
+        const parameterPlaceholderRegex = /(\?\??)/g;
         const sql = this.#props.sql;
-        const params = this.#props.params ?? [];
+        const parameters = this.#props.parameters ?? [];
         const sqlFragments = [];
         const argNodes = [];
         let paramIdx = 0;
         let sqlIdx = 0;
         let match = null;
-        while ((match = bindingRegex.exec(sql))) {
+        while ((match = parameterPlaceholderRegex.exec(sql))) {
             const str = match[1];
-            if (paramIdx >= params.length) {
-                throw new Error(`value not provided for all bindings in string ${sql}`);
+            if (paramIdx >= parameters.length) {
+                throw new Error(`value not provided for all placeholders in string ${sql}`);
             }
             if (match.index > 0 && sql[match.index - 1] === '\\') {
                 continue;
             }
             sqlFragments.push(sql.slice(sqlIdx, match.index).replaceAll('\\?', '?'));
-            argNodes.push(parseRawArg(str, params[paramIdx]));
+            argNodes.push(parseRawArg(str, parameters[paramIdx]));
             sqlIdx = match.index + str.length;
             ++paramIdx;
         }

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

@@ -12,6 +12,9 @@ import { QueryId } from '../util/query-id.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { DataTypeExpression } from '../parser/data-type-parser.js';
 import { ForeignKeyConstraintBuilder, ForeignKeyConstraintBuilderInterface } from './foreign-key-constraint-builder.js';
+/**
+ * This builder can be used to create a `alter table` query.
+ */
 export declare class AlterTableBuilder {
     #private;
     constructor(props: AlterTableBuilderProps);

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

@@ -20,6 +20,9 @@ import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.j
 import { CheckConstraintNode } from '../operation-node/check-constraint-node.js';
 import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
+/**
+ * This builder can be used to create a `alter table` query.
+ */
 export class AlterTableBuilder {
     #props;
     constructor(props) {

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

@@ -6,11 +6,11 @@ import { AnyRawBuilder } from '../util/type-utils.js';
 import { DefaultValueExpression } from '../parser/default-value-parser.js';
 export interface ColumnDefinitionBuilderInterface<R> {
     /**
-     * Makes the column automatically incrementing.
+     * Adds `auto_increment` or `autoincrement` to the column definition
+     * depending on the dialect.
      *
-     * On some dialects this may change the column type as well. For example
-     * on postgres this sets the column type to `serial` no matter what you
-     * have specified before.
+     * Some dialects like PostgreSQL don't support this. On PostgreSQL
+     * you can use the `serial` or `bigserial` data type instead.
      */
     increments(): R;
     /**
@@ -23,6 +23,10 @@ export interface ColumnDefinitionBuilderInterface<R> {
     /**
      * 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.
+     *
      * @example
      * ```ts
      * col.references('person.id')
@@ -31,6 +35,11 @@ export interface ColumnDefinitionBuilderInterface<R> {
     references(ref: string): R;
     /**
      * 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.
+     *
      */
     onDelete(onDelete: OnModifyForeignAction): R;
     /**
@@ -64,7 +73,7 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * ```ts
      * db.schema
      *   .createTable('pet')
-     *   .addColumn('number_of_legs', (col) => col.check('number_of_legs < 5', 'integer'))
+     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
      *   .execute()
      * ```
      */

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

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

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

@@ -7,7 +7,10 @@ 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';
-export declare class CreateTableBuilder implements OperationNodeSource, Compilable {
+/**
+ * This builder can be used to create a `create table` query.
+ */
+export declare class CreateTableBuilder<TB extends string, C extends string = never> implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateTableBuilderProps);
     /**
@@ -15,7 +18,7 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      *
      * If the table already exists, no error is thrown if this method has been called.
      */
-    ifNotExists(): CreateTableBuilder;
+    ifNotExists(): CreateTableBuilder<TB, C>;
     /**
      * Adds a column to the table.
      *
@@ -23,44 +26,86 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('int', 'id', (col) => col.increments().primary()),
+     *   .addColumn('id', 'integer', (col) => col.increments().primaryKey()),
      *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('varchar', 'last_name')
-     *   .addColumn('numeric(8, 2)', 'bank_balance')
+     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
+     *   .addColumn('parent_id', 'integer', (col) =>
+     *     col.references('person.id').onDelete('cascade'))
+     *   )
+     * ```
+     *
+     * 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:
+     *
+     * @example
+     * ```ts
+     *   .addColumn('parent_id', 'integer')
+     *   .addForeignKeyConstraint(
+     *     'person_parent_id_fk', ['parent_id'], 'person', ['id'],
+     *     (cb) => cb.onDelete('cascade')
+     *   )
+     * ```
+     *
+     * Another good example is that PostgreSQL doesn't support the `auto_increment`
+     * keyword and you need to define an autoincrementing column for example using
+     * `serial`:
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createTable('person')
+     *   .addColumn('id', 'serial', (col) => col.primaryKey()),
      * ```
      */
-    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnBuilderCallback): CreateTableBuilder;
+    addColumn<CN extends string>(columnName: CN, dataType: DataTypeExpression, build?: ColumnBuilderCallback): CreateTableBuilder<TB, C | CN>;
     /**
      * Adds a primary key constraint for one or more columns.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addPrimaryKeyConstraint('primary_key', ['first_name', 'last_name'])
      * ```
      */
-    addPrimaryKeyConstraint(constraintName: string, columns: string[]): CreateTableBuilder;
+    addPrimaryKeyConstraint(constraintName: string, columns: C[]): CreateTableBuilder<TB, C>;
     /**
      * Adds a unique constraint for one or more columns.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addUniqueConstraint('first_name_last_name_unique', ['first_name', 'last_name'])
      * ```
      */
-    addUniqueConstraint(constraintName: string, columns: string[]): CreateTableBuilder;
+    addUniqueConstraint(constraintName: string, columns: C[]): CreateTableBuilder<TB, C>;
     /**
      * Adds a check constraint.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addCheckConstraint('check_legs', 'number_of_legs < 5')
      * ```
      */
-    addCheckConstraint(constraintName: string, checkExpression: string): CreateTableBuilder;
+    addCheckConstraint(constraintName: string, checkExpression: string): CreateTableBuilder<TB, C>;
     /**
      * Adds a foreign key constraint.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addForeignKeyConstraint(
@@ -82,7 +127,7 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      * )
      * ```
      */
-    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[], build?: ForeignKeyConstraintBuilderCallback): CreateTableBuilder;
+    addForeignKeyConstraint(constraintName: string, columns: C[], targetTable: string, targetColumns: string[], build?: ForeignKeyConstraintBuilderCallback): CreateTableBuilder<TB, C>;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;