Initial commit - Event Planner application

node_modules/kysely/dist/esm/util/assert.d.ts

@@ -0,0 +1,2 @@
+export declare function assertNotNullOrUndefined<T>(value: T): asserts value is NonNullable<T>;
+export declare function assertIsString(value: any): asserts value is string;

node_modules/kysely/dist/esm/util/assert.js

@@ -0,0 +1,11 @@
+/// <reference types="./assert.d.ts" />
+export function assertNotNullOrUndefined(value) {
+    if (value === null || value === undefined) {
+        throw new Error(`${value} must not be null or undefined`);
+    }
+}
+export function assertIsString(value) {
+    if (typeof value !== 'string') {
+        throw new Error(`${value} must be a string`);
+    }
+}

node_modules/kysely/dist/esm/util/column-type.d.ts

@@ -0,0 +1,175 @@
+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<{
+    [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]>;
+}>;
+export {};

node_modules/kysely/dist/esm/util/column-type.js

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

node_modules/kysely/dist/esm/util/compilable.d.ts

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

node_modules/kysely/dist/esm/util/compilable.js

@@ -0,0 +1,5 @@
+/// <reference types="./compilable.d.ts" />
+import { isFunction, isObject } from './object-utils.js';
+export function isCompilable(value) {
+    return isObject(value) && isFunction(value.compile);
+}

node_modules/kysely/dist/esm/util/deferred.d.ts

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

node_modules/kysely/dist/esm/util/deferred.js

@@ -0,0 +1,25 @@
+/// <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);
+        }
+    };
+}

node_modules/kysely/dist/esm/util/explainable.d.ts

@@ -0,0 +1,40 @@
+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[]>;
+}

node_modules/kysely/dist/esm/util/explainable.js

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

node_modules/kysely/dist/esm/util/infer-result.d.ts

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

node_modules/kysely/dist/esm/util/infer-result.js

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

node_modules/kysely/dist/esm/util/json-object-args.d.ts

@@ -0,0 +1,3 @@
+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>[];

node_modules/kysely/dist/esm/util/json-object-args.js

@@ -0,0 +1,32 @@
+/// <reference types="./json-object-args.d.ts" />
+import { ExpressionWrapper } from '../expression/expression-wrapper.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { ReferenceNode } from '../operation-node/reference-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+export function getJsonObjectArgs(node, table) {
+    const args = [];
+    for (const { selection: s } of node.selections ?? []) {
+        if (ReferenceNode.is(s) && ColumnNode.is(s.column)) {
+            args.push(colName(s.column.column.name), colRef(table, s.column.column.name));
+        }
+        else if (ColumnNode.is(s)) {
+            args.push(colName(s.column.name), colRef(table, s.column.name));
+        }
+        else if (AliasNode.is(s) && 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 ExpressionWrapper(ValueNode.createImmediate(col));
+}
+function colRef(table, col) {
+    return new ExpressionWrapper(ReferenceNode.create(ColumnNode.create(col), TableNode.create(table)));
+}

node_modules/kysely/dist/esm/util/log-once.d.ts

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

node_modules/kysely/dist/esm/util/log-once.js

@@ -0,0 +1,13 @@
+/// <reference types="./log-once.d.ts" />
+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.
+ */
+export function logOnce(message) {
+    if (LOGGED_MESSAGES.has(message)) {
+        return;
+    }
+    LOGGED_MESSAGES.add(message);
+    console.log(message);
+}

node_modules/kysely/dist/esm/util/log.d.ts

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

node_modules/kysely/dist/esm/util/log.js

@@ -0,0 +1,56 @@
+/// <reference types="./log.d.ts" />
+import { freeze, isFunction } from './object-utils.js';
+const logLevels = ['query', 'error'];
+export const LOG_LEVELS = freeze(logLevels);
+export class Log {
+    #levels;
+    #logger;
+    constructor(config) {
+        if (isFunction(config)) {
+            this.#logger = config;
+            this.#levels = freeze({
+                query: true,
+                error: true,
+            });
+        }
+        else {
+            this.#logger = defaultLogger;
+            this.#levels = 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());
+        }
+    }
+}
+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,
+            })}`);
+        }
+    }
+}

node_modules/kysely/dist/esm/util/object-utils.d.ts

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

node_modules/kysely/dist/esm/util/object-utils.js

@@ -0,0 +1,141 @@
+/// <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);
+}

node_modules/kysely/dist/esm/util/performance-now.d.ts

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

node_modules/kysely/dist/esm/util/performance-now.js

@@ -0,0 +1,10 @@
+/// <reference types="./performance-now.d.ts" />
+import { isFunction } from './object-utils.js';
+export function performanceNow() {
+    if (typeof performance !== 'undefined' && isFunction(performance.now)) {
+        return performance.now();
+    }
+    else {
+        return Date.now();
+    }
+}

node_modules/kysely/dist/esm/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>;

node_modules/kysely/dist/esm/util/provide-controlled-connection.js

@@ -0,0 +1,22 @@
+/// <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,
+    });
+}

node_modules/kysely/dist/esm/util/query-id.d.ts

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

node_modules/kysely/dist/esm/util/query-id.js

@@ -0,0 +1,14 @@
+/// <reference types="./query-id.d.ts" />
+import { randomString } from './random-string.js';
+export function createQueryId() {
+    return new LazyQueryId();
+}
+class LazyQueryId {
+    #queryId;
+    get queryId() {
+        if (this.#queryId === undefined) {
+            this.#queryId = randomString(8);
+        }
+        return this.#queryId;
+    }
+}

node_modules/kysely/dist/esm/util/random-string.d.ts

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

node_modules/kysely/dist/esm/util/random-string.js

@@ -0,0 +1,75 @@
+/// <reference types="./random-string.d.ts" />
+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',
+];
+export function randomString(length) {
+    let chars = '';
+    for (let i = 0; i < length; ++i) {
+        chars += randomChar();
+    }
+    return chars;
+}
+function randomChar() {
+    return CHARS[~~(Math.random() * CHARS.length)];
+}

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/util/require-all-props.js

@@ -0,0 +1,39 @@
+/// <reference types="./require-all-props.d.ts" />
+/**
+ * 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 function requireAllProps(obj) {
+    return obj;
+}

node_modules/kysely/dist/esm/util/stack-trace-utils.d.ts

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

node_modules/kysely/dist/esm/util/stack-trace-utils.js

@@ -0,0 +1,14 @@
+/// <reference types="./stack-trace-utils.d.ts" />
+import { isObject, isString } from './object-utils.js';
+export 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 isObject(obj) && isString(obj.stack);
+}

node_modules/kysely/dist/esm/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>;
+}

node_modules/kysely/dist/esm/util/streamable.js

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

node_modules/kysely/dist/esm/util/type-error.d.ts

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

node_modules/kysely/dist/esm/util/type-error.js

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

node_modules/kysely/dist/esm/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}`;

node_modules/kysely/dist/esm/util/type-utils.js

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