@danceroutine/tango-orm 0.1.0 → 1.0.0

package/dist/query-wnl4h2o7.js

@@ -0,0 +1,671 @@
+import { __export } from "./chunk-DLY2FNSh.js";
+import { SqlSafetyEngine } from "@danceroutine/tango-core";
+
+//#region src/query/domain/internal/InternalDialect.ts
+const InternalDialect = {
+	POSTGRES: "postgres",
+	SQLITE: "sqlite"
+};
+
+//#endregion
+//#region src/query/domain/internal/InternalQNodeType.ts
+const InternalQNodeType = {
+	ATOM: "atom",
+	AND: "and",
+	OR: "or",
+	NOT: "not"
+};
+
+//#endregion
+//#region src/query/domain/internal/InternalLookupType.ts
+const InternalLookupType = {
+	EXACT: "exact",
+	LT: "lt",
+	LTE: "lte",
+	GT: "gt",
+	GTE: "gte",
+	IN: "in",
+	ISNULL: "isnull",
+	CONTAINS: "contains",
+	ICONTAINS: "icontains",
+	STARTSWITH: "startswith",
+	ISTARTSWITH: "istartswith",
+	ENDSWITH: "endswith",
+	IENDSWITH: "iendswith"
+};
+
+//#endregion
+//#region src/validation/OrmSqlSafetyAdapter.ts
+const ALLOWED_LOOKUPS = Object.values(InternalLookupType);
+var OrmSqlSafetyAdapter = class OrmSqlSafetyAdapter {
+	static BRAND = "tango.orm.orm_sql_safety_adapter";
+	__tangoBrand = OrmSqlSafetyAdapter.BRAND;
+	constructor(engine = new SqlSafetyEngine()) {
+		this.engine = engine;
+	}
+	validate(plan) {
+		switch (plan.kind) {
+			case "select": {
+				const meta = this.validateTableMeta(plan.meta, plan.relationNames ?? []);
+				return {
+					kind: "select",
+					meta,
+					selectFields: Object.fromEntries((plan.selectFields ?? []).map((field) => [field, `${meta.table}.${this.resolveColumn(meta, field)}`])),
+					filterKeys: Object.fromEntries((plan.filterKeys ?? []).map((rawKey) => [rawKey, this.validateFilterKey(meta, rawKey)])),
+					orderFields: Object.fromEntries((plan.orderFields ?? []).map((field) => [field, `${meta.table}.${this.resolveColumn(meta, field)}`])),
+					relations: Object.fromEntries((plan.relationNames ?? []).map((relationName) => [relationName, this.resolveRelation(meta, relationName)]))
+				};
+			}
+			case "insert": {
+				const meta = this.validateTableMeta(plan.meta);
+				return {
+					kind: "insert",
+					meta,
+					writeKeys: plan.writeKeys.map((key) => this.resolveColumn(meta, key))
+				};
+			}
+			case "update": {
+				const meta = this.validateTableMeta(plan.meta);
+				return {
+					kind: "update",
+					meta,
+					writeKeys: plan.writeKeys.map((key) => this.resolveColumn(meta, key))
+				};
+			}
+			case "delete": return {
+				kind: "delete",
+				meta: this.validateTableMeta(plan.meta)
+			};
+		}
+	}
+	validateTableMeta(meta, relationNames = []) {
+		const columnNames = Object.keys(meta.columns);
+		const validated = this.engine.validate({ identifiers: [
+			{
+				key: "table",
+				role: "table",
+				value: meta.table
+			},
+			{
+				key: "pk",
+				role: "primaryKey",
+				value: meta.pk,
+				allowlist: columnNames
+			},
+			...columnNames.map((column) => ({
+				key: `column:${column}`,
+				role: "column",
+				value: column
+			}))
+		] });
+		const validatedMeta = {
+			table: validated.identifiers.table.value,
+			pk: validated.identifiers.pk.value,
+			columns: Object.fromEntries(columnNames.map((column) => [validated.identifiers[`column:${column}`].value, meta.columns[column]]))
+		};
+		if (!(validatedMeta.pk in validatedMeta.columns)) throw new Error(`Unknown column '${validatedMeta.pk}' for table '${validatedMeta.table}'.`);
+		if (relationNames.length > 0) validatedMeta.relations = Object.fromEntries(relationNames.map((relationName) => [relationName, this.validateRelationMeta(validatedMeta, relationName, meta.relations)]));
+		return validatedMeta;
+	}
+	validateRelationMeta(meta, relationName, relations) {
+		const relation = relations?.[relationName];
+		if (!relation) throw new Error(`Unknown relation '${relationName}' for table '${meta.table}'.`);
+		const validated = this.engine.validate({ identifiers: [
+			{
+				key: "table",
+				role: "relationTable",
+				value: relation.table
+			},
+			{
+				key: "alias",
+				role: "alias",
+				value: relation.alias
+			},
+			{
+				key: "targetPk",
+				role: "relationTargetPrimaryKey",
+				value: relation.targetPk
+			},
+			...relation.foreignKey ? [{
+				key: "foreignKey",
+				role: "relationForeignKey",
+				value: relation.foreignKey
+			}] : []
+		] });
+		return {
+			...relation,
+			table: validated.identifiers.table.value,
+			alias: validated.identifiers.alias.value,
+			targetPk: validated.identifiers.targetPk.value,
+			localKey: relation.localKey ? this.resolveColumn(meta, relation.localKey) : undefined,
+			foreignKey: relation.foreignKey ? validated.identifiers.foreignKey.value : undefined
+		};
+	}
+	validateFilterKey(meta, rawKey) {
+		const segments = rawKey.split("__");
+		if (segments.length > 2) throw new Error(`Invalid SQL lookup key: '${rawKey}'.`);
+		const field = segments[0];
+		const lookup = segments[1] ?? InternalLookupType.EXACT;
+		const validated = this.engine.validate({ lookupTokens: [{
+			key: rawKey,
+			lookup,
+			allowed: ALLOWED_LOOKUPS
+		}] });
+		return {
+			rawKey,
+			field,
+			lookup: validated.lookupTokens[rawKey].lookup,
+			qualifiedColumn: `${meta.table}.${this.resolveColumn(meta, field)}`
+		};
+	}
+	resolveColumn(meta, field) {
+		if (!(field in meta.columns)) throw new Error(`Unknown column '${field}' for table '${meta.table}'.`);
+		return field;
+	}
+	resolveRelation(meta, relationName) {
+		const relation = meta.relations?.[relationName];
+		if (!relation) throw new Error(`Unknown relation '${relationName}' for table '${meta.table}'.`);
+		if (relation.kind === "belongsTo" && !relation.localKey) throw new Error(`Relation '${relationName}' for table '${meta.table}' requires a local key.`);
+		return relation;
+	}
+};
+
+//#endregion
+//#region src/query/compiler/QueryCompiler.ts
+const sqlSafetyAdapter = new OrmSqlSafetyAdapter();
+var QueryCompiler = class QueryCompiler {
+	static BRAND = "tango.orm.query_compiler";
+	__tangoBrand = QueryCompiler.BRAND;
+	/**
+	* Build a compiler for the given repository metadata and SQL dialect.
+	*/
+	constructor(meta, dialect = InternalDialect.POSTGRES) {
+		this.meta = meta;
+		this.dialect = dialect;
+	}
+	/**
+	* Narrow an unknown value to `QueryCompiler`.
+	*/
+	static isQueryCompiler(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === QueryCompiler.BRAND;
+	}
+	/**
+	* Compile a query state tree into a SQL statement and bound parameters.
+	*/
+	compile(state) {
+		const knownRelationNames = (state.selectRelated ?? []).filter((relationName) => this.meta.relations?.[relationName] !== undefined);
+		const validatedPlan = sqlSafetyAdapter.validate({
+			kind: "select",
+			meta: this.meta,
+			selectFields: state.select?.map(String),
+			filterKeys: this.collectStateFilterKeys(state),
+			orderFields: state.order?.map((order) => String(order.by)),
+			relationNames: knownRelationNames
+		});
+		const table = validatedPlan.meta.table;
+		const whereParts = [];
+		const params = [];
+		if (state.q) {
+			const result = this.compileQNode(state.q, params.length + 1, validatedPlan.filterKeys);
+			if (result.sql) {
+				whereParts.push(result.sql);
+				params.push(...result.params);
+			}
+		}
+		state.excludes?.forEach((exclude) => {
+			const result = this.compileQNode({
+				kind: InternalQNodeType.NOT,
+				node: exclude
+			}, params.length + 1, validatedPlan.filterKeys);
+			if (result.sql) {
+				whereParts.push(result.sql);
+				params.push(...result.params);
+			}
+		});
+		const select = state.select?.length ? state.select.map((field) => validatedPlan.selectFields[String(field)]).join(", ") : `${table}.*`;
+		const joins = knownRelationNames.map((rel) => {
+			const relation = validatedPlan.relations[rel];
+			if (!relation || relation.kind !== "belongsTo") return "";
+			return `LEFT JOIN ${relation.table} ${relation.alias} ON ${relation.alias}.${relation.targetPk} = ${table}.${relation.localKey}`;
+		}).filter(Boolean).join(" ");
+		const whereSQL = whereParts.length ? ` WHERE ${whereParts.join(" AND ")}` : "";
+		const orderSQL = ` ORDER BY ${state.order?.length ? state.order.map((order) => `${validatedPlan.orderFields[String(order.by)]} ${order.dir.toUpperCase()}`).join(", ") : `${table}.${validatedPlan.meta.pk} ASC`}`;
+		const limitSQL = state.limit ? ` LIMIT ${state.limit}` : "";
+		const offsetSQL = state.offset ? ` OFFSET ${state.offset}` : "";
+		const sql = `SELECT ${select} FROM ${table}${joins ? ` ${joins}` : ""}${whereSQL}${orderSQL}${limitSQL}${offsetSQL}`;
+		return {
+			sql,
+			params
+		};
+	}
+	compileQNode(node, paramIndex, filterKeys) {
+		switch (node.kind) {
+			case InternalQNodeType.ATOM: return this.compileAtom(node.where || {}, paramIndex, filterKeys);
+			case InternalQNodeType.AND: return this.compileAnd(node.nodes || [], paramIndex, filterKeys);
+			case InternalQNodeType.OR: return this.compileOr(node.nodes || [], paramIndex, filterKeys);
+			case InternalQNodeType.NOT: return this.compileNot(node.node, paramIndex, filterKeys);
+			default: return {
+				sql: "",
+				params: []
+			};
+		}
+	}
+	compileAtom(where, paramIndex, filterKeys) {
+		const entries = Object.entries(where).filter(([, value]) => value !== undefined);
+		const { parts, params } = entries.reduce((accumulator, [key, value]) => {
+			const descriptor = filterKeys[String(key)];
+			const idx = paramIndex + accumulator.params.length;
+			const clause = this.lookupToSQL(descriptor.qualifiedColumn, descriptor.lookup, value, idx);
+			accumulator.parts.push(clause.sql);
+			accumulator.params.push(...clause.params);
+			return accumulator;
+		}, {
+			parts: [],
+			params: []
+		});
+		return {
+			sql: parts.length ? `(${parts.join(" AND ")})` : "",
+			params
+		};
+	}
+	compileAnd(nodes, paramIndex, filterKeys) {
+		const { parts, params } = nodes.reduce((accumulator, node) => {
+			const result = this.compileQNode(node, paramIndex + accumulator.params.length, filterKeys);
+			if (result.sql) {
+				accumulator.parts.push(result.sql);
+				accumulator.params.push(...result.params);
+			}
+			return accumulator;
+		}, {
+			parts: [],
+			params: []
+		});
+		return {
+			sql: parts.length ? `(${parts.join(" AND ")})` : "",
+			params
+		};
+	}
+	compileOr(nodes, paramIndex, filterKeys) {
+		const { parts, params } = nodes.reduce((accumulator, node) => {
+			const result = this.compileQNode(node, paramIndex + accumulator.params.length, filterKeys);
+			if (result.sql) {
+				accumulator.parts.push(result.sql);
+				accumulator.params.push(...result.params);
+			}
+			return accumulator;
+		}, {
+			parts: [],
+			params: []
+		});
+		return {
+			sql: parts.length ? `(${parts.join(" OR ")})` : "",
+			params
+		};
+	}
+	compileNot(node, paramIndex, filterKeys) {
+		const result = this.compileQNode(node, paramIndex, filterKeys);
+		if (!result.sql) return {
+			sql: "",
+			params: []
+		};
+		return {
+			sql: `(NOT ${result.sql})`,
+			params: result.params
+		};
+	}
+	lookupToSQL(col, lookup, value, paramIndex) {
+		const placeholder = this.dialect === InternalDialect.POSTGRES ? `$${paramIndex}` : "?";
+		const normalized = this.normalizeParam(value);
+		switch (lookup) {
+			case InternalLookupType.EXACT:
+				if (value === null) return {
+					sql: `${col} IS NULL`,
+					params: []
+				};
+				return {
+					sql: `${col} = ${placeholder}`,
+					params: [normalized]
+				};
+			case InternalLookupType.LT: return {
+				sql: `${col} < ${placeholder}`,
+				params: [normalized]
+			};
+			case InternalLookupType.LTE: return {
+				sql: `${col} <= ${placeholder}`,
+				params: [normalized]
+			};
+			case InternalLookupType.GT: return {
+				sql: `${col} > ${placeholder}`,
+				params: [normalized]
+			};
+			case InternalLookupType.GTE: return {
+				sql: `${col} >= ${placeholder}`,
+				params: [normalized]
+			};
+			case InternalLookupType.IN: {
+				const entries = (Array.isArray(value) ? value : [value]).map((entry) => this.normalizeParam(entry));
+				if (entries.length === 0) return {
+					sql: "1=0",
+					params: []
+				};
+				const placeholders = this.dialect === InternalDialect.POSTGRES ? entries.map((_, index) => `$${paramIndex + index}`).join(", ") : entries.map(() => "?").join(", ");
+				return {
+					sql: `${col} IN (${placeholders})`,
+					params: entries
+				};
+			}
+			case InternalLookupType.ISNULL: return {
+				sql: value ? `${col} IS NULL` : `${col} IS NOT NULL`,
+				params: []
+			};
+			case InternalLookupType.CONTAINS: return {
+				sql: `${col} LIKE ${placeholder}`,
+				params: [`%${value}%`]
+			};
+			case InternalLookupType.ICONTAINS: {
+				const lowerCol = this.dialect === InternalDialect.POSTGRES ? `LOWER(${col})` : `${col}`;
+				return {
+					sql: `${lowerCol} LIKE ${placeholder}`,
+					params: [`%${String(value).toLowerCase()}%`]
+				};
+			}
+			case InternalLookupType.STARTSWITH: return {
+				sql: `${col} LIKE ${placeholder}`,
+				params: [`${value}%`]
+			};
+			case InternalLookupType.ISTARTSWITH: {
+				const lowerCol = this.dialect === InternalDialect.POSTGRES ? `LOWER(${col})` : `${col}`;
+				return {
+					sql: `${lowerCol} LIKE ${placeholder}`,
+					params: [`${String(value).toLowerCase()}%`]
+				};
+			}
+			case InternalLookupType.ENDSWITH: return {
+				sql: `${col} LIKE ${placeholder}`,
+				params: [`%${value}`]
+			};
+			case InternalLookupType.IENDSWITH: {
+				const lowerCol = this.dialect === InternalDialect.POSTGRES ? `LOWER(${col})` : `${col}`;
+				return {
+					sql: `${lowerCol} LIKE ${placeholder}`,
+					params: [`%${String(value).toLowerCase()}`]
+				};
+			}
+			default: throw new Error(`Unknown lookup: ${lookup}`);
+		}
+	}
+	normalizeParam(value) {
+		if (this.dialect === InternalDialect.SQLITE && typeof value === "boolean") return value ? 1 : 0;
+		return value;
+	}
+	collectStateFilterKeys(state) {
+		const filterKeys = new Set();
+		if (state.q) this.collectNodeFilterKeys(state.q, filterKeys);
+		state.excludes?.forEach((exclude) => this.collectNodeFilterKeys(exclude, filterKeys));
+		return [...filterKeys];
+	}
+	collectNodeFilterKeys(node, filterKeys) {
+		Object.keys(node.where ?? {}).forEach((key) => filterKeys.add(key));
+		node.nodes?.forEach((child) => this.collectNodeFilterKeys(child, filterKeys));
+		if (node.node) this.collectNodeFilterKeys(node.node, filterKeys);
+	}
+};
+
+//#endregion
+//#region src/query/compiler/index.ts
+var compiler_exports = {};
+__export(compiler_exports, { QueryCompiler: () => QueryCompiler });
+
+//#endregion
+//#region src/query/domain/index.ts
+var domain_exports = {};
+
+//#endregion
+//#region src/query/domain/internal/InternalDirection.ts
+const InternalDirection = {
+	ASC: "asc",
+	DESC: "desc"
+};
+
+//#endregion
+//#region src/query/QBuilder.ts
+var QBuilder = class QBuilder {
+	static BRAND = "tango.orm.q_builder";
+	__tangoBrand = QBuilder.BRAND;
+	/**
+	* Narrow an unknown value to `QBuilder`.
+	*/
+	static isQBuilder(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === QBuilder.BRAND;
+	}
+	/**
+	* Combine multiple filter fragments using logical `AND`.
+	*/
+	static and(...nodes) {
+		return {
+			kind: InternalQNodeType.AND,
+			nodes: nodes.map(QBuilder.wrapNode)
+		};
+	}
+	/**
+	* Combine multiple filter fragments using logical `OR`.
+	*/
+	static or(...nodes) {
+		return {
+			kind: InternalQNodeType.OR,
+			nodes: nodes.map(QBuilder.wrapNode)
+		};
+	}
+	/**
+	* Negate a filter fragment using logical `NOT`.
+	*/
+	static not(node) {
+		return {
+			kind: InternalQNodeType.NOT,
+			node: QBuilder.wrapNode(node)
+		};
+	}
+	static wrapNode(input) {
+		if (input.kind) return input;
+		return {
+			kind: InternalQNodeType.ATOM,
+			where: input
+		};
+	}
+};
+
+//#endregion
+//#region src/query/QuerySet.ts
+var QuerySet = class QuerySet {
+	static BRAND = "tango.orm.query_set";
+	__tangoBrand = QuerySet.BRAND;
+	constructor(executor, state = {}) {
+		this.executor = executor;
+		this.state = state;
+	}
+	/**
+	* Narrow an unknown value to `QuerySet`.
+	*/
+	static isQuerySet(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === QuerySet.BRAND;
+	}
+	/**
+	* Add a filter expression to the query.
+	*
+	* Multiple `filter()` calls are composed with `AND`.
+	*/
+	filter(q) {
+		const wrapped = q.kind ? q : {
+			kind: InternalQNodeType.ATOM,
+			where: q
+		};
+		const merged = this.state.q ? QBuilder.and(this.state.q, wrapped) : wrapped;
+		return new QuerySet(this.executor, {
+			...this.state,
+			q: merged
+		});
+	}
+	/**
+	* Add an exclusion expression to the query.
+	*
+	* Exclusions are translated to `NOT (...)` predicates.
+	*/
+	exclude(q) {
+		const wrapped = q.kind ? q : {
+			kind: InternalQNodeType.ATOM,
+			where: q
+		};
+		const excludes = [...this.state.excludes ?? [], wrapped];
+		return new QuerySet(this.executor, {
+			...this.state,
+			excludes
+		});
+	}
+	/**
+	* Apply ordering tokens such as `'name'` or `'-createdAt'`.
+	*/
+	orderBy(...tokens) {
+		const order = tokens.map((t) => {
+			const str = String(t);
+			if (str.startsWith("-")) return {
+				by: str.slice(1),
+				dir: InternalDirection.DESC
+			};
+			return {
+				by: t,
+				dir: InternalDirection.ASC
+			};
+		});
+		return new QuerySet(this.executor, {
+			...this.state,
+			order
+		});
+	}
+	/**
+	* Limit the maximum number of rows returned.
+	*/
+	limit(n) {
+		return new QuerySet(this.executor, {
+			...this.state,
+			limit: n
+		});
+	}
+	/**
+	* Skip the first `n` rows.
+	*/
+	offset(n) {
+		return new QuerySet(this.executor, {
+			...this.state,
+			offset: n
+		});
+	}
+	/**
+	* Restrict selected columns.
+	*/
+	select(cols) {
+		return new QuerySet(this.executor, {
+			...this.state,
+			select: cols
+		});
+	}
+	/**
+	* Request SQL joins for related data when supported by relation metadata.
+	*/
+	selectRelated(...rels) {
+		return new QuerySet(this.executor, {
+			...this.state,
+			selectRelated: rels
+		});
+	}
+	/**
+	* Register relation names for prefetch behavior.
+	*
+	* Prefetch orchestration is adapter-specific.
+	*/
+	prefetchRelated(...rels) {
+		return new QuerySet(this.executor, {
+			...this.state,
+			prefetchRelated: rels
+		});
+	}
+	/**
+	* Execute the query and optionally shape each row.
+	*/
+	async fetch(shape) {
+		const compiler = new QueryCompiler(this.executor.meta, this.executor.dialect);
+		const compiled = compiler.compile(this.state);
+		const rows = await this.executor.run(compiled);
+		const normalizedRows = this.normalizeRowsForSchemaParsing(rows, shape);
+		const results = !shape ? normalizedRows : typeof shape === "function" ? normalizedRows.map(shape) : normalizedRows.map((r) => shape.parse(r));
+		return {
+			results,
+			nextCursor: null
+		};
+	}
+	/**
+	* Execute the query and return the first row, or `null`.
+	*/
+	async fetchOne(shape) {
+		const limited = this.limit(1);
+		const result = await limited.fetch(shape);
+		return result.results[0] ?? null;
+	}
+	/**
+	* Execute a `COUNT(*)` query for the current filtered state.
+	*/
+	async count() {
+		const compiler = new QueryCompiler(this.executor.meta, this.executor.dialect);
+		const compiled = compiler.compile(this.state);
+		const countQuery = `SELECT COUNT(*) as count FROM (${compiled.sql}) AS tango_count_subquery`;
+		const rows = await this.executor.client.query(countQuery, compiled.params);
+		return Number(rows.rows[0]?.count ?? 0);
+	}
+	/**
+	* Return whether at least one row matches the current query state.
+	*/
+	async exists() {
+		const count = await this.count();
+		return count > 0;
+	}
+	normalizeRowsForSchemaParsing(rows, shape) {
+		if (!shape || typeof shape === "function" || this.executor.dialect !== InternalDialect.SQLITE) return rows;
+		const booleanColumns = Object.entries(this.executor.meta.columns).filter(([, value]) => this.isBooleanColumnType(value)).map(([column]) => column);
+		if (booleanColumns.length === 0) return rows;
+		return rows.map((row) => this.normalizeBooleanColumns(row, booleanColumns));
+	}
+	isBooleanColumnType(value) {
+		return typeof value === "string" && ["bool", "boolean"].includes(value.trim().toLowerCase());
+	}
+	normalizeSqliteBoolean(value) {
+		if (value === 0 || value === "0") return false;
+		if (value === 1 || value === "1") return true;
+		return value;
+	}
+	normalizeBooleanColumns(row, columns) {
+		let normalized = null;
+		for (const column of columns) {
+			const current = row[column];
+			const next = this.normalizeSqliteBoolean(current);
+			if (next === current) continue;
+			if (!normalized) normalized = { ...row };
+			normalized[column] = next;
+		}
+		return normalized ?? row;
+	}
+};
+
+//#endregion
+//#region src/query/index.ts
+var query_exports = {};
+__export(query_exports, {
+	Q: () => QBuilder,
+	QBuilder: () => QBuilder,
+	QueryCompiler: () => QueryCompiler,
+	QuerySet: () => QuerySet,
+	compiler: () => compiler_exports,
+	domain: () => domain_exports
+});
+
+//#endregion
+export { OrmSqlSafetyAdapter, QBuilder, QueryCompiler, QuerySet, compiler_exports, domain_exports, query_exports };
+//# sourceMappingURL=query-wnl4h2o7.js.map