durcno 1.0.0-alpha.0

package/dist/src/node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.mjs

@@ -0,0 +1,165 @@
+//#region node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const styles = {
+	modifier: {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		blackBright: [90, 39],
+		gray: [90, 39],
+		grey: [90, 39],
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39]
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49],
+		bgGrey: [100, 49],
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49]
+	}
+};
+Object.keys(styles.modifier);
+const foregroundColorNames = Object.keys(styles.color);
+const backgroundColorNames = Object.keys(styles.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+	const codes = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(styles)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+			group[styleName] = styles[styleName];
+			codes.set(style[0], style[1]);
+		}
+		Object.defineProperty(styles, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+	Object.defineProperty(styles, "codes", {
+		value: codes,
+		enumerable: false
+	});
+	styles.color.close = "\x1B[39m";
+	styles.bgColor.close = "\x1B[49m";
+	styles.color.ansi = wrapAnsi16();
+	styles.color.ansi256 = wrapAnsi256();
+	styles.color.ansi16m = wrapAnsi16m();
+	styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	Object.defineProperties(styles, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				if (red === green && green === blue) {
+					if (red < 8) return 16;
+					if (red > 248) return 231;
+					return Math.round((red - 8) / 247 * 24) + 232;
+				}
+				return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) return [
+					0,
+					0,
+					0
+				];
+				let [colorString] = matches;
+				if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
+				const integer = Number.parseInt(colorString, 16);
+				return [
+					integer >> 16 & 255,
+					integer >> 8 & 255,
+					integer & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) return 30 + code;
+				if (code < 16) return 90 + (code - 8);
+				let red;
+				let green;
+				let blue;
+				if (code >= 232) {
+					red = ((code - 232) * 10 + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+					const remainder = code % 36;
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = remainder % 6 / 5;
+				}
+				const value = Math.max(red, green, blue) * 2;
+				if (value === 0) return 30;
+				let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+				if (value === 2) result += 60;
+				return result;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+			enumerable: false
+		}
+	});
+	return styles;
+}
+const ansiStyles = assembleStyles();
+//#endregion
+export { backgroundColorNames, ansiStyles as default, foregroundColorNames };

package/dist/src/node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.mjs

@@ -0,0 +1,92 @@
+import process from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+//#region node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process.argv) {
+	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf("--");
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = process;
+let flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+function envForceColor() {
+	if ("FORCE_COLOR" in env) {
+		if (env.FORCE_COLOR === "true") return 1;
+		if (env.FORCE_COLOR === "false") return 0;
+		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
+function translateLevel(level) {
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+	if (forceColor === 0) return 0;
+	if (sniffFlags) {
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+	}
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+	const min = forceColor || 0;
+	if (env.TERM === "dumb") return min;
+	if (process.platform === "win32") {
+		const osRelease = os.release().split(".");
+		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		return 1;
+	}
+	if ("CI" in env) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+		return min;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	if (env.COLORTERM === "truecolor") return 3;
+	if (env.TERM === "xterm-kitty") return 3;
+	if (env.TERM === "xterm-ghostty") return 3;
+	if (env.TERM === "wezterm") return 3;
+	if ("TERM_PROGRAM" in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+		switch (env.TERM_PROGRAM) {
+			case "iTerm.app": return version >= 3 ? 3 : 2;
+			case "Apple_Terminal": return 2;
+		}
+	}
+	if (/-256(color)?$/i.test(env.TERM)) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+	if ("COLORTERM" in env) return 1;
+	return min;
+}
+function createSupportsColor(stream, options = {}) {
+	return translateLevel(_supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options
+	}));
+}
+const supportsColor = {
+	stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+	stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+//#endregion
+export { supportsColor as default };

package/dist/src/query-builders/aggregates.d.mts

@@ -0,0 +1,20 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { BuildFilterExpression } from "../filters/index.mjs";
+import { AnyColumn, TColsToLeftRight, TableColumn, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/aggregates.d.ts
+type AggregateFunction = "SUM" | "AVG" | "MIN" | "MAX";
+declare class AggregateQuery<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>, TColumn extends TableColumn<string, string, Key, AnyColumn>, TReturn extends number | null> extends QueryPromise<TReturn> {
+  #private;
+  constructor(table: TTableWC, column: TColumn, fn: AggregateFunction, where: BuildFilterExpression<TColsToLeftRight<TTableWC["_"]["columns"]>> | undefined, config: Config, executor: QueryExecutor);
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+  handleRows(rows: {
+    result: string | null;
+  }[]): TReturn;
+}
+//#endregion
+export { AggregateQuery };

package/dist/src/query-builders/aggregates.mjs

@@ -0,0 +1,43 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/aggregates.ts
+var AggregateQuery = class extends QueryPromise {
+	#$table;
+	#$column;
+	#$fn;
+	#$where;
+	#$config;
+	#$executor;
+	constructor(table, column, fn, where, config, executor) {
+		super();
+		this.#$table = table;
+		this.#$column = column;
+		this.#$fn = fn;
+		this.#$where = where;
+		this.#$config = config;
+		this.#$executor = executor;
+	}
+	toQuery() {
+		const columnName = this.#$column.fullName;
+		const query = new Query(`SELECT ${this.#$fn}(${columnName}) as result FROM `, this.handleRows.bind(this));
+		query.sql += this.#$table._.fullName;
+		if (this.#$where) {
+			query.sql += " WHERE ";
+			query.sql += this.#$where.toSQL();
+		}
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		const res = await this.#$executor.query(query.sql, query.arguments);
+		const rows = this.#$executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		const result = rows[0].result;
+		if (result === null) return null;
+		return Number(result);
+	}
+};
+//#endregion
+export { AggregateQuery };

package/dist/src/query-builders/count.d.mts

@@ -0,0 +1,19 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { BuildFilterExpression } from "../filters/index.mjs";
+import { AnyColumn, TColsToLeftRight, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/count.d.ts
+declare class CountQuery<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>> extends QueryPromise<number> {
+  #private;
+  constructor(table: TTableWC, where: BuildFilterExpression<TColsToLeftRight<TTableWC["_"]["columns"]>> | undefined, config: Config, executor: QueryExecutor);
+  toQuery(): Query<number>;
+  execute(): Promise<number>;
+  handleRows(rows: {
+    count: string;
+  }[]): number;
+}
+//#endregion
+export { CountQuery };

package/dist/src/query-builders/count.mjs

@@ -0,0 +1,36 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/count.ts
+var CountQuery = class extends QueryPromise {
+	#$table;
+	#$where;
+	#$config;
+	#$executor;
+	constructor(table, where, config, executor) {
+		super();
+		this.#$table = table;
+		this.#$where = where;
+		this.#$config = config;
+		this.#$executor = executor;
+	}
+	toQuery() {
+		const query = new Query("SELECT count(*) FROM ", this.handleRows.bind(this));
+		query.sql += this.#$table._.fullName;
+		if (this.#$where) {
+			query.sql += " WHERE ";
+			query.sql += this.#$where.toSQL();
+		}
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		const res = await this.#$executor.query(query.sql, query.arguments);
+		const rows = this.#$executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		return Number(rows[0].count);
+	}
+};
+//#endregion
+export { CountQuery };

package/dist/src/query-builders/delete.d.mts

@@ -0,0 +1,19 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { BuildFilterExpression } from "../filters/index.mjs";
+import { AnyColumn, TColsToLeftRight, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/delete.d.ts
+declare class DeleteQuery<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>, TPrepare extends boolean, TReturning extends { [ColName in keyof TTableWC["_"]["columns"]]?: true } | { [ColName in keyof TTableWC["_"]["columns"]]?: false } | undefined, TReturn = (TReturning extends Record<Key, boolean> ? TReturning extends { [ColName in keyof TTableWC["_"]["columns"]]?: false } ? { [ColName in keyof TTableWC["_"]["columns"] as TReturning[ColName] extends false ? never : ColName]: TTableWC["_"]["columns"][ColName]["ValTypeSelect"] }[] : { [ColName in keyof TTableWC["_"]["columns"] as TReturning[ColName] extends true ? ColName : never]: TTableWC["_"]["columns"][ColName]["ValTypeSelect"] }[] : null)> extends QueryPromise<TReturn> {
+  #private;
+  constructor(table: TTableWC, where: BuildFilterExpression<TColsToLeftRight<TTableWC["_"]["columns"]>, TPrepare> | undefined, returnings: TReturning, config: Config, executor: QueryExecutor, prepare: TPrepare);
+  where<TWhere extends BuildFilterExpression<TColsToLeftRight<TTableWC["_"]["columns"]>, TPrepare>>(where: TWhere): DeleteQuery<TTableWC, TPrepare, TReturning, TReturning extends Record<Key, boolean> ? TReturning extends { [ColName in keyof TTableWC["_"]["columns"]]?: false | undefined } ? { [ColName_1 in keyof TTableWC["_"]["columns"] as TReturning[ColName_1] extends false ? never : ColName_1]: TTableWC["_"]["columns"][ColName_1]["ValTypeSelect"] }[] : { [ColName_2 in keyof TTableWC["_"]["columns"] as TReturning[ColName_2] extends true ? ColName_2 : never]: TTableWC["_"]["columns"][ColName_2]["ValTypeSelect"] }[] : null>;
+  returning<TReturnings extends { [ColName in keyof TTableWC["_"]["columns"]]?: true } | { [ColName in keyof TTableWC["_"]["columns"]]?: false }>(returnings: TReturnings): DeleteQuery<TTableWC, TPrepare, TReturnings, TReturnings extends Record<Key, boolean> ? TReturnings extends { [ColName in keyof TTableWC["_"]["columns"]]?: false | undefined } ? { [ColName_1 in keyof TTableWC["_"]["columns"] as TReturnings[ColName_1] extends false ? never : ColName_1]: TTableWC["_"]["columns"][ColName_1]["ValTypeSelect"] }[] : { [ColName_2 in keyof TTableWC["_"]["columns"] as TReturnings[ColName_2] extends true ? ColName_2 : never]: TTableWC["_"]["columns"][ColName_2]["ValTypeSelect"] }[] : null>;
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+  handleRows(rows: Record<string, unknown>[]): TReturn;
+}
+//#endregion
+export { DeleteQuery };

package/dist/src/query-builders/delete.mjs

@@ -0,0 +1,57 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/delete.ts
+var DeleteQuery = class DeleteQuery extends QueryPromise {
+	#$table;
+	#$where;
+	#$returning;
+	#$config;
+	#$executor;
+	#$prepare;
+	constructor(table, where, returnings, config, executor, prepare) {
+		super();
+		this.#$table = table;
+		this.#$where = where;
+		this.#$returning = returnings;
+		this.#$config = config;
+		this.#$executor = executor;
+		this.#$prepare = prepare;
+	}
+	where(where) {
+		return new DeleteQuery(this.#$table, where, this.#$returning, this.#$config, this.#$executor, this.#$prepare);
+	}
+	returning(returnings) {
+		return new DeleteQuery(this.#$table, this.#$where, returnings, this.#$config, this.#$executor, this.#$prepare);
+	}
+	toQuery() {
+		const query = new Query("DELETE FROM ", this.handleRows.bind(this));
+		query.sql += this.#$table._.fullName;
+		if (this.#$where) {
+			query.sql += " WHERE ";
+			if (this.#$prepare) this.#$where.toQuery(query);
+			else query.sql += this.#$where.toSQL();
+		}
+		if (this.#$returning) {
+			query.sql += " RETURNING ";
+			const returningFields = Object.keys(this.#$returning).filter((k) => this.#$returning?.[k] === true);
+			query.sql += returningFields.map((field) => `"${this.#$table._.columns[field].nameSnake}"`).join(", ");
+		}
+		query.sql += ";";
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		const res = await this.#$executor.query(query.sql, query.arguments);
+		const rows = this.#$executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		const { columns } = this.#$table._;
+		rows.forEach((row) => {
+			for (const [key, value] of Object.entries(row)) row[key] = columns[key].fromDriver(value);
+		});
+		return rows;
+	}
+};
+//#endregion
+export { DeleteQuery };

package/dist/src/query-builders/distinct.d.mts

@@ -0,0 +1,19 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { BuildFilterExpression } from "../filters/index.mjs";
+import { AnyColumn, TColsToLeftRight, TableColumn, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/distinct.d.ts
+declare class DistinctQuery<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>, TColumn extends TableColumn<string, string, Key, AnyColumn>, TReturn = TColumn["ValTypeSelect"][]> extends QueryPromise<TReturn> {
+  #private;
+  constructor(table: TTableWC, column: TColumn, where: BuildFilterExpression<TColsToLeftRight<TTableWC["_"]["columns"]>> | undefined, config: Config, executor: QueryExecutor);
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+  handleRows(rows: {
+    value: unknown;
+  }[]): TReturn;
+}
+//#endregion
+export { DistinctQuery };

package/dist/src/query-builders/distinct.mjs

@@ -0,0 +1,42 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/distinct.ts
+var DistinctQuery = class extends QueryPromise {
+	#$table;
+	#$column;
+	#$where;
+	#$config;
+	#$executor;
+	constructor(table, column, where, config, executor) {
+		super();
+		this.#$table = table;
+		this.#$column = column;
+		this.#$where = where;
+		this.#$config = config;
+		this.#$executor = executor;
+	}
+	toQuery() {
+		const columnName = this.#$column.fullName;
+		const query = new Query(`SELECT DISTINCT ${columnName} as value FROM `, this.handleRows.bind(this));
+		query.sql += this.#$table._.fullName;
+		if (this.#$where) {
+			query.sql += " WHERE ";
+			query.sql += this.#$where.toSQL();
+		}
+		query.sql += ` ORDER BY ${columnName}`;
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		const res = await this.#$executor.query(query.sql, query.arguments);
+		const rows = this.#$executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		return rows.map((row) => {
+			return this.#$column.fromDriver(row.value);
+		});
+	}
+};
+//#endregion
+export { DistinctQuery };

package/dist/src/query-builders/exists.d.mts

@@ -0,0 +1,19 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { BuildFilterExpression } from "../filters/index.mjs";
+import { AnyColumn, TColsToLeftRight, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/exists.d.ts
+declare class ExistsQuery<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>> extends QueryPromise<boolean> {
+  #private;
+  constructor(table: TTableWC, where: BuildFilterExpression<TColsToLeftRight<TTableWC["_"]["columns"]>> | undefined, config: Config, executor: QueryExecutor);
+  toQuery(): Query<boolean>;
+  execute(): Promise<boolean>;
+  handleRows(rows: {
+    exists: boolean;
+  }[]): boolean;
+}
+//#endregion
+export { ExistsQuery };

package/dist/src/query-builders/exists.mjs

@@ -0,0 +1,37 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/exists.ts
+var ExistsQuery = class extends QueryPromise {
+	#$table;
+	#$where;
+	#$config;
+	#$executor;
+	constructor(table, where, config, executor) {
+		super();
+		this.#$table = table;
+		this.#$where = where;
+		this.#$config = config;
+		this.#$executor = executor;
+	}
+	toQuery() {
+		const query = new Query("SELECT EXISTS(SELECT 1 FROM ", this.handleRows.bind(this));
+		query.sql += this.#$table._.fullName;
+		if (this.#$where) {
+			query.sql += " WHERE ";
+			query.sql += this.#$where.toSQL();
+		}
+		query.sql += ")";
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		const res = await this.#$executor.query(query.sql, query.arguments);
+		const rows = this.#$executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		return rows[0].exists;
+	}
+};
+//#endregion
+export { ExistsQuery };

package/dist/src/query-builders/first.d.mts

@@ -0,0 +1,17 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { BuildFilterExpression } from "../filters/index.mjs";
+import { AnyColumn, TColsToLeftRight, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/first.d.ts
+declare class FirstQuery<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>, TReturn = { [ColName in keyof TTableWC["_"]["columns"]]: TTableWC["_"]["columns"][ColName]["ValTypeSelect"] } | null> extends QueryPromise<TReturn> {
+  #private;
+  constructor(table: TTableWC, where: BuildFilterExpression<TColsToLeftRight<TTableWC["_"]["columns"]>> | undefined, config: Config, executor: QueryExecutor);
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+  handleRows(rows: Record<string, unknown>[]): TReturn;
+}
+//#endregion
+export { FirstQuery };

package/dist/src/query-builders/first.mjs

@@ -0,0 +1,46 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { snakeToCamel } from "../utils.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/first.ts
+var FirstQuery = class extends QueryPromise {
+	#$table;
+	#$where;
+	#$config;
+	#$executor;
+	constructor(table, where, config, executor) {
+		super();
+		this.#$table = table;
+		this.#$where = where;
+		this.#$config = config;
+		this.#$executor = executor;
+	}
+	toQuery() {
+		const query = new Query("SELECT * FROM ", this.handleRows.bind(this));
+		query.sql += this.#$table._.fullName;
+		if (this.#$where) {
+			query.sql += " WHERE ";
+			query.sql += this.#$where.toSQL();
+		}
+		query.sql += " LIMIT 1";
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		const res = await this.#$executor.query(query.sql, query.arguments);
+		const rows = this.#$executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		if (rows.length === 0) return null;
+		const row = rows[0];
+		const { columns } = this.#$table._;
+		for (const [key, value] of Object.entries(row)) {
+			const keyCamel = snakeToCamel(key);
+			row[keyCamel] = columns[keyCamel].fromDriver(value);
+			if (keyCamel !== key) delete row[key];
+		}
+		return row;
+	}
+};
+//#endregion
+export { FirstQuery };

package/dist/src/query-builders/insert-returning.d.mts

@@ -0,0 +1,16 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { AnyColumn, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/insert-returning.d.ts
+declare class InsertReturningQuery<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>, TReturn = { [ColName in keyof TTableWC["_"]["columns"]]: TTableWC["_"]["columns"][ColName]["ValTypeSelect"] }> extends QueryPromise<TReturn> {
+  #private;
+  constructor(table: TTableWC, values: Record<string, unknown>, config: Config, executor: QueryExecutor);
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+  handleRows(rows: Record<string, unknown>[]): TReturn;
+}
+//#endregion
+export { InsertReturningQuery };