@rapiq/sql 2.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2026 Peter Placzek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# @rapiq/sql
+
+Part of [rapiq](https://github.com/tada5hi/rapiq) — typed REST queries: build, transport, validate, execute.
+
+Turns query AST nodes into **parameterized SQL fragments**. Database-agnostic: per-database behavior is injected as a small dialect option object (presets for `pg`, `mysql`, `sqlite`, `mssql`, `oracle`), and values are always bound as parameters — never interpolated. It is also the foundation the [TypeORM adapter](https://www.npmjs.com/package/@rapiq/typeorm) builds on.
+
+## Installation
+
+```sh
+npm install @rapiq/core @rapiq/sql
+```
+
+## Usage
+
+A root `Adapter` bundles one sub-adapter per parameter; `execute(query)` walks a whole `Query` into it and returns the accumulated clause fragments:
+
+```typescript
+import { Adapter, pg } from '@rapiq/sql';
+
+const adapter = new Adapter({ ...pg, rootAlias: 'user' });
+
+const fragments = adapter.execute(query);
+// {
+//     columns: ['"user"."id"', '"user"."name"', '"realm"."name"'],
+//     where: '("user"."age" >= $1 and ...)',
+//     params: [18, ...],
+//     orderBy: ['"user"."age" DESC'],
+//     limit: 25,
+//     offset: 50,
+//     relations: ['realm'],
+// }
+```
+
+Construct the `Adapter` **per request** — it accumulates per-call state, so the shareable, long-lived part is the options object, not the adapter instance.
+
+Per-parameter adapter/visitor pairs work standalone — e.g. rendering just the filters:
+
+```typescript
+import { FiltersAdapter, FiltersVisitor, RelationsAdapter, pg } from '@rapiq/sql';
+
+const filters = new FiltersAdapter(new RelationsAdapter(), pg);
+query.filters.accept(new FiltersVisitor(filters));
+
+const [sql, params] = filters.getQueryAndParameters();
+// sql:    ("name" ~* $1 and "age" >= $2)
+// params: ['jo', 18]
+```
+
+The package deliberately stops at fragments: composing the final `SELECT` — in particular `FROM`/`JOIN` conditions — is the caller's job, or a backend adapter's (that's exactly what [@rapiq/typeorm](https://www.npmjs.com/package/@rapiq/typeorm) does).
+
+Notable semantics: `null` filter values render as `IS NULL` / `IS NOT NULL` predicates, empty `IN` lists render as `1 = 0` (never invalid SQL), string-matching operators match literally on every dialect, and `resolveDialect(name)` maps driver/connection type names (`postgres`, `mariadb`, `better-sqlite3`, …) to the matching preset. On dialects without a regexp operator (SQL Server, stock SQLite), `contains`/`startsWith`/`endsWith` fall back to escaped `LIKE`; only the `regex` operator throws a typed `AdapterError`.
+
+## Documentation
+
+Full guide (dialects, null semantics, fragment API): [rapiq.tada5hi.net/packages/sql](https://rapiq.tada5hi.net/packages/sql)
+
+## License
+
+Published under the [MIT License](https://github.com/tada5hi/rapiq/blob/master/LICENSE).

package/dist/index.d.mts

@@ -0,0 +1,580 @@
+import { Field, FieldOperator, Fields, Filter, FilterFieldOperator, Filters, IField, IFieldVisitor, IFields, IFieldsVisitor, IFilterVisitor, IFiltersVisitor, IPaginationVisitor, IQuery, IQueryVisitor, IRelationVisitor, IRelationsVisitor, ISortVisitor, ISortsVisitor, Pagination, Query, Relation, Relations, Sort, SortDirection, Sorts } from "@rapiq/core";
+//#region src/helpers/relation-alias.d.ts
+type RelationAliasFn = (path: string) => string;
+/**
+ * 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).
+ */
+declare function buildRelationAlias(path: string): string;
+//#endregion
+//#region src/helpers/field.d.ts
+type Field$1 = {
+  prefix?: string;
+  relation?: string;
+  name: string;
+};
+declare function parseField(input: string, rootAlias?: string, relationAlias?: RelationAliasFn): Field$1;
+//#endregion
+//#region src/helpers/like.d.ts
+/**
+ * Escape LIKE pattern wildcards (incl. the MSSQL bracket range)
+ * so user input matches literally under `ESCAPE '\'`.
+ */
+declare function escapeLikePattern(input: string): string;
+//#endregion
+//#region src/helpers/name-split.d.ts
+declare function splitFirst(input: string): [string, string | undefined];
+declare function splitLast(input: string): [string, string | undefined];
+//#endregion
+//#region src/helpers/param-placeholder-indexer.d.ts
+declare class ParamPlaceholderIndexer {
+  protected index: number;
+  constructor(index?: number);
+  next(): number;
+  reset(): void;
+}
+//#endregion
+//#region src/types.d.ts
+type RootAliasFn<TARGET extends Record<string, any> = Record<string, any>> = (target?: TARGET) => string;
+//#endregion
+//#region src/helpers/root-alias.d.ts
+declare function toRootAliasFn<TARGET extends Record<string, any> = Record<string, any>>(input: string | RootAliasFn<TARGET>): RootAliasFn<TARGET>;
+declare function isRootAliasFn(input: string | RootAliasFn): input is RootAliasFn;
+//#endregion
+//#region src/visitor/types.d.ts
+type VisitorOptions = {
+  /**
+   * Field keys whose equality comparisons (eq/ne/in/nin) stay
+   * case-sensitive instead of the case-insensitive default —
+   * e.g. identifier or token columns. Typically forwarded from
+   * a schema's `filters.caseSensitive` list.
+   */
+  caseSensitive?: string[];
+  [key: string]: any;
+};
+//#endregion
+//#region src/adapter/filters/types.d.ts
+interface IFiltersAdapter extends ISubAdapter {
+  conditions: string[];
+  params: unknown[];
+  where(field: string, operator: string, value?: unknown): this;
+  whereRaw(sql: string, ...values: unknown[]): this;
+  buildField(input: string): string;
+  buildParamPlaceholder(): string;
+  buildParamsPlaceholders(input: unknown[]): string[];
+  getFieldPrefix(): string;
+  setFieldPrefix(prefix: string): void;
+  regexp(field: string, placeholder: string, ignoreCase: boolean): string;
+  isRegexpSupported(): boolean;
+  caseFold(input: string): string;
+  isCaseFoldable(field: string): boolean;
+  merge<T extends IFiltersAdapter>(query: T, operator?: 'and' | 'or', isInverted?: boolean): this;
+  child(): this;
+  getQueryAndParameters(): [string, unknown[]];
+}
+//#endregion
+//#region src/adapter/filters/base.d.ts
+declare abstract class FiltersBaseAdapter<RelationsAdapter extends IRelationsAdapter = IRelationsAdapter> implements IFiltersAdapter {
+  /**
+   * where conditions
+   *
+   * e.g. ['"foo.bar" = "1"' ]
+   */
+  conditions: string[];
+  params: unknown[];
+  protected relations: RelationsAdapter;
+  protected paramPlaceholderIndexer: ParamPlaceholderIndexer;
+  protected fieldPrefix: string;
+  protected constructor(relations: RelationsAdapter);
+  clear(): void;
+  protected abstract rootAlias(): string | undefined;
+  protected abstract paramPlaceholder(index: number): string;
+  protected abstract escapeField(field: string): string;
+  abstract regexp(field: string, placeholder: string, ignoreCase: boolean): string;
+  abstract execute(): void;
+  abstract child(): this;
+  /**
+   * Whether the dialect can build regular-expression conditions.
+   * Anchored operators fall back to LIKE otherwise.
+   */
+  isRegexpSupported(): boolean;
+  /**
+   * 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: string): string;
+  /**
+   * 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: string): boolean;
+  where(field: string, operator: string, value?: unknown): this;
+  whereRaw(sql: string, ...values: unknown[]): this;
+  buildParamPlaceholder(): string;
+  buildParamsPlaceholders(input: unknown[]): string[];
+  buildField(input: string): string;
+  merge<T extends IFiltersAdapter>(query: T, operator?: 'and' | 'or', isInverted?: boolean): this;
+  protected setChildAttributes<T extends FiltersBaseAdapter>(child: T): T;
+  setLastPlaceholderIndexer(input: ParamPlaceholderIndexer): void;
+  getFieldPrefix(): string;
+  setFieldPrefix(prefix: string): void;
+  getQuery(): string;
+  getQueryAndParameters(): [string, unknown[]];
+}
+//#endregion
+//#region src/dialect/types.d.ts
+type DialectOptions = {
+  /**
+   * Build a regular-expression condition.
+   * Omit when the dialect has no regexp support — anchored operators
+   * (startsWith, endsWith, contains) fall back to LIKE and the
+   * regex operator raises a typed AdapterError.
+   */
+  regexp?: (field: string, placeholder: string, ignoreCase: boolean) => string;
+  /**
+   * Fold an expression (field or parameter placeholder) for a
+   * case-insensitive equality comparison (eq/ne/in/nin on strings).
+   * Omit for the default `lower(...)` wrapping — dialects whose plain
+   * `=` already compares case-insensitively under their default
+   * collation (mysql, mssql) return the input unchanged instead.
+   */
+  caseFold?: (input: string) => string;
+  escapeField: (input: string) => string;
+  paramPlaceholder: (index: number) => string;
+};
+//#endregion
+//#region src/dialect/mssql.d.ts
+declare const mssql: DialectOptions;
+//#endregion
+//#region src/dialect/mysql.d.ts
+declare const mysql: DialectOptions;
+//#endregion
+//#region src/dialect/oracle.d.ts
+declare const oracle: DialectOptions;
+//#endregion
+//#region src/dialect/pg.d.ts
+declare const pg: DialectOptions;
+//#endregion
+//#region src/dialect/resolve.d.ts
+/**
+ * Resolve a driver/connection type name (e.g. TypeORM's
+ * `connection.options.type` or a knex client name) to the
+ * matching {@link DialectOptions} preset.
+ */
+declare function resolveDialect(name: string): DialectOptions | undefined;
+//#endregion
+//#region src/dialect/sqlite.d.ts
+declare const sqlite: DialectOptions;
+//#endregion
+//#region src/adapter/filters/module.d.ts
+type FiltersContainerOptions = {
+  rootAlias?: string;
+} & DialectOptions;
+declare class FiltersAdapter extends FiltersBaseAdapter {
+  protected options: FiltersContainerOptions;
+  constructor(relations: RelationsAdapter, options: FiltersContainerOptions);
+  rootAlias(): string | undefined;
+  paramPlaceholder(index: number): string;
+  escapeField(field: string): string;
+  isRegexpSupported(): boolean;
+  regexp(field: string, placeholder: string, ignoreCase: boolean): string;
+  caseFold(input: string): string;
+  child(): this;
+  execute(): void;
+}
+//#endregion
+//#region src/adapter/pagination/types.d.ts
+interface IPaginationAdapter extends ISubAdapter {
+  setLimit(limit?: number): void;
+  setOffset(offset?: number): void;
+}
+//#endregion
+//#region src/adapter/pagination/base.d.ts
+declare abstract class PaginationBaseAdapter implements IPaginationAdapter {
+  limit: number | undefined;
+  offset: number | undefined;
+  clear(): void;
+  setLimit(limit?: number): void;
+  setOffset(offset?: number): void;
+  abstract execute(): void;
+}
+//#endregion
+//#region src/adapter/pagination/module.d.ts
+declare class PaginationAdapter extends PaginationBaseAdapter {
+  execute(): void;
+}
+//#endregion
+//#region src/adapter/sort/types.d.ts
+interface ISortAdapter extends ISubAdapter {
+  add(input: string, value: `${SortDirection}`): void;
+}
+//#endregion
+//#region src/adapter/sort/base.d.ts
+declare abstract class SortBaseAdapter implements ISortAdapter {
+  protected relations: RelationsBaseAdapter;
+  protected value: Record<string, `${SortDirection}`>;
+  protected constructor(relations: RelationsBaseAdapter);
+  clear(): void;
+  protected abstract rootAlias(): string | undefined;
+  protected abstract escapeField(field: string): string;
+  abstract execute(): void;
+  add(input: string, value: `${SortDirection}`): void;
+  /**
+   * Escaped ORDER BY entries, e.g. ['"user"."age" DESC'].
+   */
+  getOrderBy(): string[];
+  protected normalizeField(input: string): string;
+}
+//#endregion
+//#region src/adapter/sort/module.d.ts
+type SortContainerOptions = {
+  rootAlias?: string;
+  escapeField?: (input: string) => string;
+};
+declare class SortAdapter extends SortBaseAdapter {
+  protected options: SortContainerOptions;
+  constructor(relations: RelationsAdapter, options: SortContainerOptions);
+  escapeField(field: string): string;
+  rootAlias(): string | undefined;
+  execute(): void;
+}
+//#endregion
+//#region src/adapter/types.d.ts
+/**
+ * Options for a single {@link IRootAdapter.execute} call.
+ */
+type ExecuteOptions = {
+  /**
+   * Reset the accumulated state before walking the query.
+   *
+   * `true` (default) makes execute() self-contained and re-runnable;
+   * pass `false` to accumulate across multiple execute() calls.
+   */
+  clear?: boolean;
+  /**
+   * Options forwarded to the {@link QueryVisitor} (and its sub-visitors)
+   * that walks the query.
+   */
+  visitor?: VisitorOptions;
+};
+/**
+ * Shared contract for the per-parameter sub-adapters that accumulate
+ * clause state while a query is walked, then flush it on {@link execute}.
+ */
+interface ISubAdapter {
+  execute(): void;
+  clear(): void;
+}
+/**
+ * Root adapter contract: walks a rapiq {@link IQuery} into the sub-adapters
+ * and emits the backend result — SQL fragments, or the echo of a mutated
+ * backend query object.
+ */
+interface IRootAdapter<OUTPUT = unknown> {
+  relations: IRelationsAdapter;
+  fields: IFieldsAdapter;
+  filters: IFiltersAdapter;
+  pagination: IPaginationAdapter;
+  sort: ISortAdapter;
+  /**
+   * Walk `query` into the sub-adapters and emit the backend result.
+   *
+   * @param query   the parsed rapiq query (AST) to consume.
+   * @param options per-call options ({@link ExecuteOptions}).
+   */
+  execute(query: IQuery, options?: ExecuteOptions): OUTPUT;
+  clear(): void;
+}
+/**
+ * Clause fragments accumulated from a Query walk.
+ * Statement assembly (FROM/JOIN conditions) is owned by the caller,
+ * which knows the table layout — rapiq only knows relation names.
+ */
+type SqlFragments = {
+  /**
+   * Escaped selection columns, e.g. ['"user"."id"', '"realm"."name"'].
+   */
+  columns: string[];
+  /**
+   * Joined WHERE condition ('' when no filters apply).
+   */
+  where: string;
+  /**
+   * Bound parameters for `where`.
+   */
+  params: unknown[];
+  /**
+   * Escaped ORDER BY entries, e.g. ['"user"."age" DESC'].
+   */
+  orderBy: string[];
+  limit: number | undefined;
+  offset: number | undefined;
+  /**
+   * Canonical relation paths to join (parents included),
+   * e.g. ['items', 'items.realm'].
+   */
+  relations: string[];
+};
+//#endregion
+//#region src/adapter/relations/types.d.ts
+interface IRelationsAdapter extends ISubAdapter {
+  add(input: string): void;
+  buildAlias(path: string): string;
+}
+type JoinRelationFn = (relation: string, alias?: string) => boolean;
+type RelationsAdapterBaseOptions = {
+  /**
+   * Join and select relations.
+   */
+  joinAndSelect?: boolean;
+  /**
+   * Derive the join alias for a relation path
+   * (e.g. `role.realm` -> `r4_role_5_realm`).
+   * Field references in filters/sort/fields resolve against the
+   * same derivation, so it must be injected once, on the relations
+   * adapter shared by all sub-adapters.
+   */
+  relationAlias?: RelationAliasFn;
+};
+type RelationsAdapterOptions = RelationsAdapterBaseOptions & {
+  join?: JoinRelationFn;
+};
+//#endregion
+//#region src/adapter/relations/base.d.ts
+declare abstract class RelationsBaseAdapter implements IRelationsAdapter {
+  /**
+   * joins
+   *
+   * [alias].project.user.name
+   *
+   * JOIN xxx.yyy as yyy
+   *
+   * { path: "xxx.zzz", name: "zzz" }[]
+   * @protected
+   */
+  protected value: {
+    path: string;
+    name: string;
+    executed?: boolean;
+  }[];
+  protected relationAlias: RelationAliasFn;
+  protected constructor(options?: RelationsAdapterBaseOptions);
+  /**
+   * 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: string): string;
+  clear(): void;
+  abstract execute(): void;
+  add(relation: string): boolean;
+  has(name: string): boolean;
+  /**
+   * Canonical relation paths (parents included), e.g. ['items', 'items.realm'].
+   */
+  getPaths(): string[];
+}
+//#endregion
+//#region src/adapter/relations/module.d.ts
+declare class RelationsAdapter extends RelationsBaseAdapter {
+  protected options: RelationsAdapterOptions;
+  constructor(options?: RelationsAdapterOptions);
+  execute(): void;
+}
+//#endregion
+//#region src/adapter/fields/types.d.ts
+interface IFieldsAdapter extends ISubAdapter {
+  add(input: string, operator?: `${FieldOperator}`): void;
+}
+//#endregion
+//#region src/adapter/fields/base.d.ts
+declare abstract class FieldsBaseAdapter implements IFieldsAdapter {
+  protected relations: RelationsBaseAdapter;
+  /**
+   * selection fields.
+   *
+   * e.g. ['name', 'project.id']
+   */
+  protected value: {
+    name: string;
+    operator?: `${FieldOperator}`;
+  }[];
+  protected constructor(relations: RelationsBaseAdapter);
+  clear(): void;
+  protected abstract rootAlias(): string | undefined;
+  protected abstract escapeField(field: string): string;
+  abstract execute(): void;
+  add(input: string, operator?: `${FieldOperator}`): void;
+  /**
+   * Escaped selection columns (excluded fields are dropped).
+   */
+  getColumns(): string[];
+  buildField(input: string): string;
+}
+//#endregion
+//#region src/adapter/fields/module.d.ts
+type FieldsContainerOptions = {
+  rootAlias?: string;
+  escapeField?: (input: string) => string;
+};
+declare class FieldsAdapter extends FieldsBaseAdapter {
+  protected options: FieldsContainerOptions;
+  constructor(relations: RelationsAdapter, options: FieldsContainerOptions);
+  escapeField(field: string): string;
+  rootAlias(): string | undefined;
+  execute(): void;
+}
+//#endregion
+//#region src/adapter/module.d.ts
+type AdapterOptions = DialectOptions & {
+  rootAlias?: string;
+  /**
+   * Derive the join alias for a relation path
+   * (default: length-prefixed segments, e.g. `role.realm` ->
+   * `r4_role_5_realm`).
+   */
+  relationAlias?: RelationAliasFn;
+};
+declare class Adapter implements IRootAdapter<SqlFragments> {
+  readonly relations: RelationsAdapter;
+  readonly fields: FieldsAdapter;
+  readonly filters: FiltersAdapter;
+  readonly pagination: PaginationAdapter;
+  readonly sort: SortAdapter;
+  constructor(options: AdapterOptions);
+  clear(): void;
+  /**
+   * 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: IQuery, options?: ExecuteOptions): SqlFragments;
+}
+//#endregion
+//#region src/visitor/fields.d.ts
+type FieldsInterpreterOptions = VisitorOptions;
+declare class FieldsVisitor implements IFieldsVisitor<IFieldsAdapter>, IFieldVisitor<IFieldsAdapter> {
+  protected adapter: IFieldsAdapter;
+  protected options: FieldsInterpreterOptions;
+  constructor(adapter: IFieldsAdapter, options?: FieldsInterpreterOptions);
+  visitField(expr: IField): IFieldsAdapter;
+  visitFields(expr: IFields): IFieldsAdapter;
+}
+//#endregion
+//#region src/visitor/filters.d.ts
+declare class FiltersVisitor implements IFiltersVisitor<IFiltersAdapter>, IFilterVisitor<IFiltersAdapter> {
+  protected adapter: IFiltersAdapter;
+  protected options: VisitorOptions;
+  protected caseSensitiveFields: Set<string>;
+  constructor(adapter: IFiltersAdapter, options?: VisitorOptions);
+  visitFilterEqual(expr: Filter<FilterFieldOperator.EQUAL>): IFiltersAdapter;
+  visitFilterNotEqual(expr: Filter<FilterFieldOperator.NOT_EQUAL>): IFiltersAdapter;
+  visitFilterLessThan(expr: Filter<FilterFieldOperator.LESS_THAN>): IFiltersAdapter;
+  visitFilterLessThanEqual(expr: Filter<FilterFieldOperator.LESS_THAN_EQUAL>): IFiltersAdapter;
+  visitFilterGreaterThan(expr: Filter<FilterFieldOperator.GREATER_THAN>): IFiltersAdapter;
+  visitFilterGreaterThanEqual(expr: Filter<FilterFieldOperator.GREATER_THAN_EQUAL>): IFiltersAdapter;
+  visitFilterExists(expr: Filter<FilterFieldOperator.EXISTS, boolean>): IFiltersAdapter;
+  visitFilterIn(expr: Filter<FilterFieldOperator.IN, unknown[]>): IFiltersAdapter;
+  visitFilterNotIn(expr: Filter<FilterFieldOperator.NOT_IN, unknown[]>): IFiltersAdapter;
+  visitFilterMod(expr: Filter<FilterFieldOperator.MOD, [number, number]>): IFiltersAdapter;
+  visitFilterSize(): IFiltersAdapter;
+  visitFilterElemMatch(expr: Filter<FilterFieldOperator.ELEM_MATCH, Filter | Filters>): IFiltersAdapter;
+  visitFilterStartsWith(expr: Filter<FilterFieldOperator.STARTS_WITH, unknown>): IFiltersAdapter;
+  visitFilterNotStartsWith(expr: Filter<FilterFieldOperator.NOT_STARTS_WITH, unknown>): IFiltersAdapter;
+  visitFilterEndsWith(expr: Filter<FilterFieldOperator.ENDS_WITH, unknown>): IFiltersAdapter;
+  visitFilterNotEndsWith(expr: Filter<FilterFieldOperator.NOT_ENDS_WITH, unknown>): IFiltersAdapter;
+  visitFilterContains(expr: Filter<FilterFieldOperator.CONTAINS, unknown>): IFiltersAdapter;
+  visitFilterNotContains(expr: Filter<FilterFieldOperator.NOT_CONTAINS, unknown>): IFiltersAdapter;
+  visitFilterRegex(expr: Filter<FilterFieldOperator.REGEX, RegExp | string>): IFiltersAdapter;
+  visitFilters(expr: Filters): IFiltersAdapter;
+  visitFilter(expr: Filter): IFiltersAdapter;
+  /**
+   * 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).
+   */
+  protected whereIn(fieldName: string, input: unknown[], negated: boolean): IFiltersAdapter;
+  /**
+   * Render a startsWith/endsWith/contains condition (or its negation)
+   * as a regexp condition, falling back to LIKE on regexp-less dialects.
+   */
+  protected whereAnchored(field: string, value: unknown, flag: number): IFiltersAdapter;
+  protected whereLike(field: string, pattern: string, negated?: boolean): IFiltersAdapter;
+  /**
+   * 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.
+   */
+  protected whereComplement(field: string, sql: string, ...values: unknown[]): IFiltersAdapter;
+  /**
+   * 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).
+   */
+  protected isCaseInsensitive(field: string, value: unknown): boolean;
+  protected isCaseFoldableField(field: string): boolean;
+}
+//#endregion
+//#region src/visitor/pagination.d.ts
+type PaginationVisitorOptions = VisitorOptions;
+declare class PaginationVisitor implements IPaginationVisitor<IPaginationAdapter> {
+  protected adapter: IPaginationAdapter;
+  protected options: PaginationVisitorOptions;
+  constructor(adapter: IPaginationAdapter, options?: PaginationVisitorOptions);
+  visitPagination(expr: Pagination): IPaginationAdapter;
+}
+//#endregion
+//#region src/visitor/relations.d.ts
+type RelationInterpreterOptions = VisitorOptions;
+declare class RelationsVisitor implements IRelationsVisitor<IRelationsAdapter>, IRelationVisitor<IRelationsAdapter> {
+  protected adapter: IRelationsAdapter;
+  protected options: RelationInterpreterOptions;
+  constructor(adapter: IRelationsAdapter, options?: RelationInterpreterOptions);
+  visitRelation(expr: Relation): IRelationsAdapter;
+  visitRelations(expr: Relations): IRelationsAdapter;
+}
+//#endregion
+//#region src/visitor/sort.d.ts
+type SortInterpreterOptions = VisitorOptions;
+declare class SortsVisitor implements ISortsVisitor<ISortAdapter>, ISortVisitor<ISortAdapter> {
+  protected adapter: ISortAdapter;
+  protected options: SortInterpreterOptions;
+  constructor(adapter: ISortAdapter, options?: SortInterpreterOptions);
+  visitSort(expr: Sort): ISortAdapter;
+  visitSorts(expr: Sorts): ISortAdapter;
+}
+//#endregion
+//#region src/visitor/module.d.ts
+declare class QueryVisitor implements IQueryVisitor<IRootAdapter>, IFieldsVisitor<IFieldsAdapter>, IFieldVisitor<IFieldsAdapter>, IFiltersVisitor<IFiltersAdapter>, IFilterVisitor<IFiltersAdapter>, IPaginationVisitor<IPaginationAdapter>, IRelationsVisitor<IRelationsAdapter>, IRelationVisitor<IRelationsAdapter>, ISortsVisitor<ISortAdapter>, ISortVisitor<ISortAdapter> {
+  protected container: IRootAdapter;
+  protected options: VisitorOptions;
+  readonly fields: FieldsVisitor;
+  readonly filters: FiltersVisitor;
+  readonly pagination: PaginationVisitor;
+  readonly relations: RelationsVisitor;
+  readonly sorts: SortsVisitor;
+  constructor(adapter: IRootAdapter, options?: VisitorOptions);
+  visitQuery(input: Query): IRootAdapter;
+  visitFields(expr: Fields): IFieldsAdapter;
+  visitField(expr: Field): IFieldsAdapter;
+  visitFilters(expr: Filters): IFiltersAdapter;
+  visitFilter(expr: Filter): IFiltersAdapter;
+  visitPagination(expr: Pagination): IPaginationAdapter;
+  visitRelations(input: Relations): IRelationsAdapter;
+  visitRelation(expr: Relation): IRelationsAdapter;
+  visitSorts(expr: Sorts): ISortAdapter;
+  visitSort(expr: Sort): ISortAdapter;
+}
+//#endregion
+export { Adapter, AdapterOptions, DialectOptions, ExecuteOptions, FieldsAdapter, FieldsBaseAdapter, FieldsContainerOptions, FieldsInterpreterOptions, FieldsVisitor, FiltersAdapter, FiltersBaseAdapter, FiltersContainerOptions, FiltersVisitor, IFieldsAdapter, IFiltersAdapter, IPaginationAdapter, IRelationsAdapter, IRootAdapter, ISortAdapter, ISubAdapter, JoinRelationFn, PaginationAdapter, PaginationBaseAdapter, PaginationVisitor, PaginationVisitorOptions, ParamPlaceholderIndexer, QueryVisitor, RelationAliasFn, RelationInterpreterOptions, RelationsAdapter, RelationsAdapterBaseOptions, RelationsAdapterOptions, RelationsBaseAdapter, RelationsVisitor, SortAdapter, SortBaseAdapter, SortContainerOptions, SortInterpreterOptions, SortsVisitor, SqlFragments, VisitorOptions, buildRelationAlias, escapeLikePattern, isRootAliasFn, mssql, mysql, oracle, parseField, pg, resolveDialect, splitFirst, splitLast, sqlite, toRootAliasFn };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/helpers/relation-alias.ts","../src/helpers/field.ts","../src/helpers/like.ts","../src/helpers/name-split.ts","../src/helpers/param-placeholder-indexer.ts","../src/types.ts","../src/helpers/root-alias.ts","../src/visitor/types.ts","../src/adapter/filters/types.ts","../src/adapter/filters/base.ts","../src/dialect/types.ts","../src/dialect/mssql.ts","../src/dialect/mysql.ts","../src/dialect/oracle.ts","../src/dialect/pg.ts","../src/dialect/resolve.ts","../src/dialect/sqlite.ts","../src/adapter/filters/module.ts","../src/adapter/pagination/types.ts","../src/adapter/pagination/base.ts","../src/adapter/pagination/module.ts","../src/adapter/sort/types.ts","../src/adapter/sort/base.ts","../src/adapter/sort/module.ts","../src/adapter/types.ts","../src/adapter/relations/types.ts","../src/adapter/relations/base.ts","../src/adapter/relations/module.ts","../src/adapter/fields/types.ts","../src/adapter/fields/base.ts","../src/adapter/fields/module.ts","../src/adapter/module.ts","../src/visitor/fields.ts","../src/visitor/filters.ts","../src/visitor/pagination.ts","../src/visitor/relations.ts","../src/visitor/sort.ts","../src/visitor/module.ts"],"mappings":"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"}