@decaf-ts/for-couchdb 0.3.1 → 0.3.2

package/lib/query/Statement.cjs

@@ -7,10 +7,86 @@ const constants_1 = require("./../constants.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);
     }
+    /**
+     * @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
+     */
     build() {
         const selectors = {};
         selectors[constants_1.CouchDBKeys.TABLE] = {};
@@ -88,6 +164,14 @@ class CouchDBStatement extends core_1.Statement {
             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();
@@ -97,6 +181,14 @@ class CouchDBStatement extends core_1.Statement {
             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]) {
             const [, ...keyArgs] = r[constants_1.CouchDBKeys.ID].split(constants_1.CouchDBKeys.SEPARATOR);
@@ -105,6 +197,13 @@ class CouchDBStatement extends core_1.Statement {
         }
         return 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
+     */
     async raw(rawInput) {
         const results = await this.adapter.raw(rawInput, true);
         const pkDef = (0, db_decorators_1.findPrimaryKey)(new this.fromSelector());
@@ -114,7 +213,50 @@ class CouchDBStatement extends core_1.Statement {
             return results.map((r) => this.processRecord(r, 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];
@@ -141,4 +283,4 @@ class CouchDBStatement extends core_1.Statement {
     }
 }
 exports.CouchDBStatement = CouchDBStatement;
-//# 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\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  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  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  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  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  protected parseCondition(condition: Condition<M>): MangoQuery {\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"]}
+//# 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

@@ -2,11 +2,145 @@ import { Condition, Paginator, Statement } from "@decaf-ts/core";
 import { MangoQuery } from "../types";
 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>);
+    /**
+     * @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
+     */
     private processRecord;
+    /**
+     * @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,7 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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",
@@ -15,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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3F1ZXJ5L2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFYSxRQUFBLGlCQUFpQixHQUFHLEdBQUcsQ0FBQztBQUV4QixRQUFBLGVBQWUsR0FBa0M7SUFDNUQsS0FBSyxFQUFFLEtBQUs7SUFDWixTQUFTLEVBQUUsS0FBSztJQUNoQixNQUFNLEVBQUUsS0FBSztJQUNiLFNBQVMsRUFBRSxNQUFNO0lBQ2pCLE9BQU8sRUFBRSxLQUFLO0lBQ2QsVUFBVSxFQUFFLE1BQU07SUFDbEIsdUJBQXVCO0lBQ3ZCLEdBQUcsRUFBRSxNQUFNO0lBQ1gsRUFBRSxFQUFFLEtBQUs7SUFDVCxhQUFhO0lBQ2IsTUFBTSxFQUFFLFFBQVE7Q0FDakIsQ0FBQztBQUVXLFFBQUEsb0JBQW9CLEdBQWtDO0lBQ2pFLEdBQUcsRUFBRSxNQUFNO0lBQ1gsRUFBRSxFQUFFLEtBQUs7Q0FDVixDQUFDO0FBRVcsUUFBQSxZQUFZLEdBQTJCO0lBQ2xELElBQUksRUFBRSxNQUFNO0NBQ2IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1hbmdvT3BlcmF0b3IgfSBmcm9tIFwiLi4vdHlwZXNcIjtcblxuZXhwb3J0IGNvbnN0IENvdWNoREJRdWVyeUxpbWl0ID0gMjUwO1xuXG5leHBvcnQgY29uc3QgQ291Y2hEQk9wZXJhdG9yOiBSZWNvcmQ8c3RyaW5nLCBNYW5nb09wZXJhdG9yPiA9IHtcbiAgRVFVQUw6IFwiJGVxXCIsXG4gIERJRkZFUkVOVDogXCIkbmVcIixcbiAgQklHR0VSOiBcIiRndFwiLFxuICBCSUdHRVJfRVE6IFwiJGd0ZVwiLFxuICBTTUFMTEVSOiBcIiRsdFwiLFxuICBTTUFMTEVSX0VROiBcIiRsdGVcIixcbiAgLy8gQkVUV0VFTiA9IFwiQkVUV0VFTlwiLFxuICBOT1Q6IFwiJG5vdFwiLFxuICBJTjogXCIkaW5cIixcbiAgLy8gSVMgPSBcIklTXCIsXG4gIFJFR0VYUDogXCIkcmVnZXhcIixcbn07XG5cbmV4cG9ydCBjb25zdCBDb3VjaERCR3JvdXBPcGVyYXRvcjogUmVjb3JkPHN0cmluZywgTWFuZ29PcGVyYXRvcj4gPSB7XG4gIEFORDogXCIkYW5kXCIsXG4gIE9SOiBcIiRvclwiLFxufTtcblxuZXhwb3J0IGNvbnN0IENvdWNoREJDb25zdDogUmVjb3JkPHN0cmluZywgc3RyaW5nPiA9IHtcbiAgTlVMTDogXCJudWxsXCIsXG59O1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/query/constants.d.ts

@@ -1,5 +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>;

package/lib/query/translate.cjs

@@ -3,6 +3,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.translateOperators = translateOperators;
 const constants_1 = require("./constants.cjs");
 const core_1 = require("@decaf-ts/core");
+/**
+ * @description Translates core operators to CouchDB Mango operators
+ * @summary Converts Decaf.ts core operators to their equivalent CouchDB Mango query operators
+ * @param {GroupOperator | Operator} operator - The core operator to translate
+ * @return {MangoOperator} The equivalent CouchDB Mango operator
+ * @throws {QueryError} If no translation exists for the given operator
+ * @function translateOperators
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant translateOperators
+ *   participant CouchDBOperator
+ *   participant CouchDBGroupOperator
+ *
+ *   Caller->>translateOperators: operator
+ *
+ *   translateOperators->>CouchDBOperator: Check for match
+ *   alt Found in CouchDBOperator
+ *     CouchDBOperator-->>translateOperators: Return matching operator
+ *     translateOperators-->>Caller: Return MangoOperator
+ *   else Not found
+ *     translateOperators->>CouchDBGroupOperator: Check for match
+ *     alt Found in CouchDBGroupOperator
+ *       CouchDBGroupOperator-->>translateOperators: Return matching operator
+ *       translateOperators-->>Caller: Return MangoOperator
+ *     else Not found
+ *       translateOperators-->>Caller: Throw QueryError
+ *     end
+ *   end
+ */
 function translateOperators(operator) {
     for (const operators of [constants_1.CouchDBOperator, constants_1.CouchDBGroupOperator]) {
         const el = Object.keys(operators).find((k) => k === operator);
@@ -11,4 +42,4 @@ function translateOperators(operator) {
     }
     throw new core_1.QueryError(`Could not find adapter translation for operator ${operator}`);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3F1ZXJ5L3RyYW5zbGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUtBLGdEQVVDO0FBZEQsK0NBQW9FO0FBQ3BFLHlDQUE0QztBQUc1QyxTQUFnQixrQkFBa0IsQ0FDaEMsUUFBa0M7SUFFbEMsS0FBSyxNQUFNLFNBQVMsSUFBSSxDQUFDLDJCQUFlLEVBQUUsZ0NBQW9CLENBQUMsRUFBRSxDQUFDO1FBQ2hFLE1BQU0sRUFBRSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEtBQUssUUFBUSxDQUFDLENBQUM7UUFDOUQsSUFBSSxFQUFFO1lBQUUsT0FBTyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUNELE1BQU0sSUFBSSxpQkFBVSxDQUNsQixtREFBbUQsUUFBUSxFQUFFLENBQzlELENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgR3JvdXBPcGVyYXRvciwgT3BlcmF0b3IgfSBmcm9tIFwiQGRlY2FmLXRzL2NvcmVcIjtcbmltcG9ydCB7IENvdWNoREJHcm91cE9wZXJhdG9yLCBDb3VjaERCT3BlcmF0b3IgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmltcG9ydCB7IFF1ZXJ5RXJyb3IgfSBmcm9tIFwiQGRlY2FmLXRzL2NvcmVcIjtcbmltcG9ydCB7IE1hbmdvT3BlcmF0b3IgfSBmcm9tIFwiLi4vdHlwZXNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIHRyYW5zbGF0ZU9wZXJhdG9ycyhcbiAgb3BlcmF0b3I6IEdyb3VwT3BlcmF0b3IgfCBPcGVyYXRvclxuKTogTWFuZ29PcGVyYXRvciB7XG4gIGZvciAoY29uc3Qgb3BlcmF0b3JzIG9mIFtDb3VjaERCT3BlcmF0b3IsIENvdWNoREJHcm91cE9wZXJhdG9yXSkge1xuICAgIGNvbnN0IGVsID0gT2JqZWN0LmtleXMob3BlcmF0b3JzKS5maW5kKChrKSA9PiBrID09PSBvcGVyYXRvcik7XG4gICAgaWYgKGVsKSByZXR1cm4gb3BlcmF0b3JzW2VsXTtcbiAgfVxuICB0aHJvdyBuZXcgUXVlcnlFcnJvcihcbiAgICBgQ291bGQgbm90IGZpbmQgYWRhcHRlciB0cmFuc2xhdGlvbiBmb3Igb3BlcmF0b3IgJHtvcGVyYXRvcn1gXG4gICk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/query/translate.d.ts

@@ -1,3 +1,34 @@
 import { GroupOperator, Operator } from "@decaf-ts/core";
 import { MangoOperator } from "../types";
+/**
+ * @description Translates core operators to CouchDB Mango operators
+ * @summary Converts Decaf.ts core operators to their equivalent CouchDB Mango query operators
+ * @param {GroupOperator | Operator} operator - The core operator to translate
+ * @return {MangoOperator} The equivalent CouchDB Mango operator
+ * @throws {QueryError} If no translation exists for the given operator
+ * @function translateOperators
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant translateOperators
+ *   participant CouchDBOperator
+ *   participant CouchDBGroupOperator
+ *
+ *   Caller->>translateOperators: operator
+ *
+ *   translateOperators->>CouchDBOperator: Check for match
+ *   alt Found in CouchDBOperator
+ *     CouchDBOperator-->>translateOperators: Return matching operator
+ *     translateOperators-->>Caller: Return MangoOperator
+ *   else Not found
+ *     translateOperators->>CouchDBGroupOperator: Check for match
+ *     alt Found in CouchDBGroupOperator
+ *       CouchDBGroupOperator-->>translateOperators: Return matching operator
+ *       translateOperators-->>Caller: Return MangoOperator
+ *     else Not found
+ *       translateOperators-->>Caller: Throw QueryError
+ *     end
+ *   end
+ */
 export declare function translateOperators(operator: GroupOperator | Operator): MangoOperator;