kysely 0.28.17 → 0.29.0

package/dist/esm/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/esm/util/compilable.d.ts

@@ -1,5 +0,0 @@
-import type { CompiledQuery } from '../query-compiler/compiled-query.js';
-export interface Compilable<O = unknown> {
-    compile(): CompiledQuery<O>;
-}
-export declare function isCompilable(value: unknown): value is Compilable;

package/dist/esm/util/deferred.d.ts

@@ -1,7 +0,0 @@
-export declare class Deferred<T> {
-    #private;
-    constructor();
-    get promise(): Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-}

package/dist/esm/util/deferred.js

@@ -1,25 +0,0 @@
-/// <reference types="./deferred.d.ts" />
-export 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);
-        }
-    };
-}

package/dist/esm/util/explainable.d.ts

@@ -1,40 +0,0 @@
-import type { Expression } from '../expression/expression.js';
-export type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
-export interface Explainable {
-    /**
-     * Executes query with `explain` statement before the main query.
-     *
-     * ```ts
-     * const explained = await db
-     *  .selectFrom('person')
-     *  .where('gender', '=', 'female')
-     *  .selectAll()
-     *  .explain('json')
-     * ```
-     *
-     * The generated SQL (MySQL):
-     *
-     * ```sql
-     * explain format=json select * from `person` where `gender` = ?
-     * ```
-     *
-     * You can also execute `explain analyze` statements.
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * const explained = await db
-     *  .selectFrom('person')
-     *  .where('gender', '=', 'female')
-     *  .selectAll()
-     *  .explain('json', sql`analyze`)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * explain (analyze, format json) select * from "person" where "gender" = $1
-     * ```
-     */
-    explain<O extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: Expression<any>): Promise<O[]>;
-}

package/dist/esm/util/infer-result.d.ts

@@ -1,48 +0,0 @@
-import type { DeleteResult } from '../query-builder/delete-result.js';
-import type { InsertResult } from '../query-builder/insert-result.js';
-import type { MergeResult } from '../query-builder/merge-result.js';
-import type { UpdateResult } from '../query-builder/update-result.js';
-import type { CompiledQuery } from '../query-compiler/compiled-query.js';
-import type { Compilable } from './compilable.js';
-import type { Simplify } from './type-utils.js';
-/**
- * A helper type that allows inferring a select/insert/update/delete query's result
- * type from a query builder or compiled query.
- *
- * ### Examples
- *
- * Infer a query builder's result type:
- *
- * ```ts
- * import { InferResult } from 'kysely'
- *
- * const query = db
- *   .selectFrom('person')
- *   .innerJoin('pet', 'pet.owner_id', 'person.id')
- *   .select(['person.first_name', 'pet.name'])
- *
- * type QueryResult = InferResult<typeof query> // { first_name: string; name: string; }[]
- * ```
- *
- * Infer a compiled query's result type:
- *
- * ```ts
- * import { InferResult } from 'kysely'
- *
- * const compiledQuery = db
- *   .insertInto('person')
- *   .values({
- *     first_name: 'Foo',
- *     last_name: 'Barson',
- *     gender: 'other',
- *     age: 15,
- *   })
- *   .returningAll()
- *   .compile()
- *
- * type QueryResult = InferResult<typeof compiledQuery> // Selectable<Person>[]
- * ```
- */
-export type InferResult<C extends Compilable<any> | CompiledQuery<any>> = C extends Compilable<infer O> ? ResolveResult<O> : C extends CompiledQuery<infer O> ? ResolveResult<O> : never;
-type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult | MergeResult ? O[] : Simplify<O>[];
-export {};

package/dist/esm/util/json-object-args.d.ts

@@ -1,3 +0,0 @@
-import type { Expression } from '../expression/expression.js';
-import type { SelectQueryNode } from '../operation-node/select-query-node.js';
-export declare function getJsonObjectArgs(node: SelectQueryNode, table: string): Expression<unknown>[];

package/dist/esm/util/log-once.d.ts

@@ -1,5 +0,0 @@
-/**
- * Use for system-level logging, such as deprecation messages.
- * Logs a message and ensures it won't be logged again.
- */
-export declare function logOnce(message: string): void;

package/dist/esm/util/log.d.ts

@@ -1,28 +0,0 @@
-import type { CompiledQuery } from '../query-compiler/compiled-query.js';
-import type { ArrayItemType } from './type-utils.js';
-declare const logLevels: readonly ["query", "error"];
-export declare const LOG_LEVELS: Readonly<typeof logLevels>;
-export type LogLevel = ArrayItemType<typeof LOG_LEVELS>;
-export interface QueryLogEvent {
-    readonly level: 'query';
-    readonly isStream?: boolean;
-    readonly query: CompiledQuery;
-    readonly queryDurationMillis: number;
-}
-export interface ErrorLogEvent {
-    readonly level: 'error';
-    readonly error: unknown;
-    readonly query: CompiledQuery;
-    readonly queryDurationMillis: number;
-}
-export type LogEvent = QueryLogEvent | ErrorLogEvent;
-export type Logger = (event: LogEvent) => void | Promise<void>;
-export type LogConfig = ReadonlyArray<LogLevel> | Logger;
-export declare class Log {
-    #private;
-    constructor(config: LogConfig);
-    isLevelEnabled(level: LogLevel): boolean;
-    query(getEvent: () => QueryLogEvent): Promise<void>;
-    error(getEvent: () => ErrorLogEvent): Promise<void>;
-}
-export {};

package/dist/esm/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/esm/util/object-utils.js

@@ -1,141 +0,0 @@
-/// <reference types="./object-utils.d.ts" />
-export 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;
-}
-export function isUndefined(obj) {
-    return typeof obj === 'undefined' || obj === undefined;
-}
-export function isString(obj) {
-    return typeof obj === 'string';
-}
-export function isNumber(obj) {
-    return typeof obj === 'number';
-}
-export function isBoolean(obj) {
-    return typeof obj === 'boolean';
-}
-export function isNull(obj) {
-    return obj === null;
-}
-export function isDate(obj) {
-    return obj instanceof Date;
-}
-export 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.
-export function isBuffer(obj) {
-    return typeof Buffer !== 'undefined' && Buffer.isBuffer(obj);
-}
-export function isFunction(obj) {
-    return typeof obj === 'function';
-}
-export function isObject(obj) {
-    return typeof obj === 'object' && obj !== null;
-}
-export function isArrayBufferOrView(obj) {
-    return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
-}
-export 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;
-}
-export function getLast(arr) {
-    return arr[arr.length - 1];
-}
-export function freeze(obj) {
-    return Object.freeze(obj);
-}
-export function asArray(arg) {
-    if (isReadonlyArray(arg)) {
-        return arg;
-    }
-    else {
-        return [arg];
-    }
-}
-export function asReadonlyArray(arg) {
-    if (isReadonlyArray(arg)) {
-        return arg;
-    }
-    else {
-        return freeze([arg]);
-    }
-}
-export function isReadonlyArray(arg) {
-    return Array.isArray(arg);
-}
-export function noop(obj) {
-    return obj;
-}
-export 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/esm/util/performance-now.d.ts

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

package/dist/esm/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/esm/util/provide-controlled-connection.js

@@ -1,22 +0,0 @@
-/// <reference types="./provide-controlled-connection.d.ts" />
-import { Deferred } from './deferred.js';
-import { freeze } from './object-utils.js';
-export async function provideControlledConnection(connectionProvider) {
-    const connectionDefer = new Deferred();
-    const connectionReleaseDefer = new 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 freeze({
-        connection: await connectionDefer.promise,
-        release: connectionReleaseDefer.resolve,
-    });
-}

package/dist/esm/util/query-id.d.ts

@@ -1,4 +0,0 @@
-export interface QueryId {
-    readonly queryId: string;
-}
-export declare function createQueryId(): QueryId;

package/dist/esm/util/random-string.d.ts

@@ -1 +0,0 @@
-export declare function randomString(length: number): string;

package/dist/esm/util/require-all-props.d.ts

@@ -1,45 +0,0 @@
-/**
- * Utility type to force use of all properties of T.
- *
- * Similar to Required<T> build-in type, but allows `undefined` values.
- */
-type AllProps<T> = T & {
-    [P in keyof T]-?: unknown;
-};
-/**
- * Helper function to check listed properties according to given type. Check if all properties has been used when object is initialised.
- *
- * Example use:
- *
- * ```ts
- * type SomeType = { propA: string; propB?: number; }
- *
- * // propB has to be mentioned even it is optional. It still should be initialized with undefined.
- * const a: SomeType = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
- *
- * // checked type is implicit for variable.
- * const b = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
- * ```
- *
- * Wrong use of this helper:
- *
- * 1. Omit checked type - all checked properties will be expect as of type never
- *
- * ```ts
- * type SomeType = { propA: string; propB?: number; }
- * // const z: SomeType = requireAllProps({ propC: "no type will work" }); // Property 'propA' is missing in type '{ propC: string; }' but required in type 'SomeType'.
- * ```
- *
- * 2. Apply to spreaded object - there is no way how to check in compile time if spreaded object contains all properties
- *
- * ```ts
- * type SomeType = { propA: string; propB?: number; }
- * const y: SomeType = { propA: "" }; // valid object according to SomeType declaration
- * // const x = requireAllProps<SomeType>({ ...y }); // Argument of type '{ propA: string; propB?: number; }' is not assignable to parameter of type 'AllProps<SomeType>'.
- * ```
- *
- * @param obj object to check if all properties has been used
- * @returns untouched obj parameter is returned
- */
-export declare function requireAllProps<T>(obj: AllProps<T>): T;
-export {};