@decaf-ts/for-couchdb 0.3.1 → 0.3.3

package/lib/esm/indexes/generator.js

@@ -2,6 +2,16 @@ import { PersistenceKeys, Repository, } from "@decaf-ts/core";
 import { CouchDBKeys } from "../constants";
 import { DefaultSeparator } from "@decaf-ts/db-decorators";
 import { CouchDBOperator } from "../query/constants";
+/**
+ * @description Generates a name for a CouchDB index
+ * @summary Creates a standardized name for a CouchDB index by combining name parts, compositions, and direction
+ * @param {string[]} name - Array of name parts for the index
+ * @param {OrderDirection} [direction] - Optional sort direction for the index
+ * @param {string[]} [compositions] - Optional additional attributes to include in the index name
+ * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
+ * @return {string} The generated index name
+ * @memberOf module:for-couchdb
+ */
 function generateIndexName(name, direction, compositions, separator = DefaultSeparator) {
     return [
         ...name.map((n) => (n === CouchDBKeys.TABLE ? "table" : n)),
@@ -10,6 +20,53 @@ function generateIndexName(name, direction, compositions, separator = DefaultSep
         CouchDBKeys.INDEX,
     ].join(separator);
 }
+/**
+ * @description Generates CouchDB index configurations for models
+ * @summary Creates a set of CouchDB index configurations based on the metadata of the provided models
+ * @template M - The model type that extends Model
+ * @param models - Array of model constructors to generate indexes for
+ * @return {CreateIndexRequest[]} Array of CouchDB index configurations
+ * @function generateIndexes
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant generateIndexes
+ *   participant generateIndexName
+ *   participant Repository
+ *
+ *   Caller->>generateIndexes: models
+ *
+ *   Note over generateIndexes: Create base table index
+ *   generateIndexes->>generateIndexName: [CouchDBKeys.TABLE]
+ *   generateIndexName-->>generateIndexes: tableName
+ *   generateIndexes->>generateIndexes: Create table index config
+ *
+ *   loop For each model
+ *     generateIndexes->>Repository: Get indexes metadata
+ *     Repository-->>generateIndexes: index metadata
+ *
+ *     loop For each index in metadata
+ *       Note over generateIndexes: Extract index properties
+ *       generateIndexes->>Repository: Get table name
+ *       Repository-->>generateIndexes: tableName
+ *
+ *       Note over generateIndexes: Define nested generate function
+ *
+ *       generateIndexes->>generateIndexes: Call generate() for default order
+ *       Note over generateIndexes: Create index name and config
+ *
+ *       alt Has directions
+ *         loop For each direction
+ *           generateIndexes->>generateIndexes: Call generate(direction)
+ *           Note over generateIndexes: Create ordered index config
+ *         end
+ *       end
+ *     end
+ *   end
+ *
+ *   generateIndexes-->>Caller: Array of index configurations
+ */
 export function generateIndexes(models) {
     const tableName = generateIndexName([CouchDBKeys.TABLE]);
     const indexes = {};
@@ -68,4 +125,4 @@ export function generateIndexes(models) {
     });
     return Object.values(indexes);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../src/indexes/generator.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  IndexMetadata,\n  OrderDirection,\n  PersistenceKeys,\n  Repository,\n} from \"@decaf-ts/core\";\nimport { CouchDBKeys } from \"../constants\";\nimport { DefaultSeparator } from \"@decaf-ts/db-decorators\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBOperator } from \"../query/constants\";\nimport { CreateIndexRequest } from \"../types\";\n\n/**\n * @description Generates a name for a CouchDB index\n * @summary Creates a standardized name for a CouchDB index by combining name parts, compositions, and direction\n * @param {string[]} name - Array of name parts for the index\n * @param {OrderDirection} [direction] - Optional sort direction for the index\n * @param {string[]} [compositions] - Optional additional attributes to include in the index name\n * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name\n * @return {string} The generated index name\n * @memberOf module:for-couchdb\n */\nfunction generateIndexName(\n  name: string[],\n  direction?: OrderDirection,\n  compositions?: string[],\n  separator = DefaultSeparator\n) {\n  return [\n    ...name.map((n) => (n === CouchDBKeys.TABLE ? \"table\" : n)),\n    ...(compositions || []),\n    ...(direction ? [direction] : []),\n    CouchDBKeys.INDEX,\n  ].join(separator);\n}\n\n/**\n * @description Generates CouchDB index configurations for models\n * @summary Creates a set of CouchDB index configurations based on the metadata of the provided models\n * @template M - The model type that extends Model\n * @param models - Array of model constructors to generate indexes for\n * @return {CreateIndexRequest[]} Array of CouchDB index configurations\n * @function generateIndexes\n * @memberOf module:for-couchdb\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant generateIndexes\n *   participant generateIndexName\n *   participant Repository\n *\n *   Caller->>generateIndexes: models\n *\n *   Note over generateIndexes: Create base table index\n *   generateIndexes->>generateIndexName: [CouchDBKeys.TABLE]\n *   generateIndexName-->>generateIndexes: tableName\n *   generateIndexes->>generateIndexes: Create table index config\n *\n *   loop For each model\n *     generateIndexes->>Repository: Get indexes metadata\n *     Repository-->>generateIndexes: index metadata\n *\n *     loop For each index in metadata\n *       Note over generateIndexes: Extract index properties\n *       generateIndexes->>Repository: Get table name\n *       Repository-->>generateIndexes: tableName\n *\n *       Note over generateIndexes: Define nested generate function\n *\n *       generateIndexes->>generateIndexes: Call generate() for default order\n *       Note over generateIndexes: Create index name and config\n *\n *       alt Has directions\n *         loop For each direction\n *           generateIndexes->>generateIndexes: Call generate(direction)\n *           Note over generateIndexes: Create ordered index config\n *         end\n *       end\n *     end\n *   end\n *\n *   generateIndexes-->>Caller: Array of index configurations\n */\nexport function generateIndexes<M extends Model>(\n  models: Constructor<M>[]\n): CreateIndexRequest[] {\n  const tableName = generateIndexName([CouchDBKeys.TABLE]);\n  const indexes: Record<string, CreateIndexRequest> = {};\n  indexes[tableName] = {\n    index: {\n      fields: [CouchDBKeys.TABLE],\n    },\n    name: tableName,\n    ddoc: tableName,\n    type: \"json\",\n  };\n\n  models.forEach((m) => {\n    const ind: Record<string, IndexMetadata> = Repository.indexes(m);\n    Object.entries(ind).forEach(([key, value]) => {\n      const k = Object.keys(value)[0];\n      // eslint-disable-next-line prefer-const\n      let { directions, compositions } = (value as any)[k];\n      const tableName = Repository.table(m);\n      compositions = compositions || [];\n\n      function generate(sort?: OrderDirection) {\n        const name = [\n          tableName,\n          key,\n          ...(compositions as []),\n          PersistenceKeys.INDEX,\n        ].join(DefaultSeparator);\n\n        indexes[name] = {\n          index: {\n            fields: [key, ...(compositions as []), CouchDBKeys.TABLE].reduce(\n              (accum: any[], el) => {\n                if (sort) {\n                  const res: any = {};\n                  res[el] = sort;\n                  accum.push(res);\n                } else {\n                  accum.push(el);\n                }\n                return accum;\n              },\n              []\n            ),\n          },\n          name: name,\n          ddoc: name,\n          type: \"json\",\n        };\n        if (!sort) {\n          const tableFilter: Record<string, any> = {};\n          tableFilter[CouchDBKeys.TABLE] = {};\n          tableFilter[CouchDBKeys.TABLE][CouchDBOperator.EQUAL] = tableName;\n          indexes[name].index.partial_filter_selector = tableFilter;\n        }\n      }\n\n      generate();\n      if (directions)\n        (directions as unknown as OrderDirection[]).forEach((d) => generate(d));\n    });\n  });\n  return Object.values(indexes);\n}\n"]}

package/lib/esm/interfaces/CouchDBRepository.d.ts

@@ -3,4 +3,14 @@ import { CouchDBAdapter } from "../adapter";
 import { Model } from "@decaf-ts/decorator-validation";
 import { MangoQuery } from "../types";
 import { Context, RepositoryFlags } from "@decaf-ts/db-decorators";
+/**
+ * @description Repository type for CouchDB operations
+ * @summary Type definition for a repository that works with CouchDB through the CouchDBAdapter
+ * @template M - The model type that extends Model
+ * @template Y - The scope type
+ * @template F - The repository flags type
+ * @template C - The context type that extends Context<F>
+ * @typedef {Repository<M, MangoQuery, CouchDBAdapter<Y, F, C>>} CouchDBRepository
+ * @memberOf module:for-couchdb
+ */
 export type CouchDBRepository<M extends Model, Y, F extends RepositoryFlags, C extends Context<F>> = Repository<M, MangoQuery, CouchDBAdapter<Y, F, C>>;

package/lib/esm/interfaces/CouchDBRepository.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ291Y2hEQlJlcG9zaXRvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW50ZXJmYWNlcy9Db3VjaERCUmVwb3NpdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVwb3NpdG9yeSB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuaW1wb3J0IHsgQ291Y2hEQkFkYXB0ZXIgfSBmcm9tIFwiLi4vYWRhcHRlclwiO1xuaW1wb3J0IHsgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBNYW5nb1F1ZXJ5IH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5pbXBvcnQgeyBDb250ZXh0LCBSZXBvc2l0b3J5RmxhZ3MgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcblxuZXhwb3J0IHR5cGUgQ291Y2hEQlJlcG9zaXRvcnk8XG4gIE0gZXh0ZW5kcyBNb2RlbCxcbiAgWSxcbiAgRiBleHRlbmRzIFJlcG9zaXRvcnlGbGFncyxcbiAgQyBleHRlbmRzIENvbnRleHQ8Rj4sXG4+ID0gUmVwb3NpdG9yeTxNLCBNYW5nb1F1ZXJ5LCBDb3VjaERCQWRhcHRlcjxZLCBGLCBDPj47XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ291Y2hEQlJlcG9zaXRvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW50ZXJmYWNlcy9Db3VjaERCUmVwb3NpdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVwb3NpdG9yeSB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuaW1wb3J0IHsgQ291Y2hEQkFkYXB0ZXIgfSBmcm9tIFwiLi4vYWRhcHRlclwiO1xuaW1wb3J0IHsgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBNYW5nb1F1ZXJ5IH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5pbXBvcnQgeyBDb250ZXh0LCBSZXBvc2l0b3J5RmxhZ3MgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gUmVwb3NpdG9yeSB0eXBlIGZvciBDb3VjaERCIG9wZXJhdGlvbnNcbiAqIEBzdW1tYXJ5IFR5cGUgZGVmaW5pdGlvbiBmb3IgYSByZXBvc2l0b3J5IHRoYXQgd29ya3Mgd2l0aCBDb3VjaERCIHRocm91Z2ggdGhlIENvdWNoREJBZGFwdGVyXG4gKiBAdGVtcGxhdGUgTSAtIFRoZSBtb2RlbCB0eXBlIHRoYXQgZXh0ZW5kcyBNb2RlbFxuICogQHRlbXBsYXRlIFkgLSBUaGUgc2NvcGUgdHlwZVxuICogQHRlbXBsYXRlIEYgLSBUaGUgcmVwb3NpdG9yeSBmbGFncyB0eXBlXG4gKiBAdGVtcGxhdGUgQyAtIFRoZSBjb250ZXh0IHR5cGUgdGhhdCBleHRlbmRzIENvbnRleHQ8Rj5cbiAqIEB0eXBlZGVmIHtSZXBvc2l0b3J5PE0sIE1hbmdvUXVlcnksIENvdWNoREJBZGFwdGVyPFksIEYsIEM+Pn0gQ291Y2hEQlJlcG9zaXRvcnlcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Zm9yLWNvdWNoZGJcbiAqL1xuZXhwb3J0IHR5cGUgQ291Y2hEQlJlcG9zaXRvcnk8XG4gIE0gZXh0ZW5kcyBNb2RlbCxcbiAgWSxcbiAgRiBleHRlbmRzIFJlcG9zaXRvcnlGbGFncyxcbiAgQyBleHRlbmRzIENvbnRleHQ8Rj4sXG4+ID0gUmVwb3NpdG9yeTxNLCBNYW5nb1F1ZXJ5LCBDb3VjaERCQWRhcHRlcjxZLCBGLCBDPj47XG4iXX0=

package/lib/esm/model/CouchDBSequence.d.ts

@@ -1,7 +1,26 @@
 import type { ModelArg } from "@decaf-ts/decorator-validation";
 import { BaseModel } from "@decaf-ts/core";
+/**
+ * @description Model for CouchDB sequence records
+ * @summary Represents a sequence in CouchDB used for generating sequential IDs
+ * @param {ModelArg<Sequence>} [seq] - Optional initialization data for the sequence
+ * @class
+ * @example
+ * // Example of creating and using a Sequence
+ * const sequence = new Sequence({ id: 'user-seq', current: 1 });
+ * // Increment the sequence
+ * sequence.current = Number(sequence.current) + 1;
+ */
 export declare class Sequence extends BaseModel {
+    /**
+     * @description The unique identifier for the sequence
+     * @summary Primary key for the sequence record
+     */
     id: string;
+    /**
+     * @description The current value of the sequence
+     * @summary Current sequence value that can be incremented
+     */
     current: string | number;
     constructor(seq?: ModelArg<Sequence>);
 }

package/lib/esm/model/CouchDBSequence.js

@@ -10,6 +10,17 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { model, required } from "@decaf-ts/decorator-validation";
 import { BaseModel, pk, index, table } from "@decaf-ts/core";
 import { CouchDBKeys } from "../constants";
+/**
+ * @description Model for CouchDB sequence records
+ * @summary Represents a sequence in CouchDB used for generating sequential IDs
+ * @param {ModelArg<Sequence>} [seq] - Optional initialization data for the sequence
+ * @class
+ * @example
+ * // Example of creating and using a Sequence
+ * const sequence = new Sequence({ id: 'user-seq', current: 1 });
+ * // Increment the sequence
+ * sequence.current = Number(sequence.current) + 1;
+ */
 let Sequence = class Sequence extends BaseModel {
     constructor(seq) {
         super(seq);
@@ -30,4 +41,4 @@ Sequence = __decorate([
     __metadata("design:paramtypes", [Object])
 ], Sequence);
 export { Sequence };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ291Y2hEQlNlcXVlbmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21vZGVsL0NvdWNoREJTZXF1ZW5jZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFDQSxPQUFPLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ2pFLE9BQU8sRUFBRSxTQUFTLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBSXBDLElBQU0sUUFBUSxHQUFkLE1BQU0sUUFBUyxTQUFRLFNBQVM7SUFPckMsWUFBWSxHQUF3QjtRQUNsQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDYixDQUFDO0NBQ0YsQ0FBQTtBQVJDO0lBREMsRUFBRSxFQUFFOztvQ0FDTztBQUdaO0lBRkMsUUFBUSxFQUFFO0lBQ1YsS0FBSyxFQUFFOzt5Q0FDa0I7QUFMZixRQUFRO0lBRnBCLEtBQUssQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDO0lBQzNCLEtBQUssRUFBRTs7R0FDSyxRQUFRLENBVXBCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBNb2RlbEFyZyB9IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IG1vZGVsLCByZXF1aXJlZCB9IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IEJhc2VNb2RlbCwgcGssIGluZGV4LCB0YWJsZSB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuaW1wb3J0IHsgQ291Y2hEQktleXMgfSBmcm9tIFwiLi4vY29uc3RhbnRzXCI7XG5cbkB0YWJsZShDb3VjaERCS2V5cy5TRVFVRU5DRSlcbkBtb2RlbCgpXG5leHBvcnQgY2xhc3MgU2VxdWVuY2UgZXh0ZW5kcyBCYXNlTW9kZWwge1xuICBAcGsoKVxuICBpZCE6IHN0cmluZztcbiAgQHJlcXVpcmVkKClcbiAgQGluZGV4KClcbiAgY3VycmVudCE6IHN0cmluZyB8IG51bWJlcjtcblxuICBjb25zdHJ1Y3RvcihzZXE/OiBNb2RlbEFyZzxTZXF1ZW5jZT4pIHtcbiAgICBzdXBlcihzZXEpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -2,11 +2,122 @@ import { Paginator } from "@decaf-ts/core";
 import { MangoQuery } from "../types";
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { CouchDBAdapter } from "../adapter";
+/**
+ * @description Paginator for CouchDB query results
+ * @summary Implements pagination for CouchDB queries using bookmarks for efficient navigation through result sets
+ * @template M - The model type that extends Model
+ * @template R - The result type
+ * @param {CouchDBAdapter<any, any, any>} adapter - The CouchDB adapter
+ * @param {MangoQuery} query - The Mango query to paginate
+ * @param {number} size - The page size
+ * @param {Constructor<M>} clazz - The model constructor
+ * @class CouchDBPaginator
+ * @example
+ * // Example of using CouchDBPaginator
+ * const adapter = new MyCouchDBAdapter(scope);
+ * const query = { selector: { type: "user" } };
+ * const paginator = new CouchDBPaginator(adapter, query, 10, User);
+ *
+ * // Get the first page
+ * const page1 = await paginator.page(1);
+ *
+ * // Get the next page
+ * const page2 = await paginator.page(2);
+ */
 export declare class CouchDBPaginator<M extends Model, R> extends Paginator<M, R, MangoQuery> {
+    /**
+     * @description Bookmark for CouchDB pagination
+     * @summary Stores the bookmark returned by CouchDB for continuing pagination
+     */
     private bookMark?;
+    /**
+     * @description Gets the total number of pages
+     * @summary Not supported in CouchDB - throws an error when accessed
+     * @return {number} Never returns as it throws an error
+     * @throws {InternalError} Always throws as this functionality is not available in CouchDB
+     */
     get total(): number;
+    /**
+     * @description Gets the total record count
+     * @summary Not supported in CouchDB - throws an error when accessed
+     * @return {number} Never returns as it throws an error
+     * @throws {InternalError} Always throws as this functionality is not available in CouchDB
+     */
     get count(): number;
+    /**
+     * @description Creates a new CouchDBPaginator instance
+     * @summary Initializes a paginator for CouchDB query results
+     * @param {CouchDBAdapter<any, any, any>} adapter - The CouchDB adapter
+     * @param {MangoQuery} query - The Mango query to paginate
+     * @param {number} size - The page size
+     * @param {Constructor<M>} clazz - The model constructor
+     */
     constructor(adapter: CouchDBAdapter<any, any, any>, query: MangoQuery, size: number, clazz: Constructor<M>);
+    /**
+     * @description Prepares a query for pagination
+     * @summary Modifies the raw query to include pagination parameters
+     * @param {MangoQuery} rawStatement - The original Mango query
+     * @return {MangoQuery} The prepared query with pagination parameters
+     */
     protected prepare(rawStatement: MangoQuery): MangoQuery;
+    /**
+     * @description Retrieves a specific page of results
+     * @summary Executes the query with pagination and processes the results
+     * @param {number} [page=1] - The page number to retrieve
+     * @return {Promise<R[]>} A promise that resolves to an array of results
+     * @throws {PagingError} If trying to access a page other than the first without a bookmark, or if no class is defined
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant CouchDBPaginator
+     *   participant Adapter
+     *   participant CouchDB
+     *
+     *   Client->>CouchDBPaginator: page(pageNumber)
+     *   Note over CouchDBPaginator: Clone statement
+     *   CouchDBPaginator->>CouchDBPaginator: validatePage(page)
+     *
+     *   alt page !== 1
+     *     CouchDBPaginator->>CouchDBPaginator: Check bookmark
+     *     alt No bookmark
+     *       CouchDBPaginator-->>Client: Throw PagingError
+     *     else Has bookmark
+     *       CouchDBPaginator->>CouchDBPaginator: Add bookmark to statement
+     *     end
+     *   end
+     *
+     *   CouchDBPaginator->>Adapter: raw(statement, false)
+     *   Adapter->>CouchDB: Execute query
+     *   CouchDB-->>Adapter: Return results
+     *   Adapter-->>CouchDBPaginator: Return MangoResponse
+     *
+     *   Note over CouchDBPaginator: Process results
+     *
+     *   alt Has warning
+     *     CouchDBPaginator->>CouchDBPaginator: Log warning
+     *   end
+     *
+     *   CouchDBPaginator->>CouchDBPaginator: Check for clazz
+     *
+     *   alt No clazz
+     *     CouchDBPaginator-->>Client: Throw PagingError
+     *   else Has clazz
+     *     CouchDBPaginator->>CouchDBPaginator: Find primary key
+     *
+     *     alt Has fields in statement
+     *       CouchDBPaginator->>CouchDBPaginator: Use docs directly
+     *     else No fields
+     *       CouchDBPaginator->>CouchDBPaginator: Process each document
+     *       loop For each document
+     *         CouchDBPaginator->>CouchDBPaginator: Extract original ID
+     *         CouchDBPaginator->>Adapter: revert(doc, clazz, pkDef.id, parsedId)
+     *       end
+     *     end
+     *
+     *     CouchDBPaginator->>CouchDBPaginator: Store bookmark
+     *     CouchDBPaginator->>CouchDBPaginator: Update currentPage
+     *     CouchDBPaginator-->>Client: Return results
+     *   end
+     */
     page(page?: number): Promise<R[]>;
 }

package/lib/esm/query/Paginator.js

@@ -1,16 +1,64 @@
 import { Paginator, PagingError, Sequence } from "@decaf-ts/core";
 import { findPrimaryKey, InternalError } from "@decaf-ts/db-decorators";
 import { CouchDBKeys } from "../constants";
+/**
+ * @description Paginator for CouchDB query results
+ * @summary Implements pagination for CouchDB queries using bookmarks for efficient navigation through result sets
+ * @template M - The model type that extends Model
+ * @template R - The result type
+ * @param {CouchDBAdapter<any, any, any>} adapter - The CouchDB adapter
+ * @param {MangoQuery} query - The Mango query to paginate
+ * @param {number} size - The page size
+ * @param {Constructor<M>} clazz - The model constructor
+ * @class CouchDBPaginator
+ * @example
+ * // Example of using CouchDBPaginator
+ * const adapter = new MyCouchDBAdapter(scope);
+ * const query = { selector: { type: "user" } };
+ * const paginator = new CouchDBPaginator(adapter, query, 10, User);
+ *
+ * // Get the first page
+ * const page1 = await paginator.page(1);
+ *
+ * // Get the next page
+ * const page2 = await paginator.page(2);
+ */
 export class CouchDBPaginator extends Paginator {
+    /**
+     * @description Gets the total number of pages
+     * @summary Not supported in CouchDB - throws an error when accessed
+     * @return {number} Never returns as it throws an error
+     * @throws {InternalError} Always throws as this functionality is not available in CouchDB
+     */
     get total() {
         throw new InternalError(`The total pages api is not available for couchdb`);
     }
+    /**
+     * @description Gets the total record count
+     * @summary Not supported in CouchDB - throws an error when accessed
+     * @return {number} Never returns as it throws an error
+     * @throws {InternalError} Always throws as this functionality is not available in CouchDB
+     */
     get count() {
         throw new InternalError(`The record count api is not available for couchdb`);
     }
+    /**
+     * @description Creates a new CouchDBPaginator instance
+     * @summary Initializes a paginator for CouchDB query results
+     * @param {CouchDBAdapter<any, any, any>} adapter - The CouchDB adapter
+     * @param {MangoQuery} query - The Mango query to paginate
+     * @param {number} size - The page size
+     * @param {Constructor<M>} clazz - The model constructor
+     */
     constructor(adapter, query, size, clazz) {
         super(adapter, query, size, clazz);
     }
+    /**
+     * @description Prepares a query for pagination
+     * @summary Modifies the raw query to include pagination parameters
+     * @param {MangoQuery} rawStatement - The original Mango query
+     * @return {MangoQuery} The prepared query with pagination parameters
+     */
     prepare(rawStatement) {
         const query = Object.assign({}, rawStatement);
         if (query.limit)
@@ -18,15 +66,76 @@ export class CouchDBPaginator extends Paginator {
         query.limit = this.size;
         return query;
     }
+    /**
+     * @description Retrieves a specific page of results
+     * @summary Executes the query with pagination and processes the results
+     * @param {number} [page=1] - The page number to retrieve
+     * @return {Promise<R[]>} A promise that resolves to an array of results
+     * @throws {PagingError} If trying to access a page other than the first without a bookmark, or if no class is defined
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant CouchDBPaginator
+     *   participant Adapter
+     *   participant CouchDB
+     *
+     *   Client->>CouchDBPaginator: page(pageNumber)
+     *   Note over CouchDBPaginator: Clone statement
+     *   CouchDBPaginator->>CouchDBPaginator: validatePage(page)
+     *
+     *   alt page !== 1
+     *     CouchDBPaginator->>CouchDBPaginator: Check bookmark
+     *     alt No bookmark
+     *       CouchDBPaginator-->>Client: Throw PagingError
+     *     else Has bookmark
+     *       CouchDBPaginator->>CouchDBPaginator: Add bookmark to statement
+     *     end
+     *   end
+     *
+     *   CouchDBPaginator->>Adapter: raw(statement, false)
+     *   Adapter->>CouchDB: Execute query
+     *   CouchDB-->>Adapter: Return results
+     *   Adapter-->>CouchDBPaginator: Return MangoResponse
+     *
+     *   Note over CouchDBPaginator: Process results
+     *
+     *   alt Has warning
+     *     CouchDBPaginator->>CouchDBPaginator: Log warning
+     *   end
+     *
+     *   CouchDBPaginator->>CouchDBPaginator: Check for clazz
+     *
+     *   alt No clazz
+     *     CouchDBPaginator-->>Client: Throw PagingError
+     *   else Has clazz
+     *     CouchDBPaginator->>CouchDBPaginator: Find primary key
+     *
+     *     alt Has fields in statement
+     *       CouchDBPaginator->>CouchDBPaginator: Use docs directly
+     *     else No fields
+     *       CouchDBPaginator->>CouchDBPaginator: Process each document
+     *       loop For each document
+     *         CouchDBPaginator->>CouchDBPaginator: Extract original ID
+     *         CouchDBPaginator->>Adapter: revert(doc, clazz, pkDef.id, parsedId)
+     *       end
+     *     end
+     *
+     *     CouchDBPaginator->>CouchDBPaginator: Store bookmark
+     *     CouchDBPaginator->>CouchDBPaginator: Update currentPage
+     *     CouchDBPaginator-->>Client: Return results
+     *   end
+     */
     async page(page = 1) {
         const statement = Object.assign({}, this.statement);
-        // if (!this._recordCount || !this._totalPages) {
-        //   // this._recordCount = await this.adapter
-        //   //   .Query()
-        //   //   .count()
-        //   //   .from(target)
-        //   //   .execute<number>();
-        // }
+        if (!this._recordCount || !this._totalPages) {
+            this._totalPages = this._recordCount = 0;
+            const results = await this.adapter.raw({ ...statement, limit: undefined }) || [];
+            this._recordCount = results.length;
+            if (this._recordCount > 0) {
+                const size = statement?.limit || this.size;
+                this._totalPages = Math.ceil(this._recordCount / size);
+            }
+        }
         this.validatePage(page);
         if (page !== 1) {
             if (!this.bookMark)
@@ -53,4 +162,4 @@ export class CouchDBPaginator extends Paginator {
         return results;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Paginator.js","sourceRoot":"","sources":["../../../src/query/Paginator.ts"],"names":[],"mappings":"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","sourcesContent":["import { Paginator, PagingError, Sequence } from \"@decaf-ts/core\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\nimport { MangoQuery, MangoResponse } from \"../types\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBAdapter } from \"../adapter\";\nimport { CouchDBKeys } from \"../constants\";\n\n/**\n * @description Paginator for CouchDB query results\n * @summary Implements pagination for CouchDB queries using bookmarks for efficient navigation through result sets\n * @template M - The model type that extends Model\n * @template R - The result type\n * @param {CouchDBAdapter<any, any, any>} adapter - The CouchDB adapter\n * @param {MangoQuery} query - The Mango query to paginate\n * @param {number} size - The page size\n * @param {Constructor<M>} clazz - The model constructor\n * @class CouchDBPaginator\n * @example\n * // Example of using CouchDBPaginator\n * const adapter = new MyCouchDBAdapter(scope);\n * const query = { selector: { type: \"user\" } };\n * const paginator = new CouchDBPaginator(adapter, query, 10, User);\n *\n * // Get the first page\n * const page1 = await paginator.page(1);\n *\n * // Get the next page\n * const page2 = await paginator.page(2);\n */\nexport class CouchDBPaginator<M extends Model, R> extends Paginator<\n  M,\n  R,\n  MangoQuery\n> {\n  /**\n   * @description Bookmark for CouchDB pagination\n   * @summary Stores the bookmark returned by CouchDB for continuing pagination\n   */\n  private bookMark?: string;\n\n  /**\n   * @description Gets the total number of pages\n   * @summary Not supported in CouchDB - throws an error when accessed\n   * @return {number} Never returns as it throws an error\n   * @throws {InternalError} Always throws as this functionality is not available in CouchDB\n   */\n  override get total(): number {\n    throw new InternalError(`The total pages api is not available for couchdb`);\n  }\n\n  /**\n   * @description Gets the total record count\n   * @summary Not supported in CouchDB - throws an error when accessed\n   * @return {number} Never returns as it throws an error\n   * @throws {InternalError} Always throws as this functionality is not available in CouchDB\n   */\n  override get count(): number {\n    throw new InternalError(\n      `The record count api is not available for couchdb`\n    );\n  }\n\n  /**\n   * @description Creates a new CouchDBPaginator instance\n   * @summary Initializes a paginator for CouchDB query results\n   * @param {CouchDBAdapter<any, any, any>} adapter - The CouchDB adapter\n   * @param {MangoQuery} query - The Mango query to paginate\n   * @param {number} size - The page size\n   * @param {Constructor<M>} clazz - The model constructor\n   */\n  constructor(\n    adapter: CouchDBAdapter<any, any, any>,\n    query: MangoQuery,\n    size: number,\n    clazz: Constructor<M>\n  ) {\n    super(adapter, query, size, clazz);\n  }\n\n  /**\n   * @description Prepares a query for pagination\n   * @summary Modifies the raw query to include pagination parameters\n   * @param {MangoQuery} rawStatement - The original Mango query\n   * @return {MangoQuery} The prepared query with pagination parameters\n   */\n  protected prepare(rawStatement: MangoQuery): MangoQuery {\n    const query: MangoQuery = Object.assign({}, rawStatement);\n    if (query.limit) this.limit = query.limit;\n\n    query.limit = this.size;\n\n    return query;\n  }\n\n  /**\n   * @description Retrieves a specific page of results\n   * @summary Executes the query with pagination and processes the results\n   * @param {number} [page=1] - The page number to retrieve\n   * @return {Promise<R[]>} A promise that resolves to an array of results\n   * @throws {PagingError} If trying to access a page other than the first without a bookmark, or if no class is defined\n   * @mermaid\n   * sequenceDiagram\n   *   participant Client\n   *   participant CouchDBPaginator\n   *   participant Adapter\n   *   participant CouchDB\n   *\n   *   Client->>CouchDBPaginator: page(pageNumber)\n   *   Note over CouchDBPaginator: Clone statement\n   *   CouchDBPaginator->>CouchDBPaginator: validatePage(page)\n   *\n   *   alt page !== 1\n   *     CouchDBPaginator->>CouchDBPaginator: Check bookmark\n   *     alt No bookmark\n   *       CouchDBPaginator-->>Client: Throw PagingError\n   *     else Has bookmark\n   *       CouchDBPaginator->>CouchDBPaginator: Add bookmark to statement\n   *     end\n   *   end\n   *\n   *   CouchDBPaginator->>Adapter: raw(statement, false)\n   *   Adapter->>CouchDB: Execute query\n   *   CouchDB-->>Adapter: Return results\n   *   Adapter-->>CouchDBPaginator: Return MangoResponse\n   *\n   *   Note over CouchDBPaginator: Process results\n   *\n   *   alt Has warning\n   *     CouchDBPaginator->>CouchDBPaginator: Log warning\n   *   end\n   *\n   *   CouchDBPaginator->>CouchDBPaginator: Check for clazz\n   *\n   *   alt No clazz\n   *     CouchDBPaginator-->>Client: Throw PagingError\n   *   else Has clazz\n   *     CouchDBPaginator->>CouchDBPaginator: Find primary key\n   *\n   *     alt Has fields in statement\n   *       CouchDBPaginator->>CouchDBPaginator: Use docs directly\n   *     else No fields\n   *       CouchDBPaginator->>CouchDBPaginator: Process each document\n   *       loop For each document\n   *         CouchDBPaginator->>CouchDBPaginator: Extract original ID\n   *         CouchDBPaginator->>Adapter: revert(doc, clazz, pkDef.id, parsedId)\n   *       end\n   *     end\n   *\n   *     CouchDBPaginator->>CouchDBPaginator: Store bookmark\n   *     CouchDBPaginator->>CouchDBPaginator: Update currentPage\n   *     CouchDBPaginator-->>Client: Return results\n   *   end\n   */\n  async page(page: number = 1): Promise<R[]> {\n    const statement = Object.assign({}, this.statement);\n\n   if (!this._recordCount || !this._totalPages) {\n        this._totalPages = this._recordCount = 0;\n        const results: R[] = await this.adapter.raw({ ...statement, limit: undefined }) || [];\n        this._recordCount = results.length;\n        if (this._recordCount > 0) {\n            const size = statement?.limit || this.size;\n            this._totalPages = Math.ceil(this._recordCount / size);\n        }\n    }\n\n    this.validatePage(page);\n\n    if (page !== 1) {\n      if (!this.bookMark)\n        throw new PagingError(\"No bookmark. Did you start in the first page?\");\n      statement[\"bookmark\"] = this.bookMark;\n    }\n    const rawResult: MangoResponse<any> = await this.adapter.raw(\n      statement,\n      false\n    );\n\n    const { docs, bookmark, warning } = rawResult;\n    if (warning) console.warn(warning);\n    if (!this.clazz) throw new PagingError(\"No statement target defined\");\n    const pkDef = findPrimaryKey(new this.clazz());\n    const results =\n      statement.fields && statement.fields.length\n        ? docs // has fields means its not full model\n        : docs.map((d: any) => {\n            //no fields means we need to revert to saving process\n            const originalId = d._id.split(CouchDBKeys.SEPARATOR);\n            originalId.splice(0, 1); // remove the table name\n            return this.adapter.revert(\n              d,\n              this.clazz,\n              pkDef.id,\n              Sequence.parseValue(\n                pkDef.props.type,\n                originalId.join(CouchDBKeys.SEPARATOR)\n              )\n            );\n          });\n    this.bookMark = bookmark;\n    this._currentPage = page;\n    return results;\n  }\n}\n"]}