@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/cjs/driver/driver.d.ts

@@ -0,0 +1,61 @@
+import type { QueryCompiler } from '../query-compiler/query-compiler.js';
+import type { ArrayItemType } from '../util/type-utils.js';
+import type { DatabaseConnection } from './database-connection.js';
+/**
+ * A Driver creates and releases {@link DatabaseConnection | database connections}
+ * and is also responsible for connection pooling (if the dialect supports pooling).
+ */
+export interface Driver {
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     */
+    init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Establishses a new savepoint within a transaction.
+     */
+    savepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Rolls back to a savepoint within a transaction.
+     */
+    rollbackToSavepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Releases a savepoint within a transaction.
+     */
+    releaseSavepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+}
+export interface TransactionSettings {
+    readonly accessMode?: AccessMode;
+    readonly isolationLevel?: IsolationLevel;
+}
+export declare const TRANSACTION_ACCESS_MODES: readonly ["read only", "read write"];
+export type AccessMode = ArrayItemType<typeof TRANSACTION_ACCESS_MODES>;
+export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable", "snapshot"];
+export type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;
+export declare function validateTransactionSettings(settings: TransactionSettings): void;

package/dist/server/node_modules/kysely/dist/cjs/driver/driver.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSACTION_ISOLATION_LEVELS = exports.TRANSACTION_ACCESS_MODES = void 0;
+exports.validateTransactionSettings = validateTransactionSettings;
+exports.TRANSACTION_ACCESS_MODES = ['read only', 'read write'];
+exports.TRANSACTION_ISOLATION_LEVELS = [
+    'read uncommitted',
+    'read committed',
+    'repeatable read',
+    'serializable',
+    'snapshot',
+];
+function validateTransactionSettings(settings) {
+    if (settings.accessMode &&
+        !exports.TRANSACTION_ACCESS_MODES.includes(settings.accessMode)) {
+        throw new Error(`invalid transaction access mode ${settings.accessMode}`);
+    }
+    if (settings.isolationLevel &&
+        !exports.TRANSACTION_ISOLATION_LEVELS.includes(settings.isolationLevel)) {
+        throw new Error(`invalid transaction isolation level ${settings.isolationLevel}`);
+    }
+}

package/dist/server/node_modules/kysely/dist/cjs/driver/dummy-driver.d.ts

@@ -0,0 +1,75 @@
+import type { DatabaseConnection } from './database-connection.js';
+import type { Driver } from './driver.js';
+/**
+ * A driver that does absolutely nothing.
+ *
+ * You can use this to create Kysely instances solely for building queries
+ *
+ * ### Examples
+ *
+ * This example creates a Kysely instance for building postgres queries:
+ *
+ * ```ts
+ * import {
+ *   DummyDriver,
+ *   Kysely,
+ *   PostgresAdapter,
+ *   PostgresIntrospector,
+ *   PostgresQueryCompiler
+ * } from 'kysely'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: {
+ *     createAdapter: () => new PostgresAdapter(),
+ *     createDriver: () => new DummyDriver(),
+ *     createIntrospector: (db: Kysely<any>) => new PostgresIntrospector(db),
+ *     createQueryCompiler: () => new PostgresQueryCompiler(),
+ *   },
+ * })
+ * ```
+ *
+ * You can use it to build a query and compile it to SQL but trying to
+ * execute the query will throw an error.
+ *
+ * ```ts
+ * const { sql } = db.selectFrom('person').selectAll().compile()
+ * console.log(sql) // select * from "person"
+ * ```
+ */
+export declare class DummyDriver implements Driver {
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     */
+    init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+    releaseSavepoint(): Promise<void>;
+    rollbackToSavepoint(): Promise<void>;
+    savepoint(): Promise<void>;
+}

package/dist/server/node_modules/kysely/dist/cjs/driver/dummy-driver.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyDriver = void 0;
+/**
+ * A driver that does absolutely nothing.
+ *
+ * You can use this to create Kysely instances solely for building queries
+ *
+ * ### Examples
+ *
+ * This example creates a Kysely instance for building postgres queries:
+ *
+ * ```ts
+ * import {
+ *   DummyDriver,
+ *   Kysely,
+ *   PostgresAdapter,
+ *   PostgresIntrospector,
+ *   PostgresQueryCompiler
+ * } from 'kysely'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: {
+ *     createAdapter: () => new PostgresAdapter(),
+ *     createDriver: () => new DummyDriver(),
+ *     createIntrospector: (db: Kysely<any>) => new PostgresIntrospector(db),
+ *     createQueryCompiler: () => new PostgresQueryCompiler(),
+ *   },
+ * })
+ * ```
+ *
+ * You can use it to build a query and compile it to SQL but trying to
+ * execute the query will throw an error.
+ *
+ * ```ts
+ * const { sql } = db.selectFrom('person').selectAll().compile()
+ * console.log(sql) // select * from "person"
+ * ```
+ */
+class DummyDriver {
+    async init() {
+        // Nothing to do here.
+    }
+    async acquireConnection() {
+        return new DummyConnection();
+    }
+    async beginTransaction() {
+        // Nothing to do here.
+    }
+    async commitTransaction() {
+        // Nothing to do here.
+    }
+    async rollbackTransaction() {
+        // Nothing to do here.
+    }
+    async releaseConnection() {
+        // Nothing to do here.
+    }
+    async destroy() {
+        // Nothing to do here.
+    }
+    async releaseSavepoint() {
+        // Nothing to do here.
+    }
+    async rollbackToSavepoint() {
+        // Nothing to do here.
+    }
+    async savepoint() {
+        // Nothing to do here.
+    }
+}
+exports.DummyDriver = DummyDriver;
+class DummyConnection {
+    async executeQuery() {
+        return {
+            rows: [],
+        };
+    }
+    async *streamQuery() {
+        // Nothing to do here.
+    }
+}

package/dist/server/node_modules/kysely/dist/cjs/driver/runtime-driver.d.ts

@@ -0,0 +1,47 @@
+import type { QueryCompiler } from '../query-compiler/query-compiler.js';
+import type { Log } from '../util/log.js';
+import type { DatabaseConnection } from './database-connection.js';
+import type { Driver, TransactionSettings } from './driver.js';
+/**
+ * A small wrapper around {@link Driver} that makes sure the driver is
+ * initialized before it is used, only initialized and destroyed
+ * once etc.
+ */
+export declare class RuntimeDriver implements Driver {
+    #private;
+    constructor(driver: Driver, log: Log);
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     */
+    init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+}

package/dist/server/node_modules/kysely/dist/cjs/driver/runtime-driver.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeDriver = void 0;
+const performance_now_js_1 = require("../util/performance-now.js");
+/**
+ * A small wrapper around {@link Driver} that makes sure the driver is
+ * initialized before it is used, only initialized and destroyed
+ * once etc.
+ */
+class RuntimeDriver {
+    #driver;
+    #log;
+    #initPromise;
+    #initDone;
+    #destroyPromise;
+    #connections = new WeakSet();
+    constructor(driver, log) {
+        this.#initDone = false;
+        this.#driver = driver;
+        this.#log = log;
+    }
+    async init() {
+        if (this.#destroyPromise) {
+            throw new Error('driver has already been destroyed');
+        }
+        if (!this.#initPromise) {
+            this.#initPromise = this.#driver
+                .init()
+                .then(() => {
+                this.#initDone = true;
+            })
+                .catch((err) => {
+                this.#initPromise = undefined;
+                return Promise.reject(err);
+            });
+        }
+        await this.#initPromise;
+    }
+    async acquireConnection() {
+        if (this.#destroyPromise) {
+            throw new Error('driver has already been destroyed');
+        }
+        if (!this.#initDone) {
+            await this.init();
+        }
+        const connection = await this.#driver.acquireConnection();
+        if (!this.#connections.has(connection)) {
+            if (this.#needsLogging()) {
+                this.#addLogging(connection);
+            }
+            this.#connections.add(connection);
+        }
+        return connection;
+    }
+    async releaseConnection(connection) {
+        await this.#driver.releaseConnection(connection);
+    }
+    beginTransaction(connection, settings) {
+        return this.#driver.beginTransaction(connection, settings);
+    }
+    commitTransaction(connection) {
+        return this.#driver.commitTransaction(connection);
+    }
+    rollbackTransaction(connection) {
+        return this.#driver.rollbackTransaction(connection);
+    }
+    savepoint(connection, savepointName, compileQuery) {
+        if (this.#driver.savepoint) {
+            return this.#driver.savepoint(connection, savepointName, compileQuery);
+        }
+        throw new Error('The `savepoint` method is not supported by this driver');
+    }
+    rollbackToSavepoint(connection, savepointName, compileQuery) {
+        if (this.#driver.rollbackToSavepoint) {
+            return this.#driver.rollbackToSavepoint(connection, savepointName, compileQuery);
+        }
+        throw new Error('The `rollbackToSavepoint` method is not supported by this driver');
+    }
+    releaseSavepoint(connection, savepointName, compileQuery) {
+        if (this.#driver.releaseSavepoint) {
+            return this.#driver.releaseSavepoint(connection, savepointName, compileQuery);
+        }
+        throw new Error('The `releaseSavepoint` method is not supported by this driver');
+    }
+    async destroy() {
+        if (!this.#initPromise) {
+            return;
+        }
+        await this.#initPromise;
+        if (!this.#destroyPromise) {
+            this.#destroyPromise = this.#driver.destroy().catch((err) => {
+                this.#destroyPromise = undefined;
+                return Promise.reject(err);
+            });
+        }
+        await this.#destroyPromise;
+    }
+    #needsLogging() {
+        return (this.#log.isLevelEnabled('query') || this.#log.isLevelEnabled('error'));
+    }
+    // This method monkey patches the database connection's executeQuery method
+    // by adding logging code around it. Monkey patching is not pretty, but it's
+    // the best option in this case.
+    #addLogging(connection) {
+        const executeQuery = connection.executeQuery;
+        const streamQuery = connection.streamQuery;
+        const dis = this;
+        connection.executeQuery = async (compiledQuery) => {
+            let caughtError;
+            const startTime = (0, performance_now_js_1.performanceNow)();
+            try {
+                return await executeQuery.call(connection, compiledQuery);
+            }
+            catch (error) {
+                caughtError = error;
+                await dis.#logError(error, compiledQuery, startTime);
+                throw error;
+            }
+            finally {
+                if (!caughtError) {
+                    await dis.#logQuery(compiledQuery, startTime);
+                }
+            }
+        };
+        connection.streamQuery = async function* (compiledQuery, chunkSize) {
+            let caughtError;
+            const startTime = (0, performance_now_js_1.performanceNow)();
+            try {
+                for await (const result of streamQuery.call(connection, compiledQuery, chunkSize)) {
+                    yield result;
+                }
+            }
+            catch (error) {
+                caughtError = error;
+                await dis.#logError(error, compiledQuery, startTime);
+                throw error;
+            }
+            finally {
+                if (!caughtError) {
+                    await dis.#logQuery(compiledQuery, startTime, true);
+                }
+            }
+        };
+    }
+    async #logError(error, compiledQuery, startTime) {
+        await this.#log.error(() => ({
+            level: 'error',
+            error,
+            query: compiledQuery,
+            queryDurationMillis: this.#calculateDurationMillis(startTime),
+        }));
+    }
+    async #logQuery(compiledQuery, startTime, isStream = false) {
+        await this.#log.query(() => ({
+            level: 'query',
+            isStream,
+            query: compiledQuery,
+            queryDurationMillis: this.#calculateDurationMillis(startTime),
+        }));
+    }
+    #calculateDurationMillis(startTime) {
+        return (0, performance_now_js_1.performanceNow)() - startTime;
+    }
+}
+exports.RuntimeDriver = RuntimeDriver;

package/dist/server/node_modules/kysely/dist/cjs/driver/single-connection-provider.d.ts

@@ -0,0 +1,11 @@
+import type { DatabaseConnection } from './database-connection.js';
+import type { ConnectionProvider } from './connection-provider.js';
+export declare class SingleConnectionProvider implements ConnectionProvider {
+    #private;
+    constructor(connection: DatabaseConnection);
+    /**
+     * Provides a connection for the callback and takes care of disposing
+     * the connection after the callback has been run.
+     */
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+}

package/dist/server/node_modules/kysely/dist/cjs/driver/single-connection-provider.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleConnectionProvider = void 0;
+const ignoreError = () => { };
+class SingleConnectionProvider {
+    #connection;
+    #runningPromise;
+    constructor(connection) {
+        this.#connection = connection;
+    }
+    async provideConnection(consumer) {
+        while (this.#runningPromise) {
+            await this.#runningPromise.catch(ignoreError);
+        }
+        // `#runningPromise` must be set to undefined before it's
+        // resolved or rejected. Otherwise the while loop above
+        // will misbehave.
+        this.#runningPromise = this.#run(consumer).finally(() => {
+            this.#runningPromise = undefined;
+        });
+        return this.#runningPromise;
+    }
+    // Run the runner in an async function to make sure it doesn't
+    // throw synchronous errors.
+    async #run(runner) {
+        return await runner(this.#connection);
+    }
+}
+exports.SingleConnectionProvider = SingleConnectionProvider;

package/dist/server/node_modules/kysely/dist/cjs/dynamic/dynamic-reference-builder.d.ts

@@ -0,0 +1,18 @@
+import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
+import type { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js';
+export declare class DynamicReferenceBuilder<R extends string = never> implements OperationNodeSource {
+    #private;
+    get dynamicReference(): string;
+    /**
+     * @private
+     *
+     * This needs to be here just so that the typings work. Without this
+     * the generated .d.ts file contains no reference to the type param R
+     * which causes this type to be equal to DynamicReferenceBuilder with
+     * any R.
+     */
+    protected get refType(): R;
+    constructor(reference: string);
+    toOperationNode(): SimpleReferenceExpressionNode;
+}
+export declare function isDynamicReferenceBuilder(obj: unknown): obj is DynamicReferenceBuilder<any>;

package/dist/server/node_modules/kysely/dist/cjs/dynamic/dynamic-reference-builder.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicReferenceBuilder = void 0;
+exports.isDynamicReferenceBuilder = isDynamicReferenceBuilder;
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const reference_parser_js_1 = require("../parser/reference-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+class DynamicReferenceBuilder {
+    #dynamicReference;
+    get dynamicReference() {
+        return this.#dynamicReference;
+    }
+    /**
+     * @private
+     *
+     * This needs to be here just so that the typings work. Without this
+     * the generated .d.ts file contains no reference to the type param R
+     * which causes this type to be equal to DynamicReferenceBuilder with
+     * any R.
+     */
+    get refType() {
+        return undefined;
+    }
+    constructor(reference) {
+        this.#dynamicReference = reference;
+    }
+    toOperationNode() {
+        return (0, reference_parser_js_1.parseSimpleReferenceExpression)(this.#dynamicReference);
+    }
+}
+exports.DynamicReferenceBuilder = DynamicReferenceBuilder;
+function isDynamicReferenceBuilder(obj) {
+    return ((0, object_utils_js_1.isObject)(obj) &&
+        (0, operation_node_source_js_1.isOperationNodeSource)(obj) &&
+        (0, object_utils_js_1.isString)(obj.dynamicReference));
+}

package/dist/server/node_modules/kysely/dist/cjs/dynamic/dynamic-table-builder.d.ts

@@ -0,0 +1,16 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
+export declare class DynamicTableBuilder<T extends string> {
+    #private;
+    get table(): T;
+    constructor(table: T);
+    as<A extends string>(alias: A): AliasedDynamicTableBuilder<T, A>;
+}
+export declare class AliasedDynamicTableBuilder<T extends string, A extends string> implements OperationNodeSource {
+    #private;
+    get table(): T;
+    get alias(): A;
+    constructor(table: T, alias: A);
+    toOperationNode(): AliasNode;
+}
+export declare function isAliasedDynamicTableBuilder(obj: unknown): obj is AliasedDynamicTableBuilder<any, any>;

package/dist/server/node_modules/kysely/dist/cjs/dynamic/dynamic-table-builder.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliasedDynamicTableBuilder = exports.DynamicTableBuilder = void 0;
+exports.isAliasedDynamicTableBuilder = isAliasedDynamicTableBuilder;
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+class DynamicTableBuilder {
+    #table;
+    get table() {
+        return this.#table;
+    }
+    constructor(table) {
+        this.#table = table;
+    }
+    as(alias) {
+        return new AliasedDynamicTableBuilder(this.#table, alias);
+    }
+}
+exports.DynamicTableBuilder = DynamicTableBuilder;
+class AliasedDynamicTableBuilder {
+    #table;
+    #alias;
+    get table() {
+        return this.#table;
+    }
+    get alias() {
+        return this.#alias;
+    }
+    constructor(table, alias) {
+        this.#table = table;
+        this.#alias = alias;
+    }
+    toOperationNode() {
+        return alias_node_js_1.AliasNode.create((0, table_parser_js_1.parseTable)(this.#table), identifier_node_js_1.IdentifierNode.create(this.#alias));
+    }
+}
+exports.AliasedDynamicTableBuilder = AliasedDynamicTableBuilder;
+function isAliasedDynamicTableBuilder(obj) {
+    return ((0, object_utils_js_1.isObject)(obj) &&
+        (0, operation_node_source_js_1.isOperationNodeSource)(obj) &&
+        (0, object_utils_js_1.isString)(obj.table) &&
+        (0, object_utils_js_1.isString)(obj.alias));
+}