@decaf-ts/for-couchdb 0.12.0 → 0.13.0

package/lib/types/adapter.d.ts

@@ -1,296 +0,0 @@
-import { Adapter, AdapterFlags, Paginator, RawResult, ContextualArgs, PreparedModel } from "@decaf-ts/core";
-import { BaseError, type PrimaryKeyType } from "@decaf-ts/db-decorators";
-import { Model } from "@decaf-ts/decorator-validation";
-import { type MangoQuery, ViewResponse } from "./types";
-import { CouchDBStatement } from "./query";
-import { Context } from "@decaf-ts/core";
-import { type Constructor } from "@decaf-ts/decoration";
-import { Repository } from "@decaf-ts/core";
-/**
- * @description Abstract adapter for CouchDB database operations
- * @summary Provides a base implementation for CouchDB database operations, including CRUD operations, sequence management, and error handling
- * @template Y - The scope type
- * @template F - The repository flags type
- * @template C - The context type
- * @param {Y} scope - The scope for the adapter
- * @param {string} flavour - The flavour of the adapter
- * @param {string} [alias] - Optional alias for the adapter
- * @class
- * @example
- * // Example of extending CouchDBAdapter
- * class MyCouchDBAdapter extends CouchDBAdapter<MyScope, MyFlags, MyContext> {
- *   constructor(scope: MyScope) {
- *     super(scope, 'my-couchdb', 'my-alias');
- *   }
- *
- *   // Implement abstract methods
- *   async index<M extends Model>(...models: Constructor<M>[]): Promise<void> {
- *     // Implementation
- *   }
- *
- *   async raw<R>(rawInput: MangoQuery, docsOnly: boolean): Promise<R> {
- *     // Implementation
- *   }
- *
- *   async create(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>> {
- *     // Implementation
- *   }
- *
- *   async read(tableName: string, id: string | number, ...args: any[]): Promise<Record<string, any>> {
- *     // Implementation
- *   }
- *
- *   async update(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>> {
- *     // Implementation
- *   }
- *
- *   async delete(tableName: string, id: string | number, ...args: any[]): Promise<Record<string, any>> {
- *     // Implementation
- *   }
- * }
- */
-export declare abstract class CouchDBAdapter<CONF, CONN, C extends Context<any>> extends Adapter<CONF, CONN, MangoQuery, C> {
-    protected constructor(scope: CONF, flavour: string, alias?: string);
-    /**
-     * @description Creates a new CouchDB statement for querying
-     * @summary Factory method that creates a new CouchDBStatement instance for building queries
-     * @template M - The model type
-     * @return {CouchDBStatement<M, any>} A new CouchDBStatement instance
-     */
-    Statement<M extends Model>(overrides?: Partial<AdapterFlags>): CouchDBStatement<M, Adapter<CONF, CONN, MangoQuery, C>, any>;
-    Paginator<M extends Model>(query: MangoQuery, size: number, clazz: Constructor<M>): Paginator<M, any, MangoQuery>;
-    /**
-     * @description Initializes the adapter by creating indexes for all managed models
-     * @summary Sets up the necessary database indexes for all models managed by this adapter
-     * @return {Promise<void>} A promise that resolves when initialization is complete
-     */
-    initialize(): Promise<void>;
-    repository<R extends Repository<any, Adapter<CONF, CONN, MangoQuery, C>>>(): Constructor<R>;
-    /**
-     * @description Creates indexes for the given models
-     * @summary Abstract method that must be implemented to create database indexes for the specified models
-     * @template M - The model type
-     * @param {...Constructor<M>} models - The model constructors to create indexes for
-     * @return {Promise<void>} A promise that resolves when all indexes are created
-     */
-    protected abstract index<M extends Model>(...models: Constructor<M>[]): Promise<void>;
-    /**
-     * @description Executes a raw Mango query against the database
-     * @summary Abstract method that must be implemented to execute raw Mango queries. Implementations may treat the first
-     * additional argument as a boolean `docsOnly` flag before the contextual arguments provided by repositories.
-     * @template R - The result type
-     * @param {MangoQuery} rawInput - The raw Mango query to execute
-     * @param {...MaybeContextualArg<C>} args - Optional `docsOnly` flag followed by contextual arguments
-     * @return {Promise<R>} A promise that resolves to the query result
-     */
-    abstract raw<R, D extends boolean>(rawInput: MangoQuery, docsOnly: D, ...args: ContextualArgs<C>): Promise<RawResult<R, D>>;
-    /**
-     * @description Executes a CouchDB view query
-     * @summary Invokes a design document view and returns its response
-     * @template R - The view response type
-     * @param {string} ddoc - Design document name
-     * @param {string} view - View name
-     * @param {Record<string, any>} options - Mango query options
-     * @param {...ContextualArgs<C>} args - Optional contextual arguments
-     * @return {Promise<ViewResponse<R>>} The view response
-     */
-    abstract view<R>(ddoc: string, view: string, options: Record<string, any>, ...args: ContextualArgs<C>): Promise<ViewResponse<R>>;
-    /**
-     * @description Assigns metadata to a model
-     * @summary Adds revision metadata to a model as a non-enumerable property
-     * @param {Record<string, any>} model - The model to assign metadata to
-     * @param {string} rev - The revision string to assign
-     * @return {Record<string, any>} The model with metadata assigned
-     */
-    protected assignMetadata(model: Record<string, any>, rev: string): Record<string, any>;
-    /**
-     * @description Assigns metadata to multiple models
-     * @summary Adds revision metadata to multiple models as non-enumerable properties
-     * @param models - The models to assign metadata to
-     * @param {string[]} revs - The revision strings to assign
-     * @return The models with metadata assigned
-     */
-    protected assignMultipleMetadata(models: Record<string, any>[], revs: string[]): Record<string, any>[];
-    prepare<M extends Model>(model: M, ...args: ContextualArgs<C>): PreparedModel;
-    /**
-     * @description Prepares a record for creation
-     * @summary Adds necessary CouchDB fields to a record before creation
-     * @param {string} tableName - The name of the table
-     * @param {string|number} id - The ID of the record
-     * @param {Record<string, any>} model - The model to prepare
-     * @return A tuple containing the tableName, id, and prepared record
-     */
-    protected createPrefix<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<C>): [Constructor<M>, PrimaryKeyType, Record<string, any>, ...any[], Context];
-    /**
-     * @description Creates a new record in the database
-     * @summary Abstract method that must be implemented to create a new record
-     * @param {string} tableName - The name of the table
-     * @param {string|number} id - The ID of the record
-     * @param {Record<string, any>} model - The model to create
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<Record<string, any>>} A promise that resolves to the created record
-     */
-    abstract create<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
-    /**
-     * @description Prepares multiple records for creation
-     * @summary Adds necessary CouchDB fields to multiple records before creation
-     * @param {string} tableName - The name of the table
-     * @param {string[]|number[]} ids - The IDs of the records
-     * @param models - The models to prepare
-     * @return A tuple containing the tableName, ids, and prepared records
-     * @throws {InternalError} If ids and models arrays have different lengths
-     */
-    protected createAllPrefix<M extends Model>(clazz: Constructor<M>, ids: string[] | number[], models: Record<string, any>[], ...args: ContextualArgs<C>): any[];
-    /**
-     * @description Reads a record from the database
-     * @summary Abstract method that must be implemented to read a record
-     * @param {string} tableName - The name of the table
-     * @param {string|number} id - The ID of the record
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<Record<string, any>>} A promise that resolves to the read record
-     */
-    abstract read<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
-    /**
-     * @description Prepares a record for update
-     * @summary Adds necessary CouchDB fields to a record before update
-     * @param {string} tableName - The name of the table
-     * @param {string|number} id - The ID of the record
-     * @param model - The model to prepare
-     * @param [args] - optional args for subclassing
-     * @return A tuple containing the tableName, id, and prepared record
-     * @throws {InternalError} If no revision number is found in the model
-     */
-    updatePrefix<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<C>): any[];
-    /**
-     * @description Updates a record in the database
-     * @summary Abstract method that must be implemented to update a record
-     * @param {string} tableName - The name of the table
-     * @param {string|number} id - The ID of the record
-     * @param {Record<string, any>} model - The model to update
-     * @param {any[]} args - Additional arguments
-     * @return A promise that resolves to the updated record
-     */
-    abstract update<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
-    /**
-     * @description Prepares multiple records for update
-     * @summary Adds necessary CouchDB fields to multiple records before update
-     * @param {string} tableName - The name of the table
-     * @param {string[]|number[]} ids - The IDs of the records
-     * @param models - The models to prepare
-     * @return A tuple containing the tableName, ids, and prepared records
-     * @throws {InternalError} If ids and models arrays have different lengths or if no revision number is found in a model
-     */
-    protected updateAllPrefix<M extends Model>(clazz: Constructor<M>, ids: PrimaryKeyType[], models: Record<string, any>[], ...args: ContextualArgs<C>): any[];
-    /**
-     * @description Deletes a record from the database
-     * @summary Abstract method that must be implemented to delete a record
-     * @param {Constructor<M>} tableName - The name of the table
-     * @param {PrimaryKeyType} id - The ID of the record
-     * @param {any[]} args - Additional arguments
-     * @return A promise that resolves to the deleted record
-     */
-    abstract delete<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
-    /**
-     * @description Generates a CouchDB document ID
-     * @summary Combines the table name and ID to create a CouchDB document ID
-     * @param {string} tableName - The name of the table
-     * @param {string|number} id - The ID of the record
-     * @return {string} The generated CouchDB document ID
-     */
-    protected generateId(tableName: string, id: PrimaryKeyType): string;
-    /**
-     * @description Parses an error and converts it to a BaseError
-     * @summary Converts various error types to appropriate BaseError subtypes
-     * @param {Error|string} err - The error to parse
-     * @param {string} [reason] - Optional reason for the error
-     * @return {BaseError} The parsed error as a BaseError
-     */
-    parseError<E extends BaseError>(err: Error | string, reason?: string): E;
-    /**
-     * @description Checks if an attribute is reserved
-     * @summary Determines if an attribute name is reserved in CouchDB
-     * @param {string} attr - The attribute name to check
-     * @return {boolean} True if the attribute is reserved, false otherwise
-     */
-    protected isReserved(attr: string): boolean;
-    /**
-     * @description Static method to parse an error and convert it to a BaseError
-     * @summary Converts various error types to appropriate BaseError subtypes based on error codes and messages
-     * @param {Error|string} err - The error to parse
-     * @param {string} [reason] - Optional reason for the error
-     * @return {BaseError} The parsed error as a BaseError
-     * @mermaid
-     * sequenceDiagram
-     *   participant Caller
-     *   participant parseError
-     *   participant ErrorTypes
-     *
-     *   Caller->>parseError: err, reason
-     *   Note over parseError: Check if err is already a BaseError
-     *   alt err is BaseError
-     *     parseError-->>Caller: return err
-     *   else err is string
-     *     Note over parseError: Extract code from string
-     *     alt code matches "already exist|update conflict"
-     *       parseError->>ErrorTypes: new ConflictError(code)
-     *       ErrorTypes-->>Caller: ConflictError
-     *     else code matches "missing|deleted"
-     *       parseError->>ErrorTypes: new NotFoundError(code)
-     *       ErrorTypes-->>Caller: NotFoundError
-     *     end
-     *   else err has code property
-     *     Note over parseError: Extract code and reason
-     *   else err has statusCode property
-     *     Note over parseError: Extract code and reason
-     *   else
-     *     Note over parseError: Use err.message as code
-     *   end
-     *
-     *   Note over parseError: Switch on code
-     *   alt code is 401, 412, or 409
-     *     parseError->>ErrorTypes: new ConflictError(reason)
-     *     ErrorTypes-->>Caller: ConflictError
-     *   else code is 404
-     *     parseError->>ErrorTypes: new NotFoundError(reason)
-     *     ErrorTypes-->>Caller: NotFoundError
-     *   else code is 400
-     *     alt code matches "No index exists"
-     *       parseError->>ErrorTypes: new IndexError(err)
-     *       ErrorTypes-->>Caller: IndexError
-     *     else
-     *       parseError->>ErrorTypes: new InternalError(err)
-     *       ErrorTypes-->>Caller: InternalError
-     *     end
-     *   else code matches "ECONNREFUSED"
-     *     parseError->>ErrorTypes: new ConnectionError(err)
-     *     ErrorTypes-->>Caller: ConnectionError
-     *   else
-     *     parseError->>ErrorTypes: new InternalError(err)
-     *     ErrorTypes-->>Caller: InternalError
-     *   end
-     */
-    protected static parseError<E extends BaseError>(err: Error | string, reason?: string): E;
-    /**
-     * @description Sets metadata on a model instance.
-     * @summary Attaches metadata to a model instance using a non-enumerable property.
-     * @template M - The model type that extends Model.
-     * @param {M} model - The model instance.
-     * @param {any} metadata - The metadata to attach to the model.
-     */
-    static setMetadata<M extends Model>(model: M, metadata: any): void;
-    /**
-     * @description Gets metadata from a model instance.
-     * @summary Retrieves previously attached metadata from a model instance.
-     * @template M - The model type that extends Model.
-     * @param {M} model - The model instance.
-     * @return {any} The metadata or undefined if not found.
-     */
-    static getMetadata<M extends Model>(model: M): any;
-    /**
-     * @description Removes metadata from a model instance.
-     * @summary Deletes the metadata property from a model instance.
-     * @template M - The model type that extends Model.
-     * @param {M} model - The model instance.
-     */
-    static removeMetadata<M extends Model>(model: M): void;
-}

package/lib/types/constants.d.ts

@@ -1,42 +0,0 @@
-/**
- * @description Regular expression to identify reserved attributes in CouchDB
- * @summary Matches any attribute that starts with an underscore
- * @const reservedAttributes
- * @memberOf module:for-couchdb
- */
-export declare const reservedAttributes: RegExp;
-/**
- * @description Key constants used in CouchDB operations
- * @summary Collection of string constants for CouchDB document properties and operations
- * @typedef {Object} CouchDBKeysType
- * @property {string} SEPARATOR - Separator used for combining table name and ID
- * @property {string} ID - CouchDB document ID field
- * @property {string} REV - CouchDB document revision field
- * @property {string} DELETED - CouchDB deleted document marker
- * @property {string} TABLE - Table name marker
- * @property {string} SEQUENCE - Sequence marker
- * @property {string} DDOC - Design document marker
- * @property {string} NATIVE - Native marker
- * @property {string} INDEX - Index marker
- * @memberOf module:for-couchdb
- */
-/**
- * @description Key constants used in CouchDB operations
- * @summary Collection of string constants for CouchDB document properties and operations
- * @const CouchDBKeys
- * @type {CouchDBKeysType}
- * @memberOf module:for-couchdb
- */
-export declare const CouchDBKeys: {
-    SEPARATOR: string;
-    ID: string;
-    REV: string;
-    DELETED: string;
-    TABLE: string;
-    SEQUENCE: string;
-    DDOC: string;
-    NATIVE: string;
-    INDEX: string;
-    /** @description Key for CouchDB view metadata */
-    VIEW: string;
-};

package/lib/types/decorators.d.ts

@@ -1,8 +0,0 @@
-import { Condition } from "@decaf-ts/core";
-import { AggregateOptions, CouchDBViewOptions } from "./views/index";
-export declare function groupBy(compositionsOrOptions?: string[] | string | CouchDBViewOptions, nameOrOptions?: string | CouchDBViewOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
-export declare function count(valueOrCondition?: any | Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
-export declare function sum(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
-export declare function max(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
-export declare function min(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
-export declare function distinct(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/errors.d.ts

@@ -1,21 +0,0 @@
-import { BaseError } from "@decaf-ts/db-decorators";
-/**
- * @description Error thrown when there is an issue with CouchDB indexes
- * @summary Represents an error related to CouchDB index operations
- * @param {string|Error} msg - The error message or Error object
- * @class
- * @category Errors
- * @example
- * // Example of using IndexError
- * try {
- *   // Some code that might throw an index error
- *   throw new IndexError("Index not found");
- * } catch (error) {
- *   if (error instanceof IndexError) {
- *     console.error("Index error occurred:", error.message);
- *   }
- * }
- */
-export declare class IndexError extends BaseError {
-    constructor(msg: string | Error);
-}

package/lib/types/index.d.ts

@@ -1,28 +0,0 @@
-export * from "./indexes";
-export * from "./repository";
-export * from "./adapter";
-export * from "./constants";
-export * from "./errors";
-export * from "./metadata";
-export * from "./decorators";
-export * from "./types";
-export * from "./utils";
-export * from "./query";
-export * from "./views";
-/**
- * @description CouchDB adapter for Decaf.ts
- * @summary A TypeScript adapter for CouchDB database operations, providing a seamless integration with the Decaf.ts framework. This module includes classes, interfaces, and utilities for working with CouchDB databases, including support for Mango queries, document operations, and sequence management.
- * @module for-couchdb
- */
-/**
- * @description Stores the current package version
- * @summary The version string of the for-couchdb package
- * @const VERSION
- */
-export declare const VERSION = "0.11.0";
-/**
- * @description Stores the current package name
- * @summary The version string of the for-couchdb package
- * @const PACKAGE_NAME
- */
-export declare const PACKAGE_NAME = "@decaf-ts/for-couchdb";

package/lib/types/indexes/generator.d.ts

@@ -1,51 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { CreateIndexRequest } from "../types";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @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/types/indexes/index.d.ts

@@ -1 +0,0 @@
-export * from "./generator";

package/lib/types/metadata.d.ts

@@ -1,4 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-export declare function setMetadata<M extends Model>(model: M, metadata: any): void;
-export declare function getMetadata<M extends Model>(model: M): any;
-export declare function removeMetadata<M extends Model>(model: M): void;

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

@@ -1,105 +0,0 @@
-import { MaybeContextualArg, Paginator } from "@decaf-ts/core";
-import { MangoQuery } from "../types";
-import { Model } from "@decaf-ts/decorator-validation";
-import { CouchDBAdapter } from "../adapter";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @description Paginator for ConuchDB 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> extends Paginator<M, M[], MangoQuery> {
-    /**
-     * @description Creates a new CouchDBPaginator instance
-     * @summary Initializes a paginator for CouchDB query results
-     * @param {CouchDBAdapter<any, 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 | undefined, bookmark?: any, ...args: MaybeContextualArg<any>): Promise<M[]>;
-}