@decaf-ts/core
Version:
Core persistence module for the decaf framework
276 lines • 32.1 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.MethodQueryBuilder = void 0;
const types_1 = require("./types.cjs");
const utils_1 = require("./utils.cjs");
const lowerFirst = (str) => str.charAt(0).toLowerCase() + str.slice(1);
/**
* @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
*/
class MethodQueryBuilder {
/**
* @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, ...values) {
if (!methodName.startsWith(types_1.QueryClause.FIND_BY)) {
throw new Error(`Unsupported method ${methodName}`);
}
const core = this.extractCore(methodName);
const select = this.extractSelect(methodName);
const groupBy = this.extractGroupBy(methodName);
// const orderBy = this.extractOrderBy(methodName);
const where = this.buildWhere(core, values);
const { orderBy, limit, offset } = this.extractOrderLimitOffset(core, values);
return {
action: "find",
select: select,
where,
groupBy,
orderBy,
limit,
offset,
};
}
/**
* @description
* Extracts the core part of the method name after `findBy` 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.
*
* @return {string} The extracted core string used for building conditions.
*/
static extractCore(methodName) {
const afterFindBy = methodName.substring(types_1.QueryClause.FIND_BY.length);
const regex = /(Then[A-Z]|OrderBy|GroupBy|Limit|Offset)/;
const match = afterFindBy.match(regex);
return match ? afterFindBy.substring(0, match.index) : afterFindBy;
}
/**
* @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.
*/
static extractSelect(methodName) {
const selectIndex = methodName.indexOf(types_1.QueryClause.SELECT);
if (selectIndex === -1)
return undefined;
const afterSelect = methodName.substring(selectIndex + types_1.QueryClause.SELECT.length);
// Search for next Then, GroupBy, OrderBy...
const match = afterSelect.match(/(Then[A-Z]|OrderBy|GroupBy|Limit|Offset)/);
const selectPart = match
? afterSelect.substring(0, match.index)
: afterSelect;
return selectPart.split(types_1.QueryClause.AND).map(lowerFirst).filter(Boolean);
}
/**
* @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.
*/
static extractGroupBy(methodName) {
const groupByIndex = methodName.indexOf(types_1.QueryClause.GROUP_BY);
if (groupByIndex === -1)
return undefined;
const after = methodName.substring(groupByIndex + types_1.QueryClause.GROUP_BY.length);
const groupByPart = after.split(types_1.QueryClause.ORDER_BY)[0];
return groupByPart
.split(types_1.QueryClause.THEN_BY)
.map(lowerFirst)
.filter(Boolean);
}
// private static extractOrderBy(
// methodName: string
// ): OrderBySelector<any>[] | undefined {
// const orderByIndex = methodName.indexOf(QueryClause.ORDER_BY);
// if (orderByIndex === -1) return undefined;
//
// const after = methodName.substring(
// orderByIndex + QueryClause.ORDER_BY.length
// );
// const orderParts = after.split("ThenBy");
//
// return orderParts.map((part) => {
// const match = part.match(/(.*?)(Asc|Desc|Dsc)$/);
// if (!match) throw new Error(`Invalid OrderBy part: ${part}`);
// const [, field, dir] = match;
// return [
// lowerFirst(field),
// dir.toLowerCase() === "dsc"
// ? OrderDirection.DSC
// : (dir.toLowerCase() as OrderDirection),
// ];
// });
// }
/**
* @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.
*/
static buildWhere(core, values) {
const parts = core.split(/OrderBy|GroupBy/)[0] || "";
const conditions = parts.split(/And|Or/);
const operators = core.match(/And|Or/g) || [];
let where;
conditions.forEach((token, idx) => {
const { field, operator } = this.parseFieldAndOperator(token);
const parser = operator ? utils_1.OperatorsMap[operator] : utils_1.OperatorsMap.Equals;
if (!parser)
throw new Error(`Unsupported operator ${operator}`);
const conditionValue = values[idx];
if (typeof conditionValue === "undefined") {
throw new Error(`Invalid value for field ${field}`);
}
const condition = parser(field, conditionValue);
where =
idx === 0
? condition
: operators[idx - 1] === types_1.QueryClause.AND
? where.and(condition)
: where.or(condition);
});
if (!where)
throw new Error("No conditions found in method name");
return where;
}
/**
* @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.
*/
static parseFieldAndOperator(str) {
for (const operator of Object.keys(utils_1.OperatorsMap)) {
if (str.endsWith(operator)) {
const field = str.slice(0, -operator.length);
return { field: lowerFirst(field), operator };
}
}
return { field: lowerFirst(str) };
}
/**
* @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 core {string} - The extracted core string from the method name.
* @param values {any[]} - The values corresponding to method arguments, including conditions and extras.
*
* @return {{
* orderBy?: OrderBySelector<any>[];
* limit?: number;
* offset?: number;
* }} An object containing orderBy, limit, and offset values if present.
*/
static extractOrderLimitOffset(core, values) {
const conditionCount = core.split(/And|Or/).length;
const extraArgs = values.slice(conditionCount);
let orderBy;
let limit;
let offset;
if (extraArgs.length >= 1 && Array.isArray(extraArgs[0]))
orderBy = extraArgs[0];
if (extraArgs.length >= 2 && typeof extraArgs[1] === "number")
limit = extraArgs[1];
if (extraArgs.length >= 3 && typeof extraArgs[2] === "number")
offset = extraArgs[2];
return { orderBy, limit, offset };
}
}
exports.MethodQueryBuilder = MethodQueryBuilder;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MethodQueryBuilder.js","sourceRoot":"","sources":["../../src/query/MethodQueryBuilder.ts"],"names":[],"mappings":";;;AACA,uCAAqE;AACrE,uCAAuC;AAEvC,MAAM,UAAU,GAAG,CAAC,GAAW,EAAU,EAAE,CACzC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAa,kBAAkB;IAC7B;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,KAAK,CAAC,UAAkB,EAAE,GAAG,MAAa;QAC/C,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,mBAAW,CAAC,OAAO,CAAC,EAAE,CAAC;YAChD,MAAM,IAAI,KAAK,CAAC,sBAAsB,UAAU,EAAE,CAAC,CAAC;QACtD,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;QAC1C,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QAC9C,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QAChD,mDAAmD;QACnD,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC5C,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,uBAAuB,CAC7D,IAAI,EACJ,MAAM,CACP,CAAC;QAEF,OAAO;YACL,MAAM,EAAE,MAAM;YACd,MAAM,EAAE,MAAM;YACd,KAAK;YACL,OAAO;YACP,OAAO;YACP,KAAK;YACL,MAAM;SACP,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;OAWG;IACK,MAAM,CAAC,WAAW,CAAC,UAAkB;QAC3C,MAAM,WAAW,GAAG,UAAU,CAAC,SAAS,CAAC,mBAAW,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACrE,MAAM,KAAK,GAAG,0CAA0C,CAAC;QACzD,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACvC,OAAO,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;IACrE,CAAC;IAED;;;;;;;;;;;OAWG;IACK,MAAM,CAAC,aAAa,CAAC,UAAkB;QAC7C,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,CAAC,mBAAW,CAAC,MAAM,CAAC,CAAC;QAC3D,IAAI,WAAW,KAAK,CAAC,CAAC;YAAE,OAAO,SAAS,CAAC;QAEzC,MAAM,WAAW,GAAG,UAAU,CAAC,SAAS,CACtC,WAAW,GAAG,mBAAW,CAAC,MAAM,CAAC,MAAM,CACxC,CAAC;QAEF,4CAA4C;QAC5C,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAE5E,MAAM,UAAU,GAAG,KAAK;YACtB,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC;YACvC,CAAC,CAAC,WAAW,CAAC;QAEhB,OAAO,UAAU,CAAC,KAAK,CAAC,mBAAW,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC3E,CAAC;IAED;;;;;;;;;;;OAWG;IACK,MAAM,CAAC,cAAc,CAAC,UAAkB;QAC9C,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,CAAC,mBAAW,CAAC,QAAQ,CAAC,CAAC;QAC9D,IAAI,YAAY,KAAK,CAAC,CAAC;YAAE,OAAO,SAAS,CAAC;QAE1C,MAAM,KAAK,GAAG,UAAU,CAAC,SAAS,CAChC,YAAY,GAAG,mBAAW,CAAC,QAAQ,CAAC,MAAM,CAC3C,CAAC;QACF,MAAM,WAAW,GAAG,KAAK,CAAC,KAAK,CAAC,mBAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD,OAAO,WAAW;aACf,KAAK,CAAC,mBAAW,CAAC,OAAO,CAAC;aAC1B,GAAG,CAAC,UAAU,CAAC;aACf,MAAM,CAAC,OAAO,CAAC,CAAC;IACrB,CAAC;IAED,iCAAiC;IACjC,uBAAuB;IACvB,0CAA0C;IAC1C,mEAAmE;IACnE,+CAA+C;IAC/C,EAAE;IACF,wCAAwC;IACxC,iDAAiD;IACjD,OAAO;IACP,8CAA8C;IAC9C,EAAE;IACF,sCAAsC;IACtC,wDAAwD;IACxD,oEAAoE;IACpE,oCAAoC;IACpC,eAAe;IACf,2BAA2B;IAC3B,oCAAoC;IACpC,+BAA+B;IAC/B,mDAAmD;IACnD,SAAS;IACT,QAAQ;IACR,IAAI;IAEJ;;;;;;;;;;;;OAYG;IACK,MAAM,CAAC,UAAU,CAAC,IAAY,EAAE,MAAa;QACnD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACrD,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAEzC,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QAE9C,IAAI,KAAiC,CAAC;QAEtC,UAAU,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;YAChC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;YAC9D,MAAM,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,oBAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,oBAAY,CAAC,MAAM,CAAC;YACvE,IAAI,CAAC,MAAM;gBAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,QAAQ,EAAE,CAAC,CAAC;YAEjE,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YACnC,IAAI,OAAO,cAAc,KAAK,WAAW,EAAE,CAAC;gBAC1C,MAAM,IAAI,KAAK,CAAC,2BAA2B,KAAK,EAAE,CAAC,CAAC;YACtD,CAAC;YAED,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;YAChD,KAAK;gBACH,GAAG,KAAK,CAAC;oBACP,CAAC,CAAC,SAAS;oBACX,CAAC,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,mBAAW,CAAC,GAAG;wBACtC,CAAC,CAAC,KAAM,CAAC,GAAG,CAAC,SAAS,CAAC;wBACvB,CAAC,CAAC,KAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QAClE,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;OAWG;IACK,MAAM,CAAC,qBAAqB,CAAC,GAAW;QAC9C,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,oBAAY,CAAC,EAAE,CAAC;YACjD,IAAI,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC3B,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAC7C,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;YAChD,CAAC;QACH,CAAC;QACD,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;IACpC,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACK,MAAM,CAAC,uBAAuB,CACpC,IAAY,EACZ,MAAa;QAEb,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC;QACnD,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QAE/C,IAAI,OAA2C,CAAC;QAChD,IAAI,KAAyB,CAAC;QAC9B,IAAI,MAA0B,CAAC;QAE/B,IAAI,SAAS,CAAC,MAAM,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YACtD,OAAO,GAAG,SAAS,CAAC,CAAC,CAA2B,CAAC;QAEnD,IAAI,SAAS,CAAC,MAAM,IAAI,CAAC,IAAI,OAAO,SAAS,CAAC,CAAC,CAAC,KAAK,QAAQ;YAC3D,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QAEvB,IAAI,SAAS,CAAC,MAAM,IAAI,CAAC,IAAI,OAAO,SAAS,CAAC,CAAC,CAAC,KAAK,QAAQ;YAC3D,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QAExB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IACpC,CAAC;CACF;AArPD,gDAqPC","sourcesContent":["import { Condition, OrderBySelector } from \"../query\";\nimport { FilterDescriptor, QueryAssist, QueryClause } from \"./types\";\nimport { OperatorsMap } from \"./utils\";\n\nconst lowerFirst = (str: string): string =>\n  str.charAt(0).toLowerCase() + str.slice(1);\n\n/**\n * @description\n * Utility class to build query objects from repository method names.\n *\n * @summary\n * The `MethodQueryBuilder` class parses method names that follow a specific naming convention\n * (e.g., `findByNameAndAgeOrderByCountryAsc`) and converts them into structured query objects\n * (`QueryAssist`). It extracts clauses such as `select`, `where`, `groupBy`, `orderBy`, `limit`,\n * and `offset`, ensuring that developers can declare repository queries using expressive method names.\n *\n * @param methodName {string} - The repository method name to parse and convert into a query.\n * @param values {any[]} - The values corresponding to method parameters used for query conditions.\n *\n * @return {QueryAssist} A structured query object describing the parsed action, select, where,\n * groupBy, orderBy, limit, and offset clauses.\n *\n * @class\n *\n * @example\n * ```ts\n * const query = MethodQueryBuilder.build(\n *   \"findByNameAndAgeOrderByCountryAsc\",\n *   \"John\",\n *   25,\n *   [[\"country\", \"ASC\"]]\n * );\n *\n * console.log(query);\n * // {\n * //   action: \"find\",\n * //   select: undefined,\n * //   where: { ... },\n * //   groupBy: undefined,\n * //   orderBy: [[\"country\", \"ASC\"]],\n * //   limit: undefined,\n * //   offset: undefined\n * // }\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant Repo as Repository Method\n *   participant MQB as MethodQueryBuilder\n *   participant Query as QueryAssist\n *\n *   Repo->>MQB: build(methodName, ...values)\n *   MQB->>MQB: extractCore(methodName)\n *   MQB->>MQB: extractSelect(methodName)\n *   MQB->>MQB: extractGroupBy(methodName)\n *   MQB->>MQB: buildWhere(core, values)\n *   MQB->>MQB: extractOrderLimitOffset(core, values)\n *   MQB->>Query: return structured QueryAssist object\n */\nexport class MethodQueryBuilder {\n  /**\n   * @description\n   * Builds a `QueryAssist` object by parsing a repository method name and values.\n   *\n   * @summary\n   * The method validates the method name, extracts clauses (core, select, groupBy, where,\n   * orderBy, limit, and offset), and assembles them into a structured query object\n   * that can be executed against a data source.\n   *\n   * @param methodName {string} - The repository method name that encodes query information.\n   * @param values {any[]} - The values corresponding to conditions and extra clauses.\n   *\n   * @return {QueryAssist} A structured query object representing the parsed query.\n   */\n  static build(methodName: string, ...values: any[]): QueryAssist {\n    if (!methodName.startsWith(QueryClause.FIND_BY)) {\n      throw new Error(`Unsupported method ${methodName}`);\n    }\n\n    const core = this.extractCore(methodName);\n    const select = this.extractSelect(methodName);\n    const groupBy = this.extractGroupBy(methodName);\n    // const orderBy = this.extractOrderBy(methodName);\n    const where = this.buildWhere(core, values);\n    const { orderBy, limit, offset } = this.extractOrderLimitOffset(\n      core,\n      values\n    );\n\n    return {\n      action: \"find\",\n      select: select,\n      where,\n      groupBy,\n      orderBy,\n      limit,\n      offset,\n    };\n  }\n\n  /**\n   * @description\n   * Extracts the core part of the method name after `findBy` and before any special clauses.\n   *\n   * @summary\n   * Removes prefixes and detects delimiters (`Then`, `OrderBy`, `GroupBy`, `Limit`, `Offset`)\n   * to isolate the main conditional part of the query.\n   *\n   * @param methodName {string} - The method name to parse.\n   *\n   * @return {string} The extracted core string used for building conditions.\n   */\n  private static extractCore(methodName: string): string {\n    const afterFindBy = methodName.substring(QueryClause.FIND_BY.length);\n    const regex = /(Then[A-Z]|OrderBy|GroupBy|Limit|Offset)/;\n    const match = afterFindBy.match(regex);\n    return match ? afterFindBy.substring(0, match.index) : afterFindBy;\n  }\n\n  /**\n   * @description\n   * Extracts the select clause from a method name.\n   *\n   * @summary\n   * Detects the `Select` keyword in the method name, isolates the fields following it,\n   * and returns them as an array of lowercase-first strings.\n   *\n   * @param methodName {string} - The method name to parse.\n   *\n   * @return {string[] | undefined} An array of selected fields or `undefined` if no select clause exists.\n   */\n  private static extractSelect(methodName: string): string[] | undefined {\n    const selectIndex = methodName.indexOf(QueryClause.SELECT);\n    if (selectIndex === -1) return undefined;\n\n    const afterSelect = methodName.substring(\n      selectIndex + QueryClause.SELECT.length\n    );\n\n    // Search for next Then, GroupBy, OrderBy...\n    const match = afterSelect.match(/(Then[A-Z]|OrderBy|GroupBy|Limit|Offset)/);\n\n    const selectPart = match\n      ? afterSelect.substring(0, match.index)\n      : afterSelect;\n\n    return selectPart.split(QueryClause.AND).map(lowerFirst).filter(Boolean);\n  }\n\n  /**\n   * @description\n   * Extracts the group by clause from a method name.\n   *\n   * @summary\n   * Detects the `GroupBy` keyword in the method name, isolates the fields following it,\n   * and returns them as an array of lowercase-first strings.\n   *\n   * @param methodName {string} - The method name to parse.\n   *\n   * @return {string[] | undefined} An array of group by fields or `undefined` if no group by clause exists.\n   */\n  private static extractGroupBy(methodName: string): string[] | undefined {\n    const groupByIndex = methodName.indexOf(QueryClause.GROUP_BY);\n    if (groupByIndex === -1) return undefined;\n\n    const after = methodName.substring(\n      groupByIndex + QueryClause.GROUP_BY.length\n    );\n    const groupByPart = after.split(QueryClause.ORDER_BY)[0];\n    return groupByPart\n      .split(QueryClause.THEN_BY)\n      .map(lowerFirst)\n      .filter(Boolean);\n  }\n\n  // private static extractOrderBy(\n  //   methodName: string\n  // ): OrderBySelector<any>[] | undefined {\n  //   const orderByIndex = methodName.indexOf(QueryClause.ORDER_BY);\n  //   if (orderByIndex === -1) return undefined;\n  //\n  //   const after = methodName.substring(\n  //     orderByIndex + QueryClause.ORDER_BY.length\n  //   );\n  //   const orderParts = after.split(\"ThenBy\");\n  //\n  //   return orderParts.map((part) => {\n  //     const match = part.match(/(.*?)(Asc|Desc|Dsc)$/);\n  //     if (!match) throw new Error(`Invalid OrderBy part: ${part}`);\n  //     const [, field, dir] = match;\n  //     return [\n  //       lowerFirst(field),\n  //       dir.toLowerCase() === \"dsc\"\n  //         ? OrderDirection.DSC\n  //         : (dir.toLowerCase() as OrderDirection),\n  //     ];\n  //   });\n  // }\n\n  /**\n   * @description\n   * Builds the `where` condition object based on the parsed core string and parameter values.\n   *\n   * @summary\n   * Splits the core string by logical operators (`And`, `Or`), parses each token into a field\n   * and operator, and combines them into a `Condition` object using the provided values.\n   *\n   * @param core {string} - The extracted core string from the method name.\n   * @param values {any[]} - The values corresponding to the conditions.\n   *\n   * @return {Condition<any>} A structured condition object representing the query's where clause.\n   */\n  private static buildWhere(core: string, values: any[]): Condition<any> {\n    const parts = core.split(/OrderBy|GroupBy/)[0] || \"\";\n    const conditions = parts.split(/And|Or/);\n\n    const operators = core.match(/And|Or/g) || [];\n\n    let where: Condition<any> | undefined;\n\n    conditions.forEach((token, idx) => {\n      const { field, operator } = this.parseFieldAndOperator(token);\n      const parser = operator ? OperatorsMap[operator] : OperatorsMap.Equals;\n      if (!parser) throw new Error(`Unsupported operator ${operator}`);\n\n      const conditionValue = values[idx];\n      if (typeof conditionValue === \"undefined\") {\n        throw new Error(`Invalid value for field ${field}`);\n      }\n\n      const condition = parser(field, conditionValue);\n      where =\n        idx === 0\n          ? condition\n          : operators[idx - 1] === QueryClause.AND\n            ? where!.and(condition)\n            : where!.or(condition);\n    });\n\n    if (!where) throw new Error(\"No conditions found in method name\");\n    return where;\n  }\n\n  /**\n   * @description\n   * Parses a field name and operator from a string token.\n   *\n   * @summary\n   * Identifies the operator suffix (if present) and returns a descriptor containing the field\n   * name in lowercase-first format along with the operator.\n   *\n   * @param str {string} - The token string to parse.\n   *\n   * @return {FilterDescriptor} An object containing the field name and operator.\n   */\n  private static parseFieldAndOperator(str: string): FilterDescriptor {\n    for (const operator of Object.keys(OperatorsMap)) {\n      if (str.endsWith(operator)) {\n        const field = str.slice(0, -operator.length);\n        return { field: lowerFirst(field), operator };\n      }\n    }\n    return { field: lowerFirst(str) };\n  }\n\n  /**\n   * @description\n   * Extracts `orderBy`, `limit`, and `offset` clauses from method arguments.\n   *\n   * @summary\n   * Determines the number of condition arguments, then checks the remaining arguments\n   * to resolve sorting, limiting, and pagination.\n   *\n   * @param core {string} - The extracted core string from the method name.\n   * @param values {any[]} - The values corresponding to method arguments, including conditions and extras.\n   *\n   * @return {{\n   *   orderBy?: OrderBySelector<any>[];\n   *   limit?: number;\n   *   offset?: number;\n   * }} An object containing orderBy, limit, and offset values if present.\n   */\n  private static extractOrderLimitOffset(\n    core: string,\n    values: any[]\n  ): { orderBy?: OrderBySelector<any>[]; limit?: number; offset?: number } {\n    const conditionCount = core.split(/And|Or/).length;\n    const extraArgs = values.slice(conditionCount);\n\n    let orderBy: OrderBySelector<any>[] | undefined;\n    let limit: number | undefined;\n    let offset: number | undefined;\n\n    if (extraArgs.length >= 1 && Array.isArray(extraArgs[0]))\n      orderBy = extraArgs[0] as OrderBySelector<any>[];\n\n    if (extraArgs.length >= 2 && typeof extraArgs[1] === \"number\")\n      limit = extraArgs[1];\n\n    if (extraArgs.length >= 3 && typeof extraArgs[2] === \"number\")\n      offset = extraArgs[2];\n\n    return { orderBy, limit, offset };\n  }\n}\n"]}