@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -0,0 +1,69 @@
+import { sql } from "../../raw-builder/sql.js";
+import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE } from "../../migration/migrator.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dialect/sqlite/sqlite-introspector.js
+var SqliteIntrospector = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	async getSchemas() {
+		return [];
+	}
+	async getTables(options = { withInternalKyselyTables: false }) {
+		return await this.#getTableMetadata(options);
+	}
+	async getMetadata(options) {
+		return { tables: await this.getTables(options) };
+	}
+	#tablesQuery(qb, options) {
+		let tablesQuery = qb.selectFrom("sqlite_master").where("type", "in", ["table", "view"]).where("name", "not like", "sqlite_%").select([
+			"name",
+			"sql",
+			"type"
+		]).orderBy("name");
+		if (!options.withInternalKyselyTables) tablesQuery = tablesQuery.where("name", "!=", DEFAULT_MIGRATION_TABLE).where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
+		return tablesQuery;
+	}
+	async #getTableMetadata(options) {
+		const tablesResult = await this.#tablesQuery(this.#db, options).execute();
+		const tableMetadata = await this.#db.with("table_list", (qb) => this.#tablesQuery(qb, options)).selectFrom(["table_list as tl", sql`pragma_table_info(tl.name)`.as("p")]).select([
+			"tl.name as table",
+			"p.cid",
+			"p.name",
+			"p.type",
+			"p.notnull",
+			"p.dflt_value",
+			"p.pk"
+		]).orderBy("tl.name").orderBy("p.cid").execute();
+		const columnsByTable = {};
+		for (const row of tableMetadata) {
+			columnsByTable[row.table] ??= [];
+			columnsByTable[row.table].push(row);
+		}
+		return tablesResult.map(({ name, sql: sql$1, type }) => {
+			let autoIncrementCol = sql$1?.split(/[\(\),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.trimStart()?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
+			const columns = columnsByTable[name] ?? [];
+			if (!autoIncrementCol) {
+				const pkCols = columns.filter((r) => r.pk > 0);
+				if (pkCols.length === 1 && pkCols[0].type.toLowerCase() === "integer") autoIncrementCol = pkCols[0].name;
+			}
+			return {
+				name,
+				isView: type === "view",
+				columns: columns.map((col) => ({
+					name: col.name,
+					dataType: col.type,
+					isNullable: !col.notnull,
+					isAutoIncrementing: col.name === autoIncrementCol,
+					hasDefaultValue: col.dflt_value != null,
+					comment: void 0
+				}))
+			};
+		});
+	}
+};
+
+//#endregion
+export { SqliteIntrospector };
+//# sourceMappingURL=sqlite-introspector.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dialect/sqlite/sqlite-introspector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-introspector.js","names":["#db","#getTableMetadata","#tablesQuery","sql"],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dialect/sqlite/sqlite-introspector.js"],"sourcesContent":["/// <reference types=\"./sqlite-introspector.d.ts\" />\nimport { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';\nimport { sql } from '../../raw-builder/sql.js';\nexport class SqliteIntrospector {\n    #db;\n    constructor(db) {\n        this.#db = db;\n    }\n    async getSchemas() {\n        // Sqlite doesn't support schemas.\n        return [];\n    }\n    async getTables(options = { withInternalKyselyTables: false }) {\n        return await this.#getTableMetadata(options);\n    }\n    async getMetadata(options) {\n        return {\n            tables: await this.getTables(options),\n        };\n    }\n    #tablesQuery(qb, options) {\n        let tablesQuery = qb\n            .selectFrom('sqlite_master')\n            .where('type', 'in', ['table', 'view'])\n            .where('name', 'not like', 'sqlite_%')\n            .select(['name', 'sql', 'type'])\n            .orderBy('name');\n        if (!options.withInternalKyselyTables) {\n            tablesQuery = tablesQuery\n                .where('name', '!=', DEFAULT_MIGRATION_TABLE)\n                .where('name', '!=', DEFAULT_MIGRATION_LOCK_TABLE);\n        }\n        return tablesQuery;\n    }\n    async #getTableMetadata(options) {\n        const tablesResult = await this.#tablesQuery(this.#db, options).execute();\n        const tableMetadata = await this.#db\n            .with('table_list', (qb) => this.#tablesQuery(qb, options))\n            .selectFrom([\n            'table_list as tl',\n            sql `pragma_table_info(tl.name)`.as('p'),\n        ])\n            .select([\n            'tl.name as table',\n            'p.cid',\n            'p.name',\n            'p.type',\n            'p.notnull',\n            'p.dflt_value',\n            'p.pk',\n        ])\n            .orderBy('tl.name')\n            .orderBy('p.cid')\n            .execute();\n        const columnsByTable = {};\n        for (const row of tableMetadata) {\n            columnsByTable[row.table] ??= [];\n            columnsByTable[row.table].push(row);\n        }\n        return tablesResult.map(({ name, sql, type }) => {\n            // // Try to find the name of the column that has `autoincrement` 🤦\n            let autoIncrementCol = sql\n                ?.split(/[\\(\\),]/)\n                ?.find((it) => it.toLowerCase().includes('autoincrement'))\n                ?.trimStart()\n                ?.split(/\\s+/)?.[0]\n                ?.replace(/[\"`]/g, '');\n            const columns = columnsByTable[name] ?? [];\n            // Otherwise, check for an INTEGER PRIMARY KEY\n            // https://www.sqlite.org/autoinc.html\n            if (!autoIncrementCol) {\n                const pkCols = columns.filter((r) => r.pk > 0);\n                if (pkCols.length === 1 && pkCols[0].type.toLowerCase() === 'integer') {\n                    autoIncrementCol = pkCols[0].name;\n                }\n            }\n            return {\n                name: name,\n                isView: type === 'view',\n                columns: columns.map((col) => ({\n                    name: col.name,\n                    dataType: col.type,\n                    isNullable: !col.notnull,\n                    isAutoIncrementing: col.name === autoIncrementCol,\n                    hasDefaultValue: col.dflt_value != null,\n                    comment: undefined,\n                })),\n            };\n        });\n    }\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;AAGA,IAAa,qBAAb,MAAgC;CAC5B;CACA,YAAY,IAAI;AACZ,QAAKA,KAAM;;CAEf,MAAM,aAAa;AAEf,SAAO,EAAE;;CAEb,MAAM,UAAU,UAAU,EAAE,0BAA0B,OAAO,EAAE;AAC3D,SAAO,MAAM,MAAKC,iBAAkB,QAAQ;;CAEhD,MAAM,YAAY,SAAS;AACvB,SAAO,EACH,QAAQ,MAAM,KAAK,UAAU,QAAQ,EACxC;;CAEL,aAAa,IAAI,SAAS;EACtB,IAAI,cAAc,GACb,WAAW,gBAAgB,CAC3B,MAAM,QAAQ,MAAM,CAAC,SAAS,OAAO,CAAC,CACtC,MAAM,QAAQ,YAAY,WAAW,CACrC,OAAO;GAAC;GAAQ;GAAO;GAAO,CAAC,CAC/B,QAAQ,OAAO;AACpB,MAAI,CAAC,QAAQ,yBACT,eAAc,YACT,MAAM,QAAQ,MAAM,wBAAwB,CAC5C,MAAM,QAAQ,MAAM,6BAA6B;AAE1D,SAAO;;CAEX,OAAMA,iBAAkB,SAAS;EAC7B,MAAM,eAAe,MAAM,MAAKC,YAAa,MAAKF,IAAK,QAAQ,CAAC,SAAS;EACzE,MAAM,gBAAgB,MAAM,MAAKA,GAC5B,KAAK,eAAe,OAAO,MAAKE,YAAa,IAAI,QAAQ,CAAC,CAC1D,WAAW,CACZ,oBACA,GAAI,6BAA6B,GAAG,IAAI,CAC3C,CAAC,CACG,OAAO;GACR;GACA;GACA;GACA;GACA;GACA;GACA;GACH,CAAC,CACG,QAAQ,UAAU,CAClB,QAAQ,QAAQ,CAChB,SAAS;EACd,MAAM,iBAAiB,EAAE;AACzB,OAAK,MAAM,OAAO,eAAe;AAC7B,kBAAe,IAAI,WAAW,EAAE;AAChC,kBAAe,IAAI,OAAO,KAAK,IAAI;;AAEvC,SAAO,aAAa,KAAK,EAAE,MAAM,YAAK,WAAW;GAE7C,IAAI,mBAAmBC,OACjB,MAAM,UAAU,EAChB,MAAM,OAAO,GAAG,aAAa,CAAC,SAAS,gBAAgB,CAAC,EACxD,WAAW,EACX,MAAM,MAAM,GAAG,IACf,QAAQ,SAAS,GAAG;GAC1B,MAAM,UAAU,eAAe,SAAS,EAAE;AAG1C,OAAI,CAAC,kBAAkB;IACnB,MAAM,SAAS,QAAQ,QAAQ,MAAM,EAAE,KAAK,EAAE;AAC9C,QAAI,OAAO,WAAW,KAAK,OAAO,GAAG,KAAK,aAAa,KAAK,UACxD,oBAAmB,OAAO,GAAG;;AAGrC,UAAO;IACG;IACN,QAAQ,SAAS;IACjB,SAAS,QAAQ,KAAK,SAAS;KAC3B,MAAM,IAAI;KACV,UAAU,IAAI;KACd,YAAY,CAAC,IAAI;KACjB,oBAAoB,IAAI,SAAS;KACjC,iBAAiB,IAAI,cAAc;KACnC,SAAS;KACZ,EAAE;IACN;IACH"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dialect/sqlite/sqlite-query-compiler.js

@@ -0,0 +1,38 @@
+import { DefaultQueryCompiler } from "../../query-compiler/default-query-compiler.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dialect/sqlite/sqlite-query-compiler.js
+const ID_WRAP_REGEX = /"/g;
+var SqliteQueryCompiler = class extends DefaultQueryCompiler {
+	visitOrAction(node) {
+		this.append("or ");
+		this.append(node.action);
+	}
+	getCurrentParameterPlaceholder() {
+		return "?";
+	}
+	getLeftExplainOptionsWrapper() {
+		return "";
+	}
+	getRightExplainOptionsWrapper() {
+		return "";
+	}
+	getLeftIdentifierWrapper() {
+		return "\"";
+	}
+	getRightIdentifierWrapper() {
+		return "\"";
+	}
+	getAutoIncrement() {
+		return "autoincrement";
+	}
+	sanitizeIdentifier(identifier) {
+		return identifier.replace(ID_WRAP_REGEX, "\"\"");
+	}
+	visitDefaultInsertValue(_) {
+		this.append("null");
+	}
+};
+
+//#endregion
+export { SqliteQueryCompiler };
+//# sourceMappingURL=sqlite-query-compiler.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dialect/sqlite/sqlite-query-compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-query-compiler.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dialect/sqlite/sqlite-query-compiler.js"],"sourcesContent":["/// <reference types=\"./sqlite-query-compiler.d.ts\" />\nimport { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';\nconst ID_WRAP_REGEX = /\"/g;\nexport class SqliteQueryCompiler extends DefaultQueryCompiler {\n    visitOrAction(node) {\n        this.append('or ');\n        this.append(node.action);\n    }\n    getCurrentParameterPlaceholder() {\n        return '?';\n    }\n    getLeftExplainOptionsWrapper() {\n        return '';\n    }\n    getRightExplainOptionsWrapper() {\n        return '';\n    }\n    getLeftIdentifierWrapper() {\n        return '\"';\n    }\n    getRightIdentifierWrapper() {\n        return '\"';\n    }\n    getAutoIncrement() {\n        return 'autoincrement';\n    }\n    sanitizeIdentifier(identifier) {\n        return identifier.replace(ID_WRAP_REGEX, '\"\"');\n    }\n    visitDefaultInsertValue(_) {\n        // sqlite doesn't support the `default` keyword in inserts.\n        this.append('null');\n    }\n}\n"],"x_google_ignoreList":[0],"mappings":";;;AAEA,MAAM,gBAAgB;AACtB,IAAa,sBAAb,cAAyC,qBAAqB;CAC1D,cAAc,MAAM;AAChB,OAAK,OAAO,MAAM;AAClB,OAAK,OAAO,KAAK,OAAO;;CAE5B,iCAAiC;AAC7B,SAAO;;CAEX,+BAA+B;AAC3B,SAAO;;CAEX,gCAAgC;AAC5B,SAAO;;CAEX,2BAA2B;AACvB,SAAO;;CAEX,4BAA4B;AACxB,SAAO;;CAEX,mBAAmB;AACf,SAAO;;CAEX,mBAAmB,YAAY;AAC3B,SAAO,WAAW,QAAQ,eAAe,OAAK;;CAElD,wBAAwB,GAAG;AAEvB,OAAK,OAAO,OAAO"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/default-connection-provider.js

@@ -0,0 +1,19 @@
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/default-connection-provider.js
+var DefaultConnectionProvider = class {
+	#driver;
+	constructor(driver) {
+		this.#driver = driver;
+	}
+	async provideConnection(consumer) {
+		const connection = await this.#driver.acquireConnection();
+		try {
+			return await consumer(connection);
+		} finally {
+			await this.#driver.releaseConnection(connection);
+		}
+	}
+};
+
+//#endregion
+export { DefaultConnectionProvider };
+//# sourceMappingURL=default-connection-provider.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/default-connection-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-connection-provider.js","names":["#driver"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/default-connection-provider.js"],"sourcesContent":["/// <reference types=\"./default-connection-provider.d.ts\" />\nexport class DefaultConnectionProvider {\n    #driver;\n    constructor(driver) {\n        this.#driver = driver;\n    }\n    async provideConnection(consumer) {\n        const connection = await this.#driver.acquireConnection();\n        try {\n            return await consumer(connection);\n        }\n        finally {\n            await this.#driver.releaseConnection(connection);\n        }\n    }\n}\n"],"x_google_ignoreList":[0],"mappings":";AACA,IAAa,4BAAb,MAAuC;CACnC;CACA,YAAY,QAAQ;AAChB,QAAKA,SAAU;;CAEnB,MAAM,kBAAkB,UAAU;EAC9B,MAAM,aAAa,MAAM,MAAKA,OAAQ,mBAAmB;AACzD,MAAI;AACA,UAAO,MAAM,SAAS,WAAW;YAE7B;AACJ,SAAM,MAAKA,OAAQ,kBAAkB,WAAW"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/driver.js

@@ -0,0 +1,17 @@
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/driver.js
+const TRANSACTION_ACCESS_MODES = ["read only", "read write"];
+const TRANSACTION_ISOLATION_LEVELS = [
+	"read uncommitted",
+	"read committed",
+	"repeatable read",
+	"serializable",
+	"snapshot"
+];
+function validateTransactionSettings(settings) {
+	if (settings.accessMode && !TRANSACTION_ACCESS_MODES.includes(settings.accessMode)) throw new Error(`invalid transaction access mode ${settings.accessMode}`);
+	if (settings.isolationLevel && !TRANSACTION_ISOLATION_LEVELS.includes(settings.isolationLevel)) throw new Error(`invalid transaction isolation level ${settings.isolationLevel}`);
+}
+
+//#endregion
+export { TRANSACTION_ACCESS_MODES, TRANSACTION_ISOLATION_LEVELS, validateTransactionSettings };
+//# sourceMappingURL=driver.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/driver.js"],"sourcesContent":["/// <reference types=\"./driver.d.ts\" />\nexport const TRANSACTION_ACCESS_MODES = ['read only', 'read write'];\nexport const TRANSACTION_ISOLATION_LEVELS = [\n    'read uncommitted',\n    'read committed',\n    'repeatable read',\n    'serializable',\n    'snapshot',\n];\nexport function validateTransactionSettings(settings) {\n    if (settings.accessMode &&\n        !TRANSACTION_ACCESS_MODES.includes(settings.accessMode)) {\n        throw new Error(`invalid transaction access mode ${settings.accessMode}`);\n    }\n    if (settings.isolationLevel &&\n        !TRANSACTION_ISOLATION_LEVELS.includes(settings.isolationLevel)) {\n        throw new Error(`invalid transaction isolation level ${settings.isolationLevel}`);\n    }\n}\n"],"x_google_ignoreList":[0],"mappings":";AACA,MAAa,2BAA2B,CAAC,aAAa,aAAa;AACnE,MAAa,+BAA+B;CACxC;CACA;CACA;CACA;CACA;CACH;AACD,SAAgB,4BAA4B,UAAU;AAClD,KAAI,SAAS,cACT,CAAC,yBAAyB,SAAS,SAAS,WAAW,CACvD,OAAM,IAAI,MAAM,mCAAmC,SAAS,aAAa;AAE7E,KAAI,SAAS,kBACT,CAAC,6BAA6B,SAAS,SAAS,eAAe,CAC/D,OAAM,IAAI,MAAM,uCAAuC,SAAS,iBAAiB"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/runtime-driver.js

@@ -0,0 +1,131 @@
+import { performanceNow } from "../util/performance-now.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/runtime-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.
+*/
+var RuntimeDriver = class {
+	#driver;
+	#log;
+	#initPromise;
+	#initDone;
+	#destroyPromise;
+	#connections = /* @__PURE__ */ 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 = void 0;
+			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 = void 0;
+			return Promise.reject(err);
+		});
+		await this.#destroyPromise;
+	}
+	#needsLogging() {
+		return this.#log.isLevelEnabled("query") || this.#log.isLevelEnabled("error");
+	}
+	#addLogging(connection) {
+		const executeQuery = connection.executeQuery;
+		const streamQuery = connection.streamQuery;
+		const dis = this;
+		connection.executeQuery = async (compiledQuery) => {
+			let caughtError;
+			const startTime = 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 = 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 performanceNow() - startTime;
+	}
+};
+
+//#endregion
+export { RuntimeDriver };
+//# sourceMappingURL=runtime-driver.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/runtime-driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-driver.js","names":["#initDone","#driver","#log","#destroyPromise","#initPromise","#connections","#needsLogging","#addLogging","#logError","#logQuery","#calculateDurationMillis"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/runtime-driver.js"],"sourcesContent":["/// <reference types=\"./runtime-driver.d.ts\" />\nimport { performanceNow } from '../util/performance-now.js';\n/**\n * A small wrapper around {@link Driver} that makes sure the driver is\n * initialized before it is used, only initialized and destroyed\n * once etc.\n */\nexport class RuntimeDriver {\n    #driver;\n    #log;\n    #initPromise;\n    #initDone;\n    #destroyPromise;\n    #connections = new WeakSet();\n    constructor(driver, log) {\n        this.#initDone = false;\n        this.#driver = driver;\n        this.#log = log;\n    }\n    async init() {\n        if (this.#destroyPromise) {\n            throw new Error('driver has already been destroyed');\n        }\n        if (!this.#initPromise) {\n            this.#initPromise = this.#driver\n                .init()\n                .then(() => {\n                this.#initDone = true;\n            })\n                .catch((err) => {\n                this.#initPromise = undefined;\n                return Promise.reject(err);\n            });\n        }\n        await this.#initPromise;\n    }\n    async acquireConnection() {\n        if (this.#destroyPromise) {\n            throw new Error('driver has already been destroyed');\n        }\n        if (!this.#initDone) {\n            await this.init();\n        }\n        const connection = await this.#driver.acquireConnection();\n        if (!this.#connections.has(connection)) {\n            if (this.#needsLogging()) {\n                this.#addLogging(connection);\n            }\n            this.#connections.add(connection);\n        }\n        return connection;\n    }\n    async releaseConnection(connection) {\n        await this.#driver.releaseConnection(connection);\n    }\n    beginTransaction(connection, settings) {\n        return this.#driver.beginTransaction(connection, settings);\n    }\n    commitTransaction(connection) {\n        return this.#driver.commitTransaction(connection);\n    }\n    rollbackTransaction(connection) {\n        return this.#driver.rollbackTransaction(connection);\n    }\n    savepoint(connection, savepointName, compileQuery) {\n        if (this.#driver.savepoint) {\n            return this.#driver.savepoint(connection, savepointName, compileQuery);\n        }\n        throw new Error('The `savepoint` method is not supported by this driver');\n    }\n    rollbackToSavepoint(connection, savepointName, compileQuery) {\n        if (this.#driver.rollbackToSavepoint) {\n            return this.#driver.rollbackToSavepoint(connection, savepointName, compileQuery);\n        }\n        throw new Error('The `rollbackToSavepoint` method is not supported by this driver');\n    }\n    releaseSavepoint(connection, savepointName, compileQuery) {\n        if (this.#driver.releaseSavepoint) {\n            return this.#driver.releaseSavepoint(connection, savepointName, compileQuery);\n        }\n        throw new Error('The `releaseSavepoint` method is not supported by this driver');\n    }\n    async destroy() {\n        if (!this.#initPromise) {\n            return;\n        }\n        await this.#initPromise;\n        if (!this.#destroyPromise) {\n            this.#destroyPromise = this.#driver.destroy().catch((err) => {\n                this.#destroyPromise = undefined;\n                return Promise.reject(err);\n            });\n        }\n        await this.#destroyPromise;\n    }\n    #needsLogging() {\n        return (this.#log.isLevelEnabled('query') || this.#log.isLevelEnabled('error'));\n    }\n    // This method monkey patches the database connection's executeQuery method\n    // by adding logging code around it. Monkey patching is not pretty, but it's\n    // the best option in this case.\n    #addLogging(connection) {\n        const executeQuery = connection.executeQuery;\n        const streamQuery = connection.streamQuery;\n        const dis = this;\n        connection.executeQuery = async (compiledQuery) => {\n            let caughtError;\n            const startTime = performanceNow();\n            try {\n                return await executeQuery.call(connection, compiledQuery);\n            }\n            catch (error) {\n                caughtError = error;\n                await dis.#logError(error, compiledQuery, startTime);\n                throw error;\n            }\n            finally {\n                if (!caughtError) {\n                    await dis.#logQuery(compiledQuery, startTime);\n                }\n            }\n        };\n        connection.streamQuery = async function* (compiledQuery, chunkSize) {\n            let caughtError;\n            const startTime = performanceNow();\n            try {\n                for await (const result of streamQuery.call(connection, compiledQuery, chunkSize)) {\n                    yield result;\n                }\n            }\n            catch (error) {\n                caughtError = error;\n                await dis.#logError(error, compiledQuery, startTime);\n                throw error;\n            }\n            finally {\n                if (!caughtError) {\n                    await dis.#logQuery(compiledQuery, startTime, true);\n                }\n            }\n        };\n    }\n    async #logError(error, compiledQuery, startTime) {\n        await this.#log.error(() => ({\n            level: 'error',\n            error,\n            query: compiledQuery,\n            queryDurationMillis: this.#calculateDurationMillis(startTime),\n        }));\n    }\n    async #logQuery(compiledQuery, startTime, isStream = false) {\n        await this.#log.query(() => ({\n            level: 'query',\n            isStream,\n            query: compiledQuery,\n            queryDurationMillis: this.#calculateDurationMillis(startTime),\n        }));\n    }\n    #calculateDurationMillis(startTime) {\n        return performanceNow() - startTime;\n    }\n}\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/single-connection-provider.js

@@ -0,0 +1,23 @@
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/single-connection-provider.js
+const ignoreError = () => {};
+var SingleConnectionProvider = class {
+	#connection;
+	#runningPromise;
+	constructor(connection) {
+		this.#connection = connection;
+	}
+	async provideConnection(consumer) {
+		while (this.#runningPromise) await this.#runningPromise.catch(ignoreError);
+		this.#runningPromise = this.#run(consumer).finally(() => {
+			this.#runningPromise = void 0;
+		});
+		return this.#runningPromise;
+	}
+	async #run(runner) {
+		return await runner(this.#connection);
+	}
+};
+
+//#endregion
+export { SingleConnectionProvider };
+//# sourceMappingURL=single-connection-provider.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/single-connection-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-connection-provider.js","names":["#connection","#runningPromise","#run"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/driver/single-connection-provider.js"],"sourcesContent":["/// <reference types=\"./single-connection-provider.d.ts\" />\nconst ignoreError = () => { };\nexport class SingleConnectionProvider {\n    #connection;\n    #runningPromise;\n    constructor(connection) {\n        this.#connection = connection;\n    }\n    async provideConnection(consumer) {\n        while (this.#runningPromise) {\n            await this.#runningPromise.catch(ignoreError);\n        }\n        // `#runningPromise` must be set to undefined before it's\n        // resolved or rejected. Otherwise the while loop above\n        // will misbehave.\n        this.#runningPromise = this.#run(consumer).finally(() => {\n            this.#runningPromise = undefined;\n        });\n        return this.#runningPromise;\n    }\n    // Run the runner in an async function to make sure it doesn't\n    // throw synchronous errors.\n    async #run(runner) {\n        return await runner(this.#connection);\n    }\n}\n"],"x_google_ignoreList":[0],"mappings":";AACA,MAAM,oBAAoB;AAC1B,IAAa,2BAAb,MAAsC;CAClC;CACA;CACA,YAAY,YAAY;AACpB,QAAKA,aAAc;;CAEvB,MAAM,kBAAkB,UAAU;AAC9B,SAAO,MAAKC,eACR,OAAM,MAAKA,eAAgB,MAAM,YAAY;AAKjD,QAAKA,iBAAkB,MAAKC,IAAK,SAAS,CAAC,cAAc;AACrD,SAAKD,iBAAkB;IACzB;AACF,SAAO,MAAKA;;CAIhB,OAAMC,IAAK,QAAQ;AACf,SAAO,MAAM,OAAO,MAAKF,WAAY"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic-reference-builder.js

@@ -0,0 +1,33 @@
+import { isObject, isString } from "../util/object-utils.js";
+import { isOperationNodeSource } from "../operation-node/operation-node-source.js";
+import { parseSimpleReferenceExpression } from "../parser/reference-parser.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic-reference-builder.js
+var DynamicReferenceBuilder = class {
+	#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() {}
+	constructor(reference) {
+		this.#dynamicReference = reference;
+	}
+	toOperationNode() {
+		return parseSimpleReferenceExpression(this.#dynamicReference);
+	}
+};
+function isDynamicReferenceBuilder(obj) {
+	return isObject(obj) && isOperationNodeSource(obj) && isString(obj.dynamicReference);
+}
+
+//#endregion
+export { DynamicReferenceBuilder, isDynamicReferenceBuilder };
+//# sourceMappingURL=dynamic-reference-builder.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic-reference-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-reference-builder.js","names":["#dynamicReference"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic-reference-builder.js"],"sourcesContent":["/// <reference types=\"./dynamic-reference-builder.d.ts\" />\nimport { isOperationNodeSource, } from '../operation-node/operation-node-source.js';\nimport { parseSimpleReferenceExpression } from '../parser/reference-parser.js';\nimport { isObject, isString } from '../util/object-utils.js';\nexport class DynamicReferenceBuilder {\n    #dynamicReference;\n    get dynamicReference() {\n        return this.#dynamicReference;\n    }\n    /**\n     * @private\n     *\n     * This needs to be here just so that the typings work. Without this\n     * the generated .d.ts file contains no reference to the type param R\n     * which causes this type to be equal to DynamicReferenceBuilder with\n     * any R.\n     */\n    get refType() {\n        return undefined;\n    }\n    constructor(reference) {\n        this.#dynamicReference = reference;\n    }\n    toOperationNode() {\n        return parseSimpleReferenceExpression(this.#dynamicReference);\n    }\n}\nexport function isDynamicReferenceBuilder(obj) {\n    return (isObject(obj) &&\n        isOperationNodeSource(obj) &&\n        isString(obj.dynamicReference));\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;AAIA,IAAa,0BAAb,MAAqC;CACjC;CACA,IAAI,mBAAmB;AACnB,SAAO,MAAKA;;;;;;;;;;CAUhB,IAAI,UAAU;CAGd,YAAY,WAAW;AACnB,QAAKA,mBAAoB;;CAE7B,kBAAkB;AACd,SAAO,+BAA+B,MAAKA,iBAAkB;;;AAGrE,SAAgB,0BAA0B,KAAK;AAC3C,QAAQ,SAAS,IAAI,IACjB,sBAAsB,IAAI,IAC1B,SAAS,IAAI,iBAAiB"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic-table-builder.js

@@ -0,0 +1,43 @@
+import { isObject, isString } from "../util/object-utils.js";
+import { IdentifierNode } from "../operation-node/identifier-node.js";
+import { AliasNode } from "../operation-node/alias-node.js";
+import { isOperationNodeSource } from "../operation-node/operation-node-source.js";
+import { parseTable } from "../parser/table-parser.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic-table-builder.js
+var DynamicTableBuilder = class {
+	#table;
+	get table() {
+		return this.#table;
+	}
+	constructor(table) {
+		this.#table = table;
+	}
+	as(alias) {
+		return new AliasedDynamicTableBuilder(this.#table, alias);
+	}
+};
+var AliasedDynamicTableBuilder = class {
+	#table;
+	#alias;
+	get table() {
+		return this.#table;
+	}
+	get alias() {
+		return this.#alias;
+	}
+	constructor(table, alias) {
+		this.#table = table;
+		this.#alias = alias;
+	}
+	toOperationNode() {
+		return AliasNode.create(parseTable(this.#table), IdentifierNode.create(this.#alias));
+	}
+};
+function isAliasedDynamicTableBuilder(obj) {
+	return isObject(obj) && isOperationNodeSource(obj) && isString(obj.table) && isString(obj.alias);
+}
+
+//#endregion
+export { AliasedDynamicTableBuilder, DynamicTableBuilder, isAliasedDynamicTableBuilder };
+//# sourceMappingURL=dynamic-table-builder.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic-table-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-table-builder.js","names":["#table","#alias"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic-table-builder.js"],"sourcesContent":["/// <reference types=\"./dynamic-table-builder.d.ts\" />\nimport { AliasNode } from '../operation-node/alias-node.js';\nimport { IdentifierNode } from '../operation-node/identifier-node.js';\nimport { isOperationNodeSource, } from '../operation-node/operation-node-source.js';\nimport { parseTable } from '../parser/table-parser.js';\nimport { isObject, isString } from '../util/object-utils.js';\nexport class DynamicTableBuilder {\n    #table;\n    get table() {\n        return this.#table;\n    }\n    constructor(table) {\n        this.#table = table;\n    }\n    as(alias) {\n        return new AliasedDynamicTableBuilder(this.#table, alias);\n    }\n}\nexport class AliasedDynamicTableBuilder {\n    #table;\n    #alias;\n    get table() {\n        return this.#table;\n    }\n    get alias() {\n        return this.#alias;\n    }\n    constructor(table, alias) {\n        this.#table = table;\n        this.#alias = alias;\n    }\n    toOperationNode() {\n        return AliasNode.create(parseTable(this.#table), IdentifierNode.create(this.#alias));\n    }\n}\nexport function isAliasedDynamicTableBuilder(obj) {\n    return (isObject(obj) &&\n        isOperationNodeSource(obj) &&\n        isString(obj.table) &&\n        isString(obj.alias));\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAMA,IAAa,sBAAb,MAAiC;CAC7B;CACA,IAAI,QAAQ;AACR,SAAO,MAAKA;;CAEhB,YAAY,OAAO;AACf,QAAKA,QAAS;;CAElB,GAAG,OAAO;AACN,SAAO,IAAI,2BAA2B,MAAKA,OAAQ,MAAM;;;AAGjE,IAAa,6BAAb,MAAwC;CACpC;CACA;CACA,IAAI,QAAQ;AACR,SAAO,MAAKA;;CAEhB,IAAI,QAAQ;AACR,SAAO,MAAKC;;CAEhB,YAAY,OAAO,OAAO;AACtB,QAAKD,QAAS;AACd,QAAKC,QAAS;;CAElB,kBAAkB;AACd,SAAO,UAAU,OAAO,WAAW,MAAKD,MAAO,EAAE,eAAe,OAAO,MAAKC,MAAO,CAAC;;;AAG5F,SAAgB,6BAA6B,KAAK;AAC9C,QAAQ,SAAS,IAAI,IACjB,sBAAsB,IAAI,IAC1B,SAAS,IAAI,MAAM,IACnB,SAAS,IAAI,MAAM"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic.js

@@ -0,0 +1,134 @@
+import { DynamicReferenceBuilder } from "./dynamic-reference-builder.js";
+import { DynamicTableBuilder } from "./dynamic-table-builder.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic.js
+var DynamicModule = class {
+	/**
+	* Creates a dynamic reference to a column that is not know at compile time.
+	*
+	* Kysely is built in a way that by default you can't refer to tables or columns
+	* that are not actually visible in the current query and context. This is all
+	* done by TypeScript at compile time, which means that you need to know the
+	* columns and tables at compile time. This is not always the case of course.
+	*
+	* This method is meant to be used in those cases where the column names
+	* come from the user input or are not otherwise known at compile time.
+	*
+	* WARNING! Unlike values, column names are not escaped by the database engine
+	* or Kysely and if you pass in unchecked column names using this method, you
+	* create an SQL injection vulnerability. Always __always__ validate the user
+	* input before passing it to this method.
+	*
+	* There are couple of examples below for some use cases, but you can pass
+	* `ref` to other methods as well. If the types allow you to pass a `ref`
+	* value to some place, it should work.
+	*
+	* ### Examples
+	*
+	* Filter by a column not know at compile time:
+	*
+	* ```ts
+	* async function someQuery(filterColumn: string, filterValue: string) {
+	*   const { ref } = db.dynamic
+	*
+	*   return await db
+	*     .selectFrom('person')
+	*     .selectAll()
+	*     .where(ref(filterColumn), '=', filterValue)
+	*     .execute()
+	* }
+	*
+	* someQuery('first_name', 'Arnold')
+	* someQuery('person.last_name', 'Aniston')
+	* ```
+	*
+	* Order by a column not know at compile time:
+	*
+	* ```ts
+	* async function someQuery(orderBy: string) {
+	*   const { ref } = db.dynamic
+	*
+	*   return await db
+	*     .selectFrom('person')
+	*     .select('person.first_name as fn')
+	*     .orderBy(ref(orderBy))
+	*     .execute()
+	* }
+	*
+	* someQuery('fn')
+	* ```
+	*
+	* In this example we add selections dynamically:
+	*
+	* ```ts
+	* const { ref } = db.dynamic
+	*
+	* // Some column name provided by the user. Value not known at compile time.
+	* const columnFromUserInput: PossibleColumns = 'birthdate';
+	*
+	* // A type that lists all possible values `columnFromUserInput` can have.
+	* // You can use `keyof Person` if any column of an interface is allowed.
+	* type PossibleColumns = 'last_name' | 'first_name' | 'birthdate'
+	*
+	* const [person] = await db.selectFrom('person')
+	*   .select([
+	*     ref<PossibleColumns>(columnFromUserInput),
+	*     'id'
+	*   ])
+	*   .execute()
+	*
+	* // The resulting type contains all `PossibleColumns` as optional fields
+	* // because we cannot know which field was actually selected before
+	* // running the code.
+	* const lastName: string | null | undefined = person?.last_name
+	* const firstName: string | undefined = person?.first_name
+	* const birthDate: Date | null | undefined = person?.birthdate
+	*
+	* // The result type also contains the compile time selection `id`.
+	* person?.id
+	* ```
+	*/
+	ref(reference) {
+		return new DynamicReferenceBuilder(reference);
+	}
+	/**
+	* Creates a table reference to a table that's not fully known at compile time.
+	*
+	* The type `T` is allowed to be a union of multiple tables.
+	*
+	* <!-- siteExample("select", "Generic find query", 130) -->
+	*
+	* A generic type-safe helper function for finding a row by a column value:
+	*
+	* ```ts
+	* import { SelectType } from 'kysely'
+	* import { Database } from 'type-editor'
+	*
+	* async function getRowByColumn<
+	*   T extends keyof Database,
+	*   C extends keyof Database[T] & string,
+	*   V extends SelectType<Database[T][C]>,
+	* >(t: T, c: C, v: V) {
+	*   // We need to use the dynamic module since the table name
+	*   // is not known at compile time.
+	*   const { table, ref } = db.dynamic
+	*
+	*   return await db
+	*     .selectFrom(table(t).as('t'))
+	*     .selectAll()
+	*     .where(ref(c), '=', v)
+	*     .orderBy('t.id')
+	*     .executeTakeFirstOrThrow()
+	* }
+	*
+	* const person = await getRowByColumn('person', 'first_name', 'Arnold')
+	* ```
+	*/
+	table(table) {
+		return new DynamicTableBuilder(table);
+	}
+};
+
+//#endregion
+export { DynamicModule };
+//# sourceMappingURL=dynamic.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/dynamic/dynamic.js"],"sourcesContent":["/// <reference types=\"./dynamic.d.ts\" />\nimport { DynamicReferenceBuilder } from './dynamic-reference-builder.js';\nimport { DynamicTableBuilder } from './dynamic-table-builder.js';\nexport class DynamicModule {\n    /**\n     * Creates a dynamic reference to a column that is not know at compile time.\n     *\n     * Kysely is built in a way that by default you can't refer to tables or columns\n     * that are not actually visible in the current query and context. This is all\n     * done by TypeScript at compile time, which means that you need to know the\n     * columns and tables at compile time. This is not always the case of course.\n     *\n     * This method is meant to be used in those cases where the column names\n     * come from the user input or are not otherwise known at compile time.\n     *\n     * WARNING! Unlike values, column names are not escaped by the database engine\n     * or Kysely and if you pass in unchecked column names using this method, you\n     * create an SQL injection vulnerability. Always __always__ validate the user\n     * input before passing it to this method.\n     *\n     * There are couple of examples below for some use cases, but you can pass\n     * `ref` to other methods as well. If the types allow you to pass a `ref`\n     * value to some place, it should work.\n     *\n     * ### Examples\n     *\n     * Filter by a column not know at compile time:\n     *\n     * ```ts\n     * async function someQuery(filterColumn: string, filterValue: string) {\n     *   const { ref } = db.dynamic\n     *\n     *   return await db\n     *     .selectFrom('person')\n     *     .selectAll()\n     *     .where(ref(filterColumn), '=', filterValue)\n     *     .execute()\n     * }\n     *\n     * someQuery('first_name', 'Arnold')\n     * someQuery('person.last_name', 'Aniston')\n     * ```\n     *\n     * Order by a column not know at compile time:\n     *\n     * ```ts\n     * async function someQuery(orderBy: string) {\n     *   const { ref } = db.dynamic\n     *\n     *   return await db\n     *     .selectFrom('person')\n     *     .select('person.first_name as fn')\n     *     .orderBy(ref(orderBy))\n     *     .execute()\n     * }\n     *\n     * someQuery('fn')\n     * ```\n     *\n     * In this example we add selections dynamically:\n     *\n     * ```ts\n     * const { ref } = db.dynamic\n     *\n     * // Some column name provided by the user. Value not known at compile time.\n     * const columnFromUserInput: PossibleColumns = 'birthdate';\n     *\n     * // A type that lists all possible values `columnFromUserInput` can have.\n     * // You can use `keyof Person` if any column of an interface is allowed.\n     * type PossibleColumns = 'last_name' | 'first_name' | 'birthdate'\n     *\n     * const [person] = await db.selectFrom('person')\n     *   .select([\n     *     ref<PossibleColumns>(columnFromUserInput),\n     *     'id'\n     *   ])\n     *   .execute()\n     *\n     * // The resulting type contains all `PossibleColumns` as optional fields\n     * // because we cannot know which field was actually selected before\n     * // running the code.\n     * const lastName: string | null | undefined = person?.last_name\n     * const firstName: string | undefined = person?.first_name\n     * const birthDate: Date | null | undefined = person?.birthdate\n     *\n     * // The result type also contains the compile time selection `id`.\n     * person?.id\n     * ```\n     */\n    ref(reference) {\n        return new DynamicReferenceBuilder(reference);\n    }\n    /**\n     * Creates a table reference to a table that's not fully known at compile time.\n     *\n     * The type `T` is allowed to be a union of multiple tables.\n     *\n     * <!-- siteExample(\"select\", \"Generic find query\", 130) -->\n     *\n     * A generic type-safe helper function for finding a row by a column value:\n     *\n     * ```ts\n     * import { SelectType } from 'kysely'\n     * import { Database } from 'type-editor'\n     *\n     * async function getRowByColumn<\n     *   T extends keyof Database,\n     *   C extends keyof Database[T] & string,\n     *   V extends SelectType<Database[T][C]>,\n     * >(t: T, c: C, v: V) {\n     *   // We need to use the dynamic module since the table name\n     *   // is not known at compile time.\n     *   const { table, ref } = db.dynamic\n     *\n     *   return await db\n     *     .selectFrom(table(t).as('t'))\n     *     .selectAll()\n     *     .where(ref(c), '=', v)\n     *     .orderBy('t.id')\n     *     .executeTakeFirstOrThrow()\n     * }\n     *\n     * const person = await getRowByColumn('person', 'first_name', 'Arnold')\n     * ```\n     */\n    table(table) {\n        return new DynamicTableBuilder(table);\n    }\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;AAGA,IAAa,gBAAb,MAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsFvB,IAAI,WAAW;AACX,SAAO,IAAI,wBAAwB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCjD,MAAM,OAAO;AACT,SAAO,IAAI,oBAAoB,MAAM"}