@decaf-ts/for-couchdb 0.3.1 → 0.3.2

package/lib/indexes/generator.cjs

@@ -5,6 +5,16 @@ const core_1 = require("@decaf-ts/core");
 const constants_1 = require("./../constants.cjs");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
 const constants_2 = require("./../query/constants.cjs");
+/**
+ * @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 = db_decorators_1.DefaultSeparator) {
     return [
         ...name.map((n) => (n === constants_1.CouchDBKeys.TABLE ? "table" : n)),
@@ -13,6 +23,53 @@ function generateIndexName(name, direction, compositions, separator = db_decorat
         constants_1.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
+ */
 function generateIndexes(models) {
     const tableName = generateIndexName([constants_1.CouchDBKeys.TABLE]);
     const indexes = {};
@@ -71,4 +128,4 @@ 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/indexes/generator.d.ts

@@ -1,3 +1,50 @@
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { CreateIndexRequest } from "../types";
+/**
+ * @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 declare function generateIndexes<M extends Model>(models: Constructor<M>[]): CreateIndexRequest[];

package/lib/interfaces/CouchDBRepository.cjs

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ291Y2hEQlJlcG9zaXRvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50ZXJmYWNlcy9Db3VjaERCUmVwb3NpdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVwb3NpdG9yeSB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuaW1wb3J0IHsgQ291Y2hEQkFkYXB0ZXIgfSBmcm9tIFwiLi4vYWRhcHRlclwiO1xuaW1wb3J0IHsgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBNYW5nb1F1ZXJ5IH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5pbXBvcnQgeyBDb250ZXh0LCBSZXBvc2l0b3J5RmxhZ3MgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcblxuZXhwb3J0IHR5cGUgQ291Y2hEQlJlcG9zaXRvcnk8XG4gIE0gZXh0ZW5kcyBNb2RlbCxcbiAgWSxcbiAgRiBleHRlbmRzIFJlcG9zaXRvcnlGbGFncyxcbiAgQyBleHRlbmRzIENvbnRleHQ8Rj4sXG4+ID0gUmVwb3NpdG9yeTxNLCBNYW5nb1F1ZXJ5LCBDb3VjaERCQWRhcHRlcjxZLCBGLCBDPj47XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ291Y2hEQlJlcG9zaXRvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50ZXJmYWNlcy9Db3VjaERCUmVwb3NpdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVwb3NpdG9yeSB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuaW1wb3J0IHsgQ291Y2hEQkFkYXB0ZXIgfSBmcm9tIFwiLi4vYWRhcHRlclwiO1xuaW1wb3J0IHsgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBNYW5nb1F1ZXJ5IH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5pbXBvcnQgeyBDb250ZXh0LCBSZXBvc2l0b3J5RmxhZ3MgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gUmVwb3NpdG9yeSB0eXBlIGZvciBDb3VjaERCIG9wZXJhdGlvbnNcbiAqIEBzdW1tYXJ5IFR5cGUgZGVmaW5pdGlvbiBmb3IgYSByZXBvc2l0b3J5IHRoYXQgd29ya3Mgd2l0aCBDb3VjaERCIHRocm91Z2ggdGhlIENvdWNoREJBZGFwdGVyXG4gKiBAdGVtcGxhdGUgTSAtIFRoZSBtb2RlbCB0eXBlIHRoYXQgZXh0ZW5kcyBNb2RlbFxuICogQHRlbXBsYXRlIFkgLSBUaGUgc2NvcGUgdHlwZVxuICogQHRlbXBsYXRlIEYgLSBUaGUgcmVwb3NpdG9yeSBmbGFncyB0eXBlXG4gKiBAdGVtcGxhdGUgQyAtIFRoZSBjb250ZXh0IHR5cGUgdGhhdCBleHRlbmRzIENvbnRleHQ8Rj5cbiAqIEB0eXBlZGVmIHtSZXBvc2l0b3J5PE0sIE1hbmdvUXVlcnksIENvdWNoREJBZGFwdGVyPFksIEYsIEM+Pn0gQ291Y2hEQlJlcG9zaXRvcnlcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Zm9yLWNvdWNoZGJcbiAqL1xuZXhwb3J0IHR5cGUgQ291Y2hEQlJlcG9zaXRvcnk8XG4gIE0gZXh0ZW5kcyBNb2RlbCxcbiAgWSxcbiAgRiBleHRlbmRzIFJlcG9zaXRvcnlGbGFncyxcbiAgQyBleHRlbmRzIENvbnRleHQ8Rj4sXG4+ID0gUmVwb3NpdG9yeTxNLCBNYW5nb1F1ZXJ5LCBDb3VjaERCQWRhcHRlcjxZLCBGLCBDPj47XG4iXX0=

package/lib/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/model/CouchDBSequence.cjs

@@ -13,6 +13,17 @@ exports.Sequence = void 0;
 const decorator_validation_1 = require("@decaf-ts/decorator-validation");
 const core_1 = require("@decaf-ts/core");
 const constants_1 = require("./../constants.cjs");
+/**
+ * @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 core_1.BaseModel {
     constructor(seq) {
         super(seq);
@@ -33,4 +44,4 @@ exports.Sequence = Sequence = __decorate([
     (0, decorator_validation_1.model)(),
     __metadata("design:paramtypes", [Object])
 ], Sequence);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ291Y2hEQlNlcXVlbmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21vZGVsL0NvdWNoREJTZXF1ZW5jZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFDQSx5RUFBaUU7QUFDakUseUNBQTZEO0FBQzdELGtEQUEyQztBQUlwQyxJQUFNLFFBQVEsR0FBZCxNQUFNLFFBQVMsU0FBUSxnQkFBUztJQU9yQyxZQUFZLEdBQXdCO1FBQ2xDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNiLENBQUM7Q0FDRixDQUFBO0FBVlksNEJBQVE7QUFFbkI7SUFEQyxJQUFBLFNBQUUsR0FBRTs7b0NBQ087QUFHWjtJQUZDLElBQUEsK0JBQVEsR0FBRTtJQUNWLElBQUEsWUFBSyxHQUFFOzt5Q0FDa0I7bUJBTGYsUUFBUTtJQUZwQixJQUFBLFlBQUssRUFBQyx1QkFBVyxDQUFDLFFBQVEsQ0FBQztJQUMzQixJQUFBLDRCQUFLLEdBQUU7O0dBQ0ssUUFBUSxDQVVwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTW9kZWxBcmcgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBtb2RlbCwgcmVxdWlyZWQgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBCYXNlTW9kZWwsIHBrLCBpbmRleCwgdGFibGUgfSBmcm9tIFwiQGRlY2FmLXRzL2NvcmVcIjtcbmltcG9ydCB7IENvdWNoREJLZXlzIH0gZnJvbSBcIi4uL2NvbnN0YW50c1wiO1xuXG5AdGFibGUoQ291Y2hEQktleXMuU0VRVUVOQ0UpXG5AbW9kZWwoKVxuZXhwb3J0IGNsYXNzIFNlcXVlbmNlIGV4dGVuZHMgQmFzZU1vZGVsIHtcbiAgQHBrKClcbiAgaWQhOiBzdHJpbmc7XG4gIEByZXF1aXJlZCgpXG4gIEBpbmRleCgpXG4gIGN1cnJlbnQhOiBzdHJpbmcgfCBudW1iZXI7XG5cbiAgY29uc3RydWN0b3Ioc2VxPzogTW9kZWxBcmc8U2VxdWVuY2U+KSB7XG4gICAgc3VwZXIoc2VxKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/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/query/Paginator.cjs

@@ -4,16 +4,64 @@ exports.CouchDBPaginator = void 0;
 const core_1 = require("@decaf-ts/core");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
 const constants_1 = require("./../constants.cjs");
+/**
+ * @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);
+ */
 class CouchDBPaginator extends core_1.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 db_decorators_1.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 db_decorators_1.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)
@@ -21,15 +69,76 @@ class CouchDBPaginator extends core_1.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)
@@ -57,4 +166,4 @@ class CouchDBPaginator extends core_1.Paginator {
     }
 }
 exports.CouchDBPaginator = CouchDBPaginator;
-//# 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":";;;AAAA,yCAAkE;AAClE,2DAAwE;AAIxE,kDAA2C;AAE3C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,gBAAqC,SAAQ,gBAIzD;IAOC;;;;;OAKG;IACH,IAAa,KAAK;QAChB,MAAM,IAAI,6BAAa,CAAC,kDAAkD,CAAC,CAAC;IAC9E,CAAC;IAED;;;;;OAKG;IACH,IAAa,KAAK;QAChB,MAAM,IAAI,6BAAa,CACrB,mDAAmD,CACpD,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,YACE,OAAsC,EACtC,KAAiB,EACjB,IAAY,EACZ,KAAqB;QAErB,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC;IAED;;;;;OAKG;IACO,OAAO,CAAC,YAAwB;QACxC,MAAM,KAAK,GAAe,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;QAC1D,IAAI,KAAK,CAAC,KAAK;YAAE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QAE1C,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;QAExB,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0DG;IACH,KAAK,CAAC,IAAI,CAAC,OAAe,CAAC;QACzB,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAErD,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACzC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;YACzC,MAAM,OAAO,GAAQ,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC;YACtF,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;YACnC,IAAI,IAAI,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC;gBACxB,MAAM,IAAI,GAAG,SAAS,EAAE,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC;gBAC3C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;YAC3D,CAAC;QACL,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAExB,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,CAAC,QAAQ;gBAChB,MAAM,IAAI,kBAAW,CAAC,+CAA+C,CAAC,CAAC;YACzE,SAAS,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC;QACxC,CAAC;QACD,MAAM,SAAS,GAAuB,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAC1D,SAAS,EACT,KAAK,CACN,CAAC;QAEF,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC;QAC9C,IAAI,OAAO;YAAE,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACnC,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,kBAAW,CAAC,6BAA6B,CAAC,CAAC;QACtE,MAAM,KAAK,GAAG,IAAA,8BAAc,EAAC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QAC/C,MAAM,OAAO,GACX,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,MAAM,CAAC,MAAM;YACzC,CAAC,CAAC,IAAI,CAAC,sCAAsC;YAC7C,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE;gBAClB,qDAAqD;gBACrD,MAAM,UAAU,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,uBAAW,CAAC,SAAS,CAAC,CAAC;gBACtD,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,wBAAwB;gBACjD,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CACxB,CAAC,EACD,IAAI,CAAC,KAAK,EACV,KAAK,CAAC,EAAE,EACR,eAAQ,CAAC,UAAU,CACjB,KAAK,CAAC,KAAK,CAAC,IAAI,EAChB,UAAU,CAAC,IAAI,CAAC,uBAAW,CAAC,SAAS,CAAC,CACvC,CACF,CAAC;YACJ,CAAC,CAAC,CAAC;QACT,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AA9KD,4CA8KC","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"]}

package/lib/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[]>;
 }