@decaf-ts/core 0.18.0 → 0.19.0

package/lib/types/persistence/types.d.mts

@@ -0,0 +1,86 @@
+import { BulkCrudOperationKeys, LoggerOfFlags, OperationKeys, RepositoryFlags, ContextFlags as CtxFlags } from "@decaf-ts/db-decorators";
+import { Adapter } from "./Adapter.js";
+import { Observable, type Observer } from "../interfaces/index.js";
+import { Logger } from "@decaf-ts/logging";
+import { Constructor } from "@decaf-ts/decoration";
+import { Model } from "@decaf-ts/decorator-validation";
+import { ContextualArgs, ContextualLoggedClass } from "../utils/ContextualLoggedClass.js";
+import { Context } from "./Context.js";
+import { Repository } from "../repository/Repository.js";
+import { PersistenceKeys } from "./constants.js";
+import { PreparedStatementKeys } from "../query/constants.js";
+import { ContextLock } from "./ContextLock.js";
+export type FlagsOfContext<C extends Context<any>> = C extends Context<infer F> ? F : never;
+export type LoggerOfContext<C extends Context<any>> = LoggerOfFlags<FlagsOfContext<C>>;
+export type ContextOfRepository<R extends Repository<any, any>> = R extends Repository<any, infer A> ? ContextOf<A> : never;
+export type FlagsOfRepository<R extends Repository<any, any>> = FlagsOfContext<ContextOfRepository<R>>;
+export type LoggerOfRepository<R extends Repository<any, any>> = LoggerOfContext<ContextOfRepository<R>>;
+export type ContextOf<OBJ extends Repository<any, any> | Adapter<any, any, any, any> | ContextualLoggedClass<any>> = OBJ extends Adapter<any, any, any, infer C> ? C : OBJ extends Repository<any, any> ? ContextOfRepository<OBJ> : OBJ extends ContextualLoggedClass<infer C> ? C : never;
+export type ConfigOf<OBJ extends Adapter<any, any, any, any>> = OBJ extends Adapter<infer C, any, any, any> ? C : never;
+export type LoggerOfAdapter<A extends Adapter<any, any, any, any>> = A extends Adapter<any, any, any, infer C> ? LoggerOfContext<C> : never;
+export type FlagsOfAdapter<A extends Adapter<any, any, any, any>> = A extends Adapter<any, any, any, infer C> ? FlagsOfContext<C> : never;
+export type LoggerOf<OBJ extends AdapterFlags<any> | Context<any> | Adapter<any, any, any> | Repository<any, any>> = OBJ extends AdapterFlags<any> ? LoggerOfFlags<OBJ> : OBJ extends Context<any> ? LoggerOfContext<OBJ> : OBJ extends Repository<any, any> ? LoggerOfRepository<OBJ> : OBJ extends Adapter<any, any, any> ? LoggerOfAdapter<OBJ> : Logger;
+export type ConfOf<A extends Adapter<any, any, any, any>> = A extends Adapter<infer C, any, any> ? C : never;
+export type FlagsOf<OBJ extends Repository<any, any> | Adapter<any, any, any, any> | Context<any>> = OBJ extends Context<any> ? FlagsOfContext<OBJ> : OBJ extends Repository<any, any> ? FlagsOfRepository<OBJ> : OBJ extends Adapter<any, any, any, any> ? FlagsOfAdapter<OBJ> : never;
+export type PersistenceObservable<CONTEXT extends Context<any>> = Observable<[
+    Observer,
+    ObserverFilter?
+], [
+    Constructor | string,
+    OperationKeys | BulkCrudOperationKeys | string,
+    EventIds,
+    ...ContextualArgs<CONTEXT>
+]>;
+export type PersistenceObserver<CONTEXT extends Context<any>> = Observer<[
+    Constructor | string,
+    OperationKeys | BulkCrudOperationKeys | string,
+    EventIds,
+    ...ContextualArgs<CONTEXT>
+]>;
+/**
+ * @description Type representing possible ID formats for database events
+ * @summary A union type that defines the possible formats for event identifiers in the persistence layer.
+ * These can be single values (string, number, bigint) or arrays of these types.
+ * @typedef {(string|number|bigint|string[]|number[]|bigint[])} EventIds
+ * @memberOf module:core
+ */
+export type EventIds = string | number | bigint | string[] | number[] | bigint[];
+export type ObserverFilter = (table: Constructor | string, event: AllOperationKeys, id: EventIds, ...args: ContextualArgs<any>) => boolean;
+export type InferredAdapterConfig<A> = A extends Adapter<infer CONF, any, any> ? CONF : never;
+export interface AdapterDispatch<A extends Adapter<any, any, any, any>> extends PersistenceObservable<ContextOf<A>> {
+    close(...args: ContextualArgs<ContextOf<A>>): Promise<void>;
+    updateObservers<M extends Model>(table: Constructor<M> | string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: ContextualArgs<ContextOf<A>>): Promise<void>;
+}
+export type RepositoryFor<A extends Adapter<any, any, any, any>> = A extends Adapter<any, any, any, any> ? ReturnType<A["repository"]> : never;
+export type PreparedModel = {
+    record: Record<string, any>;
+    id: string;
+    transient?: Record<string, any>;
+};
+export type ContextFlags<LOG extends Logger> = CtxFlags<LOG> & Pick<RepositoryFlags<LOG>, "operation" | "correlationId" | "ignoreDevSafeGuards" | "parentContext" | "childContexts"> & {
+    pending?: Record<string, string[]>;
+    transactionLock?: ContextLock;
+};
+export type AdapterFlags<LOG extends Logger = Logger> = RepositoryFlags<LOG> & ContextFlags<LOG> & {
+    allowGenerationOverride: boolean;
+    afterQueryHandlers: boolean;
+    enforceUpdateValidation: boolean;
+    allowRawStatements: boolean;
+    forcePrepareSimpleQueries: boolean;
+    forcePrepareComplexQueries: boolean;
+    cacheForPopulate: Record<string, any>;
+    preferFromCache: boolean;
+    noEmit: boolean;
+    noEmitSingle: boolean;
+    noEmitBulk: boolean;
+    breakOnSingleFailureInBulk: boolean;
+    observeFullResult: boolean;
+    paginateByBookmark: boolean;
+    dryRun: boolean;
+    lock?: ContextLock;
+};
+export type RawResult<R, D extends boolean> = D extends true ? R : {
+    data: R;
+    count?: number;
+};
+export type AllOperationKeys = OperationKeys | BulkCrudOperationKeys | PersistenceKeys | PreparedStatementKeys | string;

package/lib/types/query/Condition.d.cts

@@ -0,0 +1,131 @@
+import { AttributeOption, ConditionBuilderOption } from "./options.cjs";
+import { ConditionalAsync, Model, ModelArg, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
+import { GroupOperator, Operator } from "./constants.cjs";
+type InferAsync<M> = M extends Model<infer A> ? A : false;
+/**
+ * @description Represents a logical condition for database queries
+ * @summary A class that encapsulates query conditions with support for complex logical operations.
+ * This class allows for building and combining query conditions using logical operators (AND, OR, NOT)
+ * and comparison operators (equals, not equals, greater than, etc.).
+ * @template M - The model type this condition operates on
+ * @param {string | Condition<M>} attr1 - The attribute name or a nested condition
+ * @param {Operator | GroupOperator} operator - The operator to use for the condition
+ * @param {any} comparison - The value to compare against or another condition
+ * @class Condition
+ * @example
+ * // Create a simple condition
+ * const nameCondition = Condition.attribute("name").eq("John");
+ *
+ * // Create a complex condition
+ * const complexCondition = Condition.attribute("age").gt(18)
+ *   .and(Condition.attribute("status").eq("active"));
+ *
+ * // Use the builder pattern
+ * const userQuery = Condition.builder()
+ *   .attribute("email").regexp(".*@example.com")
+ *   .and(Condition.attribute("lastLogin").gt(new Date("2023-01-01")));
+ * @mermaid
+ * sequenceDiagram
+ *   participant Dev
+ *   participant Condition
+ *   Dev->>Condition: builder().attribute("age").gt(18)
+ *   Condition-->>Dev: Condition(age > 18)
+ *   Dev->>Condition: .and(attribute("status").eq("active"))
+ *   Condition-->>Dev: Condition((age > 18) AND (status = "active"))
+ */
+export declare class Condition<M extends Model<any>> extends Model<InferAsync<M>> {
+    protected attr1?: string | Condition<M>;
+    protected operator?: Operator | GroupOperator;
+    protected comparison?: any;
+    private constructor();
+    private constructor();
+    /**
+     * @description Combines this condition with another using logical AND
+     * @summary Joins two conditions with an AND operator, requiring both to be true
+     * @param {Condition<M>} condition - The condition to combine with this one
+     * @return {Condition<M>} A new condition representing the AND operation
+     */
+    and(condition: Condition<M>): Condition<M>;
+    /**
+     * @description Combines this condition with another using logical OR
+     * @summary Joins two conditions with an OR operator, requiring at least one to be true
+     * @param {Condition<M>} condition - The condition to combine with this one
+     * @return {Condition<M>} A new condition representing the OR operation
+     */
+    or(condition: Condition<M>): Condition<M>;
+    /**
+     * @description Creates a negation condition
+     * @summary Excludes a value from the result by applying a NOT operator
+     * @param {any} val - The value to negate
+     * @return {Condition<M>} A new condition representing the NOT operation
+     */
+    not(val: any): Condition<M>;
+    /**
+     * @description Validates the condition and checks for errors
+     * @summary Extends the base validation to ensure the condition is properly formed
+     * @param {...string[]} exceptions - Fields to exclude from validation
+     * @return {ModelErrorDefinition | undefined} Error definition if validation fails, undefined otherwise
+     */
+    hasErrors(...exceptions: string[]): ConditionalAsync<InferAsync<M>, ModelErrorDefinition | undefined>;
+    /**
+     * @description Creates a new condition that combines two conditions with logical AND
+     * @summary Static method that joins two conditions with an AND operator, requiring both to be true
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the AND operation
+     */
+    static and<M extends Model>(condition1: Condition<M>, condition2: Condition<M>): Condition<M>;
+    /**
+     * @description Creates a new condition that combines two conditions with logical OR
+     * @summary Static method that joins two conditions with an OR operator, requiring at least one to be true
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the OR operation
+     */
+    static or<M extends Model>(condition1: Condition<M>, condition2: Condition<M>): Condition<M>;
+    /**
+     * @description Creates a new condition that groups two conditions with a specified operator
+     * @summary Private static method that combines two conditions using the specified group operator
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {GroupOperator} operator - The group operator to use (AND, OR)
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the grouped operation
+     */
+    private static group;
+    /**
+     * @description Creates a condition builder for a specific model attribute
+     * @summary Static method that initializes a condition builder with the specified attribute
+     * @template M - The model type this condition operates on
+     * @param attr - The model attribute to build a condition for
+     * @return {AttributeOption<M>} A condition builder initialized with the attribute
+     */
+    static attribute<M extends Model>(attr: keyof M): AttributeOption<M>;
+    /**
+     * @description Alias for the attribute method
+     * @summary Shorthand method that initializes a condition builder with the specified attribute
+     * @template M - The model type this condition operates on
+     * @param attr - The model attribute to build a condition for
+     * @return {AttributeOption<M>} A condition builder initialized with the attribute
+     */
+    static attr<M extends Model>(attr: keyof M): AttributeOption<M>;
+    /**
+     * @description Provides a fluent API to build query conditions
+     * @summary A builder class that simplifies the creation of database query conditions
+     * with a chainable interface for setting attributes and operators
+     * @template M - The model type this condition builder operates on
+     * @class ConditionBuilder
+     */
+    private static Builder;
+    /**
+     * @description Creates a new condition builder
+     * @summary Factory method that returns a new instance of the condition builder
+     * @template M - The model type this condition builder will operate on
+     * @return {ConditionBuilderOption<M>} A new condition builder instance
+     */
+    static builder<M extends Model>(): ConditionBuilderOption<M>;
+    static from(obj: ModelArg<Condition<any>>): Condition<Model<any>>;
+}
+export {};

package/lib/types/query/Condition.d.mts

@@ -0,0 +1,131 @@
+import { AttributeOption, ConditionBuilderOption } from "./options.js";
+import { ConditionalAsync, Model, ModelArg, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
+import { GroupOperator, Operator } from "./constants.js";
+type InferAsync<M> = M extends Model<infer A> ? A : false;
+/**
+ * @description Represents a logical condition for database queries
+ * @summary A class that encapsulates query conditions with support for complex logical operations.
+ * This class allows for building and combining query conditions using logical operators (AND, OR, NOT)
+ * and comparison operators (equals, not equals, greater than, etc.).
+ * @template M - The model type this condition operates on
+ * @param {string | Condition<M>} attr1 - The attribute name or a nested condition
+ * @param {Operator | GroupOperator} operator - The operator to use for the condition
+ * @param {any} comparison - The value to compare against or another condition
+ * @class Condition
+ * @example
+ * // Create a simple condition
+ * const nameCondition = Condition.attribute("name").eq("John");
+ *
+ * // Create a complex condition
+ * const complexCondition = Condition.attribute("age").gt(18)
+ *   .and(Condition.attribute("status").eq("active"));
+ *
+ * // Use the builder pattern
+ * const userQuery = Condition.builder()
+ *   .attribute("email").regexp(".*@example.com")
+ *   .and(Condition.attribute("lastLogin").gt(new Date("2023-01-01")));
+ * @mermaid
+ * sequenceDiagram
+ *   participant Dev
+ *   participant Condition
+ *   Dev->>Condition: builder().attribute("age").gt(18)
+ *   Condition-->>Dev: Condition(age > 18)
+ *   Dev->>Condition: .and(attribute("status").eq("active"))
+ *   Condition-->>Dev: Condition((age > 18) AND (status = "active"))
+ */
+export declare class Condition<M extends Model<any>> extends Model<InferAsync<M>> {
+    protected attr1?: string | Condition<M>;
+    protected operator?: Operator | GroupOperator;
+    protected comparison?: any;
+    private constructor();
+    private constructor();
+    /**
+     * @description Combines this condition with another using logical AND
+     * @summary Joins two conditions with an AND operator, requiring both to be true
+     * @param {Condition<M>} condition - The condition to combine with this one
+     * @return {Condition<M>} A new condition representing the AND operation
+     */
+    and(condition: Condition<M>): Condition<M>;
+    /**
+     * @description Combines this condition with another using logical OR
+     * @summary Joins two conditions with an OR operator, requiring at least one to be true
+     * @param {Condition<M>} condition - The condition to combine with this one
+     * @return {Condition<M>} A new condition representing the OR operation
+     */
+    or(condition: Condition<M>): Condition<M>;
+    /**
+     * @description Creates a negation condition
+     * @summary Excludes a value from the result by applying a NOT operator
+     * @param {any} val - The value to negate
+     * @return {Condition<M>} A new condition representing the NOT operation
+     */
+    not(val: any): Condition<M>;
+    /**
+     * @description Validates the condition and checks for errors
+     * @summary Extends the base validation to ensure the condition is properly formed
+     * @param {...string[]} exceptions - Fields to exclude from validation
+     * @return {ModelErrorDefinition | undefined} Error definition if validation fails, undefined otherwise
+     */
+    hasErrors(...exceptions: string[]): ConditionalAsync<InferAsync<M>, ModelErrorDefinition | undefined>;
+    /**
+     * @description Creates a new condition that combines two conditions with logical AND
+     * @summary Static method that joins two conditions with an AND operator, requiring both to be true
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the AND operation
+     */
+    static and<M extends Model>(condition1: Condition<M>, condition2: Condition<M>): Condition<M>;
+    /**
+     * @description Creates a new condition that combines two conditions with logical OR
+     * @summary Static method that joins two conditions with an OR operator, requiring at least one to be true
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the OR operation
+     */
+    static or<M extends Model>(condition1: Condition<M>, condition2: Condition<M>): Condition<M>;
+    /**
+     * @description Creates a new condition that groups two conditions with a specified operator
+     * @summary Private static method that combines two conditions using the specified group operator
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {GroupOperator} operator - The group operator to use (AND, OR)
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the grouped operation
+     */
+    private static group;
+    /**
+     * @description Creates a condition builder for a specific model attribute
+     * @summary Static method that initializes a condition builder with the specified attribute
+     * @template M - The model type this condition operates on
+     * @param attr - The model attribute to build a condition for
+     * @return {AttributeOption<M>} A condition builder initialized with the attribute
+     */
+    static attribute<M extends Model>(attr: keyof M): AttributeOption<M>;
+    /**
+     * @description Alias for the attribute method
+     * @summary Shorthand method that initializes a condition builder with the specified attribute
+     * @template M - The model type this condition operates on
+     * @param attr - The model attribute to build a condition for
+     * @return {AttributeOption<M>} A condition builder initialized with the attribute
+     */
+    static attr<M extends Model>(attr: keyof M): AttributeOption<M>;
+    /**
+     * @description Provides a fluent API to build query conditions
+     * @summary A builder class that simplifies the creation of database query conditions
+     * with a chainable interface for setting attributes and operators
+     * @template M - The model type this condition builder operates on
+     * @class ConditionBuilder
+     */
+    private static Builder;
+    /**
+     * @description Creates a new condition builder
+     * @summary Factory method that returns a new instance of the condition builder
+     * @template M - The model type this condition builder will operate on
+     * @return {ConditionBuilderOption<M>} A new condition builder instance
+     */
+    static builder<M extends Model>(): ConditionBuilderOption<M>;
+    static from(obj: ModelArg<Condition<any>>): Condition<Model<any>>;
+}
+export {};

package/lib/types/query/MethodQueryBuilder.d.cts

@@ -0,0 +1,185 @@
+import { QueryAction, QueryAssist } from "./types.cjs";
+import { LoggedClass, Logger } from "@decaf-ts/logging";
+export type QueryActionPrefix = {
+    action: QueryAction;
+    prefix: string;
+};
+/**
+ * @description
+ * Utility class to build query objects from repository method names.
+ *
+ * @summary
+ * The `MethodQueryBuilder` class parses method names that follow a specific naming convention
+ * (e.g., `findByNameAndAgeOrderByCountryAsc`) and converts them into structured query objects
+ * (`QueryAssist`). It extracts clauses such as `select`, `where`, `groupBy`, `orderBy`, `limit`,
+ * and `offset`, ensuring that developers can declare repository queries using expressive method names.
+ *
+ * @param methodName {string} - The repository method name to parse and convert into a query.
+ * @param values {any[]} - The values corresponding to method parameters used for query conditions.
+ *
+ * @return {QueryAssist} A structured query object describing the parsed action, select, where,
+ * groupBy, orderBy, limit, and offset clauses.
+ *
+ * @class
+ *
+ * @example
+ * ```ts
+ * const query = MethodQueryBuilder.build(
+ *   "findByNameAndAgeOrderByCountryAsc",
+ *   "John",
+ *   25,
+ *   [["country", "ASC"]]
+ * );
+ *
+ * console.log(query);
+ * // {
+ * //   action: "find",
+ * //   select: undefined,
+ * //   where: { ... },
+ * //   groupBy: undefined,
+ * //   orderBy: [["country", "ASC"]],
+ * //   limit: undefined,
+ * //   offset: undefined
+ * // }
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Repo as Repository Method
+ *   participant MQB as MethodQueryBuilder
+ *   participant Query as QueryAssist
+ *
+ *   Repo->>MQB: build(methodName, ...values)
+ *   MQB->>MQB: extractCore(methodName)
+ *   MQB->>MQB: extractSelect(methodName)
+ *   MQB->>MQB: extractGroupBy(methodName)
+ *   MQB->>MQB: buildWhere(core, values)
+ *   MQB->>MQB: extractOrderLimitOffset(core, values)
+ *   MQB->>Query: return structured QueryAssist object
+ */
+export declare class MethodQueryBuilder extends LoggedClass {
+    private static _logger;
+    protected static get log(): Logger;
+    /**
+     * @description
+     * Map of query prefixes to their corresponding actions.
+     */
+    private static readonly prefixMap;
+    /**
+     * @description
+     * Determines the action and prefix length from a method name.
+     *
+     * @param methodName {string} - The repository method name.
+     * @return {QueryActionPrefix} | undefined} The action and prefix if found.
+     */
+    private static getActionFromMethodName;
+    /**
+     * @description
+     * Builds a `QueryAssist` object by parsing a repository method name and values.
+     *
+     * @summary
+     * The method validates the method name, extracts clauses (core, select, groupBy, where,
+     * orderBy, limit, and offset), and assembles them into a structured query object
+     * that can be executed against a data source.
+     *
+     * @param methodName {string} - The repository method name that encodes query information.
+     * @param values {any[]} - The values corresponding to conditions and extra clauses.
+     *
+     * @return {QueryAssist} A structured query object representing the parsed query.
+     */
+    static build(methodName: string, ...values: any[]): QueryAssist;
+    /**
+     * @description
+     * Extracts the aggregation selector field from method names like countByAge, sumByPrice.
+     *
+     * @param methodName {string} - The method name.
+     * @param prefix {string} - The prefix to remove.
+     * @return {string | undefined} The selector field name.
+     */
+    private static extractAggregationSelector;
+    /**
+     * @description
+     * Extracts the core part of the method name after the prefix and before any special clauses.
+     *
+     * @summary
+     * Removes prefixes and detects delimiters (`Then`, `OrderBy`, `GroupBy`, `Limit`, `Offset`)
+     * to isolate the main conditional part of the query.
+     *
+     * @param methodName {string} - The method name to parse.
+     * @param prefix {string} - The prefix to remove (e.g., "findBy", "countBy").
+     *
+     * @return {string} The extracted core string used for building conditions.
+     */
+    private static extractCore;
+    static getFieldsFromMethodName(methodName: string): Array<string>;
+    /**
+     * @description
+     * Extracts the select clause from a method name.
+     *
+     * @summary
+     * Detects the `Select` keyword in the method name, isolates the fields following it,
+     * and returns them as an array of lowercase-first strings.
+     *
+     * @param methodName {string} - The method name to parse.
+     *
+     * @return {string[] | undefined} An array of selected fields or `undefined` if no select clause exists.
+     */
+    private static extractSelect;
+    /**
+     * @description
+     * Extracts the group by clause from a method name.
+     *
+     * @summary
+     * Detects the `GroupBy` keyword in the method name, isolates the fields following it,
+     * and returns them as an array of lowercase-first strings.
+     *
+     * @param methodName {string} - The method name to parse.
+     *
+     * @return {string[] | undefined} An array of group by fields or `undefined` if no group by clause exists.
+     */
+    private static extractGroupBy;
+    /**
+     * @description
+     * Builds the `where` condition object based on the parsed core string and parameter values.
+     *
+     * @summary
+     * Splits the core string by logical operators (`And`, `Or`), parses each token into a field
+     * and operator, and combines them into a `Condition` object using the provided values.
+     *
+     * @param core {string} - The extracted core string from the method name.
+     * @param values {any[]} - The values corresponding to the conditions.
+     *
+     * @return {Condition<any>} A structured condition object representing the query's where clause.
+     */
+    private static buildWhere;
+    /**
+     * @description
+     * Parses a field name and operator from a string token.
+     *
+     * @summary
+     * Identifies the operator suffix (if present) and returns a descriptor containing the field
+     * name in lowercase-first format along with the operator.
+     *
+     * @param str {string} - The token string to parse.
+     *
+     * @return {FilterDescriptor} An object containing the field name and operator.
+     */
+    private static parseFieldAndOperator;
+    private static extractOrderByField;
+    private static getProperlyOrderByOrThrow;
+    /**
+     * @description
+     * Extracts `orderBy`, `limit`, and `offset` clauses from method arguments.
+     *
+     * @summary
+     * Determines the number of condition arguments, then checks the remaining arguments
+     * to resolve sorting, limiting, and pagination.
+     *
+     * @param methodName {string} - The method name.
+     * @param values {any[]} - The values corresponding to method arguments, including conditions and extras.
+     * @param core {string} - The pre-extracted core string.
+     *
+     * @return {OrderLimitOffsetExtract} An object containing orderBy, limit, and offset values if present.
+     */
+    private static extractOrderLimitOffset;
+}