@depup/kysely 0.28.11-depup.0

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

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

@@ -0,0 +1,24 @@
+"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.d.ts

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

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

@@ -0,0 +1,16 @@
+"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;
+    }
+}

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

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

package/dist/cjs/util/random-string.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomString = randomString;
+const CHARS = [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+];
+function randomString(length) {
+    let chars = '';
+    for (let i = 0; i < length; ++i) {
+        chars += randomChar();
+    }
+    return chars;
+}
+function randomChar() {
+    return CHARS[~~(Math.random() * CHARS.length)];
+}

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

@@ -0,0 +1,45 @@
+/**
+ * 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 {};

package/dist/cjs/util/require-all-props.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAllProps = requireAllProps;
+/**
+ * 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
+ */
+function requireAllProps(obj) {
+    return obj;
+}

package/dist/cjs/util/stack-trace-utils.d.ts

@@ -0,0 +1 @@
+export declare function extendStackTrace(err: unknown, stackError: Error): unknown;

package/dist/cjs/util/stack-trace-utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendStackTrace = extendStackTrace;
+const object_utils_js_1 = require("./object-utils.js");
+function extendStackTrace(err, stackError) {
+    if (isStackHolder(err) && stackError.stack) {
+        // Remove the first line that just says `Error`.
+        const stackExtension = stackError.stack.split('\n').slice(1).join('\n');
+        err.stack += `\n${stackExtension}`;
+        return err;
+    }
+    return err;
+}
+function isStackHolder(obj) {
+    return (0, object_utils_js_1.isObject)(obj) && (0, object_utils_js_1.isString)(obj.stack);
+}

package/dist/cjs/util/streamable.d.ts

@@ -0,0 +1,29 @@
+export interface Streamable<O> {
+    /**
+     * Executes the query and streams the rows.
+     *
+     * The optional argument `chunkSize` defines how many rows to fetch from the database
+     * at a time. It only affects some dialects like PostgreSQL that support it.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const stream = db
+     *   .selectFrom('person')
+     *   .select(['first_name', 'last_name'])
+     *   .where('gender', '=', 'other')
+     *   .stream()
+     *
+     * for await (const person of stream) {
+     *   console.log(person.first_name)
+     *
+     *   if (person.last_name === 'Something') {
+     *     // Breaking or returning before the stream has ended will release
+     *     // the database connection and invalidate the stream.
+     *     break
+     *   }
+     * }
+     * ```
+     */
+    stream(chunkSize?: number): AsyncIterableIterator<O>;
+}

package/dist/cjs/util/streamable.js

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

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

@@ -0,0 +1,3 @@
+export interface KyselyTypeError<E extends string> {
+    readonly __kyselyTypeError__: E;
+}

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

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

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

@@ -0,0 +1,189 @@
+import type { InsertResult } from '../query-builder/insert-result.js';
+import type { DeleteResult } from '../query-builder/delete-result.js';
+import type { UpdateResult } from '../query-builder/update-result.js';
+import type { KyselyTypeError } from './type-error.js';
+import type { MergeResult } from '../query-builder/merge-result.js';
+/**
+ * Given a database type and a union of table names in that db, returns
+ * a union type with all possible column names.
+ *
+ * Example:
+ *
+ * ```ts
+ * interface Person {
+ *   id: number
+ * }
+ *
+ * interface Pet {
+ *   name: string
+ *   species: 'cat' | 'dog'
+ * }
+ *
+ * interface Movie {
+ *   stars: number
+ * }
+ *
+ * interface Database {
+ *   person: Person
+ *   pet: Pet
+ *   movie: Movie
+ * }
+ *
+ * type Columns = AnyColumn<Database, 'person' | 'pet'>
+ *
+ * // Columns == 'id' | 'name' | 'species'
+ * ```
+ */
+export type AnyColumn<DB, TB extends keyof DB> = {
+    [T in TB]: keyof DB[T];
+}[TB] & string;
+/**
+ * Extracts a column type.
+ */
+export type ExtractColumnType<DB, TB extends keyof DB, C> = {
+    [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
+}[TB];
+/**
+ * Given a database type and a union of table names in that db, returns
+ * a union type with all possible `table`.`column` combinations.
+ *
+ * Example:
+ *
+ * ```ts
+ * interface Person {
+ *   id: number
+ * }
+ *
+ * interface Pet {
+ *   name: string
+ *   species: 'cat' | 'dog'
+ * }
+ *
+ * interface Movie {
+ *   stars: number
+ * }
+ *
+ * interface Database {
+ *   person: Person
+ *   pet: Pet
+ *   movie: Movie
+ * }
+ *
+ * type Columns = AnyColumnWithTable<Database, 'person' | 'pet'>
+ *
+ * // Columns == 'person.id' | 'pet.name' | 'pet.species'
+ * ```
+ */
+export type AnyColumnWithTable<DB, TB extends keyof DB> = {
+    [T in TB]: `${T & string}.${keyof DB[T] & string}`;
+}[TB];
+/**
+ * Just like {@link AnyColumn} but with a ` as <string>` suffix.
+ */
+export type AnyAliasedColumn<DB, TB extends keyof DB> = `${AnyColumn<DB, TB>} as ${string}`;
+/**
+ * Just like {@link AnyColumnWithTable} but with a ` as <string>` suffix.
+ */
+export type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = `${AnyColumnWithTable<DB, TB>} as ${string}`;
+/**
+ * Extracts the item type of an array.
+ */
+export type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
+export type SimplifySingleResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : O extends MergeResult ? O : Simplify<O> | undefined;
+export type SimplifyResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : O extends MergeResult ? O : Simplify<O>;
+export type Simplify<T> = DrainOuterGeneric<{
+    [K in keyof T]: T[K];
+} & {}>;
+/**
+ * Represents a database row whose column names and their types are unknown.
+ */
+export type UnknownRow = Record<string, unknown>;
+/**
+ * Makes all properties of object type `T` nullable.
+ */
+export type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+/**
+ * Evaluates to `true` if `T` is `never`.
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Evaluates to `true` if `T` is `any`.
+ */
+export type IsAny<T> = 0 extends T & 1 ? true : false;
+/**
+ * Evaluates to `true` if the types `T` and `U` are equal.
+ */
+export type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
+export type NarrowPartial<O, T> = DrainOuterGeneric<T extends object ? {
+    [K in keyof O & string]: K extends keyof T ? T[K] extends NotNull ? Exclude<O[K], null> : T[K] extends O[K] ? T[K] : KyselyTypeError<`$narrowType() call failed: passed type does not exist in '${K}'s type union`> : O[K];
+} : never>;
+/**
+ * A type constant for marking a column as not null. Can be used with `$narrowPartial`.
+ *
+ * Example:
+ *
+ * ```ts
+ * import type { NotNull } from 'kysely'
+ *
+ * await db.selectFrom('person')
+ *   .where('nullable_column', 'is not', null)
+ *   .selectAll()
+ *   .$narrowType<{ nullable_column: NotNull }>()
+ *   .executeTakeFirstOrThrow()
+ * ```
+ */
+export type NotNull = {
+    readonly __notNull__: unique symbol;
+};
+export type SqlBool = boolean | 0 | 1;
+/**
+ * Utility to reduce depth of TypeScript's internal type instantiation stack.
+ *
+ * Example:
+ *
+ * ```ts
+ * type A<T> = { item: T }
+ *
+ * type Test<T> = A<
+ *   A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
+ * >
+ *
+ * // type Error = Test<number> // Type instantiation is excessively deep and possibly infinite.ts (2589)
+ * ```
+ *
+ * To fix this, we can use `DrainOuterGeneric`:
+ *
+ * ```ts
+ * type A<T> = DrainOuterGeneric<{ item: T }>
+ *
+ * type Test<T> = A<
+ *  A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
+ * >
+ *
+ * type Ok = Test<number> // Ok
+ * ```
+ */
+export type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+export type ShallowRecord<K extends keyof any, T> = DrainOuterGeneric<{
+    [P in K]: T;
+}>;
+/**
+ * Dehydrates any root properties of an object that are not valid JSON types.
+ *
+ * For now, we catch anything in {@link StringsWhenDataTypeNotAvailable} and convert it to `string`.
+ */
+export type ShallowDehydrateObject<O> = {
+    [K in keyof O]: ShallowDehydrateValue<O[K]>;
+};
+/**
+ * Dehydrates a value when it is not a valid JSON type.
+ *
+ * For now, we catch anything in {@link StringsWhenDataTypeNotAvailable} and convert it to `string`,
+ * and anything in {@link NumbersWhenDataTypeNotAvailable} and convert it to `number`.
+ */
+export type ShallowDehydrateValue<T> = T extends null | undefined ? T : T extends (infer U)[] | null | undefined ? Array<ShallowDehydrateValue<U>> | Extract<T, null | undefined> : Exclude<T, StringsWhenDataTypeNotAvailable | NumbersWhenDataTypeNotAvailable> | ([Extract<T, NumbersWhenDataTypeNotAvailable>] extends [never] ? never : number) | ([Extract<T, StringsWhenDataTypeNotAvailable>] extends [never] ? never : string);
+export type StringsWhenDataTypeNotAvailable = Date | Uint8Array;
+export type NumbersWhenDataTypeNotAvailable = bigint | NumericString;
+export type NumericString = `${number}`;

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

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

package/dist/esm/dialect/database-introspector.d.ts

@@ -0,0 +1,62 @@
+/**
+ * An interface for getting the database metadata (names of the tables and columns etc.)
+ */
+export interface DatabaseIntrospector {
+    /**
+     * Get schema metadata.
+     */
+    getSchemas(): Promise<SchemaMetadata[]>;
+    /**
+     * Get tables and views metadata.
+     */
+    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
+    /**
+     * Get the database metadata such as table and column names.
+     *
+     * @deprecated Use getTables() instead.
+     */
+    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
+}
+export interface DatabaseMetadataOptions {
+    /**
+     * If this is true, the metadata contains the internal kysely tables
+     * such as the migration tables.
+     */
+    withInternalKyselyTables: boolean;
+}
+export interface SchemaMetadata {
+    readonly name: string;
+}
+export interface DatabaseMetadata {
+    /**
+     * The tables and views found in the database.
+     * The propery isView can be used to tell them apart.
+     */
+    readonly tables: TableMetadata[];
+}
+export interface TableMetadata {
+    readonly name: string;
+    readonly isView: boolean;
+    readonly columns: ColumnMetadata[];
+    readonly schema?: string;
+}
+export interface ColumnMetadata {
+    readonly name: string;
+    /**
+     * The data type of the column as reported by the database.
+     *
+     * NOTE: This value is whatever the database engine returns and it will be
+     *       different on different dialects even if you run the same migrations.
+     *       For example `integer` datatype in a migration will produce `int4`
+     *       on PostgreSQL, `INTEGER` on SQLite and `int` on MySQL.
+     */
+    readonly dataType: string;
+    /**
+     * The schema this column's data type was created in.
+     */
+    readonly dataTypeSchema?: string;
+    readonly isAutoIncrementing: boolean;
+    readonly isNullable: boolean;
+    readonly hasDefaultValue: boolean;
+    readonly comment?: string;
+}

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

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

package/dist/esm/dialect/dialect-adapter-base.d.ts

@@ -0,0 +1,94 @@
+import type { Kysely } from '../kysely.js';
+import type { DialectAdapter, MigrationLockOptions } from './dialect-adapter.js';
+/**
+ * A basic implementation of `DialectAdapter` with sensible default values.
+ * Third-party dialects can extend this instead of implementing the `DialectAdapter`
+ * interface from scratch. That way all new settings will get default values when
+ * they are added and there will be less breaking changes.
+ */
+export declare abstract class DialectAdapterBase implements DialectAdapter {
+    /**
+     * Whether or not this dialect supports `if not exists` in creation of tables/schemas/views/etc.
+     *
+     * If this is false, Kysely's internal migrations tables and schemas are created
+     * without `if not exists` in migrations. This is not a problem if the dialect
+     * supports transactional DDL.
+     */
+    get supportsCreateIfNotExists(): boolean;
+    /**
+     * Whether or not this dialect supports transactional DDL.
+     *
+     * If this is true, migrations are executed inside a transaction.
+     */
+    get supportsTransactionalDdl(): boolean;
+    /**
+     * Whether or not this dialect supports the `returning` in inserts
+     * updates and deletes.
+     */
+    get supportsReturning(): boolean;
+    get supportsOutput(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration operations to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * import { DialectAdapterBase, type MigrationLockOptions, Kysely } from 'kysely'
+     *
+     * export class MyAdapter extends DialectAdapterBase {
+     *   override async acquireMigrationLock(
+     *     db: Kysely<any>,
+     *     options: MigrationLockOptions
+     *   ): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
+     * }
+     * ```
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
+    abstract acquireMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
+    abstract releaseMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+/// <reference types="./dialect-adapter-base.d.ts" />
+/**
+ * A basic implementation of `DialectAdapter` with sensible default values.
+ * Third-party dialects can extend this instead of implementing the `DialectAdapter`
+ * interface from scratch. That way all new settings will get default values when
+ * they are added and there will be less breaking changes.
+ */
+export class DialectAdapterBase {
+    get supportsCreateIfNotExists() {
+        return true;
+    }
+    get supportsTransactionalDdl() {
+        return false;
+    }
+    get supportsReturning() {
+        return false;
+    }
+    get supportsOutput() {
+        return false;
+    }
+}