@decaf-ts/for-couchdb 0.3.0 → 0.3.2

package/lib/query/Statement.cjs

@@ -2,57 +2,285 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CouchDBStatement = void 0;
 const core_1 = require("@decaf-ts/core");
-const db_decorators_1 = require("@decaf-ts/db-decorators");
+const translate_1 = require("./translate.cjs");
 const constants_1 = require("./../constants.cjs");
-const utils_1 = require("./../sequences/utils.cjs");
+const constants_2 = require("./constants.cjs");
 const Paginator_1 = require("./Paginator.cjs");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+/**
+ * @description Statement builder for CouchDB Mango queries
+ * @summary Provides a fluent interface for building CouchDB Mango queries with type safety
+ * @template M - The model type that extends Model
+ * @template R - The result type
+ * @param adapter - The CouchDB adapter
+ * @class CouchDBStatement
+ * @example
+ * // Example of using CouchDBStatement
+ * const adapter = new MyCouchDBAdapter(scope);
+ * const statement = new CouchDBStatement<User, User[]>(adapter);
+ *
+ * // Build a query
+ * const users = await statement
+ *   .from(User)
+ *   .where(Condition.attribute<User>('age').gt(18))
+ *   .orderBy('lastName', 'asc')
+ *   .limit(10)
+ *   .execute();
+ */
 class CouchDBStatement extends core_1.Statement {
     constructor(adapter) {
         super(adapter);
     }
     /**
-     * @inheritDoc
+     * @description Builds a CouchDB Mango query from the statement
+     * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query
+     * @return {MangoQuery} The built Mango query
+     * @throws {Error} If there are invalid query conditions
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant Repository
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: build()
+     *   Note over Statement: Initialize selectors
+     *   Statement->>Repository: Get table name
+     *   Repository-->>Statement: Return table name
+     *   Statement->>Statement: Create base query
+     *
+     *   alt Has selectSelector
+     *     Statement->>Statement: Add fields to query
+     *   end
+     *
+     *   alt Has whereCondition
+     *     Statement->>Statement: Create combined condition with table
+     *     Statement->>parseCondition: Parse condition
+     *     parseCondition-->>Statement: Return parsed condition
+     *
+     *     alt Is group operator
+     *       alt Is AND operator
+     *         Statement->>Statement: Flatten nested AND conditions
+     *       else Is OR operator
+     *         Statement->>Statement: Combine with table condition
+     *       else
+     *         Statement->>Statement: Throw error
+     *       end
+     *     else
+     *       Statement->>Statement: Merge conditions with existing selector
+     *     end
+     *   end
+     *
+     *   alt Has orderBySelector
+     *     Statement->>Statement: Add sort to query
+     *     Statement->>Statement: Ensure field exists in selector
+     *   end
+     *
+     *   alt Has limitSelector
+     *     Statement->>Statement: Set limit
+     *   else
+     *     Statement->>Statement: Use default limit
+     *   end
+     *
+     *   alt Has offsetSelector
+     *     Statement->>Statement: Set skip
+     *   end
+     *
+     *   Statement-->>Statement: Return query
      */
-    async execute() {
-        try {
-            const query = this.build();
-            if (!query.limit)
-                query.limit = Number.MAX_SAFE_INTEGER;
-            return this.raw(query);
+    build() {
+        const selectors = {};
+        selectors[constants_1.CouchDBKeys.TABLE] = {};
+        selectors[constants_1.CouchDBKeys.TABLE] = core_1.Repository.table(this.fromSelector);
+        const query = { selector: selectors };
+        if (this.selectSelector)
+            query.fields = this.selectSelector;
+        if (this.whereCondition) {
+            const condition = this.parseCondition(core_1.Condition.and(this.whereCondition, core_1.Condition.attribute(constants_1.CouchDBKeys.TABLE).eq(query.selector[constants_1.CouchDBKeys.TABLE]))).selector;
+            const selectorKeys = Object.keys(condition);
+            if (selectorKeys.length === 1 &&
+                Object.values(constants_2.CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1)
+                switch (selectorKeys[0]) {
+                    case constants_2.CouchDBGroupOperator.AND:
+                        condition[constants_2.CouchDBGroupOperator.AND] = [
+                            ...Object.values(condition[constants_2.CouchDBGroupOperator.AND]).reduce((accum, val) => {
+                                const keys = Object.keys(val);
+                                if (keys.length !== 1)
+                                    throw new Error("Too many keys in query selector. should be one");
+                                const k = keys[0];
+                                if (k === constants_2.CouchDBGroupOperator.AND)
+                                    accum.push(...val[k]);
+                                else
+                                    accum.push(val);
+                                return accum;
+                            }, []),
+                        ];
+                        query.selector = condition;
+                        break;
+                    case constants_2.CouchDBGroupOperator.OR: {
+                        const s = {};
+                        s[constants_2.CouchDBGroupOperator.AND] = [
+                            condition,
+                            ...Object.entries(query.selector).map(([key, val]) => {
+                                const result = {};
+                                result[key] = val;
+                                return result;
+                            }),
+                        ];
+                        query.selector = s;
+                        break;
+                    }
+                    default:
+                        throw new Error("This should be impossible");
+                }
+            else {
+                Object.entries(condition).forEach(([key, val]) => {
+                    if (query.selector[key])
+                        console.warn(`A ${key} query param is about to be overridden: ${query.selector[key]} by ${val}`);
+                    query.selector[key] = val;
+                });
+            }
         }
-        catch (e) {
-            throw new db_decorators_1.InternalError(e);
+        if (this.orderBySelector) {
+            query.sort = query.sort || [];
+            query.selector = query.selector || {};
+            const [selector, value] = this.orderBySelector;
+            const rec = {};
+            rec[selector] = value;
+            query.sort.push(rec);
+            if (!query.selector[selector]) {
+                query.selector[selector] = {};
+                query.selector[selector][constants_2.CouchDBOperator.BIGGER] =
+                    null;
+            }
         }
+        if (this.limitSelector) {
+            query.limit = this.limitSelector;
+        }
+        else {
+            console.warn(`No limit selector defined. Using default couchdb limit of ${constants_2.CouchDBQueryLimit}`);
+            query.limit = constants_2.CouchDBQueryLimit;
+        }
+        if (this.offsetSelector)
+            query.skip = this.offsetSelector;
+        return query;
     }
+    /**
+     * @description Creates a paginator for the statement
+     * @summary Builds the query and returns a CouchDBPaginator for paginated results
+     * @template R - The result type
+     * @param {number} size - The page size
+     * @return {Promise<Paginator<M, R, MangoQuery>>} A promise that resolves to a paginator
+     * @throws {InternalError} If there's an error building the query
+     */
     async paginate(size) {
         try {
             const query = this.build();
-            return new Paginator_1.CouchDBPaginator(this, size, query);
+            return new Paginator_1.CouchDBPaginator(this.adapter, query, size, this.fromSelector);
         }
         catch (e) {
             throw new db_decorators_1.InternalError(e);
         }
     }
+    /**
+     * @description Processes a record from CouchDB
+     * @summary Extracts the ID from a CouchDB document and reverts it to a model instance
+     * @param {any} r - The raw record from CouchDB
+     * @param pkAttr - The primary key attribute of the model
+     * @param {"Number" | "BigInt" | undefined} sequenceType - The type of the sequence
+     * @return {any} The processed record
+     */
     processRecord(r, pkAttr, sequenceType) {
-        if (!r[constants_1.CouchDBKeys.ID])
-            throw new db_decorators_1.InternalError(`No CouchDB Id definition found. Should not be possible`);
-        const [, ...keyArgs] = r[constants_1.CouchDBKeys.ID].split("_");
-        const id = keyArgs.join("_");
-        return this.adapter.revert(r, this.target, pkAttr, (0, utils_1.parseSequenceValue)(sequenceType, id));
+        if (r[constants_1.CouchDBKeys.ID]) {
+            const [, ...keyArgs] = r[constants_1.CouchDBKeys.ID].split(constants_1.CouchDBKeys.SEPARATOR);
+            const id = keyArgs.join("_");
+            return this.adapter.revert(r, this.fromSelector, pkAttr, core_1.Sequence.parseValue(sequenceType, id));
+        }
+        return r;
     }
-    async raw(rawInput, ...args) {
-        const results = await this.adapter.raw(rawInput, true, ...args);
-        if (!this.fullRecord)
-            return results;
-        if (!this.target)
-            throw new db_decorators_1.InternalError("No target defined in statement. should never happen");
-        const pkDef = (0, db_decorators_1.findPrimaryKey)(new this.target());
+    /**
+     * @description Executes a raw Mango query
+     * @summary Sends a raw Mango query to CouchDB and processes the results
+     * @template R - The result type
+     * @param {MangoQuery} rawInput - The raw Mango query to execute
+     * @return {Promise<R>} A promise that resolves to the query results
+     */
+    async raw(rawInput) {
+        const results = await this.adapter.raw(rawInput, true);
+        const pkDef = (0, db_decorators_1.findPrimaryKey)(new this.fromSelector());
         const pkAttr = pkDef.id;
         const type = pkDef.props.type;
-        if (Array.isArray(results))
+        if (!this.selectSelector)
             return results.map((r) => this.processRecord(r, pkAttr, type));
-        return this.processRecord(results, pkAttr, type);
+        return results;
+    }
+    /**
+     * @description Parses a condition into a CouchDB Mango query selector
+     * @summary Converts a Condition object into a CouchDB Mango query selector structure
+     * @param {Condition<M>} condition - The condition to parse
+     * @return {MangoQuery} The Mango query with the parsed condition as its selector
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant translateOperators
+     *   participant merge
+     *
+     *   Statement->>Statement: parseCondition(condition)
+     *
+     *   Note over Statement: Extract condition parts
+     *
+     *   alt Simple comparison operator
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return CouchDB operator
+     *     Statement->>Statement: Create selector with attribute and operator
+     *   else NOT operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>translateOperators: translateOperators(Operator.NOT)
+     *     translateOperators-->>Statement: Return CouchDB NOT operator
+     *     Statement->>Statement: Create negated selector
+     *   else AND/OR operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: parseCondition(comparison)
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return CouchDB group operator
+     *     Statement->>merge: merge(operator, op1, op2)
+     *     merge-->>Statement: Return merged selector
+     *   end
+     *
+     *   Statement-->>Statement: Return query with selector
+     */
+    parseCondition(condition) {
+        /**
+         * @description Merges two selectors with a logical operator
+         * @summary Helper function to combine two selectors with a logical operator
+         * @param {MangoOperator} op - The operator to use for merging
+         * @param {MangoSelector} obj1 - The first selector
+         * @param {MangoSelector} obj2 - The second selector
+         * @return {MangoQuery} The merged query
+         */
+        function merge(op, obj1, obj2) {
+            const result = { selector: {} };
+            result.selector[op] = [obj1, obj2];
+            return result;
+        }
+        const { attr1, operator, comparison } = condition;
+        let op = {};
+        if ([core_1.GroupOperator.AND, core_1.GroupOperator.OR, core_1.Operator.NOT].indexOf(operator) === -1) {
+            op[attr1] = {};
+            op[attr1][(0, translate_1.translateOperators)(operator)] =
+                comparison;
+        }
+        else if (operator === core_1.Operator.NOT) {
+            op = this.parseCondition(attr1).selector;
+            op[(0, translate_1.translateOperators)(core_1.Operator.NOT)] = {};
+            op[(0, translate_1.translateOperators)(core_1.Operator.NOT)][attr1.attr1] = comparison;
+        }
+        else {
+            const op1 = this.parseCondition(attr1).selector;
+            const op2 = this.parseCondition(comparison).selector;
+            op = merge((0, translate_1.translateOperators)(operator), op1, op2).selector;
+        }
+        return { selector: op };
     }
 }
 exports.CouchDBStatement = CouchDBStatement;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Statement.js","sourceRoot":"","sources":["../../src/query/Statement.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Condition,\n  GroupOperator,\n  Operator,\n  OrderDirection,\n  Paginator,\n  Repository,\n  Sequence,\n  Statement,\n} from \"@decaf-ts/core\";\nimport { MangoOperator, MangoQuery, MangoSelector } from \"../types\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBAdapter } from \"../adapter\";\nimport { translateOperators } from \"./translate\";\nimport { CouchDBKeys } from \"../constants\";\nimport {\n  CouchDBGroupOperator,\n  CouchDBOperator,\n  CouchDBQueryLimit,\n} from \"./constants\";\nimport { CouchDBPaginator } from \"./Paginator\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Statement builder for CouchDB Mango queries\n * @summary Provides a fluent interface for building CouchDB Mango queries with type safety\n * @template M - The model type that extends Model\n * @template R - The result type\n * @param adapter - The CouchDB adapter\n * @class CouchDBStatement\n * @example\n * // Example of using CouchDBStatement\n * const adapter = new MyCouchDBAdapter(scope);\n * const statement = new CouchDBStatement<User, User[]>(adapter);\n *\n * // Build a query\n * const users = await statement\n *   .from(User)\n *   .where(Condition.attribute<User>('age').gt(18))\n *   .orderBy('lastName', 'asc')\n *   .limit(10)\n *   .execute();\n */\nexport class CouchDBStatement<M extends Model, R> extends Statement<\n  MangoQuery,\n  M,\n  R\n> {\n  constructor(adapter: CouchDBAdapter<any, any, any>) {\n    super(adapter);\n  }\n\n  /**\n   * @description Builds a CouchDB Mango query from the statement\n   * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query\n   * @return {MangoQuery} The built Mango query\n   * @throws {Error} If there are invalid query conditions\n   * @mermaid\n   * sequenceDiagram\n   *   participant Statement\n   *   participant Repository\n   *   participant parseCondition\n   *\n   *   Statement->>Statement: build()\n   *   Note over Statement: Initialize selectors\n   *   Statement->>Repository: Get table name\n   *   Repository-->>Statement: Return table name\n   *   Statement->>Statement: Create base query\n   *\n   *   alt Has selectSelector\n   *     Statement->>Statement: Add fields to query\n   *   end\n   *\n   *   alt Has whereCondition\n   *     Statement->>Statement: Create combined condition with table\n   *     Statement->>parseCondition: Parse condition\n   *     parseCondition-->>Statement: Return parsed condition\n   *\n   *     alt Is group operator\n   *       alt Is AND operator\n   *         Statement->>Statement: Flatten nested AND conditions\n   *       else Is OR operator\n   *         Statement->>Statement: Combine with table condition\n   *       else\n   *         Statement->>Statement: Throw error\n   *       end\n   *     else\n   *       Statement->>Statement: Merge conditions with existing selector\n   *     end\n   *   end\n   *\n   *   alt Has orderBySelector\n   *     Statement->>Statement: Add sort to query\n   *     Statement->>Statement: Ensure field exists in selector\n   *   end\n   *\n   *   alt Has limitSelector\n   *     Statement->>Statement: Set limit\n   *   else\n   *     Statement->>Statement: Use default limit\n   *   end\n   *\n   *   alt Has offsetSelector\n   *     Statement->>Statement: Set skip\n   *   end\n   *\n   *   Statement-->>Statement: Return query\n   */\n  protected build(): MangoQuery {\n    const selectors: MangoSelector = {};\n    selectors[CouchDBKeys.TABLE] = {};\n    selectors[CouchDBKeys.TABLE] = Repository.table(this.fromSelector);\n    const query: MangoQuery = { selector: selectors };\n    if (this.selectSelector) query.fields = this.selectSelector as string[];\n\n    if (this.whereCondition) {\n      const condition: MangoSelector = this.parseCondition(\n        Condition.and(\n          this.whereCondition,\n          Condition.attribute<M>(CouchDBKeys.TABLE as keyof M).eq(\n            query.selector[CouchDBKeys.TABLE]\n          )\n        )\n      ).selector;\n      const selectorKeys = Object.keys(condition) as MangoOperator[];\n      if (\n        selectorKeys.length === 1 &&\n        Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1\n      )\n        switch (selectorKeys[0]) {\n          case CouchDBGroupOperator.AND:\n            condition[CouchDBGroupOperator.AND] = [\n              ...Object.values(\n                condition[CouchDBGroupOperator.AND] as MangoSelector\n              ).reduce((accum: MangoSelector[], val: any) => {\n                const keys = Object.keys(val);\n                if (keys.length !== 1)\n                  throw new Error(\n                    \"Too many keys in query selector. should be one\"\n                  );\n                const k = keys[0];\n                if (k === CouchDBGroupOperator.AND)\n                  accum.push(...(val[k] as any[]));\n                else accum.push(val);\n                return accum;\n              }, []),\n            ];\n            query.selector = condition;\n            break;\n          case CouchDBGroupOperator.OR: {\n            const s: Record<any, any> = {};\n            s[CouchDBGroupOperator.AND] = [\n              condition,\n              ...Object.entries(query.selector).map(([key, val]) => {\n                const result: Record<any, any> = {};\n                result[key] = val;\n                return result;\n              }),\n            ];\n            query.selector = s;\n            break;\n          }\n          default:\n            throw new Error(\"This should be impossible\");\n        }\n      else {\n        Object.entries(condition).forEach(([key, val]) => {\n          if (query.selector[key])\n            console.warn(\n              `A ${key} query param is about to be overridden: ${query.selector[key]} by ${val}`\n            );\n          query.selector[key] = val;\n        });\n      }\n    }\n\n    if (this.orderBySelector) {\n      query.sort = query.sort || [];\n      query.selector = query.selector || ({} as MangoSelector);\n      const [selector, value] = this.orderBySelector as [\n        string,\n        OrderDirection,\n      ];\n      const rec: any = {};\n      rec[selector] = value;\n      (query.sort as any[]).push(rec as any);\n      if (!query.selector[selector]) {\n        query.selector[selector] = {} as MangoSelector;\n        (query.selector[selector] as MangoSelector)[CouchDBOperator.BIGGER] =\n          null;\n      }\n    }\n\n    if (this.limitSelector) {\n      query.limit = this.limitSelector;\n    } else {\n      console.warn(\n        `No limit selector defined. Using default couchdb limit of ${CouchDBQueryLimit}`\n      );\n      query.limit = CouchDBQueryLimit;\n    }\n\n    if (this.offsetSelector) query.skip = this.offsetSelector;\n\n    return query;\n  }\n\n  /**\n   * @description Creates a paginator for the statement\n   * @summary Builds the query and returns a CouchDBPaginator for paginated results\n   * @template R - The result type\n   * @param {number} size - The page size\n   * @return {Promise<Paginator<M, R, MangoQuery>>} A promise that resolves to a paginator\n   * @throws {InternalError} If there's an error building the query\n   */\n  async paginate<R>(size: number): Promise<Paginator<M, R, MangoQuery>> {\n    try {\n      const query: MangoQuery = this.build();\n      return new CouchDBPaginator(\n        this.adapter as any,\n        query,\n        size,\n        this.fromSelector\n      );\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  /**\n   * @description Processes a record from CouchDB\n   * @summary Extracts the ID from a CouchDB document and reverts it to a model instance\n   * @param {any} r - The raw record from CouchDB\n   * @param pkAttr - The primary key attribute of the model\n   * @param {\"Number\" | \"BigInt\" | undefined} sequenceType - The type of the sequence\n   * @return {any} The processed record\n   */\n  private processRecord(\n    r: any,\n    pkAttr: keyof M,\n    sequenceType: \"Number\" | \"BigInt\" | undefined\n  ) {\n    if (r[CouchDBKeys.ID]) {\n      const [, ...keyArgs] = r[CouchDBKeys.ID].split(CouchDBKeys.SEPARATOR);\n\n      const id = keyArgs.join(\"_\");\n      return this.adapter.revert(\n        r,\n        this.fromSelector,\n        pkAttr,\n        Sequence.parseValue(sequenceType, id)\n      );\n    }\n    return r;\n  }\n\n  /**\n   * @description Executes a raw Mango query\n   * @summary Sends a raw Mango query to CouchDB and processes the results\n   * @template R - The result type\n   * @param {MangoQuery} rawInput - The raw Mango query to execute\n   * @return {Promise<R>} A promise that resolves to the query results\n   */\n  override async raw<R>(rawInput: MangoQuery): Promise<R> {\n    const results: any[] = await this.adapter.raw(rawInput, true);\n\n    const pkDef = findPrimaryKey(new this.fromSelector());\n    const pkAttr = pkDef.id;\n    const type = pkDef.props.type;\n\n    if (!this.selectSelector)\n      return results.map((r) => this.processRecord(r, pkAttr, type)) as R;\n    return results as R;\n  }\n\n  /**\n   * @description Parses a condition into a CouchDB Mango query selector\n   * @summary Converts a Condition object into a CouchDB Mango query selector structure\n   * @param {Condition<M>} condition - The condition to parse\n   * @return {MangoQuery} The Mango query with the parsed condition as its selector\n   * @mermaid\n   * sequenceDiagram\n   *   participant Statement\n   *   participant translateOperators\n   *   participant merge\n   *\n   *   Statement->>Statement: parseCondition(condition)\n   *\n   *   Note over Statement: Extract condition parts\n   *\n   *   alt Simple comparison operator\n   *     Statement->>translateOperators: translateOperators(operator)\n   *     translateOperators-->>Statement: Return CouchDB operator\n   *     Statement->>Statement: Create selector with attribute and operator\n   *   else NOT operator\n   *     Statement->>Statement: parseCondition(attr1)\n   *     Statement->>translateOperators: translateOperators(Operator.NOT)\n   *     translateOperators-->>Statement: Return CouchDB NOT operator\n   *     Statement->>Statement: Create negated selector\n   *   else AND/OR operator\n   *     Statement->>Statement: parseCondition(attr1)\n   *     Statement->>Statement: parseCondition(comparison)\n   *     Statement->>translateOperators: translateOperators(operator)\n   *     translateOperators-->>Statement: Return CouchDB group operator\n   *     Statement->>merge: merge(operator, op1, op2)\n   *     merge-->>Statement: Return merged selector\n   *   end\n   *\n   *   Statement-->>Statement: Return query with selector\n   */\n  protected parseCondition(condition: Condition<M>): MangoQuery {\n    /**\n     * @description Merges two selectors with a logical operator\n     * @summary Helper function to combine two selectors with a logical operator\n     * @param {MangoOperator} op - The operator to use for merging\n     * @param {MangoSelector} obj1 - The first selector\n     * @param {MangoSelector} obj2 - The second selector\n     * @return {MangoQuery} The merged query\n     */\n    function merge(\n      op: MangoOperator,\n      obj1: MangoSelector,\n      obj2: MangoSelector\n    ): MangoQuery {\n      const result: MangoQuery = { selector: {} as MangoSelector };\n      result.selector[op] = [obj1, obj2];\n      return result;\n    }\n\n    const { attr1, operator, comparison } = condition as unknown as {\n      attr1: string | Condition<M>;\n      operator: Operator | GroupOperator;\n      comparison: any;\n    };\n\n    let op: MangoSelector = {} as MangoSelector;\n    if (\n      [GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(\n        operator as GroupOperator\n      ) === -1\n    ) {\n      op[attr1 as string] = {} as MangoSelector;\n      (op[attr1 as string] as MangoSelector)[translateOperators(operator)] =\n        comparison;\n    } else if (operator === Operator.NOT) {\n      op = this.parseCondition(attr1 as Condition<M>).selector as MangoSelector;\n      op[translateOperators(Operator.NOT)] = {} as MangoSelector;\n      (op[translateOperators(Operator.NOT)] as MangoSelector)[\n        (attr1 as unknown as { attr1: string }).attr1\n      ] = comparison;\n    } else {\n      const op1: any = this.parseCondition(attr1 as Condition<M>).selector;\n      const op2: any = this.parseCondition(comparison as Condition<M>).selector;\n      op = merge(translateOperators(operator), op1, op2).selector;\n    }\n\n    return { selector: op };\n  }\n}\n"]}

package/lib/query/Statement.d.ts

@@ -1,13 +1,146 @@
-import { Adapter, Statement } from "@decaf-ts/core";
-import { Paginator } from "@decaf-ts/core";
+import { Condition, Paginator, Statement } from "@decaf-ts/core";
 import { MangoQuery } from "../types";
-export declare class CouchDBStatement<Y> extends Statement<MangoQuery> {
-    constructor(adapter: Adapter<Y, MangoQuery, any, any>);
+import { Model } from "@decaf-ts/decorator-validation";
+import { CouchDBAdapter } from "../adapter";
+/**
+ * @description Statement builder for CouchDB Mango queries
+ * @summary Provides a fluent interface for building CouchDB Mango queries with type safety
+ * @template M - The model type that extends Model
+ * @template R - The result type
+ * @param adapter - The CouchDB adapter
+ * @class CouchDBStatement
+ * @example
+ * // Example of using CouchDBStatement
+ * const adapter = new MyCouchDBAdapter(scope);
+ * const statement = new CouchDBStatement<User, User[]>(adapter);
+ *
+ * // Build a query
+ * const users = await statement
+ *   .from(User)
+ *   .where(Condition.attribute<User>('age').gt(18))
+ *   .orderBy('lastName', 'asc')
+ *   .limit(10)
+ *   .execute();
+ */
+export declare class CouchDBStatement<M extends Model, R> extends Statement<MangoQuery, M, R> {
+    constructor(adapter: CouchDBAdapter<any, any, any>);
     /**
-     * @inheritDoc
+     * @description Builds a CouchDB Mango query from the statement
+     * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query
+     * @return {MangoQuery} The built Mango query
+     * @throws {Error} If there are invalid query conditions
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant Repository
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: build()
+     *   Note over Statement: Initialize selectors
+     *   Statement->>Repository: Get table name
+     *   Repository-->>Statement: Return table name
+     *   Statement->>Statement: Create base query
+     *
+     *   alt Has selectSelector
+     *     Statement->>Statement: Add fields to query
+     *   end
+     *
+     *   alt Has whereCondition
+     *     Statement->>Statement: Create combined condition with table
+     *     Statement->>parseCondition: Parse condition
+     *     parseCondition-->>Statement: Return parsed condition
+     *
+     *     alt Is group operator
+     *       alt Is AND operator
+     *         Statement->>Statement: Flatten nested AND conditions
+     *       else Is OR operator
+     *         Statement->>Statement: Combine with table condition
+     *       else
+     *         Statement->>Statement: Throw error
+     *       end
+     *     else
+     *       Statement->>Statement: Merge conditions with existing selector
+     *     end
+     *   end
+     *
+     *   alt Has orderBySelector
+     *     Statement->>Statement: Add sort to query
+     *     Statement->>Statement: Ensure field exists in selector
+     *   end
+     *
+     *   alt Has limitSelector
+     *     Statement->>Statement: Set limit
+     *   else
+     *     Statement->>Statement: Use default limit
+     *   end
+     *
+     *   alt Has offsetSelector
+     *     Statement->>Statement: Set skip
+     *   end
+     *
+     *   Statement-->>Statement: Return query
+     */
+    protected build(): MangoQuery;
+    /**
+     * @description Creates a paginator for the statement
+     * @summary Builds the query and returns a CouchDBPaginator for paginated results
+     * @template R - The result type
+     * @param {number} size - The page size
+     * @return {Promise<Paginator<M, R, MangoQuery>>} A promise that resolves to a paginator
+     * @throws {InternalError} If there's an error building the query
+     */
+    paginate<R>(size: number): Promise<Paginator<M, R, MangoQuery>>;
+    /**
+     * @description Processes a record from CouchDB
+     * @summary Extracts the ID from a CouchDB document and reverts it to a model instance
+     * @param {any} r - The raw record from CouchDB
+     * @param pkAttr - The primary key attribute of the model
+     * @param {"Number" | "BigInt" | undefined} sequenceType - The type of the sequence
+     * @return {any} The processed record
      */
-    execute<Y>(): Promise<Y>;
-    paginate<R>(size: number): Promise<Paginator<R, MangoQuery>>;
     private processRecord;
-    raw<R>(rawInput: MangoQuery, ...args: any[]): Promise<R>;
+    /**
+     * @description Executes a raw Mango query
+     * @summary Sends a raw Mango query to CouchDB and processes the results
+     * @template R - The result type
+     * @param {MangoQuery} rawInput - The raw Mango query to execute
+     * @return {Promise<R>} A promise that resolves to the query results
+     */
+    raw<R>(rawInput: MangoQuery): Promise<R>;
+    /**
+     * @description Parses a condition into a CouchDB Mango query selector
+     * @summary Converts a Condition object into a CouchDB Mango query selector structure
+     * @param {Condition<M>} condition - The condition to parse
+     * @return {MangoQuery} The Mango query with the parsed condition as its selector
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant translateOperators
+     *   participant merge
+     *
+     *   Statement->>Statement: parseCondition(condition)
+     *
+     *   Note over Statement: Extract condition parts
+     *
+     *   alt Simple comparison operator
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return CouchDB operator
+     *     Statement->>Statement: Create selector with attribute and operator
+     *   else NOT operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>translateOperators: translateOperators(Operator.NOT)
+     *     translateOperators-->>Statement: Return CouchDB NOT operator
+     *     Statement->>Statement: Create negated selector
+     *   else AND/OR operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: parseCondition(comparison)
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return CouchDB group operator
+     *     Statement->>merge: merge(operator, op1, op2)
+     *     merge-->>Statement: Return merged selector
+     *   end
+     *
+     *   Statement-->>Statement: Return query with selector
+     */
+    protected parseCondition(condition: Condition<M>): MangoQuery;
 }

package/lib/query/constants.cjs

@@ -1,6 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CouchDBConst = exports.CouchDBGroupOperator = exports.CouchDBOperator = void 0;
+exports.CouchDBConst = exports.CouchDBGroupOperator = exports.CouchDBOperator = exports.CouchDBQueryLimit = void 0;
+/**
+ * @description Default query limit for CouchDB queries
+ * @summary Maximum number of documents to return in a single query
+ * @const CouchDBQueryLimit
+ * @memberOf module:for-couchdb
+ */
+exports.CouchDBQueryLimit = 250;
+/**
+ * @description Mapping of operator names to CouchDB Mango query operators
+ * @summary Constants for CouchDB comparison operators used in Mango queries
+ * @typedef {Object} CouchDBOperatorType
+ * @property {string} EQUAL - Equality operator ($eq)
+ * @property {string} DIFFERENT - Inequality operator ($ne)
+ * @property {string} BIGGER - Greater than operator ($gt)
+ * @property {string} BIGGER_EQ - Greater than or equal operator ($gte)
+ * @property {string} SMALLER - Less than operator ($lt)
+ * @property {string} SMALLER_EQ - Less than or equal operator ($lte)
+ * @property {string} NOT - Negation operator ($not)
+ * @property {string} IN - In array operator ($in)
+ * @property {string} REGEXP - Regular expression operator ($regex)
+ * @const CouchDBOperator
+ * @type {CouchDBOperatorType}
+ * @memberOf module:for-couchdb
+ */
 exports.CouchDBOperator = {
     EQUAL: "$eq",
     DIFFERENT: "$ne",
@@ -14,11 +38,30 @@ exports.CouchDBOperator = {
     // IS = "IS",
     REGEXP: "$regex",
 };
+/**
+ * @description Mapping of logical operator names to CouchDB Mango query operators
+ * @summary Constants for CouchDB logical operators used in Mango queries
+ * @typedef {Object} CouchDBGroupOperatorType
+ * @property {string} AND - Logical AND operator ($and)
+ * @property {string} OR - Logical OR operator ($or)
+ * @const CouchDBGroupOperator
+ * @type {CouchDBGroupOperatorType}
+ * @memberOf module:for-couchdb
+ */
 exports.CouchDBGroupOperator = {
     AND: "$and",
     OR: "$or",
 };
+/**
+ * @description Special constant values used in CouchDB queries
+ * @summary String constants representing special values in CouchDB
+ * @typedef {Object} CouchDBConstType
+ * @property {string} NULL - String representation of null value
+ * @const CouchDBConst
+ * @type {CouchDBConstType}
+ * @memberOf module:for-couchdb
+ */
 exports.CouchDBConst = {
     NULL: "null",
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3F1ZXJ5L2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFYSxRQUFBLGVBQWUsR0FBa0M7SUFDNUQsS0FBSyxFQUFFLEtBQUs7SUFDWixTQUFTLEVBQUUsS0FBSztJQUNoQixNQUFNLEVBQUUsS0FBSztJQUNiLFNBQVMsRUFBRSxNQUFNO0lBQ2pCLE9BQU8sRUFBRSxLQUFLO0lBQ2QsVUFBVSxFQUFFLE1BQU07SUFDbEIsdUJBQXVCO0lBQ3ZCLEdBQUcsRUFBRSxNQUFNO0lBQ1gsRUFBRSxFQUFFLEtBQUs7SUFDVCxhQUFhO0lBQ2IsTUFBTSxFQUFFLFFBQVE7Q0FDakIsQ0FBQztBQUVXLFFBQUEsb0JBQW9CLEdBQWtDO0lBQ2pFLEdBQUcsRUFBRSxNQUFNO0lBQ1gsRUFBRSxFQUFFLEtBQUs7Q0FDVixDQUFDO0FBRVcsUUFBQSxZQUFZLEdBQTJCO0lBQ2xELElBQUksRUFBRSxNQUFNO0NBQ2IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1hbmdvT3BlcmF0b3IgfSBmcm9tIFwiLi4vdHlwZXNcIjtcblxuZXhwb3J0IGNvbnN0IENvdWNoREJPcGVyYXRvcjogUmVjb3JkPHN0cmluZywgTWFuZ29PcGVyYXRvcj4gPSB7XG4gIEVRVUFMOiBcIiRlcVwiLFxuICBESUZGRVJFTlQ6IFwiJG5lXCIsXG4gIEJJR0dFUjogXCIkZ3RcIixcbiAgQklHR0VSX0VROiBcIiRndGVcIixcbiAgU01BTExFUjogXCIkbHRcIixcbiAgU01BTExFUl9FUTogXCIkbHRlXCIsXG4gIC8vIEJFVFdFRU4gPSBcIkJFVFdFRU5cIixcbiAgTk9UOiBcIiRub3RcIixcbiAgSU46IFwiJGluXCIsXG4gIC8vIElTID0gXCJJU1wiLFxuICBSRUdFWFA6IFwiJHJlZ2V4XCIsXG59O1xuXG5leHBvcnQgY29uc3QgQ291Y2hEQkdyb3VwT3BlcmF0b3I6IFJlY29yZDxzdHJpbmcsIE1hbmdvT3BlcmF0b3I+ID0ge1xuICBBTkQ6IFwiJGFuZFwiLFxuICBPUjogXCIkb3JcIixcbn07XG5cbmV4cG9ydCBjb25zdCBDb3VjaERCQ29uc3Q6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gPSB7XG4gIE5VTEw6IFwibnVsbFwiLFxufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/query/constants.d.ts

@@ -1,4 +1,47 @@
 import { MangoOperator } from "../types";
+/**
+ * @description Default query limit for CouchDB queries
+ * @summary Maximum number of documents to return in a single query
+ * @const CouchDBQueryLimit
+ * @memberOf module:for-couchdb
+ */
+export declare const CouchDBQueryLimit = 250;
+/**
+ * @description Mapping of operator names to CouchDB Mango query operators
+ * @summary Constants for CouchDB comparison operators used in Mango queries
+ * @typedef {Object} CouchDBOperatorType
+ * @property {string} EQUAL - Equality operator ($eq)
+ * @property {string} DIFFERENT - Inequality operator ($ne)
+ * @property {string} BIGGER - Greater than operator ($gt)
+ * @property {string} BIGGER_EQ - Greater than or equal operator ($gte)
+ * @property {string} SMALLER - Less than operator ($lt)
+ * @property {string} SMALLER_EQ - Less than or equal operator ($lte)
+ * @property {string} NOT - Negation operator ($not)
+ * @property {string} IN - In array operator ($in)
+ * @property {string} REGEXP - Regular expression operator ($regex)
+ * @const CouchDBOperator
+ * @type {CouchDBOperatorType}
+ * @memberOf module:for-couchdb
+ */
 export declare const CouchDBOperator: Record<string, MangoOperator>;
+/**
+ * @description Mapping of logical operator names to CouchDB Mango query operators
+ * @summary Constants for CouchDB logical operators used in Mango queries
+ * @typedef {Object} CouchDBGroupOperatorType
+ * @property {string} AND - Logical AND operator ($and)
+ * @property {string} OR - Logical OR operator ($or)
+ * @const CouchDBGroupOperator
+ * @type {CouchDBGroupOperatorType}
+ * @memberOf module:for-couchdb
+ */
 export declare const CouchDBGroupOperator: Record<string, MangoOperator>;
+/**
+ * @description Special constant values used in CouchDB queries
+ * @summary String constants representing special values in CouchDB
+ * @typedef {Object} CouchDBConstType
+ * @property {string} NULL - String representation of null value
+ * @const CouchDBConst
+ * @type {CouchDBConstType}
+ * @memberOf module:for-couchdb
+ */
 export declare const CouchDBConst: Record<string, string>;