kysely 0.28.17 → 0.29.0

package/dist/cjs/util/column-type.d.ts

@@ -1,229 +0,0 @@
-import type { DrainOuterGeneric } from './type-utils.js';
-/**
- * This type can be used to specify a different type for
- * select, insert and update operations.
- *
- * Also see the {@link Generated} type.
- *
- * ### Examples
- *
- * The next example defines a number column that is optional
- * in inserts and updates. All columns are always optional
- * in updates so therefore we don't need to specify `undefined`
- * for the update type. The type below is useful for all kinds of
- * database generated columns like identifiers. The `Generated`
- * type is actually just a shortcut for the type in this example:
- *
- * ```ts
- * type GeneratedNumber = ColumnType<number, number | undefined, number>
- * ```
- *
- * The above example makes the column optional in inserts
- * and updates, but you can still choose to provide the
- * column. If you want to prevent insertion/update you
- * can se the type as `never`:
- *
- * ```ts
- * type ReadonlyNumber = ColumnType<number, never, never>
- * ```
- *
- * Here's one more example where the type is different
- * for each different operation:
- *
- * ```ts
- * type UnupdateableDate = ColumnType<Date, string, never>
- * ```
- */
-export type ColumnType<SelectType, InsertType = SelectType, UpdateType = SelectType> = {
-    readonly __select__: SelectType;
-    readonly __insert__: InsertType;
-    readonly __update__: UpdateType;
-};
-/**
- * A shortcut for defining database-generated columns. The type
- * is the same for all selects, inserts and updates but the
- * column is optional for inserts and updates.
- *
- * The update type is `S` instead of `S | undefined` because updates are always
- * optional --> no need to specify optionality.
- * ```
- */
-export type Generated<S> = ColumnType<S, S | undefined, S>;
-/**
- * A shortcut for defining columns that are only database-generated
- * (like postgres GENERATED ALWAYS AS IDENTITY). No insert/update
- * is allowed.
- */
-export type GeneratedAlways<S> = ColumnType<S, never, never>;
-/**
- * A shortcut for defining JSON columns, which are by default inserted/updated
- * as stringified JSON strings.
- */
-export type JSONColumnType<SelectType extends object | null, InsertType = string, UpdateType = string> = ColumnType<SelectType, InsertType, UpdateType>;
-/**
- * Evaluates to `K` if `T` can be `null` or `undefined`.
- */
-type IfNullable<T, K> = undefined extends T ? K : null extends T ? K : never;
-/**
- * Evaluates to `K` if `T` can't be `null` or `undefined`.
- */
-type IfNotNullable<T, K> = undefined extends T ? never : null extends T ? never : T extends never ? never : K;
-/**
- * Evaluates to `K` if `T` isn't `never`.
- */
-type IfNotNever<T, K> = T extends never ? never : K;
-export type SelectType<T> = T extends ColumnType<infer S, any, any> ? S : T;
-export type InsertType<T> = T extends ColumnType<any, infer I, any> ? I : T;
-export type UpdateType<T> = T extends ColumnType<any, any, infer U> ? U : T;
-/**
- * Keys of `R` whose `InsertType` values can be `null` or `undefined`.
- */
-export type NullableInsertKeys<R> = {
-    [K in keyof R]: IfNullable<InsertType<R[K]>, K>;
-}[keyof R];
-/**
- * Keys of `R` whose `InsertType` values can't be `null` or `undefined`.
- */
-export type NonNullableInsertKeys<R> = {
-    [K in keyof R]: IfNotNullable<InsertType<R[K]>, K>;
-}[keyof R];
-/**
- * Keys of `R` whose `SelectType` values are not `never`
- */
-type NonNeverSelectKeys<R> = {
-    [K in keyof R]: IfNotNever<SelectType<R[K]>, K>;
-}[keyof R];
-/**
- * Keys of `R` whose `UpdateType` values are not `never`
- */
-export type UpdateKeys<R> = {
-    [K in keyof R]: IfNotNever<UpdateType<R[K]>, K>;
-}[keyof R];
-/**
- * Given a table interface, extracts the select type from all
- * {@link ColumnType} types.
- *
- * ### Examples
- *
- * ```ts
- * interface PersonTable {
- *   id: Generated<number>
- *   first_name: string
- *   modified_at: ColumnType<Date, string, never>
- * }
- *
- * type Person = Selectable<PersonTable>
- * // {
- * //   id: number,
- * //   first_name: string
- * //   modified_at: Date
- * // }
- * ```
- */
-export type Selectable<R> = DrainOuterGeneric<{
-    [K in NonNeverSelectKeys<R>]: SelectType<R[K]>;
-}>;
-/**
- * Given a table interface, extracts the insert type from all
- * {@link ColumnType} types.
- *
- * ### Examples
- *
- * ```ts
- * interface PersonTable {
- *   id: Generated<number>
- *   first_name: string
- *   modified_at: ColumnType<Date, string, never>
- * }
- *
- * type InsertablePerson = Insertable<PersonTable>
- * // {
- * //   id?: number,
- * //   first_name: string
- * //   modified_at: string
- * // }
- * ```
- */
-export type Insertable<R> = DrainOuterGeneric<object & {
-    [K in NonNullableInsertKeys<R>]: InsertType<R[K]>;
-} & {
-    [K in NullableInsertKeys<R>]?: InsertType<R[K]>;
-}>;
-/**
- * Given a table interface, extracts the update type from all
- * {@link ColumnType} types.
- *
- * ### Examples
- *
- * ```ts
- * interface PersonTable {
- *   id: Generated<number>
- *   first_name: string
- *   modified_at: ColumnType<Date, string, never>
- * }
- *
- * type UpdateablePerson = Updateable<PersonTable>
- * // {
- * //   id?: number,
- * //   first_name?: string
- * // }
- * ```
- */
-export type Updateable<R> = DrainOuterGeneric<{
-    [K in UpdateKeys<R>]?: UpdateType<R[K]>;
-}>;
-/**
- * Wrap your column type to opt-out from dehydration by {@link ShallowDehydrateValue},
- * when used by JSON functions, such as the ones used by the relational helpers.
- *
- * Why need this?
- *
- * An edge case surfaced in issues where a numeric string column type was actually
- * not a numeric data type column, but text - and thus shouldn't be dehydrated
- * to `number`.
- *
- * Another use case would be, when someone finds a way to keep nested columns hydrated
- * at runtime, e.g. via a plugin, and wants to prevent dehydration of such columns
- * at the type level.
- *
- * ### Examples
- *
- * ```ts
- * import type { NonDehydrateable } from 'kysely'
- * import { jsonArrayFrom } from 'kysely/helpers/postgres'
- *
- * const result = await db
- *   .withTables<{
- *     my_table: {
- *       a_column: '1' | '2' | '3',
- *       another_column: NonDehydrateable<'1' | '2' | '3'>,
- *       column_too: NonDehydrateable<ColumnType<'1' | '2' | '3'>>
- *     }
- *   }>()
- *   .selectFrom('person')
- *   .select((eb) => [
- *     'id',
- *     jsonArrayFrom(
- *       eb.selectFrom('my_table')
- *         .select(['a_column', 'another_column', 'column_too'])
- *     ).as('related')
- *   ])
- *   .execute()
- * ```
- *
- * In the example above, "a_column" will be dehydrated to `number`
- * given it is a numeric string - which is normally a numeric data type column
- * that gets output as a string by underlying database drivers to avoid
- * precision loss or overflow.
- *
- * "another_column" and "column_too" will remain as `'1' | '2' | '3'`, given they're
- * wrapped in `NonDehydrateable`, which prevents their dehydration.
- */
-export type NonDehydrateable<T> = [T] extends [
-    ColumnType<infer S, infer I, infer U>
-] ? ColumnType<S & {
-    __kysely_dehydrate__?: false;
-}, I, U> : T & {
-    __kysely_dehydrate__?: false;
-};
-export {};

package/dist/cjs/util/column-type.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/util/compilable.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCompilable = isCompilable;
-const object_utils_js_1 = require("./object-utils.js");
-function isCompilable(value) {
-    return (0, object_utils_js_1.isObject)(value) && (0, object_utils_js_1.isFunction)(value.compile);
-}

package/dist/cjs/util/deferred.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deferred = void 0;
-class Deferred {
-    #promise;
-    #resolve;
-    #reject;
-    constructor() {
-        this.#promise = new Promise((resolve, reject) => {
-            this.#reject = reject;
-            this.#resolve = resolve;
-        });
-    }
-    get promise() {
-        return this.#promise;
-    }
-    resolve = (value) => {
-        if (this.#resolve) {
-            this.#resolve(value);
-        }
-    };
-    reject = (reason) => {
-        if (this.#reject) {
-            this.#reject(reason);
-        }
-    };
-}
-exports.Deferred = Deferred;

package/dist/cjs/util/explainable.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/util/infer-result.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/util/json-object-args.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJsonObjectArgs = getJsonObjectArgs;
-const expression_wrapper_js_1 = require("../expression/expression-wrapper.js");
-const alias_node_js_1 = require("../operation-node/alias-node.js");
-const column_node_js_1 = require("../operation-node/column-node.js");
-const identifier_node_js_1 = require("../operation-node/identifier-node.js");
-const reference_node_js_1 = require("../operation-node/reference-node.js");
-const table_node_js_1 = require("../operation-node/table-node.js");
-const value_node_js_1 = require("../operation-node/value-node.js");
-function getJsonObjectArgs(node, table) {
-    const args = [];
-    for (const { selection: s } of node.selections ?? []) {
-        if (reference_node_js_1.ReferenceNode.is(s) && column_node_js_1.ColumnNode.is(s.column)) {
-            args.push(colName(s.column.column.name), colRef(table, s.column.column.name));
-        }
-        else if (column_node_js_1.ColumnNode.is(s)) {
-            args.push(colName(s.column.name), colRef(table, s.column.name));
-        }
-        else if (alias_node_js_1.AliasNode.is(s) && identifier_node_js_1.IdentifierNode.is(s.alias)) {
-            args.push(colName(s.alias.name), colRef(table, s.alias.name));
-        }
-        else {
-            throw new Error(`can't extract column names from the select query node`);
-        }
-    }
-    return args;
-}
-function colName(col) {
-    return new expression_wrapper_js_1.ExpressionWrapper(value_node_js_1.ValueNode.createImmediate(col));
-}
-function colRef(table, col) {
-    return new expression_wrapper_js_1.ExpressionWrapper(reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(col), table_node_js_1.TableNode.create(table)));
-}

package/dist/cjs/util/log-once.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logOnce = logOnce;
-const LOGGED_MESSAGES = new Set();
-/**
- * Use for system-level logging, such as deprecation messages.
- * Logs a message and ensures it won't be logged again.
- */
-function logOnce(message) {
-    if (LOGGED_MESSAGES.has(message)) {
-        return;
-    }
-    LOGGED_MESSAGES.add(message);
-    console.log(message);
-}

package/dist/cjs/util/log.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Log = exports.LOG_LEVELS = void 0;
-const object_utils_js_1 = require("./object-utils.js");
-const logLevels = ['query', 'error'];
-exports.LOG_LEVELS = (0, object_utils_js_1.freeze)(logLevels);
-class Log {
-    #levels;
-    #logger;
-    constructor(config) {
-        if ((0, object_utils_js_1.isFunction)(config)) {
-            this.#logger = config;
-            this.#levels = (0, object_utils_js_1.freeze)({
-                query: true,
-                error: true,
-            });
-        }
-        else {
-            this.#logger = defaultLogger;
-            this.#levels = (0, object_utils_js_1.freeze)({
-                query: config.includes('query'),
-                error: config.includes('error'),
-            });
-        }
-    }
-    isLevelEnabled(level) {
-        return this.#levels[level];
-    }
-    async query(getEvent) {
-        if (this.#levels.query) {
-            await this.#logger(getEvent());
-        }
-    }
-    async error(getEvent) {
-        if (this.#levels.error) {
-            await this.#logger(getEvent());
-        }
-    }
-}
-exports.Log = Log;
-function defaultLogger(event) {
-    if (event.level === 'query') {
-        const prefix = `kysely:query:${event.isStream ? 'stream:' : ''}`;
-        console.log(`${prefix} ${event.query.sql}`);
-        console.log(`${prefix} duration: ${event.queryDurationMillis.toFixed(1)}ms`);
-    }
-    else if (event.level === 'error') {
-        if (event.error instanceof Error) {
-            console.error(`kysely:error: ${event.error.stack ?? event.error.message}`);
-        }
-        else {
-            console.error(`kysely:error: ${JSON.stringify({
-                error: event.error,
-                query: event.query.sql,
-                queryDurationMillis: event.queryDurationMillis,
-            })}`);
-        }
-    }
-}

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

@@ -1,23 +0,0 @@
-import type { ShallowRecord } from './type-utils.js';
-export declare function isEmpty(obj: ArrayLike<unknown> | string | object): boolean;
-export declare function isUndefined(obj: unknown): obj is undefined;
-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 isBigInt(obj: unknown): obj is bigint;
-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 ShallowRecord<string, unknown>;
-export declare function isArrayBufferOrView(obj: unknown): obj is ArrayBuffer | ArrayBufferView;
-export declare function isPlainObject(obj: unknown): obj is Record<string, unknown>;
-export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
-export declare function freeze<T>(obj: T): Readonly<T>;
-export declare function asArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T>;
-export declare function asReadonlyArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T>;
-export declare function isReadonlyArray(arg: unknown): arg is ReadonlyArray<unknown>;
-export declare function noop<T>(obj: T): T;
-export declare function compare(obj1: unknown, obj2: unknown): boolean;

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

@@ -1,162 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmpty = isEmpty;
-exports.isUndefined = isUndefined;
-exports.isString = isString;
-exports.isNumber = isNumber;
-exports.isBoolean = isBoolean;
-exports.isNull = isNull;
-exports.isDate = isDate;
-exports.isBigInt = isBigInt;
-exports.isBuffer = isBuffer;
-exports.isFunction = isFunction;
-exports.isObject = isObject;
-exports.isArrayBufferOrView = isArrayBufferOrView;
-exports.isPlainObject = isPlainObject;
-exports.getLast = getLast;
-exports.freeze = freeze;
-exports.asArray = asArray;
-exports.asReadonlyArray = asReadonlyArray;
-exports.isReadonlyArray = isReadonlyArray;
-exports.noop = noop;
-exports.compare = compare;
-function isEmpty(obj) {
-    if (Array.isArray(obj) || isString(obj) || isBuffer(obj)) {
-        return obj.length === 0;
-    }
-    else if (obj) {
-        return Object.keys(obj).length === 0;
-    }
-    return false;
-}
-function isUndefined(obj) {
-    return typeof obj === 'undefined' || obj === undefined;
-}
-function isString(obj) {
-    return typeof obj === 'string';
-}
-function isNumber(obj) {
-    return typeof obj === 'number';
-}
-function isBoolean(obj) {
-    return typeof obj === 'boolean';
-}
-function isNull(obj) {
-    return obj === null;
-}
-function isDate(obj) {
-    return obj instanceof Date;
-}
-function isBigInt(obj) {
-    return typeof obj === 'bigint';
-}
-// 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);
-}
-function isFunction(obj) {
-    return typeof obj === 'function';
-}
-function isObject(obj) {
-    return typeof obj === 'object' && obj !== null;
-}
-function isArrayBufferOrView(obj) {
-    return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
-}
-function isPlainObject(obj) {
-    if (!isObject(obj) || getTag(obj) !== '[object Object]') {
-        return false;
-    }
-    if (Object.getPrototypeOf(obj) === null) {
-        return true;
-    }
-    let proto = obj;
-    while (Object.getPrototypeOf(proto) !== null) {
-        proto = Object.getPrototypeOf(proto);
-    }
-    return Object.getPrototypeOf(obj) === proto;
-}
-function getLast(arr) {
-    return arr[arr.length - 1];
-}
-function freeze(obj) {
-    return Object.freeze(obj);
-}
-function asArray(arg) {
-    if (isReadonlyArray(arg)) {
-        return arg;
-    }
-    else {
-        return [arg];
-    }
-}
-function asReadonlyArray(arg) {
-    if (isReadonlyArray(arg)) {
-        return arg;
-    }
-    else {
-        return freeze([arg]);
-    }
-}
-function isReadonlyArray(arg) {
-    return Array.isArray(arg);
-}
-function noop(obj) {
-    return obj;
-}
-function compare(obj1, obj2) {
-    if (isReadonlyArray(obj1) && isReadonlyArray(obj2)) {
-        return compareArrays(obj1, obj2);
-    }
-    else if (isObject(obj1) && isObject(obj2)) {
-        return compareObjects(obj1, obj2);
-    }
-    return obj1 === obj2;
-}
-function compareArrays(arr1, arr2) {
-    if (arr1.length !== arr2.length) {
-        return false;
-    }
-    for (let i = 0; i < arr1.length; ++i) {
-        if (!compare(arr1[i], arr2[i])) {
-            return false;
-        }
-    }
-    return true;
-}
-function compareObjects(obj1, obj2) {
-    if (isBuffer(obj1) && isBuffer(obj2)) {
-        return compareBuffers(obj1, obj2);
-    }
-    else if (isDate(obj1) && isDate(obj2)) {
-        return compareDates(obj1, obj2);
-    }
-    return compareGenericObjects(obj1, obj2);
-}
-function compareBuffers(buf1, buf2) {
-    return Buffer.compare(buf1, buf2) === 0;
-}
-function compareDates(date1, date2) {
-    return date1.getTime() === date2.getTime();
-}
-function compareGenericObjects(obj1, obj2) {
-    const keys1 = Object.keys(obj1);
-    const keys2 = Object.keys(obj2);
-    if (keys1.length !== keys2.length) {
-        return false;
-    }
-    for (const key of keys1) {
-        if (!compare(obj1[key], obj2[key])) {
-            return false;
-        }
-    }
-    return true;
-}
-const toString = Object.prototype.toString;
-function getTag(value) {
-    if (value == null) {
-        return value === undefined ? '[object Undefined]' : '[object Null]';
-    }
-    return toString.call(value);
-}

package/dist/cjs/util/performance-now.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.performanceNow = performanceNow;
-const object_utils_js_1 = require("./object-utils.js");
-function performanceNow() {
-    if (typeof performance !== 'undefined' && (0, object_utils_js_1.isFunction)(performance.now)) {
-        return performance.now();
-    }
-    else {
-        return Date.now();
-    }
-}

package/dist/cjs/util/provide-controlled-connection.d.ts

@@ -1,7 +0,0 @@
-import type { ConnectionProvider } from '../driver/connection-provider.js';
-import type { DatabaseConnection } from '../driver/database-connection.js';
-export interface ControlledConnection {
-    readonly connection: DatabaseConnection;
-    readonly release: () => void;
-}
-export declare function provideControlledConnection(connectionProvider: ConnectionProvider): Promise<ControlledConnection>;

package/dist/cjs/util/provide-controlled-connection.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.provideControlledConnection = provideControlledConnection;
-const deferred_js_1 = require("./deferred.js");
-const object_utils_js_1 = require("./object-utils.js");
-async function provideControlledConnection(connectionProvider) {
-    const connectionDefer = new deferred_js_1.Deferred();
-    const connectionReleaseDefer = new deferred_js_1.Deferred();
-    connectionProvider
-        .provideConnection(async (connection) => {
-        connectionDefer.resolve(connection);
-        return await connectionReleaseDefer.promise;
-    })
-        .catch((ex) => connectionDefer.reject(ex));
-    // Create composite of the connection and the release method instead of
-    // modifying the connection or creating a new nesting `DatabaseConnection`.
-    // This way we don't accidentally override any methods of 3rd party
-    // connections and don't return wrapped connections to drivers that
-    // expect a certain specific connection class.
-    return (0, object_utils_js_1.freeze)({
-        connection: await connectionDefer.promise,
-        release: connectionReleaseDefer.resolve,
-    });
-}

package/dist/cjs/util/query-id.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createQueryId = createQueryId;
-const random_string_js_1 = require("./random-string.js");
-function createQueryId() {
-    return new LazyQueryId();
-}
-class LazyQueryId {
-    #queryId;
-    get queryId() {
-        if (this.#queryId === undefined) {
-            this.#queryId = (0, random_string_js_1.randomString)(8);
-        }
-        return this.#queryId;
-    }
-}