@rapiq/sql 2.0.0-beta.0

package/dist/index.mjs

@@ -0,0 +1,876 @@
+import { AdapterError, FieldOperator, Filter, FilterFieldOperator, FilterRegexFlag, Filters, ITSELF, createFilterRegex } from "@rapiq/core";
+//#region src/helpers/name-split.ts
+function splitFirst(input) {
+	const separatorIndex = input.indexOf(".");
+	if (separatorIndex === -1) return [input, ""];
+	return [input.substring(0, separatorIndex), input.substring(separatorIndex + 1)];
+}
+function splitLast(input) {
+	const separatorIndex = input.lastIndexOf(".");
+	if (separatorIndex === -1) return [input, ""];
+	return [input.substring(0, separatorIndex), input.substring(separatorIndex + 1)];
+}
+//#endregion
+//#region src/helpers/relation-alias.ts
+/**
+* The tightest identifier limit among the shipped dialect presets:
+* PostgreSQL truncates identifiers to 63 bytes (silently, with a
+* NOTICE), so an alias longer than that would lose its uniqueness
+* guarantee on the way into the database.
+*/
+const MAX_ALIAS_LENGTH = 63;
+/**
+* FNV-1a (32 bit) — deterministic, dependency-free disambiguator for
+* aliases that exceed the identifier limit.
+*/
+function hashPath(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+/**
+* Default join-alias derivation: every path segment is length-prefixed
+* (e.g. `role.realm` -> `r4_role_5_realm`). Unlike replacing dots with
+* underscores, this is injective even when relation names contain `_`.
+* Aliases that would exceed the database identifier limit are bounded:
+* a readable prefix plus a hash of the full path — otherwise engines
+* such as PostgreSQL would truncate them (silently collapsing long,
+* distinct paths onto one alias).
+*/
+function buildRelationAlias(path) {
+	const alias = `r${path.split(".").map((segment) => `${segment.length}_${segment}`).join("_")}`;
+	if (alias.length <= MAX_ALIAS_LENGTH) return alias;
+	const suffix = `_h${hashPath(path)}`;
+	return `${alias.substring(0, MAX_ALIAS_LENGTH - suffix.length)}${suffix}`;
+}
+//#endregion
+//#region src/helpers/field.ts
+function parseField(input, rootAlias, relationAlias = buildRelationAlias) {
+	const [relation, name] = splitLast(input);
+	if (!name) {
+		if (rootAlias) return {
+			prefix: rootAlias,
+			name: relation
+		};
+		return { name: relation };
+	}
+	return {
+		relation,
+		prefix: relationAlias(relation),
+		name
+	};
+}
+//#endregion
+//#region src/helpers/like.ts
+/**
+* Escape LIKE pattern wildcards (incl. the MSSQL bracket range)
+* so user input matches literally under `ESCAPE '\'`.
+*/
+function escapeLikePattern(input) {
+	return input.replace(/[\\%_[]/g, (character) => `\\${character}`);
+}
+//#endregion
+//#region src/helpers/param-placeholder-indexer.ts
+var ParamPlaceholderIndexer = class {
+	index;
+	constructor(index) {
+		this.index = index ?? 0;
+	}
+	next() {
+		this.index++;
+		return this.index;
+	}
+	reset() {
+		this.index = 0;
+	}
+};
+//#endregion
+//#region src/helpers/root-alias.ts
+function toRootAliasFn(input) {
+	if (typeof input === "function") return input;
+	return () => input;
+}
+function isRootAliasFn(input) {
+	return typeof input === "function";
+}
+//#endregion
+//#region src/adapter/fields/base.ts
+var FieldsBaseAdapter = class {
+	relations;
+	/**
+	* selection fields.
+	*
+	* e.g. ['name', 'project.id']
+	*/
+	value;
+	constructor(relations) {
+		this.relations = relations;
+		this.value = [];
+	}
+	clear() {
+		this.value = [];
+	}
+	add(input, operator) {
+		const name = this.buildField(input);
+		this.value.push({
+			name,
+			operator
+		});
+	}
+	/**
+	* Escaped selection columns (excluded fields are dropped).
+	*/
+	getColumns() {
+		const output = [];
+		for (let i = 0; i < this.value.length; i++) {
+			const element = this.value[i];
+			if (element.operator === FieldOperator.EXCLUDE) continue;
+			output.push(element.name);
+		}
+		return output;
+	}
+	buildField(input) {
+		const output = parseField(input, this.rootAlias(), (path) => this.relations.buildAlias(path));
+		if (output.relation) this.relations.add(output.relation);
+		if (output.prefix) return `${this.escapeField(output.prefix)}.${this.escapeField(output.name)}`;
+		return this.escapeField(output.name);
+	}
+};
+//#endregion
+//#region src/adapter/fields/module.ts
+var FieldsAdapter = class extends FieldsBaseAdapter {
+	options;
+	constructor(relations, options) {
+		super(relations);
+		this.options = options;
+	}
+	escapeField(field) {
+		if (this.options.escapeField) return this.options.escapeField(field);
+		return field;
+	}
+	rootAlias() {
+		if (this.options.rootAlias) return this.options.rootAlias;
+	}
+	execute() {}
+};
+//#endregion
+//#region src/adapter/filters/base.ts
+var FiltersBaseAdapter = class {
+	/**
+	* where conditions
+	*
+	* e.g. ['"foo.bar" = "1"' ]
+	*/
+	conditions;
+	params;
+	relations;
+	paramPlaceholderIndexer;
+	fieldPrefix;
+	constructor(relations) {
+		this.conditions = [];
+		this.params = [];
+		this.relations = relations;
+		this.paramPlaceholderIndexer = new ParamPlaceholderIndexer();
+		this.fieldPrefix = "";
+	}
+	clear() {
+		this.conditions = [];
+		this.params = [];
+		this.paramPlaceholderIndexer.reset();
+		this.fieldPrefix = "";
+	}
+	/**
+	* Whether the dialect can build regular-expression conditions.
+	* Anchored operators fall back to LIKE otherwise.
+	*/
+	isRegexpSupported() {
+		return true;
+	}
+	/**
+	* Fold an expression for a case-insensitive equality comparison
+	* (eq/ne/in/nin on strings). Dialects whose plain `=` already
+	* compares case-insensitively return the input unchanged.
+	*/
+	caseFold(input) {
+		return `lower(${input})`;
+	}
+	/**
+	* Whether equality comparisons on this field may case-fold at all.
+	* Backends with column metadata override this to exempt non-string
+	* columns — folding them is wasted work at best and a type error at
+	* worst (e.g. `lower(integer)` on postgres).
+	*/
+	isCaseFoldable(_field) {
+		return true;
+	}
+	where(field, operator, value) {
+		return this.whereRaw(`${this.buildField(field)} ${operator} ${this.buildParamPlaceholder()}`, value);
+	}
+	whereRaw(sql, ...values) {
+		this.conditions.push(sql);
+		if (values) this.params.push(...values);
+		return this;
+	}
+	buildParamPlaceholder() {
+		return this.paramPlaceholder(this.paramPlaceholderIndexer.next());
+	}
+	buildParamsPlaceholders(input) {
+		return input.map((_) => this.paramPlaceholder(this.paramPlaceholderIndexer.next()));
+	}
+	buildField(input) {
+		let inputNormalized;
+		if (this.fieldPrefix) inputNormalized = this.fieldPrefix + input;
+		else inputNormalized = input;
+		if (inputNormalized.split(".").includes(ITSELF)) throw AdapterError.featureUnsupported("filters:itself");
+		const output = parseField(inputNormalized, this.rootAlias(), (path) => this.relations.buildAlias(path));
+		if (output.relation) this.relations.add(output.relation);
+		if (output.prefix) return `${this.escapeField(output.prefix)}.${this.escapeField(output.name)}`;
+		return this.escapeField(output.name);
+	}
+	merge(query, operator = "and", isInverted = false) {
+		if (query.conditions.length > 0) {
+			let sql = query.conditions.join(` ${operator} `);
+			if (query.conditions.length > 1) sql = `(${sql})`;
+			this.conditions.push(`${isInverted ? "not " : ""}${sql}`);
+			this.params.push(...query.params);
+		}
+		return this;
+	}
+	setChildAttributes(child) {
+		child.setFieldPrefix(this.fieldPrefix);
+		child.setLastPlaceholderIndexer(this.paramPlaceholderIndexer);
+		return child;
+	}
+	setLastPlaceholderIndexer(input) {
+		this.paramPlaceholderIndexer = input;
+	}
+	getFieldPrefix() {
+		return this.fieldPrefix;
+	}
+	setFieldPrefix(prefix) {
+		this.fieldPrefix = prefix;
+	}
+	getQuery() {
+		return this.conditions.join(" and ");
+	}
+	getQueryAndParameters() {
+		return [this.getQuery(), this.params];
+	}
+};
+//#endregion
+//#region src/adapter/filters/module.ts
+var FiltersAdapter = class FiltersAdapter extends FiltersBaseAdapter {
+	options;
+	constructor(relations, options) {
+		super(relations);
+		this.options = options;
+	}
+	rootAlias() {
+		return this.options.rootAlias;
+	}
+	paramPlaceholder(index) {
+		return this.options.paramPlaceholder(index);
+	}
+	escapeField(field) {
+		return this.options.escapeField(field);
+	}
+	isRegexpSupported() {
+		return typeof this.options.regexp !== "undefined";
+	}
+	regexp(field, placeholder, ignoreCase) {
+		if (!this.options.regexp) throw AdapterError.featureUnsupported("regexp");
+		return this.options.regexp(field, placeholder, ignoreCase);
+	}
+	caseFold(input) {
+		if (this.options.caseFold) return this.options.caseFold(input);
+		return super.caseFold(input);
+	}
+	child() {
+		const child = new FiltersAdapter(this.relations, this.options);
+		this.setChildAttributes(child);
+		return child;
+	}
+	execute() {}
+};
+//#endregion
+//#region src/visitor/fields.ts
+var FieldsVisitor = class {
+	adapter;
+	options = {};
+	constructor(adapter, options = {}) {
+		this.adapter = adapter;
+		this.options = options;
+	}
+	visitField(expr) {
+		this.adapter.add(expr.name, expr.operator);
+		return this.adapter;
+	}
+	visitFields(expr) {
+		for (const item of expr.value) item.accept(this);
+		return this.adapter;
+	}
+};
+//#endregion
+//#region src/visitor/filters.ts
+var FiltersVisitor = class FiltersVisitor {
+	adapter;
+	options;
+	caseSensitiveFields;
+	constructor(adapter, options = {}) {
+		this.adapter = adapter;
+		this.options = options;
+		this.caseSensitiveFields = new Set(options.caseSensitive || []);
+	}
+	visitFilterEqual(expr) {
+		if (expr.value === null) return this.adapter.whereRaw(`${this.adapter.buildField(expr.field)} is null`);
+		if (this.isCaseInsensitive(expr.field, expr.value)) {
+			const field = this.adapter.buildField(expr.field);
+			return this.adapter.whereRaw(`${this.adapter.caseFold(field)} = ${this.adapter.caseFold(this.adapter.buildParamPlaceholder())}`, expr.value);
+		}
+		return this.adapter.where(expr.field, "=", expr.value);
+	}
+	visitFilterNotEqual(expr) {
+		const field = this.adapter.buildField(expr.field);
+		if (expr.value === null) return this.adapter.whereRaw(`${field} is not null`);
+		if (this.isCaseInsensitive(expr.field, expr.value)) return this.whereComplement(field, `${this.adapter.caseFold(field)} <> ${this.adapter.caseFold(this.adapter.buildParamPlaceholder())}`, expr.value);
+		return this.whereComplement(field, `${field} <> ${this.adapter.buildParamPlaceholder()}`, expr.value);
+	}
+	visitFilterLessThan(expr) {
+		return this.adapter.where(expr.field, "<", expr.value);
+	}
+	visitFilterLessThanEqual(expr) {
+		return this.adapter.where(expr.field, "<=", expr.value);
+	}
+	visitFilterGreaterThan(expr) {
+		return this.adapter.where(expr.field, ">", expr.value);
+	}
+	visitFilterGreaterThanEqual(expr) {
+		return this.adapter.where(expr.field, ">=", expr.value);
+	}
+	visitFilterExists(expr) {
+		return this.adapter.whereRaw(`${this.adapter.buildField(expr.field)} is ${expr.value ? "not " : ""}null`);
+	}
+	visitFilterIn(expr) {
+		return this.whereIn(expr.field, expr.value, false);
+	}
+	visitFilterNotIn(expr) {
+		return this.whereIn(expr.field, expr.value, true);
+	}
+	visitFilterMod(expr) {
+		const params = this.adapter.buildParamsPlaceholders(expr.value);
+		const sql = `mod(${this.adapter.buildField(expr.field)}, ${params[0]}) = ${params[1]}`;
+		return this.adapter.whereRaw(sql, ...expr.value);
+	}
+	visitFilterSize() {
+		throw AdapterError.featureUnsupported("filters:size");
+	}
+	visitFilterElemMatch(expr) {
+		const oldPrefix = this.adapter.getFieldPrefix();
+		this.adapter.setFieldPrefix(`${oldPrefix}${expr.field}.`);
+		expr.value.accept(this);
+		this.adapter.setFieldPrefix(oldPrefix);
+		return this.adapter;
+	}
+	visitFilterStartsWith(expr) {
+		return this.whereAnchored(expr.field, expr.value, FilterRegexFlag.STARTS_WITH);
+	}
+	visitFilterNotStartsWith(expr) {
+		return this.whereAnchored(expr.field, expr.value, FilterRegexFlag.STARTS_WITH | FilterRegexFlag.NEGATION);
+	}
+	visitFilterEndsWith(expr) {
+		return this.whereAnchored(expr.field, expr.value, FilterRegexFlag.ENDS_WITH);
+	}
+	visitFilterNotEndsWith(expr) {
+		return this.whereAnchored(expr.field, expr.value, FilterRegexFlag.ENDS_WITH | FilterRegexFlag.NEGATION);
+	}
+	visitFilterContains(expr) {
+		return this.whereAnchored(expr.field, expr.value, FilterRegexFlag.CONTAINS);
+	}
+	visitFilterNotContains(expr) {
+		return this.whereAnchored(expr.field, expr.value, FilterRegexFlag.CONTAINS | FilterRegexFlag.NEGATION);
+	}
+	visitFilterRegex(expr) {
+		const isRegExp = expr.value instanceof RegExp;
+		if (!isRegExp && typeof expr.value !== "string") throw AdapterError.featureUnsupported("filters:regex:value");
+		const source = isRegExp ? expr.value.source : expr.value;
+		const ignoreCase = isRegExp ? expr.value.ignoreCase : false;
+		const sql = this.adapter.regexp(this.adapter.buildField(expr.field), this.adapter.buildParamPlaceholder(), ignoreCase);
+		return this.adapter.whereRaw(sql, source);
+	}
+	visitFilters(expr) {
+		const adapter = this.adapter.child();
+		const visitor = new FiltersVisitor(adapter, this.options);
+		for (let i = 0; i < expr.value.length; i++) {
+			const child = expr.value[i];
+			if (child instanceof Filter) child.accept(visitor);
+			if (child instanceof Filters) child.accept(visitor);
+		}
+		switch (expr.operator) {
+			case "or":
+				this.adapter.merge(adapter, "or");
+				break;
+			case "nor":
+				this.adapter.merge(adapter, "or", true);
+				break;
+			case "not":
+				this.adapter.merge(adapter, "and", true);
+				break;
+			default: this.adapter.merge(adapter, "and");
+		}
+		return adapter;
+	}
+	visitFilter(expr) {
+		throw AdapterError.operatorUnsupported(expr.operator);
+	}
+	/**
+	* Render an IN/NOT IN condition.
+	* A null element also matches the absence of a value (IS NULL);
+	* an empty list matches no row (every row when negated).
+	*/
+	whereIn(fieldName, input, negated) {
+		if (input.length === 0) return this.adapter.whereRaw(negated ? "1 = 1" : "1 = 0");
+		const values = input.filter((value) => value !== null);
+		const field = this.adapter.buildField(fieldName);
+		const nullCondition = `${field} is ${negated ? "not " : ""}null`;
+		if (values.length === 0) return this.adapter.whereRaw(nullCondition);
+		let inCondition;
+		if (this.isCaseFoldableField(fieldName) && values.some((value) => typeof value === "string")) {
+			const placeholders = values.map((value) => {
+				const placeholder = this.adapter.buildParamPlaceholder();
+				return typeof value === "string" ? this.adapter.caseFold(placeholder) : placeholder;
+			});
+			inCondition = `${this.adapter.caseFold(field)} ${negated ? "not " : ""}in(${placeholders.join(", ")})`;
+		} else inCondition = `${field} ${negated ? "not " : ""}in(${this.adapter.buildParamsPlaceholders(values).join(", ")})`;
+		if (values.length === input.length) {
+			if (negated) return this.whereComplement(field, inCondition, ...values);
+			return this.adapter.whereRaw(inCondition, ...values);
+		}
+		return this.adapter.whereRaw(`(${inCondition} ${negated ? "and" : "or"} ${nullCondition})`, ...values);
+	}
+	/**
+	* Render a startsWith/endsWith/contains condition (or its negation)
+	* as a regexp condition, falling back to LIKE on regexp-less dialects.
+	*/
+	whereAnchored(field, value, flag) {
+		if (!this.adapter.isRegexpSupported()) {
+			const escaped = escapeLikePattern(`${value}`);
+			let pattern;
+			if (flag & FilterRegexFlag.STARTS_WITH) pattern = `${escaped}%`;
+			else if (flag & FilterRegexFlag.ENDS_WITH) pattern = `%${escaped}`;
+			else pattern = `%${escaped}%`;
+			return this.whereLike(field, pattern, !!(flag & FilterRegexFlag.NEGATION));
+		}
+		const regex = createFilterRegex(`${value}`, flag);
+		if (!(flag & FilterRegexFlag.NEGATION)) return this.visitFilterRegex(new Filter(FilterFieldOperator.REGEX, field, regex));
+		const fieldBuilt = this.adapter.buildField(field);
+		const sql = this.adapter.regexp(fieldBuilt, this.adapter.buildParamPlaceholder(), regex.ignoreCase);
+		return this.whereComplement(fieldBuilt, sql, regex.source);
+	}
+	whereLike(field, pattern, negated = false) {
+		const fieldBuilt = this.adapter.buildField(field);
+		const condition = `${fieldBuilt} ${negated ? "not " : ""}like ${this.adapter.buildParamPlaceholder()} escape '\\'`;
+		if (negated) return this.whereComplement(fieldBuilt, condition, pattern);
+		return this.adapter.whereRaw(condition, pattern);
+	}
+	/**
+	* Render a negated condition null-inclusively. Negated operators are
+	* exact complements of their positive twins (complement law), but the
+	* bare SQL negation follows three-valued logic and drops NULL rows.
+	*/
+	whereComplement(field, sql, ...values) {
+		return this.adapter.whereRaw(`(${sql} or ${field} is null)`, ...values);
+	}
+	/**
+	* Equality-family comparisons (eq/ne/in/nin) match string values
+	* case-insensitively unless the field is opted out via the
+	* `caseSensitive` visitor option or the adapter exempts it
+	* (non-string columns never fold).
+	*/
+	isCaseInsensitive(field, value) {
+		return typeof value === "string" && this.isCaseFoldableField(field);
+	}
+	isCaseFoldableField(field) {
+		const path = `${this.adapter.getFieldPrefix()}${field}`;
+		return !this.caseSensitiveFields.has(path) && this.adapter.isCaseFoldable(path);
+	}
+};
+//#endregion
+//#region src/visitor/pagination.ts
+var PaginationVisitor = class {
+	adapter;
+	options = {};
+	constructor(adapter, options = {}) {
+		this.adapter = adapter;
+		this.options = options;
+	}
+	visitPagination(expr) {
+		this.adapter.setLimit(expr.limit);
+		this.adapter.setOffset(expr.offset);
+		return this.adapter;
+	}
+};
+//#endregion
+//#region src/visitor/relations.ts
+var RelationsVisitor = class {
+	adapter;
+	options = {};
+	constructor(adapter, options = {}) {
+		this.adapter = adapter;
+		this.options = options;
+	}
+	visitRelation(expr) {
+		this.adapter.add(expr.name);
+		return this.adapter;
+	}
+	visitRelations(expr) {
+		for (const item of expr.value) item.accept(this);
+		return this.adapter;
+	}
+};
+//#endregion
+//#region src/visitor/sort.ts
+var SortsVisitor = class {
+	adapter;
+	options;
+	constructor(adapter, options = {}) {
+		this.adapter = adapter;
+		this.options = options;
+	}
+	visitSort(expr) {
+		this.adapter.add(expr.name, expr.operator);
+		return this.adapter;
+	}
+	visitSorts(expr) {
+		for (const item of expr.value) item.accept(this);
+		return this.adapter;
+	}
+};
+//#endregion
+//#region src/visitor/module.ts
+var QueryVisitor = class {
+	container;
+	options;
+	fields;
+	filters;
+	pagination;
+	relations;
+	sorts;
+	constructor(adapter, options = {}) {
+		this.container = adapter;
+		this.options = options;
+		this.fields = new FieldsVisitor(adapter.fields, options);
+		this.filters = new FiltersVisitor(adapter.filters, options);
+		this.pagination = new PaginationVisitor(adapter.pagination, options);
+		this.relations = new RelationsVisitor(adapter.relations, options);
+		this.sorts = new SortsVisitor(adapter.sort, options);
+	}
+	visitQuery(input) {
+		input.relations.accept(this.relations);
+		input.fields.accept(this.fields);
+		input.filters.accept(this.filters);
+		input.pagination.accept(this.pagination);
+		input.sorts.accept(this.sorts);
+		return this.container;
+	}
+	visitFields(expr) {
+		return expr.accept(this.fields);
+	}
+	visitField(expr) {
+		return expr.accept(this.fields);
+	}
+	visitFilters(expr) {
+		return expr.accept(this.filters);
+	}
+	visitFilter(expr) {
+		return expr.accept(this.filters);
+	}
+	visitPagination(expr) {
+		return expr.accept(this.pagination);
+	}
+	visitRelations(input) {
+		return input.accept(this.relations);
+	}
+	visitRelation(expr) {
+		return expr.accept(this.relations);
+	}
+	visitSorts(expr) {
+		return expr.accept(this.sorts);
+	}
+	visitSort(expr) {
+		return expr.accept(this.sorts);
+	}
+};
+//#endregion
+//#region src/adapter/pagination/base.ts
+var PaginationBaseAdapter = class {
+	limit;
+	offset;
+	clear() {
+		this.limit = void 0;
+		this.offset = void 0;
+	}
+	setLimit(limit) {
+		this.limit = limit;
+	}
+	setOffset(offset) {
+		this.offset = offset;
+	}
+};
+//#endregion
+//#region src/adapter/pagination/module.ts
+var PaginationAdapter = class extends PaginationBaseAdapter {
+	execute() {}
+};
+//#endregion
+//#region src/adapter/relations/base.ts
+var RelationsBaseAdapter = class {
+	/**
+	* joins
+	*
+	* [alias].project.user.name
+	*
+	* JOIN xxx.yyy as yyy
+	*
+	* { path: "xxx.zzz", name: "zzz" }[]
+	* @protected
+	*/
+	value;
+	relationAlias;
+	constructor(options = {}) {
+		this.value = [];
+		this.relationAlias = options.relationAlias ?? buildRelationAlias;
+	}
+	/**
+	* Join alias for a relation path (e.g. `role.realm` ->
+	* `r4_role_5_realm`).
+	* The single derivation point shared by join application and the
+	* field references built by the fields/filters/sort adapters.
+	*/
+	buildAlias(path) {
+		return this.relationAlias(path);
+	}
+	clear() {
+		this.value = [];
+	}
+	add(relation) {
+		if (this.has(relation)) return true;
+		let path;
+		let last = relation;
+		while (last) {
+			let relationName;
+			[relationName, last] = splitFirst(last);
+			path = path ? `${path}.${relationName}` : relationName;
+			if (this.has(path)) continue;
+			this.value.push({
+				path,
+				name: relationName
+			});
+		}
+		return true;
+	}
+	has(name) {
+		return this.value.some((join) => join.path === name);
+	}
+	/**
+	* Canonical relation paths (parents included), e.g. ['items', 'items.realm'].
+	*/
+	getPaths() {
+		return this.value.map((join) => join.path);
+	}
+};
+//#endregion
+//#region src/adapter/relations/module.ts
+var RelationsAdapter = class extends RelationsBaseAdapter {
+	options;
+	constructor(options = {}) {
+		super(options);
+		this.options = options;
+	}
+	execute() {}
+};
+//#endregion
+//#region src/adapter/sort/base.ts
+var SortBaseAdapter = class {
+	relations;
+	value;
+	constructor(relations) {
+		this.relations = relations;
+		this.value = {};
+	}
+	clear() {
+		this.value = {};
+	}
+	add(input, value) {
+		const name = this.normalizeField(input);
+		this.value[name] = value;
+	}
+	/**
+	* Escaped ORDER BY entries, e.g. ['"user"."age" DESC'].
+	*/
+	getOrderBy() {
+		const keys = Object.keys(this.value);
+		const output = [];
+		for (const key_ of keys) {
+			const key = key_;
+			output.push(`${key} ${this.value[key]}`);
+		}
+		return output;
+	}
+	normalizeField(input) {
+		const output = parseField(input, this.rootAlias(), (path) => this.relations.buildAlias(path));
+		if (output.relation) this.relations.add(output.relation);
+		if (output.prefix) return `${this.escapeField(output.prefix)}.${this.escapeField(output.name)}`;
+		return this.escapeField(output.name);
+	}
+};
+//#endregion
+//#region src/adapter/sort/module.ts
+var SortAdapter = class extends SortBaseAdapter {
+	options;
+	constructor(relations, options) {
+		super(relations);
+		this.options = options;
+	}
+	escapeField(field) {
+		if (this.options.escapeField) return this.options.escapeField(field);
+		return field;
+	}
+	rootAlias() {
+		if (this.options.rootAlias) return this.options.rootAlias;
+	}
+	execute() {}
+};
+//#endregion
+//#region src/adapter/module.ts
+var Adapter = class {
+	relations;
+	fields;
+	filters;
+	pagination;
+	sort;
+	constructor(options) {
+		this.relations = new RelationsAdapter({
+			join: () => true,
+			relationAlias: options.relationAlias
+		});
+		this.fields = new FieldsAdapter(this.relations, {
+			escapeField: options.escapeField,
+			rootAlias: options.rootAlias
+		});
+		this.filters = new FiltersAdapter(this.relations, {
+			paramPlaceholder: options.paramPlaceholder,
+			regexp: options.regexp,
+			caseFold: options.caseFold,
+			escapeField: options.escapeField,
+			rootAlias: options.rootAlias
+		});
+		this.pagination = new PaginationAdapter();
+		this.sort = new SortAdapter(this.relations, {
+			escapeField: options.escapeField,
+			rootAlias: options.rootAlias
+		});
+	}
+	clear() {
+		this.fields.clear();
+		this.filters.clear();
+		this.pagination.clear();
+		this.sort.clear();
+		this.relations.clear();
+	}
+	/**
+	* Walk `query` into the sub-adapters and collect the accumulated
+	* clause fragments. Plain SQL has no backend target — it returns the
+	* fragments for the caller to assemble.
+	*/
+	execute(query, options = {}) {
+		if (options.clear ?? true) this.clear();
+		query.accept(new QueryVisitor(this, options.visitor));
+		const [where, params] = this.filters.getQueryAndParameters();
+		return {
+			columns: this.fields.getColumns(),
+			where,
+			params,
+			orderBy: this.sort.getOrderBy(),
+			limit: this.pagination.limit,
+			offset: this.pagination.offset,
+			relations: this.relations.getPaths()
+		};
+	}
+};
+//#endregion
+//#region src/dialect/mssql.ts
+const mssql = {
+	paramPlaceholder: () => "?",
+	escapeField: (field) => `[${field}]`,
+	caseFold: (input) => input
+};
+//#endregion
+//#region src/dialect/mysql.ts
+const mysql = {
+	regexp: (field, placeholder) => `${field} regexp ${placeholder} = 1`,
+	paramPlaceholder: () => "?",
+	escapeField: (field) => `\`${field}\``,
+	caseFold: (input) => input
+};
+//#endregion
+//#region src/dialect/oracle.ts
+const oracle = {
+	regexp: (field, placeholder, ignoreCase) => ignoreCase ? `regexp_like(${field}, ${placeholder}, 'i')` : `regexp_like(${field}, ${placeholder})`,
+	escapeField: (field) => `"${field}"`,
+	paramPlaceholder: (index) => `:${index}`
+};
+//#endregion
+//#region src/dialect/pg.ts
+const pg = {
+	regexp: (field, placeholder, ignoreCase) => {
+		return `${field} ${ignoreCase ? "~*" : "~"} ${placeholder}`;
+	},
+	escapeField: (field) => `"${field}"`,
+	paramPlaceholder: (index) => `$${index}`
+};
+//#endregion
+//#region src/dialect/sqlite.ts
+const sqlite = {
+	paramPlaceholder: mysql.paramPlaceholder,
+	escapeField: mysql.escapeField
+};
+//#endregion
+//#region src/dialect/resolve.ts
+const presets = {
+	pg,
+	postgres: pg,
+	postgresql: pg,
+	"aurora-postgres": pg,
+	cockroachdb: pg,
+	mysql,
+	mysql2: mysql,
+	mariadb: mysql,
+	"aurora-mysql": mysql,
+	sqlite,
+	sqlite3: sqlite,
+	"better-sqlite3": sqlite,
+	sqljs: sqlite,
+	capacitor: sqlite,
+	cordova: sqlite,
+	"react-native": sqlite,
+	nativescript: sqlite,
+	expo: sqlite,
+	mssql,
+	oracle,
+	oracledb: oracle
+};
+/**
+* Resolve a driver/connection type name (e.g. TypeORM's
+* `connection.options.type` or a knex client name) to the
+* matching {@link DialectOptions} preset.
+*/
+function resolveDialect(name) {
+	return presets[name.toLowerCase()];
+}
+//#endregion
+export { Adapter, FieldsAdapter, FieldsBaseAdapter, FieldsVisitor, FiltersAdapter, FiltersBaseAdapter, FiltersVisitor, PaginationAdapter, PaginationBaseAdapter, PaginationVisitor, ParamPlaceholderIndexer, QueryVisitor, RelationsAdapter, RelationsBaseAdapter, RelationsVisitor, SortAdapter, SortBaseAdapter, SortsVisitor, buildRelationAlias, escapeLikePattern, isRootAliasFn, mssql, mysql, oracle, parseField, pg, resolveDialect, splitFirst, splitLast, sqlite, toRootAliasFn };
+
+//# sourceMappingURL=index.mjs.map