@uql/core 1.0.12 → 3.1.0

package/dist/type/querierPool.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcmllclBvb2wuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZS9xdWVyaWVyUG9vbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBEaWFsZWN0LCBFeHRyYU9wdGlvbnMsIFF1ZXJpZXIgfSBmcm9tICcuL3F1ZXJpZXIuanMnO1xuXG4vKipcbiAqIHF1ZXJpZXIgcG9vbC5cbiAqL1xuZXhwb3J0IHR5cGUgUXVlcmllclBvb2w8USBleHRlbmRzIFF1ZXJpZXIgPSBRdWVyaWVyPiA9IHtcbiAgLyoqXG4gICAqIHRoZSBkYXRhYmFzZSBkaWFsZWN0LlxuICAgKi9cbiAgcmVhZG9ubHkgZGlhbGVjdDogRGlhbGVjdDtcblxuICAvKipcbiAgICogZXh0cmEgb3B0aW9uc1xuICAgKi9cbiAgcmVhZG9ubHkgZXh0cmE/OiBFeHRyYU9wdGlvbnM7XG5cbiAgLyoqXG4gICAqIGdldCBhIHF1ZXJpZXIgZnJvbSB0aGUgcG9vbC5cbiAgICovXG4gIGdldFF1ZXJpZXI6ICgpID0+IFByb21pc2U8UT47XG5cbiAgLyoqXG4gICAqIGVuZCB0aGUgcG9vbC5cbiAgICovXG4gIGVuZCgpOiBQcm9taXNlPHZvaWQ+O1xufTtcbiJdfQ==

package/{type → dist/type}/query.d.ts

@@ -1,60 +1,68 @@
-import { FieldKey, IdValue, Key, RelationKey } from './entity';
-import { BooleanLike, ExpandScalar, Scalar, Type, Unpacked } from './utility';
+import type { FieldKey, IdValue, Key, RelationKey } from './entity.js';
+import type { BooleanLike, ExpandScalar, Scalar, Type, Unpacked } from './utility.js';
 export type QueryOptions = {
     /**
      * use or omit `softDelete` attribute.
      */
-    readonly softDelete?: boolean;
+    softDelete?: boolean;
     /**
      * prefix the query with this.
      */
-    readonly prefix?: string;
+    prefix?: string;
     /**
      * automatically infer the prefix for the query.
      */
-    readonly autoPrefix?: boolean;
+    autoPrefix?: boolean;
 };
-export type QueryProjectOptions = {
+export type QuerySelectOptions = {
     /**
      * prefix the query with this.
      */
-    readonly prefix?: string;
+    prefix?: string;
     /**
      * automatically add the prefix for the alias.
      */
-    readonly autoPrefixAlias?: boolean;
+    autoPrefixAlias?: boolean;
 };
 /**
- * query projection as an array.
+ * query selection as an array.
  */
-export type QueryProjectArray<E> = readonly (Key<E> | QueryRaw)[];
+export type QuerySelectArray<E> = (Key<E> | QueryRaw)[];
 /**
- * query projection as a map.
+ * query selection as a map.
  */
-export type QueryProjectMap<E> = QueryProjectFieldMap<E> | QueryProjectRelationMap<E>;
+export type QuerySelectMap<E> = QuerySelectFieldMap<E> | QuerySelectRelationMap<E>;
 /**
- * query projection.
+ * query selection.
  */
-export type QueryProject<E> = QueryProjectArray<E> | QueryProjectMap<E>;
+export type QuerySelect<E> = QuerySelectArray<E> | QuerySelectMap<E>;
 /**
- * query projection of fields as a map.
+ * query selection of fields as a map.
  */
-export type QueryProjectFieldMap<E> = {
+export type QuerySelectFieldMap<E> = {
     [K in FieldKey<E>]?: BooleanLike;
-} | {
-    [K: string]: QueryRaw;
 };
 /**
- * query projection of relations as a map.
+ * query conflict paths map.
  */
-export type QueryProjectRelationMap<E> = {
-    [K in RelationKey<E>]?: BooleanLike | readonly Key<Unpacked<E[K]>>[] | QueryProjectRelationOptions<E[K]>;
+export type QueryConflictPathsMap<E> = {
+    [K in FieldKey<E>]?: true;
 };
 /**
- * options to project a relation.
+ * query conflict paths.
  */
-export type QueryProjectRelationOptions<E> = (E extends any[] ? Query<Unpacked<E>> : QueryUnique<Unpacked<E>>) & {
-    readonly $required?: boolean;
+export type QueryConflictPaths<E> = QueryConflictPathsMap<E>;
+/**
+ * query selection of relations as a map.
+ */
+export type QuerySelectRelationMap<E> = {
+    [K in RelationKey<E>]?: BooleanLike | Key<Unpacked<E[K]>>[] | QuerySelectRelationOptions<E[K]>;
+};
+/**
+ * options to select a relation.
+ */
+export type QuerySelectRelationOptions<E> = (E extends unknown[] ? Query<Unpacked<E>> : QueryUnique<Unpacked<E>>) & {
+    $required?: boolean;
 };
 /**
  * options for full-text-search operator.
@@ -63,137 +71,142 @@ export type QueryTextSearchOptions<E> = {
     /**
      * text to search for.
      */
-    readonly $value: string;
+    $value: string;
     /**
      * list of fields to search on.
      */
-    readonly $fields?: readonly FieldKey<E>[];
+    $fields?: FieldKey<E>[];
 };
-/**
- * value for a logical filtering.
- */
-export type QueryFilterLogical<E> = readonly QueryFilter<E>[];
 /**
  * comparison by fields.
  */
-export type QueryFilterFieldMap<E> = {
-    readonly [K in FieldKey<E>]?: QueryFilterFieldValue<E[K]>;
+export type QueryWhereFieldMap<E> = {
+    [K in FieldKey<E>]?: QueryWhereFieldValue<E[K]>;
 };
 /**
  * complex operators.
  */
-export type QueryFilterMap<E> = QueryFilterFieldMap<E> & {
+export type QueryWhereMap<E> = QueryWhereFieldMap<E> & QueryWhereRootOperator<E>;
+export type QueryWhereRootOperator<E> = {
     /**
      * joins query clauses with a logical `AND`, returns records that match all the clauses.
      */
-    readonly $and?: QueryFilterLogical<E>;
+    $and?: QueryWhereArray<E>;
     /**
      * joins query clauses with a logical `OR`, returns records that match any of the clauses.
      */
-    readonly $or?: QueryFilterLogical<E>;
+    $or?: QueryWhereArray<E>;
     /**
      * joins query clauses with a logical `AND`, returns records that do not match all the clauses.
      */
-    readonly $not?: QueryFilterLogical<E>;
+    $not?: QueryWhereArray<E>;
     /**
      * joins query clauses with a logical `OR`, returns records that do not match any of the clauses.
      */
-    readonly $nor?: QueryFilterLogical<E>;
+    $nor?: QueryWhereArray<E>;
     /**
      * whether the specified fields match against a full-text search of the given string.
      */
-    readonly $text?: QueryTextSearchOptions<E>;
+    $text?: QueryTextSearchOptions<E>;
     /**
      * whether the record exists in the given sub-query.
      */
-    readonly $exists?: QueryRaw;
+    $exists?: QueryRaw;
     /**
      * whether the record does not exists in the given sub-query.
      */
-    readonly $nexists?: QueryRaw;
+    $nexists?: QueryRaw;
 };
-export type QueryFilterFieldOperatorMap<T> = {
+export type QueryWhereFieldOperatorMap<T> = {
     /**
      * whether a value is equal to the given value.
      */
-    readonly $eq?: ExpandScalar<T>;
+    $eq?: ExpandScalar<T>;
     /**
      * whether a value is not equal to the given value.
      */
-    readonly $ne?: ExpandScalar<T>;
+    $ne?: ExpandScalar<T>;
     /**
      * negates the given comparison.
      */
-    readonly $not?: QueryFilterFieldValue<T>;
+    $not?: QueryWhereFieldValue<T>;
     /**
      * whether a value is less than the given value.
      */
-    readonly $lt?: ExpandScalar<T>;
+    $lt?: ExpandScalar<T>;
     /**
      * whether a value is less than or equal to the given value.
      */
-    readonly $lte?: ExpandScalar<T>;
+    $lte?: ExpandScalar<T>;
     /**
      * whether a value is greater than the given value.
      */
-    readonly $gt?: ExpandScalar<T>;
+    $gt?: ExpandScalar<T>;
     /**
      * whether a value is greater than or equal to the given value.
      */
-    readonly $gte?: ExpandScalar<T>;
+    $gte?: ExpandScalar<T>;
     /**
      * whether a string begins with the given string (case sensitive).
      */
-    readonly $startsWith?: string;
+    $startsWith?: string;
     /**
      * whether a string begins with the given string (case insensitive).
      */
-    readonly $istartsWith?: string;
+    $istartsWith?: string;
     /**
      * whether a string ends with the given string (case sensitive).
      */
-    readonly $endsWith?: string;
+    $endsWith?: string;
     /**
      * whether a string ends with the given string (case insensitive).
      */
-    readonly $iendsWith?: string;
+    $iendsWith?: string;
     /**
      * whether a string is contained within the given string (case sensitive).
      */
-    readonly $includes?: string;
+    $includes?: string;
     /**
      * whether a string is contained within the given string (case insensitive).
      */
-    readonly $iincludes?: string;
+    $iincludes?: string;
     /**
      * whether a string fulfills the given pattern (case sensitive).
      */
-    readonly $like?: string;
+    $like?: string;
     /**
      * whether a string fulfills the given pattern (case insensitive).
      */
-    readonly $ilike?: string;
+    $ilike?: string;
     /**
      * whether a string matches the given regular expression.
      */
-    readonly $regex?: string;
+    $regex?: string;
     /**
      * whether a value matches any of the given values.
      */
-    readonly $in?: readonly ExpandScalar<T>[];
+    $in?: ExpandScalar<T>[];
     /**
      * whether a value does not match any of the given values.
      */
-    readonly $nin?: readonly ExpandScalar<T>[];
+    $nin?: ExpandScalar<T>[];
 };
 /**
  * Value for a field comparison.
  */
-export type QueryFilterFieldValue<T> = T | readonly T[] | QueryFilterFieldOperatorMap<T> | QueryRaw;
+export type QueryWhereFieldValue<T> = T | T[] | QueryWhereFieldOperatorMap<T> | QueryRaw;
+/**
+ * query single filter.
+ */
+export type QueryWhereSingle<E> = IdValue<E> | IdValue<E>[] | QueryWhereMap<E> | QueryRaw;
+/**
+ * query filter array.
+ */
+export type QueryWhereArray<E> = QueryWhereSingle<E>[];
 /**
  * query filter.
  */
-export type QueryFilter<E> = IdValue<E> | readonly IdValue<E>[] | QueryRaw | QueryFilterMap<E>;
+export type QueryWhere<E> = QueryWhereSingle<E> | QueryWhereArray<E>;
 /**
  * direction for the sort.
  */
@@ -201,13 +214,13 @@ export type QuerySortDirection = -1 | 1 | 'asc' | 'desc';
 /**
  * sort by tuples
  */
-export type QuerySortTuples<E> = readonly [FieldKey<E>, QuerySortDirection][];
+export type QuerySortTuples<E> = [FieldKey<E>, QuerySortDirection][];
 /**
  * sort by objects.
  */
-export type QuerySortObjects<E> = readonly {
-    readonly field: FieldKey<E>;
-    readonly sort: QuerySortDirection;
+export type QuerySortObjects<E> = {
+    field: FieldKey<E>;
+    sort: QuerySortDirection;
 }[];
 /**
  * sort by fields.
@@ -233,7 +246,13 @@ export type QuerySort<E> = QuerySortMap<E> | QuerySortTuples<E> | QuerySortObjec
  * pager options.
  */
 export type QueryPager = {
+    /**
+     * Index from where start the search
+     */
     $skip?: number;
+    /**
+     * Max number of records to retrieve
+     */
     $limit?: number;
 };
 /**
@@ -243,34 +262,25 @@ export type QuerySearch<E> = {
     /**
      * filtering options.
      */
-    $filter?: QueryFilter<E>;
-    /**
-     * list of fields to group.
-     */
-    $group?: readonly FieldKey<E>[];
-    /**
-     * having options.
-     */
-    $having?: QueryFilter<E>;
-};
-/**
- * criteria options.
- */
-export type QueryCriteria<E> = QuerySearch<E> & {
+    $where?: QueryWhere<E>;
     /**
      * sorting options.
      */
     $sort?: QuerySort<E>;
 } & QueryPager;
+/**
+ * criteria one options.
+ */
+export type QuerySearchOne<E> = Omit<QuerySearch<E>, '$limit'>;
 /**
  * query options.
  */
 export type Query<E> = {
     /**
-     * projection options.
+     * selection options.
      */
-    $project?: QueryProject<E>;
-} & QueryCriteria<E>;
+    $select?: QuerySelect<E>;
+} & QuerySearch<E>;
 /**
  * options to get a single record.
  */
@@ -278,25 +288,29 @@ export type QueryOne<E> = Omit<Query<E>, '$limit'>;
 /**
  * options to get an unique record.
  */
-export type QueryUnique<E> = Pick<Query<E>, '$project' | '$filter'>;
+export type QueryUnique<E> = Pick<QueryOne<E>, '$select' | '$where'>;
 /**
  * stringified query.
  */
 export type QueryStringified = {
-    readonly [K in keyof Query<any>]?: string;
+    [K in keyof Query<unknown>]?: string;
 };
 /**
  * result of an update operation.
  */
 export type QueryUpdateResult = {
     /**
-     * number of changes.
+     * number of affected records.
      */
-    readonly changes?: number;
+    changes?: number;
+    /**
+     * the inserted IDs.
+     */
+    ids?: number[] | string[];
     /**
      * first inserted ID.
      */
-    readonly firstId?: number;
+    firstId?: number | string;
 };
 /**
  * options for the `raw` function.
@@ -305,20 +319,24 @@ export type QueryRawFnOptions = {
     /**
      * the current dialect.
      */
-    readonly dialect: QueryDialect;
+    dialect?: QueryDialect;
     /**
      * the prefix.
      */
-    readonly prefix?: string;
+    prefix?: string;
     /**
      * the escaped prefix.
      */
-    readonly escapedPrefix?: string;
+    escapedPrefix?: string;
+    /**
+     * the query context.
+     */
+    ctx?: QueryContext;
 };
 /**
  * a `raw` function
  */
-export type QueryRawFn = (opts?: QueryRawFnOptions) => string;
+export type QueryRawFn = (opts?: QueryRawFnOptions) => void | Scalar;
 export declare class QueryRaw {
     readonly value: Scalar | QueryRawFn;
     readonly alias?: string;
@@ -331,54 +349,74 @@ export type QueryComparisonOptions = QueryOptions & {
     /**
      * use precedence for the comparison or not.
      */
-    readonly usePrecedence?: boolean;
+    usePrecedence?: boolean;
 };
 /**
  * query filter options.
  */
-export type QueryFilterOptions = QueryComparisonOptions & {
+export type QueryWhereOptions = QueryComparisonOptions & {
     /**
      * clause to be used in the filter.
      */
-    readonly clause?: 'WHERE' | 'HAVING' | false;
+    clause?: 'WHERE' | false;
 };
+export interface QueryContext {
+    append(sql: string): this;
+    addValue(value: unknown): this;
+    pushValue(value: unknown): this;
+    readonly sql: string;
+    readonly values: unknown[];
+}
 export interface QueryDialect {
     /**
-     * counts the number of records matching the given search parameters.
+     * obtains the records matching the given search parameters.
+     * @param ctx the query context
      * @param entity the target entity
-     * @param qm the criteria options
+     * @param q the criteria options
      * @param opts the query options
      */
-    count<E>(entity: Type<E>, qm: QuerySearch<E>, opts?: QueryOptions): string;
+    find<E>(ctx: QueryContext, entity: Type<E>, q: Query<E>, opts?: QueryOptions): void;
     /**
-     * obtains the records matching the given search parameters.
+     * counts the number of records matching the given search parameters.
+     * @param ctx the query context
      * @param entity the target entity
-     * @param qm the criteria options
+     * @param q the criteria options
      * @param opts the query options
      */
-    find<E>(entity: Type<E>, qm: Query<E>, opts?: QueryOptions): string;
+    count<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): void;
     /**
-     * inser records.
+     * insert records.
+     * @param ctx the query context
      * @param entity the target entity
-     * @param qm the criteria options
+     * @param payload the payload
      * @param opts the query options
      */
-    insert<E>(entity: Type<E>, payload: E | readonly E[], opts?: QueryOptions): string;
+    insert<E>(ctx: QueryContext, entity: Type<E>, payload: E | E[], opts?: QueryOptions): void;
     /**
      * update records.
+     * @param ctx the query context
      * @param entity the target entity
-     * @param qm the criteria options
+     * @param q the criteria options
      * @param payload
      * @param opts the query options
      */
-    update<E>(entity: Type<E>, qm: QueryCriteria<E>, payload: E, opts?: QueryOptions): string;
+    update<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, payload: E, opts?: QueryOptions): void;
+    /**
+     * upsert records.
+     * @param ctx the query context
+     * @param entity the target entity
+     * @param conflictPaths the conflict paths
+     * @param payload
+     */
+    upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): void;
     /**
      * delete records.
+     * @param ctx the query context
      * @param entity the target entity
-     * @param qm the criteria options
+     * @param q the criteria options
      * @param opts the query options
      */
-    delete<E>(entity: Type<E>, qm: QueryCriteria<E>, opts?: QueryOptions): string;
+    delete<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): void;
     /**
      * escape an identifier.
      * @param val the value to be escaped
@@ -390,5 +428,29 @@ export interface QueryDialect {
      * escape a value.
      * @param val the value to escape
      */
-    escape(val: any): Scalar;
+    escape(val: unknown): string;
+    /**
+     * add a value to the query.
+     * @param values the values array
+     * @param value the value to add
+     */
+    addValue(values: unknown[], value: unknown): string;
+    /**
+     * create a new query context.
+     */
+    createContext(): QueryContext;
+}
+/**
+ * Minimal dialect interface exposing escapeIdChar for SQL operations
+ */
+export interface SqlQueryDialect extends QueryDialect {
+    /**
+     * the escape character for identifiers.
+     */
+    readonly escapeIdChar: '"' | '`';
+    /**
+     * Get the placeholder for a parameter at the given index (1-based).
+     * Default: '?' for MySQL/MariaDB/SQLite, '$n' for PostgreSQL.
+     */
+    placeholder(index: number): string;
 }

package/dist/type/query.js

@@ -0,0 +1,9 @@
+export class QueryRaw {
+    value;
+    alias;
+    constructor(value, alias) {
+        this.value = value;
+        this.alias = alias;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/type/query.ts"],"names":[],"mappings":"AAqXA,MAAM,OAAO,QAAQ;IAER;IACA;IAFX,YACW,KAA0B,EAC1B,KAAc;QADd,UAAK,GAAL,KAAK,CAAqB;QAC1B,UAAK,GAAL,KAAK,CAAS;IACtB,CAAC;CACL","sourcesContent":["import type { FieldKey, IdValue, Key, RelationKey } from './entity.js';\nimport type { BooleanLike, ExpandScalar, Scalar, Type, Unpacked } from './utility.js';\n\nexport type QueryOptions = {\n  /**\n   * use or omit `softDelete` attribute.\n   */\n  softDelete?: boolean;\n  /**\n   * prefix the query with this.\n   */\n  prefix?: string;\n  /**\n   * automatically infer the prefix for the query.\n   */\n  autoPrefix?: boolean;\n};\n\nexport type QuerySelectOptions = {\n  /**\n   * prefix the query with this.\n   */\n  prefix?: string;\n  /**\n   * automatically add the prefix for the alias.\n   */\n  autoPrefixAlias?: boolean;\n};\n\n/**\n * query selection as an array.\n */\nexport type QuerySelectArray<E> = (Key<E> | QueryRaw)[];\n\n/**\n * query selection as a map.\n */\nexport type QuerySelectMap<E> = QuerySelectFieldMap<E> | QuerySelectRelationMap<E>;\n\n/**\n * query selection.\n */\nexport type QuerySelect<E> = QuerySelectArray<E> | QuerySelectMap<E>;\n\n/**\n * query selection of fields as a map.\n */\nexport type QuerySelectFieldMap<E> = {\n  [K in FieldKey<E>]?: BooleanLike;\n};\n\n/**\n * query conflict paths map.\n */\nexport type QueryConflictPathsMap<E> = {\n  [K in FieldKey<E>]?: true;\n};\n\n/**\n * query conflict paths.\n */\nexport type QueryConflictPaths<E> = QueryConflictPathsMap<E>;\n\n/**\n * query selection of relations as a map.\n */\nexport type QuerySelectRelationMap<E> = {\n  [K in RelationKey<E>]?: BooleanLike | Key<Unpacked<E[K]>>[] | QuerySelectRelationOptions<E[K]>;\n};\n\n/**\n * options to select a relation.\n */\nexport type QuerySelectRelationOptions<E> = (E extends unknown[] ? Query<Unpacked<E>> : QueryUnique<Unpacked<E>>) & {\n  $required?: boolean;\n};\n\n/**\n * options for full-text-search operator.\n */\nexport type QueryTextSearchOptions<E> = {\n  /**\n   * text to search for.\n   */\n  $value: string;\n  /**\n   * list of fields to search on.\n   */\n  $fields?: FieldKey<E>[];\n};\n\n/**\n * comparison by fields.\n */\nexport type QueryWhereFieldMap<E> = { [K in FieldKey<E>]?: QueryWhereFieldValue<E[K]> };\n\n/**\n * complex operators.\n */\nexport type QueryWhereMap<E> = QueryWhereFieldMap<E> & QueryWhereRootOperator<E>;\n\nexport type QueryWhereRootOperator<E> = {\n  /**\n   * joins query clauses with a logical `AND`, returns records that match all the clauses.\n   */\n  $and?: QueryWhereArray<E>;\n  /**\n   * joins query clauses with a logical `OR`, returns records that match any of the clauses.\n   */\n  $or?: QueryWhereArray<E>;\n  /**\n   * joins query clauses with a logical `AND`, returns records that do not match all the clauses.\n   */\n  $not?: QueryWhereArray<E>;\n  /**\n   * joins query clauses with a logical `OR`, returns records that do not match any of the clauses.\n   */\n  $nor?: QueryWhereArray<E>;\n  /**\n   * whether the specified fields match against a full-text search of the given string.\n   */\n  $text?: QueryTextSearchOptions<E>;\n  /**\n   * whether the record exists in the given sub-query.\n   */\n  $exists?: QueryRaw;\n  /**\n   * whether the record does not exists in the given sub-query.\n   */\n  $nexists?: QueryRaw;\n};\n\nexport type QueryWhereFieldOperatorMap<T> = {\n  /**\n   * whether a value is equal to the given value.\n   */\n  $eq?: ExpandScalar<T>;\n  /**\n   * whether a value is not equal to the given value.\n   */\n  $ne?: ExpandScalar<T>;\n  /**\n   * negates the given comparison.\n   */\n  $not?: QueryWhereFieldValue<T>;\n  /**\n   * whether a value is less than the given value.\n   */\n  $lt?: ExpandScalar<T>;\n  /**\n   * whether a value is less than or equal to the given value.\n   */\n  $lte?: ExpandScalar<T>;\n  /**\n   * whether a value is greater than the given value.\n   */\n  $gt?: ExpandScalar<T>;\n  /**\n   * whether a value is greater than or equal to the given value.\n   */\n  $gte?: ExpandScalar<T>;\n  /**\n   * whether a string begins with the given string (case sensitive).\n   */\n  $startsWith?: string;\n  /**\n   * whether a string begins with the given string (case insensitive).\n   */\n  $istartsWith?: string;\n  /**\n   * whether a string ends with the given string (case sensitive).\n   */\n  $endsWith?: string;\n  /**\n   * whether a string ends with the given string (case insensitive).\n   */\n  $iendsWith?: string;\n  /**\n   * whether a string is contained within the given string (case sensitive).\n   */\n  $includes?: string;\n  /**\n   * whether a string is contained within the given string (case insensitive).\n   */\n  $iincludes?: string;\n  /**\n   * whether a string fulfills the given pattern (case sensitive).\n   */\n  $like?: string;\n  /**\n   * whether a string fulfills the given pattern (case insensitive).\n   */\n  $ilike?: string;\n  /**\n   * whether a string matches the given regular expression.\n   */\n  $regex?: string;\n  /**\n   * whether a value matches any of the given values.\n   */\n  $in?: ExpandScalar<T>[];\n  /**\n   * whether a value does not match any of the given values.\n   */\n  $nin?: ExpandScalar<T>[];\n};\n\n/**\n * Value for a field comparison.\n */\nexport type QueryWhereFieldValue<T> = T | T[] | QueryWhereFieldOperatorMap<T> | QueryRaw;\n\n/**\n * query single filter.\n */\nexport type QueryWhereSingle<E> = IdValue<E> | IdValue<E>[] | QueryWhereMap<E> | QueryRaw;\n\n/**\n * query filter array.\n */\nexport type QueryWhereArray<E> = QueryWhereSingle<E>[];\n\n/**\n * query filter.\n */\nexport type QueryWhere<E> = QueryWhereSingle<E> | QueryWhereArray<E>;\n\n/**\n * direction for the sort.\n */\nexport type QuerySortDirection = -1 | 1 | 'asc' | 'desc';\n\n/**\n * sort by tuples\n */\nexport type QuerySortTuples<E> = [FieldKey<E>, QuerySortDirection][];\n\n/**\n * sort by objects.\n */\nexport type QuerySortObjects<E> = { field: FieldKey<E>; sort: QuerySortDirection }[];\n\n/**\n * sort by fields.\n */\nexport type QuerySortFieldMap<E> = {\n  [K in FieldKey<E>]?: QuerySortDirection;\n};\n\n/**\n * sort by relations fields.\n */\nexport type QuerySortRelationMap<E> = {\n  [K in RelationKey<E>]?: QuerySortMap<Unpacked<E[K]>>;\n};\n\n/**\n * sort by map.\n */\nexport type QuerySortMap<E> = QuerySortFieldMap<E> | QuerySortRelationMap<E>;\n\n/**\n * sort options.\n */\nexport type QuerySort<E> = QuerySortMap<E> | QuerySortTuples<E> | QuerySortObjects<E>;\n\n/**\n * pager options.\n */\nexport type QueryPager = {\n  /**\n   * Index from where start the search\n   */\n  $skip?: number;\n\n  /**\n   * Max number of records to retrieve\n   */\n  $limit?: number;\n};\n\n/**\n * search options.\n */\nexport type QuerySearch<E> = {\n  /**\n   * filtering options.\n   */\n  $where?: QueryWhere<E>;\n\n  /**\n   * sorting options.\n   */\n  $sort?: QuerySort<E>;\n} & QueryPager;\n\n/**\n * criteria one options.\n */\nexport type QuerySearchOne<E> = Omit<QuerySearch<E>, '$limit'>;\n\n/**\n * query options.\n */\nexport type Query<E> = {\n  /**\n   * selection options.\n   */\n  $select?: QuerySelect<E>;\n} & QuerySearch<E>;\n\n/**\n * options to get a single record.\n */\nexport type QueryOne<E> = Omit<Query<E>, '$limit'>;\n\n/**\n * options to get an unique record.\n */\nexport type QueryUnique<E> = Pick<QueryOne<E>, '$select' | '$where'>;\n\n/**\n * stringified query.\n */\nexport type QueryStringified = {\n  [K in keyof Query<unknown>]?: string;\n};\n\n/**\n * result of an update operation.\n */\nexport type QueryUpdateResult = {\n  /**\n   * number of affected records.\n   */\n  changes?: number;\n  /**\n   * the inserted IDs.\n   */\n  ids?: number[] | string[];\n  /**\n   * first inserted ID.\n   */\n  firstId?: number | string;\n};\n\n/**\n * options for the `raw` function.\n */\nexport type QueryRawFnOptions = {\n  /**\n   * the current dialect.\n   */\n  dialect?: QueryDialect;\n  /**\n   * the prefix.\n   */\n  prefix?: string;\n  /**\n   * the escaped prefix.\n   */\n  escapedPrefix?: string;\n  /**\n   * the query context.\n   */\n  ctx?: QueryContext;\n};\n\n/**\n * a `raw` function\n */\nexport type QueryRawFn = (opts?: QueryRawFnOptions) => void | Scalar;\n\nexport class QueryRaw {\n  constructor(\n    readonly value: Scalar | QueryRawFn,\n    readonly alias?: string,\n  ) {}\n}\n\n/**\n * comparison options.\n */\nexport type QueryComparisonOptions = QueryOptions & {\n  /**\n   * use precedence for the comparison or not.\n   */\n  usePrecedence?: boolean;\n};\n\n/**\n * query filter options.\n */\nexport type QueryWhereOptions = QueryComparisonOptions & {\n  /**\n   * clause to be used in the filter.\n   */\n  clause?: 'WHERE' | false;\n};\n\nexport interface QueryContext {\n  append(sql: string): this;\n  addValue(value: unknown): this;\n  pushValue(value: unknown): this;\n  readonly sql: string;\n  readonly values: unknown[];\n}\n\nexport interface QueryDialect {\n  /**\n   * obtains the records matching the given search parameters.\n   * @param ctx the query context\n   * @param entity the target entity\n   * @param q the criteria options\n   * @param opts the query options\n   */\n  find<E>(ctx: QueryContext, entity: Type<E>, q: Query<E>, opts?: QueryOptions): void;\n\n  /**\n   * counts the number of records matching the given search parameters.\n   * @param ctx the query context\n   * @param entity the target entity\n   * @param q the criteria options\n   * @param opts the query options\n   */\n  count<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): void;\n\n  /**\n   * insert records.\n   * @param ctx the query context\n   * @param entity the target entity\n   * @param payload the payload\n   * @param opts the query options\n   */\n  insert<E>(ctx: QueryContext, entity: Type<E>, payload: E | E[], opts?: QueryOptions): void;\n\n  /**\n   * update records.\n   * @param ctx the query context\n   * @param entity the target entity\n   * @param q the criteria options\n   * @param payload\n   * @param opts the query options\n   */\n  update<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, payload: E, opts?: QueryOptions): void;\n\n  /**\n   * upsert records.\n   * @param ctx the query context\n   * @param entity the target entity\n   * @param conflictPaths the conflict paths\n   * @param payload\n   */\n  upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): void;\n\n  /**\n   * delete records.\n   * @param ctx the query context\n   * @param entity the target entity\n   * @param q the criteria options\n   * @param opts the query options\n   */\n  delete<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): void;\n\n  /**\n   * escape an identifier.\n   * @param val the value to be escaped\n   * @param forbidQualified don't escape dots\n   * @param addDot use a dot as suffix\n   */\n  escapeId(val: string, forbidQualified?: boolean, addDot?: boolean): string;\n\n  /**\n   * escape a value.\n   * @param val the value to escape\n   */\n  escape(val: unknown): string;\n\n  /**\n   * add a value to the query.\n   * @param values the values array\n   * @param value the value to add\n   */\n  addValue(values: unknown[], value: unknown): string;\n\n  /**\n   * create a new query context.\n   */\n  createContext(): QueryContext;\n}\n\n/**\n * Minimal dialect interface exposing escapeIdChar for SQL operations\n */\nexport interface SqlQueryDialect extends QueryDialect {\n  /**\n   * the escape character for identifiers.\n   */\n  readonly escapeIdChar: '\"' | '`';\n\n  /**\n   * Get the placeholder for a parameter at the given index (1-based).\n   * Default: '?' for MySQL/MariaDB/SQLite, '$n' for PostgreSQL.\n   */\n  placeholder(index: number): string;\n}\n"]}