semola 0.5.4 → 0.6.0

package/dist/lib/orm/index.cjs

@@ -0,0 +1,1642 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/lib/orm/column/index.ts
+const createColumnBuilder = (column) => {
+	const primaryKey = () => {
+		return createColumnBuilder({
+			...column,
+			_meta: {
+				...column._meta,
+				isNullable: false,
+				isPrimaryKey: true
+			}
+		});
+	};
+	const notNull = () => {
+		return createColumnBuilder({
+			...column,
+			_meta: {
+				...column._meta,
+				isNullable: false
+			}
+		});
+	};
+	const nullable = (() => {
+		if (column._meta.isPrimaryKey) return createColumnBuilder({
+			...column,
+			_meta: {
+				...column._meta,
+				isNullable: false
+			}
+		});
+		return createColumnBuilder({
+			...column,
+			_meta: {
+				...column._meta,
+				isNullable: true
+			}
+		});
+	});
+	const unique = () => {
+		return createColumnBuilder({
+			...column,
+			_meta: {
+				...column._meta,
+				isUnique: true
+			}
+		});
+	};
+	const defaultHandler = (value) => {
+		return createColumnBuilder({
+			...column,
+			_meta: {
+				...column._meta,
+				hasDefault: true
+			},
+			_default: value
+		});
+	};
+	const referencesBuilder = (tableColumn) => {
+		return createColumnBuilder({
+			...column,
+			references: { tableColumn }
+		});
+	};
+	const references = referencesBuilder;
+	references.tableColumn = column.references?.tableColumn;
+	return {
+		...column,
+		primaryKey,
+		notNull,
+		nullable,
+		unique,
+		default: defaultHandler,
+		references
+	};
+};
+const createBaseColumn = (sqlName, type, enumValues) => {
+	return createColumnBuilder({
+		sqlName,
+		type,
+		enumValues,
+		_meta: {
+			isNullable: true,
+			isPrimaryKey: false,
+			isUnique: false,
+			hasDefault: false
+		}
+	});
+};
+const string = (sqlName) => {
+	return createBaseColumn(sqlName, "string");
+};
+const uuid = (sqlName) => {
+	return string(sqlName);
+};
+const number = (sqlName) => {
+	return createBaseColumn(sqlName, "number");
+};
+const boolean = (sqlName) => {
+	return createBaseColumn(sqlName, "boolean");
+};
+const date = (sqlName) => {
+	return createBaseColumn(sqlName, "date");
+};
+const enumType = (sqlName, values) => {
+	return createBaseColumn(sqlName, "enum", values);
+};
+const json = (sqlName) => {
+	return createBaseColumn(sqlName, "json");
+};
+const jsonb = (sqlName) => {
+	return createBaseColumn(sqlName, "jsonb");
+};
+//#endregion
+//#region src/lib/orm/utils.ts
+const quoteIdentifier = (identifier) => {
+	identifier = identifier.replaceAll("\"", "\"\"");
+	return `"${identifier}"`;
+};
+//#endregion
+//#region src/lib/orm/dialect/relation-fk.ts
+const resolveHasManyForeignKeyColumn = (sourceTable, targetTable) => {
+	const sourceColumnValues = Object.values(sourceTable.columns);
+	const candidates = [];
+	for (const [, column] of Object.entries(targetTable.columns)) {
+		if (!column.references) continue;
+		const getReferencedColumn = column.references.tableColumn;
+		if (!getReferencedColumn) continue;
+		const referencedColumn = getReferencedColumn();
+		if (sourceColumnValues.some((sourceCol) => {
+			return sourceCol === referencedColumn;
+		})) candidates.push({
+			fk: column,
+			source: referencedColumn
+		});
+	}
+	if (candidates.length > 1) throw new Error(`Ambiguous hasMany foreign key from ${targetTable.sqlName} to ${sourceTable.sqlName}`);
+	const [candidate] = candidates;
+	if (!candidate) throw new Error(`Missing hasMany foreign key from ${targetTable.sqlName} to ${sourceTable.sqlName}`);
+	return candidate;
+};
+const resolveHasOneForeignKeyColumn = (input) => {
+	const { sourceTable, relationTable, relationForeignKey } = input;
+	const localForeignKey = sourceTable.columns[relationForeignKey];
+	if (!localForeignKey) throw new Error(`Missing hasOne foreign key column ${relationForeignKey} on ${sourceTable.sqlName}`);
+	if (!localForeignKey.references?.tableColumn) throw new Error(`Column ${relationForeignKey} on ${sourceTable.sqlName} is not a foreign key - call .references() on it`);
+	const referencedColumn = localForeignKey.references.tableColumn();
+	if (!Object.values(relationTable.columns).some((column) => {
+		return column === referencedColumn;
+	})) throw new Error(`Column ${relationForeignKey} on ${sourceTable.sqlName} does not reference ${relationTable.sqlName}`);
+	return {
+		localForeignKey,
+		target: referencedColumn
+	};
+};
+//#endregion
+//#region src/lib/orm/dialect/clauses.ts
+const FALSE_WHERE_SQL = "(1 = 0)";
+const TRUE_WHERE_SQL = "(1 = 1)";
+const RELATION_FILTER_KEYS = [
+	"every",
+	"some",
+	"none"
+];
+const EMPTY_INCLUDE = {
+	sql: "",
+	params: [],
+	descriptors: []
+};
+const serializeParam = (value) => {
+	if (value instanceof Date) return value.toISOString();
+	return value;
+};
+const escapeLikeValue = (value) => {
+	return serializeParam(`${serializeParam(value)}`.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_"));
+};
+const OPERATORS = {
+	equals: {
+		sql: (ph) => `= ${ph}`,
+		transform: (v) => serializeParam(v)
+	},
+	gt: {
+		sql: (ph) => `> ${ph}`,
+		transform: (v) => serializeParam(v)
+	},
+	gte: {
+		sql: (ph) => `>= ${ph}`,
+		transform: (v) => serializeParam(v)
+	},
+	lt: {
+		sql: (ph) => `< ${ph}`,
+		transform: (v) => serializeParam(v)
+	},
+	lte: {
+		sql: (ph) => `<= ${ph}`,
+		transform: (v) => serializeParam(v)
+	},
+	startsWith: {
+		sql: (ph) => `LIKE ${ph} ESCAPE '\\'`,
+		transform: (v) => serializeParam(`${escapeLikeValue(v)}%`)
+	},
+	endsWith: {
+		sql: (ph) => `LIKE ${ph} ESCAPE '\\'`,
+		transform: (v) => serializeParam(`%${escapeLikeValue(v)}`)
+	},
+	contains: {
+		sql: (ph) => `LIKE ${ph} ESCAPE '\\'`,
+		transform: (v) => serializeParam(`%${escapeLikeValue(v)}%`)
+	}
+};
+const createNextPlaceholder = (spec) => {
+	let index = 0;
+	return () => {
+		index += 1;
+		return spec.formatPlaceholder(index);
+	};
+};
+const buildSelectList = (columns, include) => {
+	if (include.sql) return `${columns}, ${include.sql}`;
+	return columns;
+};
+const serializeColumnValue = (column, value) => {
+	if (column.type !== "json" && column.type !== "jsonb") return serializeParam(value);
+	if (value === null) return value;
+	if (value === void 0) return null;
+	return JSON.stringify(value);
+};
+const isPlainObject = (value) => {
+	if (value === null) return false;
+	if (typeof value !== "object") return false;
+	if (Array.isArray(value)) return false;
+	if (value instanceof Date) return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype === null) return true;
+	if (prototype === Object.prototype) return true;
+	return false;
+};
+const appendDirectWhereClause = (input) => {
+	const { clauses, params, nextPlaceholder, column, sqlName, value } = input;
+	if (value === null) {
+		clauses.push(`${sqlName} IS NULL`);
+		return;
+	}
+	clauses.push(`${sqlName} = ${nextPlaceholder()}`);
+	params.push(serializeColumnValue(column, value));
+};
+const appendOperatorWhereClauses = (input) => {
+	const { clauses, params, nextPlaceholder, column, sqlName, jsKey, value } = input;
+	const entries = Object.entries(value);
+	if (!entries.length) throw new Error(`Missing where operator for field ${jsKey}`);
+	for (const [op, operand] of entries) {
+		if (op === "in" || op === "notIn") {
+			if (!Array.isArray(operand)) throw new Error(`Expected array for where operator: ${op} for field ${jsKey}`);
+			if (op === "in" && operand.length === 0) {
+				clauses.push(FALSE_WHERE_SQL);
+				continue;
+			}
+			if (op === "notIn" && operand.length === 0) continue;
+			const placeholders = operand.map(() => nextPlaceholder());
+			const keyword = op === "in" ? "IN" : "NOT IN";
+			clauses.push(`${sqlName} ${keyword} (${placeholders.join(", ")})`);
+			for (const item of operand) params.push(serializeColumnValue(column, item));
+			continue;
+		}
+		if (op === "between") {
+			if (!Array.isArray(operand)) throw new Error(`Expected array for where operator: ${op} for field ${jsKey}`);
+			if (operand.length !== 2) throw new Error(`Expected 2-element array for where operator: ${op} for field ${jsKey}`);
+			const [min, max] = operand;
+			const ph1 = nextPlaceholder();
+			const ph2 = nextPlaceholder();
+			clauses.push(`${sqlName} BETWEEN ${ph1} AND ${ph2}`);
+			params.push(serializeColumnValue(column, min), serializeColumnValue(column, max));
+			continue;
+		}
+		const operator = OPERATORS[op];
+		if (!operator) throw new Error(`Unknown where operator: ${op} for field ${jsKey}`);
+		if (op === "equals" && operand === null) {
+			clauses.push(`${sqlName} IS NULL`);
+			continue;
+		}
+		clauses.push(`${sqlName} ${operator.sql(nextPlaceholder())}`);
+		params.push(operator.transform(serializeColumnValue(column, operand)));
+	}
+};
+const parseRelationFilters = (relationName, value) => {
+	if (!isPlainObject(value)) throw new Error(`Relation where filter for ${relationName} must be an object`);
+	const filter = value;
+	const filters = [];
+	for (const filterKey of RELATION_FILTER_KEYS) {
+		if (!(filterKey in filter)) continue;
+		const nestedWhere = filter[filterKey];
+		if (!isPlainObject(nestedWhere)) throw new Error(`Relation where filter ${filterKey} must be an object`);
+		filters.push({
+			key: filterKey,
+			where: nestedWhere
+		});
+	}
+	if (filters.length === 0) throw new Error(`Relation where filter for ${relationName} must include at least one of every, some, or none`);
+	return filters;
+};
+const isRelationFilterValue = (value) => {
+	if (!isPlainObject(value)) return false;
+	const filter = value;
+	for (const key of RELATION_FILTER_KEYS) if (key in filter) return true;
+	return Object.keys(filter).length === 0;
+};
+const buildRelationForeignKeyCondition = (input) => {
+	const { parentTable, parentAlias, relation, relationTable, relationAlias } = input;
+	if (relation._type === "hasMany") {
+		const { fk: foreignKey, source: sourceColumn } = resolveHasManyForeignKeyColumn(parentTable, relationTable);
+		return `${relationAlias}.${quoteIdentifier(foreignKey.sqlName)} = ${parentAlias}.${quoteIdentifier(sourceColumn.sqlName)}`;
+	}
+	if (relation._type !== "hasOne") throw new Error("Expected hasOne relation");
+	const { localForeignKey, target } = resolveHasOneForeignKeyColumn({
+		sourceTable: parentTable,
+		relationTable,
+		relationForeignKey: relation._foreignKey
+	});
+	return `${relationAlias}.${quoteIdentifier(target.sqlName)} = ${parentAlias}.${quoteIdentifier(localForeignKey.sqlName)}`;
+};
+const appendRelationFilterClause = (input) => {
+	const { clauses, params, nextPlaceholder, parentAlias, table, relation, relationName, key, where: nestedWhere } = input;
+	if (!parentAlias) throw new Error("parentAlias is required for relation where filters");
+	const relationTable = relation._table;
+	const relationAlias = `where_${relationName}__${relationTable.sqlName}`;
+	const fkCondition = buildRelationForeignKeyCondition({
+		parentTable: table,
+		parentAlias,
+		relation,
+		relationTable,
+		relationAlias
+	});
+	const nested = buildWhereClause({
+		nextPlaceholder,
+		table: relationTable,
+		where: nestedWhere
+	});
+	const nestedCondition = nested.sql ? nested.sql : TRUE_WHERE_SQL;
+	params.push(...nested.params);
+	const relationFrom = `${quoteIdentifier(relationTable.sqlName)} AS ${relationAlias}`;
+	if (key === "some") {
+		clauses.push(`EXISTS (SELECT 1 FROM ${relationFrom} WHERE ${fkCondition} AND (${nestedCondition}))`);
+		return;
+	}
+	if (key === "none") {
+		clauses.push(`NOT EXISTS (SELECT 1 FROM ${relationFrom} WHERE ${fkCondition} AND (${nestedCondition}))`);
+		return;
+	}
+	clauses.push(`NOT EXISTS (SELECT 1 FROM ${relationFrom} WHERE ${fkCondition} AND NOT (${nestedCondition}))`);
+};
+const appendRelationWhereClause = (input) => {
+	const { parentAlias, relationName, value } = input;
+	if (!parentAlias) throw new Error("parentAlias is required for relation where filters");
+	const filters = parseRelationFilters(relationName, value);
+	for (const filter of filters) appendRelationFilterClause({
+		...input,
+		...filter,
+		parentAlias
+	});
+};
+const appendWhereClause = (input) => {
+	const { clauses, params, nextPlaceholder, table, jsKey, value } = input;
+	if (!(jsKey in table.columns)) throw new Error(`Unknown where key "${jsKey}" on table ${table.sqlName}`);
+	const column = table.columns[jsKey];
+	if (!column) throw new Error(`Unknown where key "${jsKey}" on table ${table.sqlName}`);
+	const sqlName = quoteIdentifier(column.sqlName);
+	if (!isPlainObject(value)) {
+		appendDirectWhereClause({
+			clauses,
+			params,
+			nextPlaceholder,
+			column,
+			sqlName,
+			value
+		});
+		return;
+	}
+	appendOperatorWhereClauses({
+		clauses,
+		params,
+		nextPlaceholder,
+		column,
+		sqlName,
+		jsKey,
+		value
+	});
+};
+const buildWhereClause = (input) => {
+	const { where, relations, parentAlias } = input;
+	const clauses = [];
+	const params = [];
+	if (!where) return {
+		sql: "",
+		params
+	};
+	for (const [jsKey, value] of Object.entries(where)) {
+		if (value === void 0) continue;
+		const logicalWhereKey = getLogicalWhereKey(jsKey);
+		if (logicalWhereKey) {
+			appendLogicalWhereClause({
+				...input,
+				clauses,
+				params,
+				jsKey: logicalWhereKey,
+				value
+			});
+			continue;
+		}
+		const relation = relations?.[jsKey];
+		if (relation && isRelationFilterValue(value)) {
+			appendRelationWhereClause({
+				...input,
+				clauses,
+				params,
+				jsKey,
+				value,
+				relation,
+				relationName: jsKey,
+				parentAlias: parentAlias ?? quoteIdentifier(input.table.sqlName)
+			});
+			continue;
+		}
+		appendWhereClause({
+			...input,
+			clauses,
+			params,
+			jsKey,
+			value
+		});
+	}
+	return {
+		sql: clauses.join(` AND `),
+		params
+	};
+};
+const getLogicalWhereKey = (jsKey) => {
+	if (jsKey === "$and") return jsKey;
+	if (jsKey === "$not") return jsKey;
+	if (jsKey === "$or") return jsKey;
+	return null;
+};
+const getLogicalOperator = (jsKey) => {
+	if (jsKey === "$or") return "OR";
+	return "AND";
+};
+const getLogicalWhereValues = (jsKey, value) => {
+	if (jsKey === "$or" && !Array.isArray(value)) throw new Error("$or where value must be an array");
+	if (Array.isArray(value)) return value;
+	return [value];
+};
+const appendLogicalWhereClause = (input) => {
+	const { clauses, params, jsKey } = input;
+	const collected = collectLogicalWhereClauses(input);
+	if (typeof collected === "string") {
+		clauses.push(collected);
+		return;
+	}
+	if (!collected.nestedClauses.length) return;
+	params.push(...collected.nestedParams);
+	if (jsKey === "$not") {
+		const operator = "NOT";
+		const combinedNegatedClause = collected.nestedClauses.map((nestedClause) => `${operator} (${nestedClause})`).join(` AND `);
+		clauses.push(combinedNegatedClause);
+		return;
+	}
+	const operator = getLogicalOperator(jsKey);
+	clauses.push(`(${collected.nestedClauses.join(` ${operator} `)})`);
+};
+const collectLogicalWhereClauses = (input) => {
+	const { jsKey, value } = input;
+	const values = getLogicalWhereValues(jsKey, value);
+	const nestedClauses = [];
+	const nestedParams = [];
+	for (const nestedValue of values) {
+		if (!isPlainObject(nestedValue)) throw new Error(`${jsKey} where value must contain object filters`);
+		const nested = buildWhereClause({
+			...input,
+			where: nestedValue
+		});
+		if (!nested.sql) {
+			if (jsKey === "$or") return TRUE_WHERE_SQL;
+			continue;
+		}
+		nestedClauses.push(`(${nested.sql})`);
+		nestedParams.push(...nested.params);
+	}
+	if (jsKey === "$or" && !nestedClauses.length) return FALSE_WHERE_SQL;
+	return {
+		nestedClauses,
+		nestedParams
+	};
+};
+const getColumnAlias = (sqlName, jsKey) => {
+	return `${quoteIdentifier(sqlName)} AS ${quoteIdentifier(jsKey)}`;
+};
+const buildSelectColumns = (table, select) => {
+	if (!select || Object.keys(select).length === 0) return Object.entries(table.columns).map(([key, column]) => getColumnAlias(column.sqlName, key)).join(", ");
+	const selectedColumns = [];
+	const keys = Object.keys(select);
+	for (const key of keys) {
+		const column = table.columns[key];
+		if (!column) throw new Error(`Unknown select key "${key}" on table ${table.sqlName}`);
+		selectedColumns.push(getColumnAlias(column.sqlName, key));
+	}
+	return selectedColumns.join(", ");
+};
+const buildOrderByClause = (table, orderBy) => {
+	if (!orderBy) return "";
+	const clauses = [];
+	for (const [jsKey, direction] of Object.entries(orderBy)) {
+		const column = table.columns[jsKey];
+		if (!column) throw new Error(`Unknown orderBy key "${jsKey}" on table ${table.sqlName}`);
+		if (direction === "desc") {
+			clauses.push(`${quoteIdentifier(column.sqlName)} DESC`);
+			continue;
+		}
+		if (direction === "asc") {
+			clauses.push(`${quoteIdentifier(column.sqlName)} ASC`);
+			continue;
+		}
+		throw new Error(`Unknown orderBy direction "${direction}" for key "${jsKey}" on table ${table.sqlName}`);
+	}
+	if (!clauses.length) return "";
+	return clauses.join(", ");
+};
+const buildPaginationClause = (input) => {
+	const { spec, nextPlaceholder, take, skip } = input;
+	const params = [];
+	if (take === void 0) {
+		if (skip === void 0) return {
+			sql: "",
+			params
+		};
+		const skipPh = nextPlaceholder();
+		params.push(skip);
+		return {
+			sql: `${spec.unlimitedOffsetKeyword} ${skipPh}`,
+			params
+		};
+	}
+	const takePh = nextPlaceholder();
+	params.push(take);
+	if (skip === void 0) return {
+		sql: `LIMIT ${takePh}`,
+		params
+	};
+	const skipPh = nextPlaceholder();
+	params.push(skip);
+	return {
+		sql: `LIMIT ${takePh} OFFSET ${skipPh}`,
+		params
+	};
+};
+const buildSelectStatement = (input) => {
+	const { tableName, columns, where, orderBy, pagination } = input;
+	let query = `SELECT ${columns} FROM ${tableName}`;
+	if (where) query = `${query} WHERE ${where}`;
+	if (orderBy) query = `${query} ORDER BY ${orderBy}`;
+	if (pagination) query = `${query} ${pagination}`;
+	return query;
+};
+const validateFindUniqueWhere = (table, where) => {
+	const entries = Object.entries(where).filter(([, value]) => value !== void 0);
+	if (!entries.map(([key]) => key).length) throw new Error("findUnique requires at least one where key");
+	let hasUniqueKey = false;
+	for (const [key] of entries) {
+		const column = table.columns[key];
+		if (!column) throw new Error(`Unknown where key ${key} on table ${table.sqlName}`);
+		if (column._meta.isPrimaryKey || column._meta.isUnique) hasUniqueKey = true;
+	}
+	if (!hasUniqueKey) throw new Error("findUnique where must include at least one unique or primary key column");
+};
+const resolveCreateValue = (column, provided) => {
+	if (provided !== void 0) return provided;
+	if (column._default) return column._default();
+	return null;
+};
+const buildSetClauses = (input) => {
+	const { nextPlaceholder, table, data } = input;
+	const setClauses = [];
+	const params = [];
+	for (const [jsKey, value] of Object.entries(data)) {
+		if (value === void 0) continue;
+		const column = table.columns[jsKey];
+		if (!column) continue;
+		setClauses.push(`${quoteIdentifier(column.sqlName)} = ${nextPlaceholder()}`);
+		params.push(serializeColumnValue(column, value));
+	}
+	return {
+		setClauses,
+		params
+	};
+};
+//#endregion
+//#region src/lib/orm/dialect/relations.ts
+const buildJsonObjectExpression = (input) => {
+	const { spec, alias, table, extraPairs = [], select } = input;
+	const allEntries = Object.entries(table.columns);
+	const hasSelect = select !== void 0 && Object.keys(select).length > 0;
+	let visibleEntries = allEntries;
+	if (hasSelect) {
+		for (const key of Object.keys(select)) if (!(key in table.columns)) throw new Error(`Unknown select key "${key}" on table ${table.sqlName}`);
+		visibleEntries = allEntries.filter(([key]) => key in select);
+	}
+	const pairs = visibleEntries.flatMap(([jsKey, column]) => [`'${jsKey}'`, `${alias}.${quoteIdentifier(column.sqlName)}`]);
+	return `${spec.jsonObjectFunctionName}(${[...pairs, ...extraPairs].join(", ")})`;
+};
+const getRelationOptions = (includeValue) => {
+	let options = {};
+	if (typeof includeValue === "object" && includeValue !== null) options = includeValue;
+	return options;
+};
+const buildNestedIncludePairs = (input) => {
+	const { spec, nextPlaceholder, relationTable, relationAlias, tableRelationsMap, options } = input;
+	const nestedRelations = tableRelationsMap.get(relationTable) ?? {};
+	const nestedExtraPairs = [];
+	const nestedParams = [];
+	const nestedDescriptors = [];
+	if (!options.include) return {
+		nestedExtraPairs,
+		nestedParams,
+		nestedDescriptors
+	};
+	for (const [nestedName, nestedValue] of Object.entries(options.include)) {
+		if (!nestedValue) continue;
+		const nestedRelation = nestedRelations[nestedName];
+		if (!nestedRelation) throw new Error(`Unknown relation ${nestedName} on table ${relationTable.sqlName}`);
+		const result = buildRelationSubquery({
+			spec,
+			nextPlaceholder,
+			parentTable: relationTable,
+			parentAlias: relationAlias,
+			relation: nestedRelation,
+			relationName: nestedName,
+			includeValue: nestedValue,
+			tableRelationsMap
+		});
+		nestedExtraPairs.push(`'${nestedName}'`, result.sql);
+		nestedParams.push(...result.params);
+		nestedDescriptors.push(result.descriptor);
+	}
+	return {
+		nestedExtraPairs,
+		nestedParams,
+		nestedDescriptors
+	};
+};
+const joinWhereSql = (fkCondition, whereSql) => {
+	if (whereSql) return `${fkCondition} AND ${whereSql}`;
+	return fkCondition;
+};
+const buildNestedHasManySubquery = (input) => {
+	const { spec, relationTable, relationAlias, whereSql, orderBy, paginationSql, jsonObj } = input;
+	if (!orderBy && !paginationSql) return `SELECT ${spec.jsonArrayAggregateFunctionName}(${jsonObj}) FROM ${quoteIdentifier(relationTable.sqlName)} AS ${relationAlias} WHERE ${whereSql}`;
+	let innerQuery = `SELECT * FROM ${quoteIdentifier(relationTable.sqlName)} AS ${relationAlias} WHERE ${whereSql}`;
+	if (orderBy) innerQuery = `${innerQuery} ORDER BY ${orderBy}`;
+	if (paginationSql) innerQuery = `${innerQuery} ${paginationSql}`;
+	return `SELECT ${spec.jsonArrayAggregateFunctionName}(${jsonObj}) FROM (${innerQuery}) AS ${relationAlias}`;
+};
+const buildHasManyRelationSubquery = (input) => {
+	const { spec, parentTable, parentAlias, relationTable, relationAlias, relationName, jsonObj, nestedDescriptors, whereSql, orderBy, paginationSql, allParams } = input;
+	const { fk: foreignKey, source: sourceColumn } = resolveHasManyForeignKeyColumn(parentTable, relationTable);
+	return {
+		sql: `COALESCE((${buildNestedHasManySubquery({
+			spec,
+			relationTable,
+			relationAlias,
+			whereSql: joinWhereSql(`${relationAlias}.${quoteIdentifier(foreignKey.sqlName)} = ${parentAlias}.${quoteIdentifier(sourceColumn.sqlName)}`, whereSql),
+			orderBy,
+			paginationSql,
+			jsonObj
+		})}), ${spec.emptyJsonArrayLiteral})`,
+		params: allParams,
+		descriptor: {
+			name: relationName,
+			type: "hasMany",
+			table: relationTable,
+			nested: nestedDescriptors
+		}
+	};
+};
+const buildHasOneRelationSubquery = (input) => {
+	const { parentTable, parentAlias, relation, relationTable, relationAlias, relationName, jsonObj, nestedDescriptors, whereSql, allParams } = input;
+	if (relation._type !== "hasOne") throw new Error(`Expected hasOne relation for ${relationName}`);
+	const { localForeignKey, target } = resolveHasOneForeignKeyColumn({
+		sourceTable: parentTable,
+		relationTable,
+		relationForeignKey: relation._foreignKey
+	});
+	const combinedWhereSql = joinWhereSql(`${relationAlias}.${quoteIdentifier(target.sqlName)} = ${parentAlias}.${quoteIdentifier(localForeignKey.sqlName)}`, whereSql);
+	return {
+		sql: `(${`SELECT ${jsonObj} FROM ${quoteIdentifier(relationTable.sqlName)} AS ${relationAlias} WHERE ${combinedWhereSql} LIMIT 1`})`,
+		params: allParams,
+		descriptor: {
+			name: relationName,
+			type: "hasOne",
+			table: relationTable,
+			nested: nestedDescriptors
+		}
+	};
+};
+const buildRelationSubquery = (input) => {
+	const { spec, nextPlaceholder, relation, relationName } = input;
+	const options = getRelationOptions(input.includeValue);
+	const relationTable = relation._table;
+	const relationAlias = `${relationName}__${relationTable.sqlName}`;
+	const { nestedExtraPairs, nestedParams, nestedDescriptors } = buildNestedIncludePairs({
+		...input,
+		relationTable,
+		relationAlias,
+		options
+	});
+	const jsonObj = buildJsonObjectExpression({
+		spec,
+		alias: relationAlias,
+		table: relationTable,
+		extraPairs: nestedExtraPairs,
+		select: options.select
+	});
+	const where = buildWhereClause({
+		nextPlaceholder,
+		table: relationTable,
+		where: options.where
+	});
+	const orderBy = buildOrderByClause(relationTable, options.orderBy);
+	const pagination = buildPaginationClause({
+		spec,
+		nextPlaceholder,
+		take: options.take,
+		skip: options.skip
+	});
+	const allParams = [
+		...nestedParams,
+		...where.params,
+		...pagination.params
+	];
+	if (relation._type === "hasMany") return buildHasManyRelationSubquery({
+		...input,
+		relationTable,
+		relationAlias,
+		jsonObj,
+		nestedDescriptors,
+		whereSql: where.sql,
+		orderBy,
+		paginationSql: pagination.sql,
+		allParams
+	});
+	return buildHasOneRelationSubquery({
+		...input,
+		relationTable,
+		relationAlias,
+		jsonObj,
+		nestedDescriptors,
+		whereSql: where.sql,
+		allParams
+	});
+};
+const buildIncludeClause = (input) => {
+	const { spec, nextPlaceholder, table, parentAlias, relations, tableRelationsMap, include } = input;
+	if (!include) return EMPTY_INCLUDE;
+	const enabledRelations = Object.entries(include).filter(([, v]) => Boolean(v));
+	if (!enabledRelations.length) return EMPTY_INCLUDE;
+	const clauses = [];
+	const params = [];
+	const descriptors = [];
+	for (const [relationName, includeValue] of enabledRelations) {
+		const relation = relations[relationName];
+		if (!relation) throw new Error(`Unknown relation ${relationName} on table ${table.sqlName}`);
+		const result = buildRelationSubquery({
+			spec,
+			nextPlaceholder,
+			parentTable: table,
+			parentAlias,
+			relation,
+			relationName,
+			includeValue,
+			tableRelationsMap
+		});
+		clauses.push(`${result.sql} AS ${quoteIdentifier(relationName)}`);
+		params.push(...result.params);
+		descriptors.push(result.descriptor);
+	}
+	return {
+		sql: clauses.join(", "),
+		params,
+		descriptors
+	};
+};
+//#endregion
+//#region src/lib/orm/dialect/query-builder.ts
+var DialectQueryBuilder = class {
+	spec;
+	table;
+	relations;
+	tableRelationsMap;
+	constructor(input) {
+		this.spec = input.spec;
+		this.table = input.table;
+		this.relations = input.relations;
+		this.tableRelationsMap = input.tableRelationsMap ?? /* @__PURE__ */ new Map();
+	}
+	buildFindMany(options) {
+		const nextPlaceholder = createNextPlaceholder(this.spec);
+		const { include, where, selectColumns } = this.buildSelectIncludeWhere(nextPlaceholder, {
+			where: options?.where,
+			select: options?.select,
+			include: options?.include
+		});
+		const orderBy = buildOrderByClause(this.table, options?.orderBy);
+		const pagination = buildPaginationClause({
+			spec: this.spec,
+			nextPlaceholder,
+			take: options?.take,
+			skip: options?.skip
+		});
+		const params = [
+			...include.params,
+			...where.params,
+			...pagination.params
+		];
+		return {
+			statement: buildSelectStatement({
+				tableName: quoteIdentifier(this.table.sqlName),
+				columns: selectColumns,
+				where: where.sql,
+				orderBy,
+				pagination: pagination.sql
+			}),
+			params,
+			includeDescriptors: include.descriptors
+		};
+	}
+	buildFindFirst(options) {
+		return this.buildFindMany({
+			...options,
+			take: 1
+		});
+	}
+	buildFindUnique(options) {
+		validateFindUniqueWhere(this.table, options.where);
+		const nextPlaceholder = createNextPlaceholder(this.spec);
+		const { include, where, selectColumns } = this.buildSelectIncludeWhere(nextPlaceholder, {
+			where: options.where,
+			select: options.select,
+			include: options.include
+		});
+		return {
+			statement: buildSelectStatement({
+				tableName: quoteIdentifier(this.table.sqlName),
+				columns: selectColumns,
+				where: where.sql,
+				orderBy: "",
+				pagination: "LIMIT 1"
+			}),
+			params: [...include.params, ...where.params],
+			includeDescriptors: include.descriptors
+		};
+	}
+	buildCreate(options) {
+		const nextPlaceholder = createNextPlaceholder(this.spec);
+		const provided = new Map(Object.entries(options.data));
+		const sqlNames = [];
+		const placeholders = [];
+		const params = [];
+		for (const [jsKey, column] of Object.entries(this.table.columns)) {
+			const value = resolveCreateValue(column, provided.get(jsKey));
+			sqlNames.push(quoteIdentifier(column.sqlName));
+			placeholders.push(nextPlaceholder());
+			params.push(serializeColumnValue(column, value));
+		}
+		const columns = buildSelectColumns(this.table, options.select);
+		const include = this.buildInclude(nextPlaceholder, options.include);
+		const returning = buildSelectList(columns, include);
+		return {
+			statement: `INSERT INTO ${quoteIdentifier(this.table.sqlName)} (${sqlNames.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING ${returning}`,
+			params: [...params, ...include.params],
+			includeDescriptors: include.descriptors
+		};
+	}
+	buildUpdate(options) {
+		validateFindUniqueWhere(this.table, options.where);
+		const nextPlaceholder = createNextPlaceholder(this.spec);
+		const { setClauses, params } = buildSetClauses({
+			nextPlaceholder,
+			table: this.table,
+			data: options.data
+		});
+		if (!setClauses.length) throw new Error("update requires at least one field in data");
+		const { where, include, returning } = this.buildWhereIncludeReturning(nextPlaceholder, {
+			where: options.where,
+			select: options.select,
+			include: options.include
+		});
+		let statement = `UPDATE ${quoteIdentifier(this.table.sqlName)} SET ${setClauses.join(", ")}`;
+		if (where.sql) statement = `${statement} WHERE ${where.sql}`;
+		statement = `${statement} RETURNING ${returning}`;
+		params.push(...where.params, ...include.params);
+		return {
+			statement,
+			params,
+			includeDescriptors: include.descriptors
+		};
+	}
+	buildDelete(options) {
+		validateFindUniqueWhere(this.table, options.where);
+		const nextPlaceholder = createNextPlaceholder(this.spec);
+		const { where, include, returning } = this.buildWhereIncludeReturning(nextPlaceholder, {
+			where: options.where,
+			select: options.select,
+			include: options.include
+		});
+		let statement = `DELETE FROM ${quoteIdentifier(this.table.sqlName)}`;
+		if (where.sql) statement = `${statement} WHERE ${where.sql}`;
+		statement = `${statement} RETURNING ${returning}`;
+		return {
+			statement,
+			params: [...where.params, ...include.params],
+			includeDescriptors: include.descriptors
+		};
+	}
+	buildCreateMany(options) {
+		if (!options.data.length) return {
+			statement: "",
+			params: [],
+			includeDescriptors: []
+		};
+		const nextPlaceholder = createNextPlaceholder(this.spec);
+		const columnEntries = Object.entries(this.table.columns);
+		const sqlNames = columnEntries.map(([, col]) => {
+			return quoteIdentifier(col.sqlName);
+		});
+		const params = [];
+		const rowPlaceholders = [];
+		for (const row of options.data) {
+			const rowRecord = row;
+			const placeholders = [];
+			for (const [jsKey, column] of columnEntries) {
+				const value = resolveCreateValue(column, rowRecord[jsKey]);
+				placeholders.push(nextPlaceholder());
+				params.push(serializeColumnValue(column, value));
+			}
+			rowPlaceholders.push(`(${placeholders.join(", ")})`);
+		}
+		const returning = buildSelectColumns(this.table, void 0);
+		return {
+			statement: `INSERT INTO ${quoteIdentifier(this.table.sqlName)} (${sqlNames.join(", ")}) VALUES ${rowPlaceholders.join(", ")} RETURNING ${returning}`,
+			params,
+			includeDescriptors: []
+		};
+	}
+	buildUpdateMany(options) {
+		const nextPlaceholder = createNextPlaceholder(this.spec);
+		const { setClauses, params } = buildSetClauses({
+			nextPlaceholder,
+			table: this.table,
+			data: options.data
+		});
+		if (!setClauses.length) throw new Error("updateMany requires at least one field in data");
+		const where = buildWhereClause({
+			nextPlaceholder,
+			table: this.table,
+			where: options.where,
+			relations: this.relations,
+			parentAlias: quoteIdentifier(this.table.sqlName)
+		});
+		let statement = `UPDATE ${quoteIdentifier(this.table.sqlName)} SET ${setClauses.join(", ")}`;
+		if (where.sql) statement = `${statement} WHERE ${where.sql}`;
+		params.push(...where.params);
+		const returning = buildSelectColumns(this.table, void 0);
+		statement = `${statement} RETURNING ${returning}`;
+		return {
+			statement,
+			params,
+			includeDescriptors: []
+		};
+	}
+	buildDeleteMany(options) {
+		const where = buildWhereClause({
+			nextPlaceholder: createNextPlaceholder(this.spec),
+			table: this.table,
+			where: options.where,
+			relations: this.relations,
+			parentAlias: quoteIdentifier(this.table.sqlName)
+		});
+		let statement = `DELETE FROM ${quoteIdentifier(this.table.sqlName)}`;
+		if (where.sql) statement = `${statement} WHERE ${where.sql}`;
+		const returning = buildSelectColumns(this.table, void 0);
+		statement = `${statement} RETURNING ${returning}`;
+		return {
+			statement,
+			params: where.params,
+			includeDescriptors: []
+		};
+	}
+	buildInclude(nextPlaceholder, include) {
+		return buildIncludeClause({
+			spec: this.spec,
+			nextPlaceholder,
+			table: this.table,
+			parentAlias: quoteIdentifier(this.table.sqlName),
+			relations: this.relations,
+			tableRelationsMap: this.tableRelationsMap,
+			include
+		});
+	}
+	buildSelectIncludeWhere(nextPlaceholder, input) {
+		const include = this.buildInclude(nextPlaceholder, input.include);
+		return {
+			include,
+			where: buildWhereClause({
+				nextPlaceholder,
+				table: this.table,
+				where: input.where,
+				relations: this.relations,
+				parentAlias: quoteIdentifier(this.table.sqlName)
+			}),
+			selectColumns: buildSelectList(buildSelectColumns(this.table, input.select), include)
+		};
+	}
+	buildWhereIncludeReturning(nextPlaceholder, input) {
+		const where = buildWhereClause({
+			nextPlaceholder,
+			table: this.table,
+			where: input.where,
+			relations: this.relations,
+			parentAlias: quoteIdentifier(this.table.sqlName)
+		});
+		const columns = buildSelectColumns(this.table, input.select);
+		const include = this.buildInclude(nextPlaceholder, input.include);
+		return {
+			where,
+			include,
+			returning: buildSelectList(columns, include)
+		};
+	}
+};
+//#endregion
+//#region src/lib/orm/dialect/rows.ts
+const coerceBooleanValue = (val) => {
+	if (val === null) return val;
+	if (val === void 0) return val;
+	return Boolean(val);
+};
+const coerceRelationItems = (input) => {
+	const { value, table, nested } = input;
+	if (Array.isArray(value)) {
+		for (const item of value) if (typeof item === "object" && item !== null) coerceRow({
+			row: item,
+			table,
+			descriptors: nested
+		});
+		return;
+	}
+	if (typeof value === "object" && value !== null) coerceRow({
+		row: value,
+		table,
+		descriptors: nested
+	});
+};
+const getColumnKeysByType = (table) => {
+	const boolKeys = /* @__PURE__ */ new Set();
+	const jsonKeys = /* @__PURE__ */ new Set();
+	for (const [key, col] of Object.entries(table.columns)) {
+		if (col.type === "boolean") boolKeys.add(key);
+		if (col.type === "json") jsonKeys.add(key);
+		if (col.type === "jsonb") jsonKeys.add(key);
+	}
+	return {
+		boolKeys,
+		jsonKeys
+	};
+};
+const coerceColumnValues = (row, table) => {
+	const { boolKeys, jsonKeys } = getColumnKeysByType(table);
+	for (const key of boolKeys) if (key in row) row[key] = coerceBooleanValue(row[key]);
+	for (const key of jsonKeys) {
+		if (!(key in row)) continue;
+		const val = row[key];
+		if (typeof val !== "string") continue;
+		row[key] = JSON.parse(val);
+	}
+};
+const coerceRelationValue = (input) => {
+	const { row, descriptor } = input;
+	const value = row[descriptor.name];
+	if (value === null) {
+		if (descriptor.type === "hasMany") row[descriptor.name] = [];
+		return;
+	}
+	const nested = descriptor.nested ?? [];
+	if (typeof value === "string") {
+		const parsed = JSON.parse(value);
+		coerceRelationItems({
+			value: parsed,
+			table: descriptor.table,
+			nested
+		});
+		row[descriptor.name] = parsed;
+		return;
+	}
+	coerceRelationItems({
+		value,
+		table: descriptor.table,
+		nested
+	});
+};
+const coerceRelationValues = (row, descriptors) => {
+	for (const descriptor of descriptors) coerceRelationValue({
+		row,
+		descriptor
+	});
+};
+const coerceRow = (input) => {
+	const { row, table, descriptors } = input;
+	coerceColumnValues(row, table);
+	coerceRelationValues(row, descriptors);
+};
+const parseIncludeRows = (input) => {
+	const { table, rows, descriptors } = input;
+	for (const row of rows) coerceRow({
+		row,
+		table,
+		descriptors
+	});
+};
+const executeQuery = async (sql, table, query) => {
+	const rows = [...await sql.unsafe(query.statement, query.params)];
+	parseIncludeRows({
+		table,
+		rows,
+		descriptors: query.includeDescriptors
+	});
+	return rows;
+};
+//#endregion
+//#region src/lib/orm/dialect/shared.ts
+const createDialect = (input) => {
+	const { spec, table, relations, tableRelationsMap = /* @__PURE__ */ new Map() } = input;
+	const builder = new DialectQueryBuilder({
+		spec,
+		table,
+		relations,
+		tableRelationsMap
+	});
+	const executeAndUnwrap = async (sql, query, operation) => {
+		const [row] = await executeQuery(sql, table, query);
+		if (!row) throw new Error(`Record not found after ${operation} on table ${table.sqlName}`);
+		return row;
+	};
+	return {
+		name: spec.name,
+		findMany: async (sql, options) => {
+			return await executeQuery(sql, table, builder.buildFindMany(options));
+		},
+		findFirst: async (sql, options) => {
+			const [row] = await executeQuery(sql, table, builder.buildFindFirst(options));
+			return row ?? null;
+		},
+		findUnique: async (sql, options) => {
+			const [row] = await executeQuery(sql, table, builder.buildFindUnique(options));
+			return row ?? null;
+		},
+		create: async (sql, options) => {
+			return executeAndUnwrap(sql, builder.buildCreate(options), "insert");
+		},
+		createMany: async (sql, options) => {
+			if (!options.data.length) return [];
+			return await executeQuery(sql, table, builder.buildCreateMany(options));
+		},
+		update: async (sql, options) => {
+			return executeAndUnwrap(sql, builder.buildUpdate(options), "update");
+		},
+		updateMany: async (sql, options) => {
+			return await executeQuery(sql, table, builder.buildUpdateMany(options));
+		},
+		delete: async (sql, options) => {
+			return executeAndUnwrap(sql, builder.buildDelete(options), "delete");
+		},
+		deleteMany: async (sql, options) => {
+			return await executeQuery(sql, table, builder.buildDeleteMany(options));
+		}
+	};
+};
+//#endregion
+//#region src/lib/orm/dialect/postgres.ts
+const POSTGRES_SPEC = {
+	name: "postgres",
+	formatPlaceholder: (index) => `$${index}`,
+	unlimitedOffsetKeyword: "LIMIT ALL OFFSET",
+	jsonObjectFunctionName: "jsonb_build_object",
+	jsonArrayAggregateFunctionName: "jsonb_agg",
+	emptyJsonArrayLiteral: "'[]'::jsonb"
+};
+const createPostgresDialect = (input) => createDialect({
+	spec: POSTGRES_SPEC,
+	...input
+});
+//#endregion
+//#region src/lib/orm/dialect/sqlite.ts
+const SQLITE_SPEC = {
+	name: "sqlite",
+	formatPlaceholder: () => "?",
+	unlimitedOffsetKeyword: "LIMIT -1 OFFSET",
+	jsonObjectFunctionName: "json_object",
+	jsonArrayAggregateFunctionName: "json_group_array",
+	emptyJsonArrayLiteral: "'[]'"
+};
+const createSqliteDialect = (input) => createDialect({
+	spec: SQLITE_SPEC,
+	...input
+});
+//#endregion
+//#region src/lib/orm/dialect/index.ts
+const getDialect = (input) => {
+	const { adapter, table, relations, tableRelationsMap = /* @__PURE__ */ new Map() } = input;
+	switch (adapter) {
+		case "sqlite": return createSqliteDialect({
+			table,
+			relations,
+			tableRelationsMap
+		});
+		case "postgres": return createPostgresDialect({
+			table,
+			relations,
+			tableRelationsMap
+		});
+		default: throw new Error(`Unsupported adapter: ${adapter}`);
+	}
+};
+//#endregion
+//#region src/lib/orm/orm/index.ts
+const many = (table) => {
+	return {
+		_type: "hasMany",
+		_table: table()
+	};
+};
+const one = (foreignKey, table) => {
+	return {
+		_type: "hasOne",
+		_table: table(),
+		_foreignKey: foreignKey
+	};
+};
+const shouldSkipHooks = (options) => {
+	return options?.$skipHooks === true;
+};
+const withoutSkipHooks = (options) => {
+	const { $skipHooks, ...queryOptions } = options;
+	return queryOptions;
+};
+const toHookOptions = (options) => {
+	if (!options) return;
+	return withoutSkipHooks(options);
+};
+const pickGlobalHooks = (hooksConfig) => {
+	const { tables, ...globalHooks } = hooksConfig;
+	return globalHooks;
+};
+const runHook = async (hook, ctx) => {
+	await hook?.(ctx);
+};
+const runReadHooks = async (globalHook, tableHook, ctx) => {
+	await runHook(globalHook, ctx);
+	await runHook(tableHook, ctx);
+};
+const withReadHooks = async (input) => {
+	const beforeCtx = {
+		tableName: input.tableName,
+		table: input.table,
+		options: input.hookOptions
+	};
+	if (!input.skipHooks) await runReadHooks(input.beforeGlobal, input.beforeTable, beforeCtx);
+	const result = await input.query();
+	if (!input.skipHooks) await runReadHooks(input.afterGlobal, input.afterTable, {
+		...beforeCtx,
+		result
+	});
+	return result;
+};
+const createTableClient = (input) => {
+	const { sql, tableName, table, adapter, relations, tableRelationsMap, globalHooks, tableHooks } = input;
+	const dialect = getDialect({
+		adapter,
+		table,
+		relations,
+		tableRelationsMap
+	});
+	return {
+		findMany: async (options) => {
+			const skipHooks = shouldSkipHooks(options);
+			const hookOptions = toHookOptions(options);
+			return withReadHooks({
+				skipHooks,
+				tableName,
+				table,
+				hookOptions,
+				beforeGlobal: globalHooks?.beforeFindMany,
+				beforeTable: tableHooks?.beforeFindMany,
+				afterGlobal: globalHooks?.afterFindMany,
+				afterTable: tableHooks?.afterFindMany,
+				query: () => dialect.findMany(sql, hookOptions)
+			});
+		},
+		findFirst: async (options) => {
+			const skipHooks = shouldSkipHooks(options);
+			const hookOptions = toHookOptions(options);
+			return withReadHooks({
+				skipHooks,
+				tableName,
+				table,
+				hookOptions,
+				beforeGlobal: globalHooks?.beforeFindFirst,
+				beforeTable: tableHooks?.beforeFindFirst,
+				afterGlobal: globalHooks?.afterFindFirst,
+				afterTable: tableHooks?.afterFindFirst,
+				query: () => dialect.findFirst(sql, hookOptions)
+			});
+		},
+		findUnique: async (options) => {
+			const skipHooks = shouldSkipHooks(options);
+			const hookOptions = withoutSkipHooks(options);
+			return withReadHooks({
+				skipHooks,
+				tableName,
+				table,
+				hookOptions,
+				beforeGlobal: globalHooks?.beforeFindUnique,
+				beforeTable: tableHooks?.beforeFindUnique,
+				afterGlobal: globalHooks?.afterFindUnique,
+				afterTable: tableHooks?.afterFindUnique,
+				query: () => dialect.findUnique(sql, hookOptions)
+			});
+		},
+		create: async (options) => {
+			const skipHooks = shouldSkipHooks(options);
+			const hookOptions = withoutSkipHooks(options);
+			let queryOptions = hookOptions;
+			if (!skipHooks) {
+				const createHookResult = await globalHooks?.beforeCreate?.({
+					tableName,
+					table,
+					options: hookOptions
+				});
+				queryOptions = {
+					...hookOptions,
+					...createHookResult
+				};
+				const tableCreateHookResult = await tableHooks?.beforeCreate?.({
+					tableName,
+					table,
+					options: queryOptions
+				});
+				queryOptions = {
+					...queryOptions,
+					...tableCreateHookResult
+				};
+			}
+			const result = await dialect.create(sql, queryOptions);
+			if (!skipHooks) await runReadHooks(globalHooks?.afterCreate, tableHooks?.afterCreate, {
+				tableName,
+				table,
+				options: queryOptions,
+				result
+			});
+			return result;
+		},
+		createMany: async (options) => {
+			const skipHooks = shouldSkipHooks(options);
+			const hookOptions = withoutSkipHooks(options);
+			let queryOptions = hookOptions;
+			if (!skipHooks) {
+				const createManyHookResult = await globalHooks?.beforeCreateMany?.({
+					tableName,
+					table,
+					options: hookOptions
+				});
+				queryOptions = {
+					...hookOptions,
+					...createManyHookResult
+				};
+				const tableCreateManyHookResult = await tableHooks?.beforeCreateMany?.({
+					tableName,
+					table,
+					options: queryOptions
+				});
+				queryOptions = {
+					...queryOptions,
+					...tableCreateManyHookResult
+				};
+			}
+			const result = await dialect.createMany(sql, queryOptions);
+			if (!skipHooks) {
+				const hookCtx = {
+					tableName,
+					table,
+					options: queryOptions,
+					result
+				};
+				await runHook(globalHooks?.afterCreateMany, hookCtx);
+				await runHook(tableHooks?.afterCreateMany, hookCtx);
+			}
+			return result;
+		},
+		update: async (options) => {
+			const skipHooks = shouldSkipHooks(options);
+			const hookOptions = withoutSkipHooks(options);
+			let queryOptions = hookOptions;
+			if (!skipHooks) {
+				const updateHookResult = await globalHooks?.beforeUpdate?.({
+					tableName,
+					table,
+					options: hookOptions
+				});
+				queryOptions = {
+					...hookOptions,
+					...updateHookResult
+				};
+				const tableUpdateHookResult = await tableHooks?.beforeUpdate?.({
+					tableName,
+					table,
+					options: queryOptions
+				});
+				queryOptions = {
+					...queryOptions,
+					...tableUpdateHookResult
+				};
+			}
+			const result = await dialect.update(sql, queryOptions);
+			if (!skipHooks) await runReadHooks(globalHooks?.afterUpdate, tableHooks?.afterUpdate, {
+				tableName,
+				table,
+				options: queryOptions,
+				result
+			});
+			return result;
+		},
+		updateMany: async (options) => {
+			const skipHooks = shouldSkipHooks(options);
+			const hookOptions = withoutSkipHooks(options);
+			let queryOptions = hookOptions;
+			if (!skipHooks) {
+				const updateManyHookResult = await globalHooks?.beforeUpdateMany?.({
+					tableName,
+					table,
+					options: hookOptions
+				});
+				queryOptions = {
+					...hookOptions,
+					...updateManyHookResult
+				};
+				const tableUpdateManyHookResult = await tableHooks?.beforeUpdateMany?.({
+					tableName,
+					table,
+					options: queryOptions
+				});
+				queryOptions = {
+					...queryOptions,
+					...tableUpdateManyHookResult
+				};
+			}
+			const result = await dialect.updateMany(sql, queryOptions);
+			if (!skipHooks) {
+				const hookCtx = {
+					tableName,
+					table,
+					options: queryOptions,
+					result
+				};
+				await runHook(globalHooks?.afterUpdateMany, hookCtx);
+				await runHook(tableHooks?.afterUpdateMany, hookCtx);
+			}
+			return result;
+		},
+		delete: async (options) => {
+			const skipHooks = shouldSkipHooks(options);
+			const hookOptions = withoutSkipHooks(options);
+			let queryOptions = hookOptions;
+			if (!skipHooks) {
+				const deleteHookResult = await globalHooks?.beforeDelete?.({
+					tableName,
+					table,
+					options: hookOptions
+				});
+				queryOptions = {
+					...hookOptions,
+					...deleteHookResult
+				};
+				const tableDeleteHookResult = await tableHooks?.beforeDelete?.({
+					tableName,
+					table,
+					options: queryOptions
+				});
+				queryOptions = {
+					...queryOptions,
+					...tableDeleteHookResult
+				};
+			}
+			const result = await dialect.delete(sql, queryOptions);
+			if (!skipHooks) await runReadHooks(globalHooks?.afterDelete, tableHooks?.afterDelete, {
+				tableName,
+				table,
+				options: queryOptions,
+				result
+			});
+			return result;
+		},
+		deleteMany: async (options) => {
+			const skipHooks = shouldSkipHooks(options);
+			const hookOptions = withoutSkipHooks(options);
+			let queryOptions = hookOptions;
+			if (!skipHooks) {
+				const deleteManyHookResult = await globalHooks?.beforeDeleteMany?.({
+					tableName,
+					table,
+					options: hookOptions
+				});
+				queryOptions = {
+					...hookOptions,
+					...deleteManyHookResult
+				};
+				const tableDeleteManyHookResult = await tableHooks?.beforeDeleteMany?.({
+					tableName,
+					table,
+					options: queryOptions
+				});
+				queryOptions = {
+					...queryOptions,
+					...tableDeleteManyHookResult
+				};
+			}
+			const result = await dialect.deleteMany(sql, queryOptions);
+			if (!skipHooks) {
+				const hookCtx = {
+					tableName,
+					table,
+					options: queryOptions,
+					result
+				};
+				await runHook(globalHooks?.afterDeleteMany, hookCtx);
+				await runHook(tableHooks?.afterDeleteMany, hookCtx);
+			}
+			return result;
+		}
+	};
+};
+const toObjectEntries = (object) => {
+	const result = [];
+	for (const key in object) {
+		if (!Object.hasOwn(object, key)) continue;
+		result.push([key, object[key]]);
+	}
+	return result;
+};
+const getTableRelations = (relations, tableName) => {
+	if (!relations) return Object.create(null);
+	if (!Object.hasOwn(relations, tableName)) return Object.create(null);
+	const tableRelations = relations[tableName];
+	if (!tableRelations) return Object.create(null);
+	return tableRelations;
+};
+const buildTableClients = (input) => {
+	const { tables, relations, sql, adapter, tableRelationsMap, hooks } = input;
+	const clients = Object.create(null);
+	for (const entry of toObjectEntries(tables)) {
+		const setTableClient = (tableName, table) => {
+			const tableRelations = getTableRelations(relations, tableName);
+			tableRelationsMap.set(table, tableRelations);
+			clients[tableName] = createTableClient({
+				sql,
+				tableName,
+				table,
+				adapter,
+				relations: tableRelations,
+				tableRelationsMap,
+				globalHooks: hooks ? pickGlobalHooks(hooks) : void 0,
+				tableHooks: hooks?.tables?.[tableName]
+			});
+		};
+		setTableClient(entry[0], entry[1]);
+	}
+	return clients;
+};
+const buildOrmClient = (input) => {
+	const { tableClients, sql, transaction } = input;
+	return {
+		...tableClients,
+		$raw: sql,
+		$transaction: transaction
+	};
+};
+const buildTransactionClient = (tableClients, sql) => ({
+	...tableClients,
+	$raw: sql
+});
+const createOrm = (options) => {
+	const sql = new Bun.SQL(options.url, { adapter: options.adapter });
+	const tableRelationsMap = /* @__PURE__ */ new Map();
+	return buildOrmClient({
+		tableClients: buildTableClients({
+			tables: options.tables,
+			relations: options.relations,
+			sql,
+			adapter: options.adapter,
+			tableRelationsMap,
+			hooks: options.hooks
+		}),
+		sql,
+		transaction: async (callback) => {
+			return await sql.begin(async (txSql) => {
+				return await callback(buildTransactionClient(buildTableClients({
+					tables: options.tables,
+					relations: options.relations,
+					sql: txSql,
+					adapter: options.adapter,
+					tableRelationsMap,
+					hooks: options.hooks
+				}), txSql));
+			});
+		}
+	});
+};
+//#endregion
+//#region src/lib/orm/table/index.ts
+const defineTable = (sqlName, columns) => {
+	return {
+		sqlName,
+		columns
+	};
+};
+//#endregion
+exports.boolean = boolean;
+exports.createOrm = createOrm;
+exports.date = date;
+exports.defineTable = defineTable;
+exports.enumType = enumType;
+exports.json = json;
+exports.jsonb = jsonb;
+exports.many = many;
+exports.number = number;
+exports.one = one;
+exports.string = string;
+exports.uuid = uuid;