@decaf-ts/core 0.5.28 → 0.5.30

package/lib/esm/query/MethodQueryBuilder.js

@@ -0,0 +1,272 @@
+import { QueryClause } from "./types.js";
+import { OperatorsMap } from "./utils.js";
+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
+ */
+export 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(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(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(QueryClause.SELECT);
+        if (selectIndex === -1)
+            return undefined;
+        const afterSelect = methodName.substring(selectIndex + 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(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(QueryClause.GROUP_BY);
+        if (groupByIndex === -1)
+            return undefined;
+        const after = methodName.substring(groupByIndex + QueryClause.GROUP_BY.length);
+        const groupByPart = after.split(QueryClause.ORDER_BY)[0];
+        return groupByPart
+            .split(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 ? OperatorsMap[operator] : 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] === 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(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 };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MethodQueryBuilder.js","sourceRoot":"","sources":["../../../src/query/MethodQueryBuilder.ts"],"names":[],"mappings":"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","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"]}

package/lib/esm/query/decorators.d.ts

@@ -0,0 +1,2 @@
+import { QueryOptions } from "./types";
+export declare function query(options?: QueryOptions): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any> | void;

package/lib/esm/query/decorators.js

@@ -0,0 +1,45 @@
+import { MethodQueryBuilder } from "./MethodQueryBuilder.js";
+import { QueryError } from "./errors.js";
+export function query(options = {}) {
+    return (target, propertyKey, descriptor) => {
+        // const originalMethod = descriptor.value;
+        const methodName = propertyKey.toString();
+        descriptor.value = function (...args) {
+            const { select, where, groupBy, orderBy, limit, offset } = MethodQueryBuilder.build(methodName, ...args);
+            let stmt = this.select(select);
+            if (where)
+                stmt = stmt.where(where);
+            // if (orderBy) stmt = stmt.orderBy(orderBy[0]);
+            if (groupBy) {
+                // group by not implemented yet
+                /* stmt = stmt.groupBy(groupBy); */
+            }
+            // allow limit and offset by default
+            const { allowLimit, allowOffset, allowOrderBy, throws } = {
+                allowLimit: true,
+                allowOrderBy: true,
+                allowOffset: true,
+                throws: true,
+                ...options,
+            };
+            const params = [
+                // keep the order to ensure the expected behavior
+                { key: "orderBy", value: (orderBy || [])[0], allowed: allowOrderBy }, // orderBy only supports one sentence
+                { key: "limit", value: limit, allowed: allowLimit },
+                { key: "offset", value: offset, allowed: allowOffset },
+            ];
+            for (const param of params) {
+                if (param.value !== undefined) {
+                    if (!param.allowed && throws) {
+                        throw new QueryError(`${param.key[0].toUpperCase() + param.key.slice(1)} is not allowed for this query`);
+                    }
+                    else if (param.allowed) {
+                        stmt = stmt[param.key](param.value);
+                    }
+                }
+            }
+            return stmt.execute();
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/query/index.d.ts

@@ -5,3 +5,7 @@ export * from "./options";
 export * from "./Paginator";
 export * from "./selectors";
 export * from "./Statement";
+export * from "./decorators";
+export * from "./MethodQueryBuilder";
+export * from "./types";
+export * from "./utils";

package/lib/esm/query/index.js

@@ -5,4 +5,8 @@ export * from "./options.js";
 export * from "./Paginator.js";
 export * from "./selectors.js";
 export * from "./Statement.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcXVlcnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0JBQTRCO0FBQzVCLCtCQUE0QjtBQUM1Qiw0QkFBeUI7QUFDekIsNkJBQTBCO0FBQzFCLCtCQUE0QjtBQUM1QiwrQkFBNEI7QUFDNUIsK0JBQTRCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vQ29uZGl0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Vycm9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vb3B0aW9uc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vUGFnaW5hdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZWxlY3RvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1N0YXRlbWVudFwiO1xuIl19
+export * from "./decorators.js";
+export * from "./MethodQueryBuilder.js";
+export * from "./types.js";
+export * from "./utils.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcXVlcnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0JBQTRCO0FBQzVCLCtCQUE0QjtBQUM1Qiw0QkFBeUI7QUFDekIsNkJBQTBCO0FBQzFCLCtCQUE0QjtBQUM1QiwrQkFBNEI7QUFDNUIsK0JBQTRCO0FBQzVCLGdDQUE2QjtBQUM3Qix3Q0FBcUM7QUFDckMsMkJBQXdCO0FBQ3hCLDJCQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL0NvbmRpdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lcnJvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL29wdGlvbnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1BhZ2luYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2VsZWN0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9TdGF0ZW1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL01ldGhvZFF1ZXJ5QnVpbGRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG4iXX0=

package/lib/esm/query/types.d.ts

@@ -0,0 +1,96 @@
+import { Condition } from "./Condition";
+import { OrderBySelector } from "./selectors";
+/**
+ * @description
+ * Options for configuring query building behavior.
+ *
+ * @summary
+ * The `QueryOptions` type defines flags that determine whether certain clauses
+ * (limit, offset, order by) are permitted, as well as whether violations
+ * should throw an error during query construction.
+ *
+ * @memberOf module:query
+ */
+export type QueryOptions = {
+    allowLimit?: boolean;
+    allowOffset?: boolean;
+    allowOrderBy?: boolean;
+    throws?: boolean;
+};
+/**
+ * @description
+ * Structured query object representing parsed query clauses.
+ *
+ * @summary
+ * The `QueryAssist` interface defines the standard structure returned
+ * by query builders. It includes actions such as find, optional clauses
+ * like select, groupBy, and orderBy, and pagination controls (limit, offset).
+ *
+ * @template T The entity or record type that conditions may apply to.
+ *
+ * @interface QueryAssist
+ * @memberOf module:query
+ */
+export interface QueryAssist {
+    action: "find";
+    select: undefined | string[];
+    where: Condition<any>;
+    groupBy?: string[];
+    orderBy?: OrderBySelector<any>[];
+    limit: number | undefined;
+    offset: number | undefined;
+}
+/**
+ * @description
+ * Enumeration of supported query clauses for building method-based queries.
+ *
+ * @summary
+ * The `QueryClause` enum defines string literals that represent
+ * different segments of a query (e.g., `findBy`, `Select`, `And`, `Or`).
+ *
+ * @enum QueryClause
+ * @memberOf module:query
+ */
+export declare enum QueryClause {
+    FIND_BY = "findBy",
+    SELECT = "Select",
+    AND = "And",
+    OR = "Or",
+    GROUP_BY = "GroupBy",
+    ORDER_BY = "OrderBy",
+    THEN = "Then",
+    THEN_BY = "ThenBy"
+}
+/**
+ * @description
+ * Function signature for parsing operators in query building.
+ *
+ * @summary
+ * The `OperatorParser` type represents a function that takes a field name
+ * and arguments, then produces a `Condition` object that can be used in a query.
+ *
+ * @template T The type of the condition result.
+ *
+ * @param field {string} - The name of the field being parsed.
+ * @param args {any[]} - Additional arguments for operator evaluation.
+ *
+ * @return {Condition<any>} A condition object representing the parsed operator.
+ *
+ * @memberOf module:query
+ */
+export type OperatorParser = (field: string, ...args: any) => Condition<any>;
+/**
+ * @description
+ * Descriptor for fields and their associated operators in query parsing.
+ *
+ * @summary
+ * The `FilterDescriptor` interface defines the structure used when parsing
+ * method segments into filterable fields and associated operators.
+ *
+ * @interface FilterDescriptor
+ * @memberOf module:query
+ */
+export interface FilterDescriptor {
+    field: string;
+    operator?: string;
+}

package/lib/esm/query/types.js

@@ -0,0 +1,23 @@
+/**
+ * @description
+ * Enumeration of supported query clauses for building method-based queries.
+ *
+ * @summary
+ * The `QueryClause` enum defines string literals that represent
+ * different segments of a query (e.g., `findBy`, `Select`, `And`, `Or`).
+ *
+ * @enum QueryClause
+ * @memberOf module:query
+ */
+export var QueryClause;
+(function (QueryClause) {
+    QueryClause["FIND_BY"] = "findBy";
+    QueryClause["SELECT"] = "Select";
+    QueryClause["AND"] = "And";
+    QueryClause["OR"] = "Or";
+    QueryClause["GROUP_BY"] = "GroupBy";
+    QueryClause["ORDER_BY"] = "OrderBy";
+    QueryClause["THEN"] = "Then";
+    QueryClause["THEN_BY"] = "ThenBy";
+})(QueryClause || (QueryClause = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/query/utils.d.ts

@@ -0,0 +1,40 @@
+import { OperatorParser } from "./types";
+/**
+ * @description
+ * Map of supported operators to their corresponding parser functions.
+ *
+ * @summary
+ * The `OperatorsMap` defines a collection of operator names as keys
+ * (such as `Equals`, `LessThan`, `Between`, etc.), each mapped to a
+ * function that constructs a `Condition` object for that operator.
+ * These functions translate query clauses into concrete condition
+ * builders, enabling dynamic query construction from method names.
+ *
+ * @template T The type of the field values used in conditions.
+ *
+ * @param f {string} - The field name the condition applies to.
+ * @param v1 {any} - The value to compare the field against or the lower bound value for range-based operators.
+ * @param v2 {any} - The upper bound value for range-based operators.
+ *
+ * @return {Condition<any>} A condition object representing the operator applied to the field.
+ *
+ * @function OperatorsMap
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client as Caller
+ *   participant Map as OperatorsMap
+ *   participant Parser as OperatorParser
+ *   participant Cond as Condition
+ *
+ *   Client->>Map: Request operator parser ("Between", field, v1, v2)
+ *   Map->>Parser: Call corresponding operator function
+ *   Parser->>Cond: Condition.attribute(field)
+ *   Cond-->>Parser: Condition instance
+ *   Parser->>Cond: Apply gte(v1)
+ *   Parser->>Cond: Apply and(lte(v2))
+ *   Parser-->>Client: Return built Condition
+ *
+ * @memberOf module:query
+ */
+export declare const OperatorsMap: Record<string, OperatorParser>;

package/lib/esm/query/utils.js

@@ -0,0 +1,51 @@
+import { Condition } from "./Condition.js";
+/**
+ * @description
+ * Map of supported operators to their corresponding parser functions.
+ *
+ * @summary
+ * The `OperatorsMap` defines a collection of operator names as keys
+ * (such as `Equals`, `LessThan`, `Between`, etc.), each mapped to a
+ * function that constructs a `Condition` object for that operator.
+ * These functions translate query clauses into concrete condition
+ * builders, enabling dynamic query construction from method names.
+ *
+ * @template T The type of the field values used in conditions.
+ *
+ * @param f {string} - The field name the condition applies to.
+ * @param v1 {any} - The value to compare the field against or the lower bound value for range-based operators.
+ * @param v2 {any} - The upper bound value for range-based operators.
+ *
+ * @return {Condition<any>} A condition object representing the operator applied to the field.
+ *
+ * @function OperatorsMap
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client as Caller
+ *   participant Map as OperatorsMap
+ *   participant Parser as OperatorParser
+ *   participant Cond as Condition
+ *
+ *   Client->>Map: Request operator parser ("Between", field, v1, v2)
+ *   Map->>Parser: Call corresponding operator function
+ *   Parser->>Cond: Condition.attribute(field)
+ *   Cond-->>Parser: Condition instance
+ *   Parser->>Cond: Apply gte(v1)
+ *   Parser->>Cond: Apply and(lte(v2))
+ *   Parser-->>Client: Return built Condition
+ *
+ * @memberOf module:query
+ */
+export const OperatorsMap = {
+    Equals: (f, v) => Condition.attribute(f).eq(v),
+    Diff: (f, v) => Condition.attribute(f).dif(v),
+    LessThan: (f, v) => Condition.attribute(f).lt(v),
+    LessThanEqual: (f, v) => Condition.attribute(f).lte(v),
+    GreaterThan: (f, v) => Condition.attribute(f).gt(v),
+    GreaterThanEqual: (f, v) => Condition.attribute(f).gte(v),
+    Between: (f, v1, v2) => Condition.attribute(f).gte(v1).and(Condition.attribute(f).lte(v2)),
+    In: (f, v) => Condition.attribute(f).in(v),
+    Matches: (f, v) => Condition.attribute(f).regexp(v),
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.cjs

@@ -42,5 +42,5 @@ __exportStar(require("./persistence/index.cjs"), exports);
  * @const VERSION
  * @memberOf module:core
  */
-exports.VERSION = "0.5.28";
+exports.VERSION = "0.5.30";
 //# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -19,4 +19,4 @@ export * from "./persistence";
  * @const VERSION
  * @memberOf module:core
  */
-export declare const VERSION = "0.5.28";
+export declare const VERSION = "0.5.30";