kysely 0.16.1 → 0.16.5

package/dist/cjs/query-builder/insert-query-builder.d.ts

@@ -342,6 +342,22 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * values ($1, $2)
      * on conflict ("name") do nothing
      * ```
+     *
+     * You can refer to the columns of the virtual `excluded` table
+     * in a type-safe way using a callback and the `ref` method of
+     * `ExpressionBuilder`:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
      */
     onConflict(callback: (builder: OnConflictBuilder<DB, TB>) => OnConflictDoNothingBuilder<DB, TB> | OnConflictUpdateBuilder<DB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**

package/dist/cjs/query-builder/insert-query-builder.js

@@ -248,6 +248,22 @@ class InsertQueryBuilder {
      * values ($1, $2)
      * on conflict ("name") do nothing
      * ```
+     *
+     * You can refer to the columns of the virtual `excluded` table
+     * in a type-safe way using a callback and the `ref` method of
+     * `ExpressionBuilder`:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
      */
     onConflict(callback) {
         return new InsertQueryBuilder({

package/dist/cjs/query-builder/on-conflict-builder.d.ts

@@ -377,14 +377,16 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * do update set "first_name" = $3
      * ```
      */
-    doUpdateSet(updates: MutationObject<DB, TB>): OnConflictUpdateBuilder<{
-        [K in keyof DB | 'excluded']: K extends keyof DB ? DB[K] : DB[TB];
-    }, TB | 'excluded'>;
+    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
 }
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;
     readonly parseContext: ParseContext;
 }
+export declare type OnConflictDatabase<DB, TB extends keyof DB> = {
+    [K in keyof DB | 'excluded']: K extends keyof DB ? DB[K] : DB[TB];
+};
+export declare type OnConflictTables<TB> = TB | 'excluded';
 export declare class OnConflictDoNothingBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
     #private;
     constructor(props: OnConflictBuilderProps);

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

@@ -44,7 +44,6 @@ import { ValueNode } from '../operation-node/value-node.js';
 import { WhereNode } from '../operation-node/where-node.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { WithNode } from '../operation-node/with-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { CompiledQuery } from './compiled-query.js';
 import { RootOperationNode, QueryCompiler } from './query-compiler.js';
 import { HavingNode } from '../operation-node/having-node.js';
@@ -150,5 +149,5 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected getRightIdentifierWrapper(): string;
     protected getCurrentParameterPlaceholder(): string;
     protected addParameter(parameter: unknown): void;
-    protected appendImmediateValue(value: PrimitiveValue): void;
+    protected appendImmediateValue(value: unknown): void;
 }

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

@@ -412,7 +412,7 @@ export declare class QueryCreator<DB> {
      * @param params - The parameters that will be bound to the `?` and `??` placeholders in
      *    the sql string.
      */
-    raw<T = unknown>(sql: string, parameters?: any[]): RawBuilder<T>;
+    raw<T = unknown>(sql: string, parameters?: unknown[]): RawBuilder<T>;
 }
 export interface QueryCreatorProps {
     readonly executor: QueryExecutor;

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

@@ -5,13 +5,13 @@ import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionBuilder, ColumnDefinitionBuilderInterface } from './column-definition-builder.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 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';
+import { DefaultValueExpression } from '../parser/default-value-parser.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -43,7 +43,7 @@ export declare class AlterColumnBuilder {
     #private;
     constructor(props: AlterColumnBuilderProps);
     setDataType(dataType: ColumnDataType): AlterTableExecutor;
-    setDefault(value: PrimitiveValue | AnyRawBuilder): AlterTableExecutor;
+    setDefault(value: DefaultValueExpression): AlterTableExecutor;
     dropDefault(): AlterTableExecutor;
     setNotNull(): AlterTableExecutor;
     dropNotNull(): AlterTableExecutor;
@@ -141,8 +141,21 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
+    defaultTo(value: DefaultValueExpression): AlterTableAddColumnBuilder;
     /**
      * Adds a check constraint for the column.
      *
@@ -286,8 +299,21 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
+    defaultTo(value: DefaultValueExpression): AlterTableModifyColumnBuilder;
     /**
      * Adds a check constraint for the column.
      *

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

@@ -8,10 +8,8 @@ const column_definition_node_js_1 = require("../operation-node/column-definition
 const data_type_node_js_1 = require("../operation-node/data-type-node.js");
 const drop_column_node_js_1 = require("../operation-node/drop-column-node.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const rename_column_node_js_1 = require("../operation-node/rename-column-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
-const value_node_js_1 = require("../operation-node/value-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const column_definition_builder_js_1 = require("./column-definition-builder.js");
@@ -23,6 +21,7 @@ const unique_constraint_node_js_1 = require("../operation-node/unique-constraint
 const check_constraint_node_js_1 = require("../operation-node/check-constraint-node.js");
 const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-constraint-node.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
+const default_value_parser_js_1 = require("../parser/default-value-parser.js");
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -130,9 +129,7 @@ class AlterColumnBuilder {
             ...this.#props,
             alterTableNode: alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
                 alterColumn: alter_column_node_js_1.AlterColumnNode.cloneWith(this.#props.alterColumnNode, {
-                    setDefault: (0, operation_node_source_js_1.isOperationNodeSource)(value)
-                        ? value.toOperationNode()
-                        : value_node_js_1.ValueNode.createImmediate(value),
+                    setDefault: (0, default_value_parser_js_1.parseDefaultValueExpression)(value),
                 }),
             }),
         });

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

@@ -1,6 +1,5 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { OnModifyForeignAction } from '../operation-node/references-node.js';
-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';
@@ -83,8 +82,21 @@ export interface ColumnDefinitionBuilderInterface {
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): ColumnDefinitionBuilderInterface;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilderInterface;
     /**
      * Adds a check constraint for the column.
      *
@@ -222,6 +234,19 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
     defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
     /**

package/dist/cjs/util/object-utils.d.ts

@@ -1,14 +1,13 @@
-/// <reference types="node" />
-export declare type PrimitiveValue = string | number | boolean | null | Date | Buffer | BigInt;
-export declare function isEmpty(obj: ArrayLike<unknown> | string | object | Buffer): boolean;
+export declare function isEmpty(obj: ArrayLike<unknown> | string | object): boolean;
 export declare function isString(obj: unknown): obj is string;
 export declare function isNumber(obj: unknown): obj is number;
 export declare function isBoolean(obj: unknown): obj is boolean;
 export declare function isNull(obj: unknown): obj is null;
 export declare function isDate(obj: unknown): obj is Date;
-export declare function isBuffer(obj: unknown): obj is Buffer;
 export declare function isBigInt(obj: unknown): obj is BigInt;
-export declare function isPrimitive(obj: unknown): obj is PrimitiveValue;
+export declare function isBuffer(obj: unknown): obj is {
+    length: number;
+};
 export declare function isFunction(obj: unknown): obj is Function;
 export declare function isObject(obj: unknown): obj is Record<string, unknown>;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;

package/dist/cjs/util/object-utils.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isPrimitive = exports.isBigInt = exports.isBuffer = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isEmpty = void 0;
+exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isEmpty = void 0;
 function isEmpty(obj) {
-    if (Array.isArray(obj) || isString(obj) || Buffer.isBuffer(obj)) {
+    if (Array.isArray(obj) || isString(obj) || isBuffer(obj)) {
         return obj.length === 0;
     }
     else if (obj) {
@@ -31,24 +31,16 @@ function isDate(obj) {
     return obj instanceof Date;
 }
 exports.isDate = isDate;
-function isBuffer(obj) {
-    return Buffer.isBuffer(obj);
-}
-exports.isBuffer = isBuffer;
 function isBigInt(obj) {
     return typeof obj === 'bigint';
 }
 exports.isBigInt = isBigInt;
-function isPrimitive(obj) {
-    return (isString(obj) ||
-        isNumber(obj) ||
-        isBoolean(obj) ||
-        isNull(obj) ||
-        isDate(obj) ||
-        isBuffer(obj) ||
-        isBigInt(obj));
-}
-exports.isPrimitive = isPrimitive;
+// Don't change the returnd type to `obj is Buffer` to not create a
+// hard dependency to node.
+function isBuffer(obj) {
+    return typeof Buffer !== 'undefined' && Buffer.isBuffer(obj);
+}
+exports.isBuffer = isBuffer;
 function isFunction(obj) {
     return typeof obj === 'function';
 }

package/dist/esm/dialect/database-introspector.js

@@ -1 +1,2 @@
+/// <reference types="./database-introspector.d.ts" />
 export {};

package/dist/esm/dialect/dialect-adapter-base.js

@@ -1,3 +1,4 @@
+/// <reference types="./dialect-adapter-base.d.ts" />
 /**
  * A basic implementation of `DialectAdapter` with sensible default values.
  * 3rd party dialects can extend this instead of implementing the `DialectAdapter`

package/dist/esm/dialect/dialect-adapter.js

@@ -1 +1,2 @@
+/// <reference types="./dialect-adapter.d.ts" />
 export {};

package/dist/esm/dialect/dialect.js

@@ -1 +1,2 @@
+/// <reference types="./dialect.d.ts" />
 export {};

package/dist/esm/dialect/mysql/mysql-adapter.js

@@ -1,3 +1,4 @@
+/// <reference types="./mysql-adapter.d.ts" />
 import { DialectAdapterBase } from '../dialect-adapter-base.js';
 const LOCK_ID = 'ea586330-2c93-47c8-908d-981d9d270f9d';
 const LOCK_TIMEOUT_SECONDS = 60 * 60;

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

@@ -0,0 +1,205 @@
+import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * Config for the MySQL dialect.
+ *
+ * This interface is equal to `mysql2` library's pool config.
+ *
+ * https://github.com/sidorares/node-mysql2#using-connection-pools
+ */
+export interface MysqlDialectConfig {
+    /**
+     * The MySQL user to authenticate as
+     */
+    user?: string;
+    /**
+     * The password of that MySQL user
+     */
+    password?: string;
+    /**
+     * Name of the database to use for this connection
+     */
+    database?: string;
+    /**
+     * The charset for the connection. This is called 'collation' in the SQL-level of MySQL (like utf8_general_ci).
+     * If a SQL-level charset is specified (like utf8mb4) then the default collation for that charset is used.
+     * (Default: 'UTF8_GENERAL_CI')
+     */
+    charset?: string;
+    /**
+     * The hostname of the database you are connecting to. (Default: localhost)
+     */
+    host?: string;
+    /**
+     * The port number to connect to. (Default: 3306)
+     */
+    port?: number;
+    /**
+     * The source IP address to use for TCP connection
+     */
+    localAddress?: string;
+    /**
+     * The path to a unix domain socket to connect to. When used host and port are ignored
+     */
+    socketPath?: string;
+    /**
+     * The timezone used to store local dates. (Default: 'local')
+     */
+    timezone?: string | 'local';
+    /**
+     * The milliseconds before a timeout occurs during the initial connection to the MySQL server. (Default: 10 seconds)
+     */
+    connectTimeout?: number;
+    /**
+     * Stringify objects instead of converting to values. (Default: 'false')
+     */
+    stringifyObjects?: boolean;
+    /**
+     * Allow connecting to MySQL instances that ask for the old (insecure) authentication method. (Default: false)
+     */
+    insecureAuth?: boolean;
+    /**
+     * Determines if column values should be converted to native JavaScript types. It is not recommended (and may go away / change in the future)
+     * to disable type casting, but you can currently do so on either the connection or query level. (Default: true)
+     *
+     * You can also specify a function (field: any, next: () => void) => {} to do the type casting yourself.
+     *
+     * WARNING: YOU MUST INVOKE the parser using one of these three field functions in your custom typeCast callback. They can only be called once.
+     *
+     * field.string()
+     * field.buffer()
+     * field.geometry()
+     *
+     * are aliases for
+     *
+     * parser.parseLengthCodedString()
+     * parser.parseLengthCodedBuffer()
+     * parser.parseGeometryValue()
+     *
+     * You can find which field function you need to use by looking at: RowDataPacket.prototype._typeCast
+     */
+    typeCast?: boolean | ((field: any, next: () => void) => any);
+    /**
+     * A custom query format function
+     */
+    queryFormat?: (query: string, values: any) => void;
+    /**
+     * When dealing with big numbers (BIGINT and DECIMAL columns) in the database, you should enable this option
+     * (Default: false)
+     */
+    supportBigNumbers?: boolean;
+    /**
+     * Enabling both supportBigNumbers and bigNumberStrings forces big numbers (BIGINT and DECIMAL columns) to be
+     * always returned as JavaScript String objects (Default: false). Enabling supportBigNumbers but leaving
+     * bigNumberStrings disabled will return big numbers as String objects only when they cannot be accurately
+     * represented with [JavaScript Number objects] (http://ecma262-5.com/ELS5_HTML.htm#Section_8.5)
+     * (which happens when they exceed the [-2^53, +2^53] range), otherwise they will be returned as Number objects.
+     * This option is ignored if supportBigNumbers is disabled.
+     */
+    bigNumberStrings?: boolean;
+    /**
+     * Force date types (TIMESTAMP, DATETIME, DATE) to be returned as strings rather then inflated into JavaScript Date
+     * objects. Can be true/false or an array of type names to keep as strings.
+     *
+     * (Default: false)
+     */
+    dateStrings?: boolean | Array<'TIMESTAMP' | 'DATETIME' | 'DATE'>;
+    /**
+     * This will print all incoming and outgoing packets on stdout.
+     * You can also restrict debugging to packet types by passing an array of types (strings) to debug;
+     *
+     * (Default: false)
+     */
+    debug?: any;
+    /**
+     * Generates stack traces on Error to include call site of library entrance ('long stack traces'). Slight
+     * performance penalty for most calls. (Default: true)
+     */
+    trace?: boolean;
+    /**
+     * Allow multiple MySQL statements per query. Be careful with this, it exposes you to SQL injection attacks. (Default: false)
+     */
+    multipleStatements?: boolean;
+    /**
+     * List of connection flags to use other than the default ones. It is also possible to blacklist default ones
+     */
+    flags?: Array<string>;
+    /**
+     * object with ssl parameters or a string containing name of ssl profile
+     */
+    ssl?: string | MysqlSslOptions;
+    /**
+     * Return each row as an array, not as an object.
+     * This is useful when you have duplicate column names.
+     * This can also be set in the `QueryOption` object to be applied per-query.
+     */
+    rowsAsArray?: boolean;
+    /**
+     * The milliseconds before a timeout occurs during the connection acquisition. This is slightly different from connectTimeout,
+     * because acquiring a pool connection does not always involve making a connection. (Default: 10 seconds)
+     */
+    acquireTimeout?: number;
+    /**
+     * Determines the pool's action when no connections are available and the limit has been reached. If true, the pool will queue
+     * the connection request and call it when one becomes available. If false, the pool will immediately call back with an error.
+     * (Default: true)
+     */
+    waitForConnections?: boolean;
+    /**
+     * The maximum number of connections to create at once. (Default: 10)
+     */
+    connectionLimit?: number;
+    /**
+     * The maximum number of connection requests the pool will queue before returning an error from getConnection. If set to 0, there
+     * is no limit to the number of queued connection requests. (Default: 0)
+     */
+    queueLimit?: number;
+    /**
+     * Enable keep-alive on the socket.  It's disabled by default, but the
+     * user can enable it and supply an initial delay.
+     */
+    enableKeepAlive?: true;
+    /**
+     * If keep-alive is enabled users can supply an initial delay.
+     */
+    keepAliveInitialDelay?: number;
+    /**
+     * Called once for each created connection.
+     *
+     * This is a Kysely specific feature and does not come from the `mysql2` module.
+     */
+    onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
+}
+export interface MysqlSslOptions {
+    /**
+     * A string or buffer holding the PFX or PKCS12 encoded private key, certificate and CA certificates
+     */
+    pfx?: string;
+    /**
+     * A string holding the PEM encoded private key
+     */
+    key?: string;
+    /**
+     * A string of passphrase for the private key or pfx
+     */
+    passphrase?: string;
+    /**
+     * A string holding the PEM encoded certificate
+     */
+    cert?: string;
+    /**
+     * Either a string or list of strings of PEM encoded CA certificates to trust.
+     */
+    ca?: string | string[];
+    /**
+     * Either a string or list of strings of PEM encoded CRLs (Certificate Revocation List)
+     */
+    crl?: string | string[];
+    /**
+     * A string describing the ciphers to use or exclude
+     */
+    ciphers?: string;
+    /**
+     * You can also connect to a MySQL server without properly providing the appropriate CA to trust. You should not do this.
+     */
+    rejectUnauthorized?: boolean;
+}

package/dist/esm/dialect/mysql/mysql-dialect-config.js

@@ -0,0 +1,2 @@
+/// <reference types="./mysql-dialect-config.d.ts" />
+export {};