@uql/core 1.0.11 → 3.0.0

package/dist/type/querierPool.d.ts

@@ -0,0 +1,22 @@
+import type { Dialect, ExtraOptions, Querier } from './querier.js';
+/**
+ * querier pool.
+ */
+export type QuerierPool<Q extends Querier = Querier> = {
+    /**
+     * the database dialect.
+     */
+    readonly dialect: Dialect;
+    /**
+     * extra options
+     */
+    readonly extra?: ExtraOptions;
+    /**
+     * get a querier from the pool.
+     */
+    getQuerier: () => Promise<Q>;
+    /**
+     * end the pool.
+     */
+    end(): Promise<void>;
+};

package/dist/type/querierPool.js

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

package/dist/type/query.d.ts

@@ -0,0 +1,456 @@
+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.
+     */
+    softDelete?: boolean;
+    /**
+     * prefix the query with this.
+     */
+    prefix?: string;
+    /**
+     * automatically infer the prefix for the query.
+     */
+    autoPrefix?: boolean;
+};
+export type QuerySelectOptions = {
+    /**
+     * prefix the query with this.
+     */
+    prefix?: string;
+    /**
+     * automatically add the prefix for the alias.
+     */
+    autoPrefixAlias?: boolean;
+};
+/**
+ * query selection as an array.
+ */
+export type QuerySelectArray<E> = (Key<E> | QueryRaw)[];
+/**
+ * query selection as a map.
+ */
+export type QuerySelectMap<E> = QuerySelectFieldMap<E> | QuerySelectRelationMap<E>;
+/**
+ * query selection.
+ */
+export type QuerySelect<E> = QuerySelectArray<E> | QuerySelectMap<E>;
+/**
+ * query selection of fields as a map.
+ */
+export type QuerySelectFieldMap<E> = {
+    [K in FieldKey<E>]?: BooleanLike;
+};
+/**
+ * query conflict paths map.
+ */
+export type QueryConflictPathsMap<E> = {
+    [K in FieldKey<E>]?: true;
+};
+/**
+ * query conflict paths.
+ */
+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.
+ */
+export type QueryTextSearchOptions<E> = {
+    /**
+     * text to search for.
+     */
+    $value: string;
+    /**
+     * list of fields to search on.
+     */
+    $fields?: FieldKey<E>[];
+};
+/**
+ * comparison by fields.
+ */
+export type QueryWhereFieldMap<E> = {
+    [K in FieldKey<E>]?: QueryWhereFieldValue<E[K]>;
+};
+/**
+ * complex operators.
+ */
+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.
+     */
+    $and?: QueryWhereArray<E>;
+    /**
+     * joins query clauses with a logical `OR`, returns records that match any of the clauses.
+     */
+    $or?: QueryWhereArray<E>;
+    /**
+     * joins query clauses with a logical `AND`, returns records that do not match all the clauses.
+     */
+    $not?: QueryWhereArray<E>;
+    /**
+     * joins query clauses with a logical `OR`, returns records that do not match any of the clauses.
+     */
+    $nor?: QueryWhereArray<E>;
+    /**
+     * whether the specified fields match against a full-text search of the given string.
+     */
+    $text?: QueryTextSearchOptions<E>;
+    /**
+     * whether the record exists in the given sub-query.
+     */
+    $exists?: QueryRaw;
+    /**
+     * whether the record does not exists in the given sub-query.
+     */
+    $nexists?: QueryRaw;
+};
+export type QueryWhereFieldOperatorMap<T> = {
+    /**
+     * whether a value is equal to the given value.
+     */
+    $eq?: ExpandScalar<T>;
+    /**
+     * whether a value is not equal to the given value.
+     */
+    $ne?: ExpandScalar<T>;
+    /**
+     * negates the given comparison.
+     */
+    $not?: QueryWhereFieldValue<T>;
+    /**
+     * whether a value is less than the given value.
+     */
+    $lt?: ExpandScalar<T>;
+    /**
+     * whether a value is less than or equal to the given value.
+     */
+    $lte?: ExpandScalar<T>;
+    /**
+     * whether a value is greater than the given value.
+     */
+    $gt?: ExpandScalar<T>;
+    /**
+     * whether a value is greater than or equal to the given value.
+     */
+    $gte?: ExpandScalar<T>;
+    /**
+     * whether a string begins with the given string (case sensitive).
+     */
+    $startsWith?: string;
+    /**
+     * whether a string begins with the given string (case insensitive).
+     */
+    $istartsWith?: string;
+    /**
+     * whether a string ends with the given string (case sensitive).
+     */
+    $endsWith?: string;
+    /**
+     * whether a string ends with the given string (case insensitive).
+     */
+    $iendsWith?: string;
+    /**
+     * whether a string is contained within the given string (case sensitive).
+     */
+    $includes?: string;
+    /**
+     * whether a string is contained within the given string (case insensitive).
+     */
+    $iincludes?: string;
+    /**
+     * whether a string fulfills the given pattern (case sensitive).
+     */
+    $like?: string;
+    /**
+     * whether a string fulfills the given pattern (case insensitive).
+     */
+    $ilike?: string;
+    /**
+     * whether a string matches the given regular expression.
+     */
+    $regex?: string;
+    /**
+     * whether a value matches any of the given values.
+     */
+    $in?: ExpandScalar<T>[];
+    /**
+     * whether a value does not match any of the given values.
+     */
+    $nin?: ExpandScalar<T>[];
+};
+/**
+ * Value for a field comparison.
+ */
+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 QueryWhere<E> = QueryWhereSingle<E> | QueryWhereArray<E>;
+/**
+ * direction for the sort.
+ */
+export type QuerySortDirection = -1 | 1 | 'asc' | 'desc';
+/**
+ * sort by tuples
+ */
+export type QuerySortTuples<E> = [FieldKey<E>, QuerySortDirection][];
+/**
+ * sort by objects.
+ */
+export type QuerySortObjects<E> = {
+    field: FieldKey<E>;
+    sort: QuerySortDirection;
+}[];
+/**
+ * sort by fields.
+ */
+export type QuerySortFieldMap<E> = {
+    [K in FieldKey<E>]?: QuerySortDirection;
+};
+/**
+ * sort by relations fields.
+ */
+export type QuerySortRelationMap<E> = {
+    [K in RelationKey<E>]?: QuerySortMap<Unpacked<E[K]>>;
+};
+/**
+ * sort by map.
+ */
+export type QuerySortMap<E> = QuerySortFieldMap<E> | QuerySortRelationMap<E>;
+/**
+ * sort options.
+ */
+export type QuerySort<E> = QuerySortMap<E> | QuerySortTuples<E> | QuerySortObjects<E>;
+/**
+ * pager options.
+ */
+export type QueryPager = {
+    /**
+     * Index from where start the search
+     */
+    $skip?: number;
+    /**
+     * Max number of records to retrieve
+     */
+    $limit?: number;
+};
+/**
+ * search options.
+ */
+export type QuerySearch<E> = {
+    /**
+     * filtering options.
+     */
+    $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> = {
+    /**
+     * selection options.
+     */
+    $select?: QuerySelect<E>;
+} & QuerySearch<E>;
+/**
+ * options to get a single record.
+ */
+export type QueryOne<E> = Omit<Query<E>, '$limit'>;
+/**
+ * options to get an unique record.
+ */
+export type QueryUnique<E> = Pick<QueryOne<E>, '$select' | '$where'>;
+/**
+ * stringified query.
+ */
+export type QueryStringified = {
+    [K in keyof Query<unknown>]?: string;
+};
+/**
+ * result of an update operation.
+ */
+export type QueryUpdateResult = {
+    /**
+     * number of affected records.
+     */
+    changes?: number;
+    /**
+     * the inserted IDs.
+     */
+    ids?: number[] | string[];
+    /**
+     * first inserted ID.
+     */
+    firstId?: number | string;
+};
+/**
+ * options for the `raw` function.
+ */
+export type QueryRawFnOptions = {
+    /**
+     * the current dialect.
+     */
+    dialect?: QueryDialect;
+    /**
+     * the prefix.
+     */
+    prefix?: string;
+    /**
+     * the escaped prefix.
+     */
+    escapedPrefix?: string;
+    /**
+     * the query context.
+     */
+    ctx?: QueryContext;
+};
+/**
+ * a `raw` function
+ */
+export type QueryRawFn = (opts?: QueryRawFnOptions) => void | Scalar;
+export declare class QueryRaw {
+    readonly value: Scalar | QueryRawFn;
+    readonly alias?: string;
+    constructor(value: Scalar | QueryRawFn, alias?: string);
+}
+/**
+ * comparison options.
+ */
+export type QueryComparisonOptions = QueryOptions & {
+    /**
+     * use precedence for the comparison or not.
+     */
+    usePrecedence?: boolean;
+};
+/**
+ * query filter options.
+ */
+export type QueryWhereOptions = QueryComparisonOptions & {
+    /**
+     * clause to be used in the filter.
+     */
+    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 {
+    /**
+     * obtains the records matching the given search parameters.
+     * @param ctx the query context
+     * @param entity the target entity
+     * @param q the criteria options
+     * @param opts the query options
+     */
+    find<E>(ctx: QueryContext, entity: Type<E>, q: Query<E>, opts?: QueryOptions): void;
+    /**
+     * counts the number of records matching the given search parameters.
+     * @param ctx the query context
+     * @param entity the target entity
+     * @param q the criteria options
+     * @param opts the query options
+     */
+    count<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): void;
+    /**
+     * insert records.
+     * @param ctx the query context
+     * @param entity the target entity
+     * @param payload the payload
+     * @param opts the query options
+     */
+    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 q the criteria options
+     * @param payload
+     * @param opts the query options
+     */
+    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 q the criteria options
+     * @param opts the query options
+     */
+    delete<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): void;
+    /**
+     * escape an identifier.
+     * @param val the value to be escaped
+     * @param forbidQualified don't escape dots
+     * @param addDot use a dot as suffix
+     */
+    escapeId(val: string, forbidQualified?: boolean, addDot?: boolean): string;
+    /**
+     * escape a value.
+     * @param val the value to escape
+     */
+    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"]}

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

@@ -1,105 +1,112 @@
-import { IdValue } from './entity';
-import { Querier } from './querier';
-import { Query, QueryCriteria, QueryOne, QueryOptions, QuerySearch, QueryUnique } from './query';
-import { Type } from './utility';
+import type { IdValue } from './entity.js';
+import type { Query, QueryConflictPaths, QueryOne, QueryOptions, QuerySearch, QueryUpdateResult } from './query.js';
+import type { UniversalQuerier } from './universalQuerier.js';
+import type { Type } from './utility.js';
 /**
  * A `repository` allows to interact with the datasource to perform persistence operations on a specific entity.
  */
-export declare type UniversalRepository<E> = {
+export type UniversalRepository<E> = {
     /**
-     * counts the number of records matching the given search parameters.
-     * @param qm the search options
+     * the `entity` class to which this `repository` is linked to.
+     */
+    readonly entity: Type<E>;
+    /**
+     * the `querier` instance to which this `repository` is linked to.
      */
-    count(qm: QuerySearch<E>): Promise<any>;
+    readonly querier: UniversalQuerier;
     /**
      * obtains the record with the given primary key.
      * @param id the primary key value
-     * @param qm the criteria options
+     * @param q the criteria options
      */
-    findOneById(id: IdValue<E>, qm?: QueryUnique<E>): Promise<any>;
+    findOneById(id: IdValue<E>, q?: QueryOne<E>): Promise<unknown>;
     /**
      * obtains the first record matching the given search parameters.
-     * @param qm the criteria options
+     * @param q the criteria options
      */
-    findOne(qm: QueryOne<E>): Promise<any>;
+    findOne(q: QueryOne<E>): Promise<unknown>;
     /**
      * obtains the records matching the given search parameters.
-     * @param qm the criteria options
+     * @param q the criteria options
      */
-    findMany(qm: Query<E>): Promise<any>;
+    findMany(q: Query<E>): Promise<unknown>;
     /**
      * obtains the records matching the given search parameters,
      * also counts the number of matches ignoring pagination.
-     * @param qm the criteria options
+     * @param q the criteria options
+     */
+    findManyAndCount(q: Query<E>): Promise<unknown>;
+    /**
+     * counts the number of records matching the given search parameters.
+     * @param q the search options
      */
-    findManyAndCount(qm: Query<E>): Promise<any>;
+    count(q: QuerySearch<E>): Promise<unknown>;
     /**
      * inserts a record.
      * @param payload the data to be persisted
      */
-    insertOne(payload: E): Promise<any>;
+    insertOne(payload: E): Promise<unknown>;
     /**
      * Inserts many records.
      * @param entity the entity to persist on
      * @param payload the data to be persisted
      */
-    insertMany?(payload: E[]): Promise<any>;
+    insertMany?(payload: E[]): Promise<unknown>;
     /**
      * updates a record partially.
      * @param id the primary key of the record to be updated
      * @param payload the data to be persisted
      */
-    updateOneById(id: IdValue<E>, payload: E): Promise<any>;
+    updateOneById(id: IdValue<E>, payload: E): Promise<unknown>;
     /**
      * updates many records partially.
      * @param qm the criteria to look for the records
      * @param payload the data to be persisted
      */
-    updateMany?(qm: QueryCriteria<E>, payload: E): Promise<any>;
+    updateMany?(qm: QuerySearch<E>, payload: E): Promise<unknown>;
+    /**
+     * Insert or update a record given a search criteria.
+     * @param conflictPaths the keys to use for the unique search.
+     * @param payload the data to insert or update.
+     */
+    upsertOne?(conflictPaths: QueryConflictPaths<E>, payload: E): Promise<unknown>;
     /**
      * Insert or update a record.
      * @param payload the data to be persisted
      */
-    saveOne(payload: E): Promise<any>;
+    saveOne(payload: E): Promise<unknown>;
     /**
      * insert or update records.
      * @param payload the data to be persisted
      */
-    saveMany?(payload: E[]): Promise<any>;
+    saveMany?(payload: E[]): Promise<unknown>;
     /**
      * delete or SoftDelete a record.
      * @param id the primary key of the record
      */
-    deleteOneById(id: IdValue<E>, opts?: QueryOptions): Promise<any>;
+    deleteOneById(id: IdValue<E>, opts?: QueryOptions): Promise<unknown>;
     /**
      * delete or SoftDelete records.
      * @param qm the criteria to look for the records
      */
-    deleteMany(qm: QueryCriteria<E>, opts?: QueryOptions): Promise<any>;
+    deleteMany(qm: QuerySearch<E>, opts?: QueryOptions): Promise<unknown>;
 };
 /**
  * base contract for the backend repositories.
  */
 export interface Repository<E> extends UniversalRepository<E> {
-    /**
-     * the `entity` type to which this `repository` is linked to.
-     */
-    readonly entity: Type<E>;
-    /**
-     * the `querier` instance to which this `repository` is linked to.
-     */
-    readonly querier: Querier;
-    count(qm: QueryCriteria<E>): Promise<number>;
-    findOneById(id: IdValue<E>, qm?: QueryUnique<E>): Promise<E>;
+    findOneById(id: IdValue<E>, q?: QueryOne<E>): Promise<E>;
     findOne(qm: QueryOne<E>): Promise<E>;
     findMany(qm: Query<E>): Promise<E[]>;
     findManyAndCount(qm: Query<E>): Promise<[E[], number]>;
+    count(q?: QuerySearch<E>): Promise<number>;
     insertOne(payload: E): Promise<IdValue<E>>;
     insertMany(payload: E[]): Promise<IdValue<E>[]>;
     updateOneById(id: IdValue<E>, payload: E): Promise<number>;
-    updateMany(qm: QueryCriteria<E>, payload: E): Promise<number>;
+    updateMany(qm: QuerySearch<E>, payload: E): Promise<number>;
+    upsertOne(conflictPaths: QueryConflictPaths<E>, payload: E): Promise<QueryUpdateResult>;
     saveOne(payload: E): Promise<IdValue<E>>;
     saveMany?(payload: E[]): Promise<IdValue<E>[]>;
     deleteOneById(id: IdValue<E>, opts?: QueryOptions): Promise<number>;
-    deleteMany(qm: QueryCriteria<E>, opts?: QueryOptions): Promise<number>;
+    deleteMany(qm: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
 }