@decaf-ts/core 0.5.27 → 0.5.29

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcXVlcnkvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBNkNBOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLENBQU4sSUFBWSxXQVNYO0FBVEQsV0FBWSxXQUFXO0lBQ3JCLGlDQUFrQixDQUFBO0lBQ2xCLGdDQUFpQixDQUFBO0lBQ2pCLDBCQUFXLENBQUE7SUFDWCx3QkFBUyxDQUFBO0lBQ1QsbUNBQW9CLENBQUE7SUFDcEIsbUNBQW9CLENBQUE7SUFDcEIsNEJBQWEsQ0FBQTtJQUNiLGlDQUFrQixDQUFBO0FBQ3BCLENBQUMsRUFUVyxXQUFXLEtBQVgsV0FBVyxRQVN0QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbmRpdGlvbiB9IGZyb20gXCIuL0NvbmRpdGlvblwiO1xuaW1wb3J0IHsgT3JkZXJCeVNlbGVjdG9yIH0gZnJvbSBcIi4vc2VsZWN0b3JzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uXG4gKiBPcHRpb25zIGZvciBjb25maWd1cmluZyBxdWVyeSBidWlsZGluZyBiZWhhdmlvci5cbiAqXG4gKiBAc3VtbWFyeVxuICogVGhlIGBRdWVyeU9wdGlvbnNgIHR5cGUgZGVmaW5lcyBmbGFncyB0aGF0IGRldGVybWluZSB3aGV0aGVyIGNlcnRhaW4gY2xhdXNlc1xuICogKGxpbWl0LCBvZmZzZXQsIG9yZGVyIGJ5KSBhcmUgcGVybWl0dGVkLCBhcyB3ZWxsIGFzIHdoZXRoZXIgdmlvbGF0aW9uc1xuICogc2hvdWxkIHRocm93IGFuIGVycm9yIGR1cmluZyBxdWVyeSBjb25zdHJ1Y3Rpb24uXG4gKlxuICogQG1lbWJlck9mIG1vZHVsZTpxdWVyeVxuICovXG5leHBvcnQgdHlwZSBRdWVyeU9wdGlvbnMgPSB7XG4gIGFsbG93TGltaXQ/OiBib29sZWFuO1xuICBhbGxvd09mZnNldD86IGJvb2xlYW47XG4gIGFsbG93T3JkZXJCeT86IGJvb2xlYW47XG4gIHRocm93cz86IGJvb2xlYW47XG59O1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvblxuICogU3RydWN0dXJlZCBxdWVyeSBvYmplY3QgcmVwcmVzZW50aW5nIHBhcnNlZCBxdWVyeSBjbGF1c2VzLlxuICpcbiAqIEBzdW1tYXJ5XG4gKiBUaGUgYFF1ZXJ5QXNzaXN0YCBpbnRlcmZhY2UgZGVmaW5lcyB0aGUgc3RhbmRhcmQgc3RydWN0dXJlIHJldHVybmVkXG4gKiBieSBxdWVyeSBidWlsZGVycy4gSXQgaW5jbHVkZXMgYWN0aW9ucyBzdWNoIGFzIGZpbmQsIG9wdGlvbmFsIGNsYXVzZXNcbiAqIGxpa2Ugc2VsZWN0LCBncm91cEJ5LCBhbmQgb3JkZXJCeSwgYW5kIHBhZ2luYXRpb24gY29udHJvbHMgKGxpbWl0LCBvZmZzZXQpLlxuICpcbiAqIEB0ZW1wbGF0ZSBUIFRoZSBlbnRpdHkgb3IgcmVjb3JkIHR5cGUgdGhhdCBjb25kaXRpb25zIG1heSBhcHBseSB0by5cbiAqXG4gKiBAaW50ZXJmYWNlIFF1ZXJ5QXNzaXN0XG4gKiBAbWVtYmVyT2YgbW9kdWxlOnF1ZXJ5XG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUXVlcnlBc3Npc3Qge1xuICBhY3Rpb246IFwiZmluZFwiO1xuICBzZWxlY3Q6IHVuZGVmaW5lZCB8IHN0cmluZ1tdO1xuICB3aGVyZTogQ29uZGl0aW9uPGFueT47XG4gIGdyb3VwQnk/OiBzdHJpbmdbXTtcbiAgb3JkZXJCeT86IE9yZGVyQnlTZWxlY3Rvcjxhbnk+W107XG4gIGxpbWl0OiBudW1iZXIgfCB1bmRlZmluZWQ7XG4gIG9mZnNldDogbnVtYmVyIHwgdW5kZWZpbmVkO1xufVxuXG4vKipcbiAqIEBkZXNjcmlwdGlvblxuICogRW51bWVyYXRpb24gb2Ygc3VwcG9ydGVkIHF1ZXJ5IGNsYXVzZXMgZm9yIGJ1aWxkaW5nIG1ldGhvZC1iYXNlZCBxdWVyaWVzLlxuICpcbiAqIEBzdW1tYXJ5XG4gKiBUaGUgYFF1ZXJ5Q2xhdXNlYCBlbnVtIGRlZmluZXMgc3RyaW5nIGxpdGVyYWxzIHRoYXQgcmVwcmVzZW50XG4gKiBkaWZmZXJlbnQgc2VnbWVudHMgb2YgYSBxdWVyeSAoZS5nLiwgYGZpbmRCeWAsIGBTZWxlY3RgLCBgQW5kYCwgYE9yYCkuXG4gKlxuICogQGVudW0gUXVlcnlDbGF1c2VcbiAqIEBtZW1iZXJPZiBtb2R1bGU6cXVlcnlcbiAqL1xuZXhwb3J0IGVudW0gUXVlcnlDbGF1c2Uge1xuICBGSU5EX0JZID0gXCJmaW5kQnlcIixcbiAgU0VMRUNUID0gXCJTZWxlY3RcIixcbiAgQU5EID0gXCJBbmRcIixcbiAgT1IgPSBcIk9yXCIsXG4gIEdST1VQX0JZID0gXCJHcm91cEJ5XCIsXG4gIE9SREVSX0JZID0gXCJPcmRlckJ5XCIsXG4gIFRIRU4gPSBcIlRoZW5cIixcbiAgVEhFTl9CWSA9IFwiVGhlbkJ5XCIsXG59XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uXG4gKiBGdW5jdGlvbiBzaWduYXR1cmUgZm9yIHBhcnNpbmcgb3BlcmF0b3JzIGluIHF1ZXJ5IGJ1aWxkaW5nLlxuICpcbiAqIEBzdW1tYXJ5XG4gKiBUaGUgYE9wZXJhdG9yUGFyc2VyYCB0eXBlIHJlcHJlc2VudHMgYSBmdW5jdGlvbiB0aGF0IHRha2VzIGEgZmllbGQgbmFtZVxuICogYW5kIGFyZ3VtZW50cywgdGhlbiBwcm9kdWNlcyBhIGBDb25kaXRpb25gIG9iamVjdCB0aGF0IGNhbiBiZSB1c2VkIGluIGEgcXVlcnkuXG4gKlxuICogQHRlbXBsYXRlIFQgVGhlIHR5cGUgb2YgdGhlIGNvbmRpdGlvbiByZXN1bHQuXG4gKlxuICogQHBhcmFtIGZpZWxkIHtzdHJpbmd9IC0gVGhlIG5hbWUgb2YgdGhlIGZpZWxkIGJlaW5nIHBhcnNlZC5cbiAqIEBwYXJhbSBhcmdzIHthbnlbXX0gLSBBZGRpdGlvbmFsIGFyZ3VtZW50cyBmb3Igb3BlcmF0b3IgZXZhbHVhdGlvbi5cbiAqXG4gKiBAcmV0dXJuIHtDb25kaXRpb248YW55Pn0gQSBjb25kaXRpb24gb2JqZWN0IHJlcHJlc2VudGluZyB0aGUgcGFyc2VkIG9wZXJhdG9yLlxuICpcbiAqIEBtZW1iZXJPZiBtb2R1bGU6cXVlcnlcbiAqL1xuZXhwb3J0IHR5cGUgT3BlcmF0b3JQYXJzZXIgPSAoZmllbGQ6IHN0cmluZywgLi4uYXJnczogYW55KSA9PiBDb25kaXRpb248YW55PjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb25cbiAqIERlc2NyaXB0b3IgZm9yIGZpZWxkcyBhbmQgdGhlaXIgYXNzb2NpYXRlZCBvcGVyYXRvcnMgaW4gcXVlcnkgcGFyc2luZy5cbiAqXG4gKiBAc3VtbWFyeVxuICogVGhlIGBGaWx0ZXJEZXNjcmlwdG9yYCBpbnRlcmZhY2UgZGVmaW5lcyB0aGUgc3RydWN0dXJlIHVzZWQgd2hlbiBwYXJzaW5nXG4gKiBtZXRob2Qgc2VnbWVudHMgaW50byBmaWx0ZXJhYmxlIGZpZWxkcyBhbmQgYXNzb2NpYXRlZCBvcGVyYXRvcnMuXG4gKlxuICogQGludGVyZmFjZSBGaWx0ZXJEZXNjcmlwdG9yXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnF1ZXJ5XG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRmlsdGVyRGVzY3JpcHRvciB7XG4gIGZpZWxkOiBzdHJpbmc7XG4gIG9wZXJhdG9yPzogc3RyaW5nO1xufVxuIl19

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/identity/decorators.cjs

@@ -10,6 +10,7 @@ const decorators_1 = require("./../model/decorators.cjs");
 const utils_1 = require("./utils.cjs");
 const repository_1 = require("./../repository/index.cjs");
 const reflection_1 = require("@decaf-ts/reflection");
+const defaultPkPriority = 60; // Default priority for primary key to run latter than other properties
 /**
  * @description Callback function for primary key creation
  * @summary Handles the creation of primary key values for models using sequences
@@ -97,16 +98,16 @@ function pk(opts = SequenceOptions_1.DefaultSequenceOptions) {
             : opts.generated || SequenceOptions_1.DefaultSequenceOptions.generated,
     });
     const key = Repository_1.Repository.key(db_decorators_1.DBKeys.ID);
-    function pkDec(options) {
+    function pkDec(options, groupsort) {
         return function pkDec(obj, attr) {
-            return (0, reflection_1.apply)((0, decorators_1.index)([repository_1.OrderDirection.ASC, repository_1.OrderDirection.DSC]), (0, decorator_validation_1.required)(), (0, db_decorators_1.readonly)(), (0, decorator_validation_1.propMetadata)(key, options), (0, db_decorators_1.onCreate)(pkOnCreate, options), (0, decorator_validation_1.propMetadata)(db_decorators_1.DBKeys.ID, attr))(obj, attr);
+            return (0, reflection_1.apply)((0, decorators_1.index)([repository_1.OrderDirection.ASC, repository_1.OrderDirection.DSC]), (0, decorator_validation_1.required)(), (0, db_decorators_1.readonly)(), (0, decorator_validation_1.propMetadata)(key, options), (0, db_decorators_1.onCreate)(pkOnCreate, options, groupsort), (0, decorator_validation_1.propMetadata)(db_decorators_1.DBKeys.ID, attr))(obj, attr);
         };
     }
     return decorator_validation_1.Decoration.for(key)
         .define({
         decorator: pkDec,
-        args: [opts],
+        args: [opts, { priority: defaultPkPriority }],
     })
         .apply();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/identity/decorators.ts"],"names":[],"mappings":";;AA6DA,gCA0CC;AAsBD,gBAgCC;AA7JD,yEAKwC;AACxC,yEAGuC;AACvC,2DAMiC;AACjC,+DAA4D;AAC5D,0DAA4C;AAC5C,uCAA+C;AAG/C,0DAA+C;AAC/C,qDAA6C;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACI,KAAK,UAAU,UAAU,CAQ9B,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QAChD,OAAO;IACT,CAAC;IAED,MAAM,kBAAkB,GAAG,UACzB,MAAS,EACT,WAAmB,EACnB,KAA+B;QAE/B,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE;YACzC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,KAAK;YACf,YAAY,EAAE,IAAI;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,IAAI,CAAC,IAAI,CAAC,IAAI;QAAE,IAAI,CAAC,IAAI,GAAG,IAAA,4BAAoB,EAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC9D,IAAI,QAAkB,CAAC;IACvB,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,MAAM,IAAI,6BAAa,CACrB,kCAAkC,IAAI,CAAC,IAAI,KAAK,CAAC,EAAE,CACpD,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IACnC,kBAAkB,CAAC,KAAK,EAAE,GAAa,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,EAAE,CAChB,OAGI,wCAAsB;IAE1B,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,wCAAsB,EAAE,IAAI,EAAE;QACrD,SAAS,EACP,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,WAAW;YAChD,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,wCAAsB,CAAC,SAAS;KACzD,CAAoB,CAAC;IAEtB,MAAM,GAAG,GAAG,uBAAU,CAAC,GAAG,CAAC,sBAAM,CAAC,EAAE,CAAC,CAAC;IACtC,SAAS,KAAK,CAAC,OAAwB;QACrC,OAAO,SAAS,KAAK,CAAC,GAAQ,EAAE,IAAS;YACvC,OAAO,IAAA,kBAAK,EACV,IAAA,kBAAK,EAAC,CAAC,2BAAc,CAAC,GAAG,EAAE,2BAAc,CAAC,GAAG,CAAC,CAAC,EAC/C,IAAA,+BAAQ,GAAE,EACV,IAAA,wBAAQ,GAAE,EACV,IAAA,mCAAY,EAAC,GAAG,EAAE,OAAO,CAAC,EAC1B,IAAA,wBAAQ,EAAC,UAAU,EAAE,OAAO,CAAC,EAC7B,IAAA,mCAAY,EAAC,sBAAM,CAAC,EAAE,EAAE,IAAI,CAAC,CAC9B,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACf,CAAC,CAAC;IACJ,CAAC;IACD,OAAO,iCAAU,CAAC,GAAG,CAAC,GAAG,CAAC;SACvB,MAAM,CAAC;QACN,SAAS,EAAE,KAAK;QAChB,IAAI,EAAE,CAAC,IAAI,CAAC;KACb,CAAC;SACD,KAAK,EAAE,CAAC;AACb,CAAC","sourcesContent":["import {\n  Decoration,\n  Model,\n  propMetadata,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport {\n  DefaultSequenceOptions,\n  SequenceOptions,\n} from \"../interfaces/SequenceOptions\";\nimport {\n  DBKeys,\n  InternalError,\n  onCreate,\n  readonly,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { index } from \"../model/decorators\";\nimport { sequenceNameForModel } from \"./utils\";\nimport { Sequence } from \"../persistence/Sequence\";\nimport { Context } from \"@decaf-ts/db-decorators\";\nimport { OrderDirection } from \"../repository\";\nimport { apply } from \"@decaf-ts/reflection\";\n\n/**\n * @description Callback function for primary key creation\n * @summary Handles the creation of primary key values for models using sequences\n * @template M - Type that extends Model\n * @template R - Type that extends Repo<M, F, C>\n * @template V - Type that extends SequenceOptions\n * @template F - Type that extends RepositoryFlags\n * @template C - Type that extends Context<F>\n * @param {Context<F>} context - The execution context\n * @param {V} data - The sequence options\n * @param key - The property key to set as primary key\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the primary key is set\n * @function pkOnCreate\n * @category Property Decorators\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant pkOnCreate\n *   participant Adapter\n *   participant Sequence\n *\n *   Model->>pkOnCreate: Call with model instance\n *   Note over pkOnCreate: Check if key already exists\n *   alt Key exists or no type specified\n *     pkOnCreate-->>Model: Return early\n *   else Key needs to be created\n *     pkOnCreate->>pkOnCreate: Generate sequence name if not provided\n *     pkOnCreate->>Adapter: Request Sequence(data)\n *     Adapter->>Sequence: Create sequence\n *     Sequence-->>pkOnCreate: Return sequence\n *     pkOnCreate->>Sequence: Call next()\n *     Sequence-->>pkOnCreate: Return next value\n *     pkOnCreate->>Model: Set primary key value\n *   end\n */\nexport async function pkOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends SequenceOptions,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!data.type || !data.generated || model[key]) {\n    return;\n  }\n\n  const setPrimaryKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n\n  if (!data.name) data.name = sequenceNameForModel(model, \"pk\");\n  let sequence: Sequence;\n  try {\n    sequence = await this.adapter.Sequence(data);\n  } catch (e: any) {\n    throw new InternalError(\n      `Failed to instantiate Sequence ${data.name}: ${e}`\n    );\n  }\n\n  const next = await sequence.next();\n  setPrimaryKeyValue(model, key as string, next);\n}\n\n/**\n * @description Primary Key Decorator\n * @summary Marks a property as the model's primary key with automatic sequence generation\n * This decorator combines multiple behaviors: it marks the property as unique, required,\n * and ensures the index is created properly according to the provided sequence options.\n * @param {Omit<SequenceOptions, \"cycle\" | \"startWith\" | \"incrementBy\">} opts - Options for the sequence generation\n * @return {PropertyDecorator} A property decorator that can be applied to model properties\n * @function pk\n * @category Property Decorators\n * @example\n * ```typescript\n * class User extends BaseModel {\n *   @pk()\n *   id!: string;\n *\n *   @required()\n *   username!: string;\n * }\n * ```\n */\nexport function pk(\n  opts: Omit<\n    SequenceOptions,\n    \"cycle\" | \"startWith\" | \"incrementBy\"\n  > = DefaultSequenceOptions\n) {\n  opts = Object.assign({}, DefaultSequenceOptions, opts, {\n    generated:\n      opts.type && typeof opts.generated === \"undefined\"\n        ? true\n        : opts.generated || DefaultSequenceOptions.generated,\n  }) as SequenceOptions;\n\n  const key = Repository.key(DBKeys.ID);\n  function pkDec(options: SequenceOptions) {\n    return function pkDec(obj: any, attr: any) {\n      return apply(\n        index([OrderDirection.ASC, OrderDirection.DSC]),\n        required(),\n        readonly(),\n        propMetadata(key, options),\n        onCreate(pkOnCreate, options),\n        propMetadata(DBKeys.ID, attr)\n      )(obj, attr);\n    };\n  }\n  return Decoration.for(key)\n    .define({\n      decorator: pkDec,\n      args: [opts],\n    })\n    .apply();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/identity/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Decoration,\n  Model,\n  propMetadata,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport {\n  DefaultSequenceOptions,\n  SequenceOptions,\n} from \"../interfaces/SequenceOptions\";\nimport {\n  DBKeys,\n  GroupSort,\n  InternalError,\n  onCreate,\n  readonly,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { index } from \"../model/decorators\";\nimport { sequenceNameForModel } from \"./utils\";\nimport { Sequence } from \"../persistence/Sequence\";\nimport { Context } from \"@decaf-ts/db-decorators\";\nimport { OrderDirection } from \"../repository\";\nimport { apply } from \"@decaf-ts/reflection\";\n\nconst defaultPkPriority = 60; // Default priority for primary key to run latter than other properties\n\n/**\n * @description Callback function for primary key creation\n * @summary Handles the creation of primary key values for models using sequences\n * @template M - Type that extends Model\n * @template R - Type that extends Repo<M, F, C>\n * @template V - Type that extends SequenceOptions\n * @template F - Type that extends RepositoryFlags\n * @template C - Type that extends Context<F>\n * @param {Context<F>} context - The execution context\n * @param {V} data - The sequence options\n * @param key - The property key to set as primary key\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the primary key is set\n * @function pkOnCreate\n * @category Property Decorators\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant pkOnCreate\n *   participant Adapter\n *   participant Sequence\n *\n *   Model->>pkOnCreate: Call with model instance\n *   Note over pkOnCreate: Check if key already exists\n *   alt Key exists or no type specified\n *     pkOnCreate-->>Model: Return early\n *   else Key needs to be created\n *     pkOnCreate->>pkOnCreate: Generate sequence name if not provided\n *     pkOnCreate->>Adapter: Request Sequence(data)\n *     Adapter->>Sequence: Create sequence\n *     Sequence-->>pkOnCreate: Return sequence\n *     pkOnCreate->>Sequence: Call next()\n *     Sequence-->>pkOnCreate: Return next value\n *     pkOnCreate->>Model: Set primary key value\n *   end\n */\nexport async function pkOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends SequenceOptions,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!data.type || !data.generated || model[key]) {\n    return;\n  }\n\n  const setPrimaryKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n\n  if (!data.name) data.name = sequenceNameForModel(model, \"pk\");\n  let sequence: Sequence;\n  try {\n    sequence = await this.adapter.Sequence(data);\n  } catch (e: any) {\n    throw new InternalError(\n      `Failed to instantiate Sequence ${data.name}: ${e}`\n    );\n  }\n\n  const next = await sequence.next();\n  setPrimaryKeyValue(model, key as string, next);\n}\n\n/**\n * @description Primary Key Decorator\n * @summary Marks a property as the model's primary key with automatic sequence generation\n * This decorator combines multiple behaviors: it marks the property as unique, required,\n * and ensures the index is created properly according to the provided sequence options.\n * @param {Omit<SequenceOptions, \"cycle\" | \"startWith\" | \"incrementBy\">} opts - Options for the sequence generation\n * @return {PropertyDecorator} A property decorator that can be applied to model properties\n * @function pk\n * @category Property Decorators\n * @example\n * ```typescript\n * class User extends BaseModel {\n *   @pk()\n *   id!: string;\n *\n *   @required()\n *   username!: string;\n * }\n * ```\n */\nexport function pk(\n  opts: Omit<\n    SequenceOptions,\n    \"cycle\" | \"startWith\" | \"incrementBy\"\n  > = DefaultSequenceOptions\n) {\n  opts = Object.assign({}, DefaultSequenceOptions, opts, {\n    generated:\n      opts.type && typeof opts.generated === \"undefined\"\n        ? true\n        : opts.generated || DefaultSequenceOptions.generated,\n  }) as SequenceOptions;\n\n  const key = Repository.key(DBKeys.ID);\n  function pkDec(options: SequenceOptions, groupsort?: GroupSort) {\n    return function pkDec(obj: any, attr: any) {\n      return apply(\n        index([OrderDirection.ASC, OrderDirection.DSC]),\n        required(),\n        readonly(),\n        propMetadata(key, options),\n        onCreate(pkOnCreate, options, groupsort),\n        propMetadata(DBKeys.ID, attr)\n      )(obj, attr);\n    };\n  }\n  return Decoration.for(key)\n    .define({\n      decorator: pkDec,\n      args: [opts, { priority: defaultPkPriority }],\n    })\n    .apply();\n}\n"]}

package/lib/index.cjs

@@ -42,5 +42,5 @@ __exportStar(require("./persistence/index.cjs"), exports);
  * @const VERSION
  * @memberOf module:core
  */
-exports.VERSION = "0.5.27";
+exports.VERSION = "0.5.29";
 //# 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.27";
+export declare const VERSION = "0.5.29";

package/lib/query/MethodQueryBuilder.cjs

@@ -0,0 +1,276 @@
+"use strict";
+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":"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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"]}