@decaf-ts/for-couchdb 0.3.1 → 0.3.2

package/lib/esm/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/esm/query/Statement.js

@@ -4,10 +4,86 @@ import { CouchDBKeys } from "../constants";
 import { CouchDBGroupOperator, CouchDBOperator, CouchDBQueryLimit, } from "./constants";
 import { CouchDBPaginator } from "./Paginator";
 import { findPrimaryKey, InternalError } from "@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();
+ */
 export class CouchDBStatement extends 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[CouchDBKeys.TABLE] = {};
@@ -85,6 +161,14 @@ export class CouchDBStatement extends 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();
@@ -94,6 +178,14 @@ export class CouchDBStatement extends Statement {
             throw new 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[CouchDBKeys.ID]) {
             const [, ...keyArgs] = r[CouchDBKeys.ID].split(CouchDBKeys.SEPARATOR);
@@ -102,6 +194,13 @@ export class CouchDBStatement extends 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 = findPrimaryKey(new this.fromSelector());
@@ -111,7 +210,50 @@ export class CouchDBStatement extends 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];
@@ -137,4 +279,4 @@ export class CouchDBStatement extends Statement {
         return { selector: op };
     }
 }
-//# 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/esm/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/esm/query/constants.js

@@ -1,4 +1,27 @@
+/**
+ * @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 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 const CouchDBOperator = {
     EQUAL: "$eq",
     DIFFERENT: "$ne",
@@ -12,11 +35,30 @@ export const 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
+ */
 export const 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
+ */
 export const CouchDBConst = {
     NULL: "null",
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3F1ZXJ5L2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxHQUFHLENBQUM7QUFFckMsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFrQztJQUM1RCxLQUFLLEVBQUUsS0FBSztJQUNaLFNBQVMsRUFBRSxLQUFLO0lBQ2hCLE1BQU0sRUFBRSxLQUFLO0lBQ2IsU0FBUyxFQUFFLE1BQU07SUFDakIsT0FBTyxFQUFFLEtBQUs7SUFDZCxVQUFVLEVBQUUsTUFBTTtJQUNsQix1QkFBdUI7SUFDdkIsR0FBRyxFQUFFLE1BQU07SUFDWCxFQUFFLEVBQUUsS0FBSztJQUNULGFBQWE7SUFDYixNQUFNLEVBQUUsUUFBUTtDQUNqQixDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQWtDO0lBQ2pFLEdBQUcsRUFBRSxNQUFNO0lBQ1gsRUFBRSxFQUFFLEtBQUs7Q0FDVixDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUEyQjtJQUNsRCxJQUFJLEVBQUUsTUFBTTtDQUNiLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNYW5nb09wZXJhdG9yIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5cbmV4cG9ydCBjb25zdCBDb3VjaERCUXVlcnlMaW1pdCA9IDI1MDtcblxuZXhwb3J0IGNvbnN0IENvdWNoREJPcGVyYXRvcjogUmVjb3JkPHN0cmluZywgTWFuZ29PcGVyYXRvcj4gPSB7XG4gIEVRVUFMOiBcIiRlcVwiLFxuICBESUZGRVJFTlQ6IFwiJG5lXCIsXG4gIEJJR0dFUjogXCIkZ3RcIixcbiAgQklHR0VSX0VROiBcIiRndGVcIixcbiAgU01BTExFUjogXCIkbHRcIixcbiAgU01BTExFUl9FUTogXCIkbHRlXCIsXG4gIC8vIEJFVFdFRU4gPSBcIkJFVFdFRU5cIixcbiAgTk9UOiBcIiRub3RcIixcbiAgSU46IFwiJGluXCIsXG4gIC8vIElTID0gXCJJU1wiLFxuICBSRUdFWFA6IFwiJHJlZ2V4XCIsXG59O1xuXG5leHBvcnQgY29uc3QgQ291Y2hEQkdyb3VwT3BlcmF0b3I6IFJlY29yZDxzdHJpbmcsIE1hbmdvT3BlcmF0b3I+ID0ge1xuICBBTkQ6IFwiJGFuZFwiLFxuICBPUjogXCIkb3JcIixcbn07XG5cbmV4cG9ydCBjb25zdCBDb3VjaERCQ29uc3Q6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gPSB7XG4gIE5VTEw6IFwibnVsbFwiLFxufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/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;

package/lib/esm/query/translate.js

@@ -1,5 +1,36 @@
 import { CouchDBGroupOperator, CouchDBOperator } from "./constants";
 import { QueryError } from "@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
+ */
 export function translateOperators(operator) {
     for (const operators of [CouchDBOperator, CouchDBGroupOperator]) {
         const el = Object.keys(operators).find((k) => k === operator);
@@ -8,4 +39,4 @@ export function translateOperators(operator) {
     }
     throw new QueryError(`Could not find adapter translation for operator ${operator}`);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3F1ZXJ5L3RyYW5zbGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsZUFBZSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3BFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUc1QyxNQUFNLFVBQVUsa0JBQWtCLENBQ2hDLFFBQWtDO0lBRWxDLEtBQUssTUFBTSxTQUFTLElBQUksQ0FBQyxlQUFlLEVBQUUsb0JBQW9CLENBQUMsRUFBRSxDQUFDO1FBQ2hFLE1BQU0sRUFBRSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEtBQUssUUFBUSxDQUFDLENBQUM7UUFDOUQsSUFBSSxFQUFFO1lBQUUsT0FBTyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUNELE1BQU0sSUFBSSxVQUFVLENBQ2xCLG1EQUFtRCxRQUFRLEVBQUUsQ0FDOUQsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBHcm91cE9wZXJhdG9yLCBPcGVyYXRvciB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuaW1wb3J0IHsgQ291Y2hEQkdyb3VwT3BlcmF0b3IsIENvdWNoREJPcGVyYXRvciB9IGZyb20gXCIuL2NvbnN0YW50c1wiO1xuaW1wb3J0IHsgUXVlcnlFcnJvciB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuaW1wb3J0IHsgTWFuZ29PcGVyYXRvciB9IGZyb20gXCIuLi90eXBlc1wiO1xuXG5leHBvcnQgZnVuY3Rpb24gdHJhbnNsYXRlT3BlcmF0b3JzKFxuICBvcGVyYXRvcjogR3JvdXBPcGVyYXRvciB8IE9wZXJhdG9yXG4pOiBNYW5nb09wZXJhdG9yIHtcbiAgZm9yIChjb25zdCBvcGVyYXRvcnMgb2YgW0NvdWNoREJPcGVyYXRvciwgQ291Y2hEQkdyb3VwT3BlcmF0b3JdKSB7XG4gICAgY29uc3QgZWwgPSBPYmplY3Qua2V5cyhvcGVyYXRvcnMpLmZpbmQoKGspID0+IGsgPT09IG9wZXJhdG9yKTtcbiAgICBpZiAoZWwpIHJldHVybiBvcGVyYXRvcnNbZWxdO1xuICB9XG4gIHRocm93IG5ldyBRdWVyeUVycm9yKFxuICAgIGBDb3VsZCBub3QgZmluZCBhZGFwdGVyIHRyYW5zbGF0aW9uIGZvciBvcGVyYXRvciAke29wZXJhdG9yfWBcbiAgKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/sequences/Sequence.d.ts

@@ -11,8 +11,6 @@ import { CouchDBRepository } from "../interfaces";
  *
  * @class CouchDBSequence
  * @implements Sequence
- *
- * @category Sequences
  */
 export declare class CouchDBSequence extends Sequence {
     protected repo: CouchDBRepository<Seq, any, any, any>;