@decaf-ts/for-couchdb 0.3.0 → 0.3.2

package/dist/for-couchdb.esm.cjs

@@ -1,12 +1,40 @@
-import { Repository, PersistenceKeys, pk, index, table, BaseModel, Sequence as Sequence$1, Paginator, PagingError, Statement, FromClause, InsertClause, WhereClause, Condition, SelectClause, Const, ValuesClause, ClauseFactory, GroupByClause, LimitClause, OffsetClause, QueryError, OrderByClause, Adapter, GroupOperator, Operator, ConnectionError } from '@decaf-ts/core';
-import { DefaultSeparator, InternalError, NotFoundError, findPrimaryKey, BaseError, prefixMethod, ConflictError } from '@decaf-ts/db-decorators';
+import { Repository, PersistenceKeys, pk, index, table, BaseModel, Sequence as Sequence$1, Paginator, PagingError, QueryError, Statement, Condition, GroupOperator, Operator, final, Adapter, ConnectionError } from '@decaf-ts/core';
+import { DefaultSeparator, NotFoundError, InternalError, BaseError, findPrimaryKey, prefixMethod, ConflictError } from '@decaf-ts/db-decorators';
 import { __decorate, __metadata } from 'tslib';
-import { required, model, sf } from '@decaf-ts/decorator-validation';
+import { required, model } from '@decaf-ts/decorator-validation';
 import 'reflect-metadata';
 
+/**
+ * @description Regular expression to identify reserved attributes in CouchDB
+ * @summary Matches any attribute that starts with an underscore
+ * @const reservedAttributes
+ * @memberOf module:for-couchdb
+ */
 const reservedAttributes = /^_.*$/g;
+/**
+ * @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
+ */
 const CouchDBKeys = {
-    SEPARATOR: "_",
+    SEPARATOR: "__",
     ID: "_id",
     REV: "_rev",
     DELETED: "_deleted",
@@ -17,6 +45,30 @@ const CouchDBKeys = {
     INDEX: "index",
 };
 
+/**
+ * @description Default query limit for CouchDB queries
+ * @summary Maximum number of documents to return in a single query
+ * @const CouchDBQueryLimit
+ * @memberOf module:for-couchdb
+ */
+const CouchDBQueryLimit = 250;
+/**
+ * @description Mapping of operator names to CouchDB Mango query operators
+ * @summary Constants for CouchDB comparison operators used in Mango queries
+ * @typedef {Object} CouchDBOperatorType
+ * @property {string} EQUAL - Equality operator ($eq)
+ * @property {string} DIFFERENT - Inequality operator ($ne)
+ * @property {string} BIGGER - Greater than operator ($gt)
+ * @property {string} BIGGER_EQ - Greater than or equal operator ($gte)
+ * @property {string} SMALLER - Less than operator ($lt)
+ * @property {string} SMALLER_EQ - Less than or equal operator ($lte)
+ * @property {string} NOT - Negation operator ($not)
+ * @property {string} IN - In array operator ($in)
+ * @property {string} REGEXP - Regular expression operator ($regex)
+ * @const CouchDBOperator
+ * @type {CouchDBOperatorType}
+ * @memberOf module:for-couchdb
+ */
 const CouchDBOperator = {
     EQUAL: "$eq",
     DIFFERENT: "$ne",
@@ -30,11 +82,31 @@ const CouchDBOperator = {
     // IS = "IS",
     REGEXP: "$regex",
 };
+/**
+ * @description Mapping of logical operator names to CouchDB Mango query operators
+ * @summary Constants for CouchDB logical operators used in Mango queries
+ * @typedef {Object} CouchDBGroupOperatorType
+ * @property {string} AND - Logical AND operator ($and)
+ * @property {string} OR - Logical OR operator ($or)
+ * @const CouchDBGroupOperator
+ * @type {CouchDBGroupOperatorType}
+ * @memberOf module:for-couchdb
+ */
 const CouchDBGroupOperator = {
     AND: "$and",
     OR: "$or",
 };
 
+/**
+ * @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$1(name, direction, compositions, separator = DefaultSeparator) {
     return [
         ...name.map((n) => (n === CouchDBKeys.TABLE ? "table" : n)),
@@ -43,6 +115,53 @@ function generateIndexName$1(name, direction, compositions, separator = DefaultS
         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$1([CouchDBKeys.TABLE]);
     const indexes = {};
@@ -102,6 +221,17 @@ function generateIndexes(models) {
     return Object.values(indexes);
 }
 
+/**
+ * @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);
@@ -122,21 +252,6 @@ Sequence = __decorate([
     __metadata("design:paramtypes", [Object])
 ], Sequence);
 
-function parseSequenceValue(type, value) {
-    switch (type) {
-        case "Number":
-            return typeof value === "string"
-                ? parseInt(value)
-                : typeof value === "number"
-                    ? value
-                    : BigInt(value);
-        case "BigInt":
-            return BigInt(value);
-        default:
-            throw new InternalError("Should never happen");
-    }
-}
-
 /**
  * @summary Abstract implementation of a Sequence
  * @description provides the basic functionality for {@link Sequence}s
@@ -145,13 +260,11 @@ function parseSequenceValue(type, value) {
  *
  * @class CouchDBSequence
  * @implements Sequence
- *
- * @category Sequences
  */
 class CouchDBSequence extends Sequence$1 {
     constructor(options, adapter) {
         super(options);
-        this.repo = Repository.forModel(Sequence, adapter.flavour);
+        this.repo = Repository.forModel(Sequence, adapter.alias);
     }
     /**
      * @summary Retrieves the current value for the sequence
@@ -171,10 +284,10 @@ class CouchDBSequence extends Sequence$1 {
                     return this.parse(startWith);
                 }
                 catch (e) {
-                    throw new InternalError(sf("Failed to parse initial value for sequence {0}: {1}", startWith.toString(), e));
+                    throw new InternalError(`Failed to parse initial value for sequence ${startWith}: ${e}`);
                 }
             }
-            throw new InternalError(sf("Failed to retrieve current value for sequence {0}: {1}", name, e));
+            throw new InternalError(`Failed to retrieve current value for sequence ${name}: ${e}`);
         }
     }
     /**
@@ -184,7 +297,7 @@ class CouchDBSequence extends Sequence$1 {
      * @param value
      */
     parse(value) {
-        return parseSequenceValue(this.options.type, value);
+        return Sequence$1.parseValue(this.options.type, value);
     }
     /**
      * @summary increments the sequence
@@ -245,16 +358,87 @@ class CouchDBSequence extends Sequence$1 {
     }
 }
 
+/**
+ * @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);
+ *   }
+ * }
+ */
+class IndexError extends BaseError {
+    constructor(msg) {
+        super(IndexError.name, msg, 404);
+    }
+}
+
+/**
+ * @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 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`);
     }
-    constructor(statement, size, rawStatement) {
-        super(statement, size, rawStatement);
+    /**
+     * @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)
@@ -262,39 +446,96 @@ class CouchDBPaginator extends Paginator {
         query.limit = this.size;
         return query;
     }
-    async page(page = 1, ...args) {
+    /**
+     * @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);
-        const target = this.stat.getTarget();
-        // 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)
                 throw new PagingError("No bookmark. Did you start in the first page?");
             statement["bookmark"] = this.bookMark;
         }
-        const rawResult = await this.adapter.raw(statement, false, ...args);
+        const rawResult = await this.adapter.raw(statement, false);
         const { docs, bookmark, warning } = rawResult;
         if (warning)
             console.warn(warning);
-        if (!target)
+        if (!this.clazz)
             throw new PagingError("No statement target defined");
-        const pkDef = findPrimaryKey(new target());
+        const pkDef = findPrimaryKey(new this.clazz());
         const results = statement.fields && statement.fields.length
             ? docs // has fields means its not full model
             : docs.map((d) => {
                 //no fields means we need to revert to saving process
-                if (!target)
-                    throw new PagingError("No statement target defined");
-                const pk = pkDef.id;
-                const originalId = d._id.split(DefaultSeparator);
+                const originalId = d._id.split(CouchDBKeys.SEPARATOR);
                 originalId.splice(0, 1); // remove the table name
-                return this.adapter.revert(d, target, pk, parseSequenceValue(pkDef.props.type, originalId.join(DefaultSeparator)));
+                return this.adapter.revert(d, this.clazz, pkDef.id, Sequence$1.parseValue(pkDef.props.type, originalId.join(CouchDBKeys.SEPARATOR)));
             });
         this.bookMark = bookmark;
         this._currentPage = page;
@@ -302,300 +543,296 @@ class CouchDBPaginator extends Paginator {
     }
 }
 
+/**
+ * @description Translates core operators to CouchDB Mango operators
+ * @summary Converts Decaf.ts core operators to their equivalent CouchDB Mango query operators
+ * @param {GroupOperator | Operator} operator - The core operator to translate
+ * @return {MangoOperator} The equivalent CouchDB Mango operator
+ * @throws {QueryError} If no translation exists for the given operator
+ * @function translateOperators
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant translateOperators
+ *   participant CouchDBOperator
+ *   participant CouchDBGroupOperator
+ *
+ *   Caller->>translateOperators: operator
+ *
+ *   translateOperators->>CouchDBOperator: Check for match
+ *   alt Found in CouchDBOperator
+ *     CouchDBOperator-->>translateOperators: Return matching operator
+ *     translateOperators-->>Caller: Return MangoOperator
+ *   else Not found
+ *     translateOperators->>CouchDBGroupOperator: Check for match
+ *     alt Found in CouchDBGroupOperator
+ *       CouchDBGroupOperator-->>translateOperators: Return matching operator
+ *       translateOperators-->>Caller: Return MangoOperator
+ *     else Not found
+ *       translateOperators-->>Caller: Throw QueryError
+ *     end
+ *   end
+ */
+function translateOperators(operator) {
+    for (const operators of [CouchDBOperator, CouchDBGroupOperator]) {
+        const el = Object.keys(operators).find((k) => k === operator);
+        if (el)
+            return operators[el];
+    }
+    throw new QueryError(`Could not find adapter translation for operator ${operator}`);
+}
+
+/**
+ * @description Statement builder for CouchDB Mango queries
+ * @summary Provides a fluent interface for building CouchDB Mango queries with type safety
+ * @template M - The model type that extends Model
+ * @template R - The result type
+ * @param adapter - The CouchDB adapter
+ * @class CouchDBStatement
+ * @example
+ * // Example of using CouchDBStatement
+ * const adapter = new MyCouchDBAdapter(scope);
+ * const statement = new CouchDBStatement<User, User[]>(adapter);
+ *
+ * // Build a query
+ * const users = await statement
+ *   .from(User)
+ *   .where(Condition.attribute<User>('age').gt(18))
+ *   .orderBy('lastName', 'asc')
+ *   .limit(10)
+ *   .execute();
+ */
 class CouchDBStatement extends Statement {
     constructor(adapter) {
         super(adapter);
     }
     /**
-     * @inheritDoc
+     * @description Builds a CouchDB Mango query from the statement
+     * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query
+     * @return {MangoQuery} The built Mango query
+     * @throws {Error} If there are invalid query conditions
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant Repository
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: build()
+     *   Note over Statement: Initialize selectors
+     *   Statement->>Repository: Get table name
+     *   Repository-->>Statement: Return table name
+     *   Statement->>Statement: Create base query
+     *
+     *   alt Has selectSelector
+     *     Statement->>Statement: Add fields to query
+     *   end
+     *
+     *   alt Has whereCondition
+     *     Statement->>Statement: Create combined condition with table
+     *     Statement->>parseCondition: Parse condition
+     *     parseCondition-->>Statement: Return parsed condition
+     *
+     *     alt Is group operator
+     *       alt Is AND operator
+     *         Statement->>Statement: Flatten nested AND conditions
+     *       else Is OR operator
+     *         Statement->>Statement: Combine with table condition
+     *       else
+     *         Statement->>Statement: Throw error
+     *       end
+     *     else
+     *       Statement->>Statement: Merge conditions with existing selector
+     *     end
+     *   end
+     *
+     *   alt Has orderBySelector
+     *     Statement->>Statement: Add sort to query
+     *     Statement->>Statement: Ensure field exists in selector
+     *   end
+     *
+     *   alt Has limitSelector
+     *     Statement->>Statement: Set limit
+     *   else
+     *     Statement->>Statement: Use default limit
+     *   end
+     *
+     *   alt Has offsetSelector
+     *     Statement->>Statement: Set skip
+     *   end
+     *
+     *   Statement-->>Statement: Return query
      */
-    async execute() {
-        try {
-            const query = this.build();
-            if (!query.limit)
-                query.limit = Number.MAX_SAFE_INTEGER;
-            return this.raw(query);
+    build() {
+        const selectors = {};
+        selectors[CouchDBKeys.TABLE] = {};
+        selectors[CouchDBKeys.TABLE] = Repository.table(this.fromSelector);
+        const query = { selector: selectors };
+        if (this.selectSelector)
+            query.fields = this.selectSelector;
+        if (this.whereCondition) {
+            const condition = this.parseCondition(Condition.and(this.whereCondition, Condition.attribute(CouchDBKeys.TABLE).eq(query.selector[CouchDBKeys.TABLE]))).selector;
+            const selectorKeys = Object.keys(condition);
+            if (selectorKeys.length === 1 &&
+                Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1)
+                switch (selectorKeys[0]) {
+                    case CouchDBGroupOperator.AND:
+                        condition[CouchDBGroupOperator.AND] = [
+                            ...Object.values(condition[CouchDBGroupOperator.AND]).reduce((accum, val) => {
+                                const keys = Object.keys(val);
+                                if (keys.length !== 1)
+                                    throw new Error("Too many keys in query selector. should be one");
+                                const k = keys[0];
+                                if (k === CouchDBGroupOperator.AND)
+                                    accum.push(...val[k]);
+                                else
+                                    accum.push(val);
+                                return accum;
+                            }, []),
+                        ];
+                        query.selector = condition;
+                        break;
+                    case CouchDBGroupOperator.OR: {
+                        const s = {};
+                        s[CouchDBGroupOperator.AND] = [
+                            condition,
+                            ...Object.entries(query.selector).map(([key, val]) => {
+                                const result = {};
+                                result[key] = val;
+                                return result;
+                            }),
+                        ];
+                        query.selector = s;
+                        break;
+                    }
+                    default:
+                        throw new Error("This should be impossible");
+                }
+            else {
+                Object.entries(condition).forEach(([key, val]) => {
+                    if (query.selector[key])
+                        console.warn(`A ${key} query param is about to be overridden: ${query.selector[key]} by ${val}`);
+                    query.selector[key] = val;
+                });
+            }
         }
-        catch (e) {
-            throw new InternalError(e);
+        if (this.orderBySelector) {
+            query.sort = query.sort || [];
+            query.selector = query.selector || {};
+            const [selector, value] = this.orderBySelector;
+            const rec = {};
+            rec[selector] = value;
+            query.sort.push(rec);
+            if (!query.selector[selector]) {
+                query.selector[selector] = {};
+                query.selector[selector][CouchDBOperator.BIGGER] =
+                    null;
+            }
         }
+        if (this.limitSelector) {
+            query.limit = this.limitSelector;
+        }
+        else {
+            console.warn(`No limit selector defined. Using default couchdb limit of ${CouchDBQueryLimit}`);
+            query.limit = CouchDBQueryLimit;
+        }
+        if (this.offsetSelector)
+            query.skip = this.offsetSelector;
+        return query;
     }
+    /**
+     * @description Creates a paginator for the statement
+     * @summary Builds the query and returns a CouchDBPaginator for paginated results
+     * @template R - The result type
+     * @param {number} size - The page size
+     * @return {Promise<Paginator<M, R, MangoQuery>>} A promise that resolves to a paginator
+     * @throws {InternalError} If there's an error building the query
+     */
     async paginate(size) {
         try {
             const query = this.build();
-            return new CouchDBPaginator(this, size, query);
+            return new CouchDBPaginator(this.adapter, query, size, this.fromSelector);
         }
         catch (e) {
             throw new InternalError(e);
         }
     }
+    /**
+     * @description Processes a record from CouchDB
+     * @summary Extracts the ID from a CouchDB document and reverts it to a model instance
+     * @param {any} r - The raw record from CouchDB
+     * @param pkAttr - The primary key attribute of the model
+     * @param {"Number" | "BigInt" | undefined} sequenceType - The type of the sequence
+     * @return {any} The processed record
+     */
     processRecord(r, pkAttr, sequenceType) {
-        if (!r[CouchDBKeys.ID])
-            throw new InternalError(`No CouchDB Id definition found. Should not be possible`);
-        const [, ...keyArgs] = r[CouchDBKeys.ID].split("_");
-        const id = keyArgs.join("_");
-        return this.adapter.revert(r, this.target, pkAttr, parseSequenceValue(sequenceType, id));
-    }
-    async raw(rawInput, ...args) {
-        const results = await this.adapter.raw(rawInput, true, ...args);
-        if (!this.fullRecord)
-            return results;
-        if (!this.target)
-            throw new InternalError("No target defined in statement. should never happen");
-        const pkDef = findPrimaryKey(new this.target());
+        if (r[CouchDBKeys.ID]) {
+            const [, ...keyArgs] = r[CouchDBKeys.ID].split(CouchDBKeys.SEPARATOR);
+            const id = keyArgs.join("_");
+            return this.adapter.revert(r, this.fromSelector, pkAttr, Sequence$1.parseValue(sequenceType, id));
+        }
+        return r;
+    }
+    /**
+     * @description Executes a raw Mango query
+     * @summary Sends a raw Mango query to CouchDB and processes the results
+     * @template R - The result type
+     * @param {MangoQuery} rawInput - The raw Mango query to execute
+     * @return {Promise<R>} A promise that resolves to the query results
+     */
+    async raw(rawInput) {
+        const results = await this.adapter.raw(rawInput, true);
+        const pkDef = findPrimaryKey(new this.fromSelector());
         const pkAttr = pkDef.id;
         const type = pkDef.props.type;
-        if (Array.isArray(results))
+        if (!this.selectSelector)
             return results.map((r) => this.processRecord(r, pkAttr, type));
-        return this.processRecord(results, pkAttr, type);
-    }
-}
-
-// noinspection JSAnnotator
-class CouchDBFromClause extends FromClause {
-    constructor(clause) {
-        super(clause);
-    }
-    build(previous) {
-        const selectors = {};
-        selectors[CouchDBKeys.TABLE] = {};
-        selectors[CouchDBKeys.TABLE] =
-            typeof this.selector === "string"
-                ? this.selector
-                : Repository.table(this.selector);
-        previous.selector = selectors;
-        return previous;
-    }
-}
-
-// noinspection JSAnnotator
-class CouchDBInsertClause extends InsertClause {
-    constructor(clause) {
-        super(clause);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    build(query) {
-        throw new InternalError("Not supported");
-    }
-}
-
-class CouchDBWhereClause extends WhereClause {
-    constructor(clause) {
-        super(clause);
-    }
-    build(query) {
-        const condition = this.adapter.parseCondition(Condition.and(this.condition, Condition.attribute(CouchDBKeys.TABLE).eq(query.selector[CouchDBKeys.TABLE]))).selector;
-        const selectorKeys = Object.keys(condition);
-        if (selectorKeys.length === 1 &&
-            Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1)
-            switch (selectorKeys[0]) {
-                case CouchDBGroupOperator.AND:
-                    condition[CouchDBGroupOperator.AND] = [
-                        ...Object.values(condition[CouchDBGroupOperator.AND]).reduce((accum, val) => {
-                            const keys = Object.keys(val);
-                            if (keys.length !== 1)
-                                throw new Error("Too many keys in query selector. should be one");
-                            const k = keys[0];
-                            if (k === CouchDBGroupOperator.AND)
-                                accum.push(...val[k]);
-                            else
-                                accum.push(val);
-                            return accum;
-                        }, []),
-                    ];
-                    query.selector = condition;
-                    break;
-                case CouchDBGroupOperator.OR: {
-                    const s = {};
-                    s[CouchDBGroupOperator.AND] = [
-                        condition,
-                        ...Object.entries(query.selector).map(([key, val]) => {
-                            const result = {};
-                            result[key] = val;
-                            return result;
-                        }),
-                    ];
-                    query.selector = s;
-                    break;
-                }
-                default:
-                    throw new Error("This should be impossible");
-            }
-        else {
-            Object.entries(condition).forEach(([key, val]) => {
-                if (query.selector[key])
-                    console.warn(sf("A {0} query param is about to be overridden: {1} by {2}", key, query.selector[key], val));
-                query.selector[key] = val;
-            });
-        }
-        return query;
-    }
-}
-
-class CouchDBSelectClause extends SelectClause {
-    constructor(clause) {
-        super(clause);
-    }
-    build(query) {
-        if (!this.selector || this.selector === Const.FULL_RECORD)
-            return query;
-        query.fields =
-            typeof this.selector === "string"
-                ? [this.selector]
-                : this.selector;
-        return query;
-    }
-}
-
-class CouchDBValuesClause extends ValuesClause {
-    constructor(clause) {
-        super(clause);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    build(previous) {
-        throw new InternalError("Not implemented");
-    }
-}
-
-class Factory extends ClauseFactory {
-    constructor(adapter) {
-        super(adapter);
-    }
-    from(statement, selector) {
-        return new CouchDBFromClause({ statement: statement, selector: selector });
-    }
-    groupBy(statement, selector) {
-        return new (class extends GroupByClause {
-            constructor(clause) {
-                super(clause);
-            }
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            build(query) {
-                throw new InternalError("Not implemented");
-            }
-        })({
-            statement: statement,
-            selector: selector,
-        });
-    }
-    insert() {
-        return new CouchDBInsertClause({
-            statement: new CouchDBStatement(this.adapter),
-        });
-    }
-    limit(statement, selector) {
-        return new (class extends LimitClause {
-            constructor(clause) {
-                super(clause);
-            }
-            build(query) {
-                query.limit = this.selector;
-                return query;
-            }
-        })({
-            statement: statement,
-            selector: selector,
-        });
-    }
-    offset(statement, selector) {
-        return new (class extends OffsetClause {
-            constructor(clause) {
-                super(clause);
-            }
-            build(query) {
-                const skip = parseInt(this.selector);
-                if (isNaN(skip))
-                    throw new QueryError("Failed to parse offset");
-                query.skip = skip;
-                return query;
-            }
-        })({
-            statement: statement,
-            selector: selector,
-        });
-    }
-    orderBy(statement, selector) {
-        return new (class extends OrderByClause {
-            constructor(clause) {
-                super(clause);
-            }
-            build(query) {
-                query.sort = query.sort || [];
-                query.selector = query.selector || {};
-                this.selector.forEach((s) => {
-                    const [selector, value] = s;
-                    const rec = {};
-                    rec[selector] = value;
-                    query.sort.push(rec);
-                    if (!query.selector[selector]) {
-                        query.selector[selector] = {};
-                        query.selector[selector][CouchDBOperator.BIGGER] = null;
-                    }
-                    // query.fields = query.fields || [];
-                    // query.fields = [...new Set([...query.fields, selector]).keys()]
-                });
-                return query;
-            }
-        })({
-            statement: statement,
-            selector: selector,
-        });
-    }
-    select(selector) {
-        return new CouchDBSelectClause({
-            statement: new CouchDBStatement(this.adapter),
-            selector: selector,
-        });
-    }
-    values(statement, values) {
-        return new CouchDBValuesClause({
-            statement: statement,
-            values: values,
-        });
-    }
-    where(statement, condition) {
-        return new CouchDBWhereClause({
-            statement: statement,
-            condition: condition,
-        });
-    }
-}
-
-function translateOperators(operator) {
-    for (const operators of [CouchDBOperator, CouchDBGroupOperator]) {
-        const el = Object.keys(operators).find((k) => k === operator);
-        if (el)
-            return operators[el];
-    }
-    throw new QueryError(`Could not find adapter translation for operator ${operator}`);
-}
-
-class IndexError extends BaseError {
-    constructor(msg) {
-        super(IndexError.name, msg);
-    }
-}
-
-class CouchDBAdapter extends Adapter {
-    constructor(scope, flavour) {
-        super(scope, flavour);
-        [this.create, this.createAll, this.update, this.updateAll].forEach((m) => {
-            const name = m.name;
-            prefixMethod(this, m, this[name + "Prefix"]);
-        });
-    }
-    get Clauses() {
-        if (!this.factory)
-            this.factory = new Factory(this);
-        return this.factory;
-    }
-    Query() {
-        return super.Query();
-    }
-    get Statement() {
-        return new CouchDBStatement(this);
+        return results;
     }
+    /**
+     * @description Parses a condition into a CouchDB Mango query selector
+     * @summary Converts a Condition object into a CouchDB Mango query selector structure
+     * @param {Condition<M>} condition - The condition to parse
+     * @return {MangoQuery} The Mango query with the parsed condition as its selector
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant translateOperators
+     *   participant merge
+     *
+     *   Statement->>Statement: parseCondition(condition)
+     *
+     *   Note over Statement: Extract condition parts
+     *
+     *   alt Simple comparison operator
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return CouchDB operator
+     *     Statement->>Statement: Create selector with attribute and operator
+     *   else NOT operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>translateOperators: translateOperators(Operator.NOT)
+     *     translateOperators-->>Statement: Return CouchDB NOT operator
+     *     Statement->>Statement: Create negated selector
+     *   else AND/OR operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: parseCondition(comparison)
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return CouchDB group operator
+     *     Statement->>merge: merge(operator, op1, op2)
+     *     merge-->>Statement: Return merged selector
+     *   end
+     *
+     *   Statement-->>Statement: Return query with selector
+     */
     parseCondition(condition) {
+        /**
+         * @description Merges two selectors with a logical operator
+         * @summary Helper function to combine two selectors with a logical operator
+         * @param {MangoOperator} op - The operator to use for merging
+         * @param {MangoSelector} obj1 - The first selector
+         * @param {MangoSelector} obj2 - The second selector
+         * @return {MangoQuery} The merged query
+         */
         function merge(op, obj1, obj2) {
             const result = { selector: {} };
             result.selector[op] = [obj1, obj2];
@@ -620,13 +857,93 @@ class CouchDBAdapter extends Adapter {
         }
         return { selector: op };
     }
+}
+
+/**
+ * @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
+ *   }
+ * }
+ */
+class CouchDBAdapter extends Adapter {
+    constructor(scope, flavour, alias) {
+        super(scope, flavour, alias);
+        [this.create, this.createAll, this.update, this.updateAll].forEach((m) => {
+            const name = m.name;
+            prefixMethod(this, m, this[name + "Prefix"]);
+        });
+    }
+    /**
+     * @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() {
+        return new CouchDBStatement(this);
+    }
+    /**
+     * @description Creates a new CouchDB sequence
+     * @summary Factory method that creates a new CouchDBSequence instance for managing sequences
+     * @param {SequenceOptions} options - The options for the sequence
+     * @return {Promise<Sequence>} A promise that resolves to a new Sequence instance
+     */
     async Sequence(options) {
         return new CouchDBSequence(options, this);
     }
+    /**
+     * @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
+     */
     async initialize() {
         const managedModels = Adapter.models(this.flavour);
         return this.index(...managedModels);
     }
+    /**
+     * @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
+     */
     assignMetadata(model, rev) {
         Object.defineProperty(model, PersistenceKeys.METADATA, {
             enumerable: false,
@@ -636,6 +953,13 @@ class CouchDBAdapter extends Adapter {
         });
         return model;
     }
+    /**
+     * @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
+     */
     assignMultipleMetadata(models, revs) {
         models.forEach((m, i) => {
             Repository.setMetadata(m, revs[i]);
@@ -643,6 +967,14 @@ class CouchDBAdapter extends Adapter {
         });
         return models;
     }
+    /**
+     * @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
+     */
     createPrefix(tableName, id, model) {
         const record = {};
         record[CouchDBKeys.TABLE] = tableName;
@@ -650,6 +982,15 @@ class CouchDBAdapter extends Adapter {
         Object.assign(record, model);
         return [tableName, id, record];
     }
+    /**
+     * @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
+     */
     createAllPrefix(tableName, ids, models) {
         if (ids.length !== models.length)
             throw new InternalError("Ids and models must have the same length");
@@ -662,6 +1003,15 @@ class CouchDBAdapter extends Adapter {
         });
         return [tableName, ids, records];
     }
+    /**
+     * @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
+     * @return A tuple containing the tableName, id, and prepared record
+     * @throws {InternalError} If no revision number is found in the model
+     */
     updatePrefix(tableName, id, model) {
         const record = {};
         record[CouchDBKeys.TABLE] = tableName;
@@ -673,6 +1023,15 @@ class CouchDBAdapter extends Adapter {
         record[CouchDBKeys.REV] = rev;
         return [tableName, id, record];
     }
+    /**
+     * @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
+     */
     updateAllPrefix(tableName, ids, models) {
         if (ids.length !== models.length)
             throw new InternalError("Ids and models must have the same length");
@@ -689,15 +1048,91 @@ class CouchDBAdapter extends Adapter {
         });
         return [tableName, ids, records];
     }
+    /**
+     * @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
+     */
     generateId(tableName, id) {
         return [tableName, id].join(CouchDBKeys.SEPARATOR);
     }
+    /**
+     * @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(err, reason) {
         return CouchDBAdapter.parseError(err, reason);
     }
+    /**
+     * @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
+     */
     isReserved(attr) {
         return !!attr.match(reservedAttributes);
     }
+    /**
+     * @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
+     */
     static parseError(err, reason) {
         if (err instanceof BaseError)
             return err;
@@ -738,10 +1173,104 @@ class CouchDBAdapter extends Adapter {
         }
     }
 }
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", CouchDBStatement)
+], CouchDBAdapter.prototype, "Statement", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CouchDBAdapter.prototype, "Sequence", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Object)
+], CouchDBAdapter.prototype, "assignMetadata", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Array]),
+    __metadata("design:returntype", Array)
+], CouchDBAdapter.prototype, "assignMultipleMetadata", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", void 0)
+], CouchDBAdapter.prototype, "createPrefix", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Array]),
+    __metadata("design:returntype", void 0)
+], CouchDBAdapter.prototype, "createAllPrefix", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", void 0)
+], CouchDBAdapter.prototype, "updatePrefix", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Array]),
+    __metadata("design:returntype", void 0)
+], CouchDBAdapter.prototype, "updateAllPrefix", null);
 
+/**
+ * @description Re-authenticates a connection to CouchDB
+ * @summary Refreshes the authentication for a CouchDB connection using the provided credentials
+ * @param {any} con - The CouchDB connection object
+ * @param {string} user - The username for authentication
+ * @param {string} pass - The password for authentication
+ * @return {Promise<any>} A promise that resolves to the authentication result
+ * @function reAuth
+ * @memberOf module:for-couchdb
+ */
 async function reAuth(con, user, pass) {
     return con.auth(user, pass);
 }
+/**
+ * @description Wraps a CouchDB database connection with automatic re-authentication
+ * @summary Creates a proxy around a CouchDB database connection that automatically re-authenticates before each operation
+ * @param {any} con - The CouchDB connection object
+ * @param {string} dbName - The name of the database to use
+ * @param {string} user - The username for authentication
+ * @param {string} pass - The password for authentication
+ * @return {any} The wrapped database connection object
+ * @function wrapDocumentScope
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant wrapDocumentScope
+ *   participant DB
+ *   participant reAuth
+ *
+ *   Client->>wrapDocumentScope: con, dbName, user, pass
+ *   wrapDocumentScope->>DB: con.use(dbName)
+ *   Note over wrapDocumentScope: Wrap DB methods with re-auth
+ *
+ *   loop For each method (insert, get, put, destroy, find)
+ *     wrapDocumentScope->>wrapDocumentScope: Store original method
+ *     wrapDocumentScope->>wrapDocumentScope: Define new method with re-auth
+ *   end
+ *
+ *   wrapDocumentScope->>wrapDocumentScope: Add NATIVE property with con value
+ *   wrapDocumentScope-->>Client: Return wrapped DB
+ *
+ *   Note over Client: Later when client uses DB methods
+ *   Client->>DB: Any wrapped method call
+ *   DB->>reAuth: Authenticate before operation
+ *   reAuth-->>DB: Authentication complete
+ *   DB->>DB: Call original method
+ *   DB-->>Client: Return result
+ */
 function wrapDocumentScope(con, dbName, user, pass) {
     const db = con.use(dbName);
     ["insert", "get", "put", "destroy", "find"].forEach((k) => {
@@ -763,10 +1292,30 @@ function wrapDocumentScope(con, dbName, user, pass) {
     });
     return db;
 }
+/**
+ * @description Tests if an attribute name is reserved in CouchDB
+ * @summary Checks if an attribute name starts with an underscore, which indicates it's a reserved attribute in CouchDB
+ * @param {string} attr - The attribute name to test
+ * @return {RegExpMatchArray|null} The match result or null if no match
+ * @function testReservedAttributes
+ * @memberOf module:for-couchdb
+ */
 function testReservedAttributes(attr) {
     const regexp = /^_.*$/g;
     return attr.match(regexp);
 }
+/**
+ * @description Generates a name for a CouchDB index
+ * @summary Creates a standardized name for a CouchDB index based on the table, attribute, compositions, and order
+ * @param {string} attribute - The primary attribute for the index
+ * @param {string} tableName - The name of the table
+ * @param {string[]} [compositions] - Optional additional attributes to include in the index
+ * @param {OrderDirection} [order] - Optional sort order for the index
+ * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
+ * @return {string} The generated index name
+ * @function generateIndexName
+ * @memberOf module:for-couchdb
+ */
 function generateIndexName(attribute, tableName, compositions, order, separator = DefaultSeparator) {
     const attr = [PersistenceKeys.INDEX, tableName, attribute];
     if (compositions)
@@ -775,6 +1324,45 @@ function generateIndexName(attribute, tableName, compositions, order, separator
         attr.push(order);
     return attr.join(separator);
 }
+/**
+ * @description Generates a CouchDB index configuration
+ * @summary Creates a complete CreateIndexRequest object for defining a CouchDB index based on specified parameters
+ * @param {string} attribute - The primary attribute for the index
+ * @param {string} tableName - The name of the table
+ * @param {string[]} [compositions] - Optional additional attributes to include in the index
+ * @param {OrderDirection} [order] - Optional sort order for the index
+ * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
+ * @return {CreateIndexRequest} The complete index configuration object
+ * @function generateIndexDoc
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant generateIndexDoc
+ *   participant generateIndexName
+ *
+ *   Caller->>generateIndexDoc: attribute, tableName, compositions, order, separator
+ *
+ *   Note over generateIndexDoc: Create partial filter selector
+ *   generateIndexDoc->>generateIndexDoc: Set up filter for tableName
+ *
+ *   alt order is specified
+ *     Note over generateIndexDoc: Create ordered fields array
+ *     generateIndexDoc->>generateIndexDoc: Create orderProp for attribute
+ *     generateIndexDoc->>generateIndexDoc: Map compositions to ordered props
+ *     generateIndexDoc->>generateIndexDoc: Create sortedTable for table field
+ *     generateIndexDoc->>generateIndexDoc: Combine all ordered fields
+ *   else
+ *     Note over generateIndexDoc: Create simple fields array
+ *     generateIndexDoc->>generateIndexDoc: Use attribute, compositions, and table as strings
+ *   end
+ *
+ *   generateIndexDoc->>generateIndexName: Generate index name
+ *   generateIndexName-->>generateIndexDoc: Return name
+ *
+ *   Note over generateIndexDoc: Create final index request
+ *   generateIndexDoc-->>Caller: Return CreateIndexRequest
+ */
 function generateIndexDoc(attribute, tableName, compositions, order, separator = DefaultSeparator) {
     const partialFilterSelector = {};
     partialFilterSelector[CouchDBKeys.TABLE] = {};
@@ -807,23 +1395,16 @@ function generateIndexDoc(attribute, tableName, compositions, order, separator =
 }
 
 /**
- * @summary Module summary
- * @description Module description
- * @module ts-workspace
- */
-/**
- * @summary Namespace summary
- * @description Namespace description
- * @namespace Namespace
- * @memberOf module:ts-workspace
+ * @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
  */
 /**
- * @summary stores the current package version
- * @description this is how you should document a constant
+ * @description Stores the current package version
+ * @summary The version string of the for-couchdb package
  * @const VERSION
- * @memberOf module:ts-workspace
  */
-const VERSION = "0.3.0";
+const VERSION = "0.3.2";
 
 export { CouchDBAdapter, CouchDBKeys, CouchDBSequence, IndexError, Sequence, VERSION, generateIndexDoc, generateIndexName, generateIndexes, reAuth, reservedAttributes, testReservedAttributes, wrapDocumentScope };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-couchdb.esm.cjs","sources":["../src/constants.ts","../src/query/constants.ts","../src/indexes/generator.ts","../src/model/CouchDBSequence.ts","../src/sequences/utils.ts","../src/sequences/Sequence.ts","../src/query/Paginator.ts","../src/query/Statement.ts","../src/query/FromClause.ts","../src/query/InsertClause.ts","../src/query/WhereClause.ts","../src/query/SelectClause.ts","../src/query/ValuesClause.ts","../src/query/factory.ts","../src/query/translate.ts","../src/errors.ts","../src/adapter.ts","../src/utils.ts","../src/index.ts"],"sourcesContent":["export const reservedAttributes = /^_.*$/g;\n\nexport const CouchDBKeys = {\n  SEPARATOR: \"_\",\n  ID: \"_id\",\n  REV: \"_rev\",\n  DELETED: \"_deleted\",\n  TABLE: \"??table\",\n  SEQUENCE: \"??sequence\",\n  DDOC: \"ddoc\",\n  NATIVE: \"__native\",\n  INDEX: \"index\",\n};\n","import { MangoOperator } from \"../types\";\n\nexport const CouchDBOperator: Record<string, MangoOperator> = {\n  EQUAL: \"$eq\",\n  DIFFERENT: \"$ne\",\n  BIGGER: \"$gt\",\n  BIGGER_EQ: \"$gte\",\n  SMALLER: \"$lt\",\n  SMALLER_EQ: \"$lte\",\n  // BETWEEN = \"BETWEEN\",\n  NOT: \"$not\",\n  IN: \"$in\",\n  // IS = \"IS\",\n  REGEXP: \"$regex\",\n};\n\nexport const CouchDBGroupOperator: Record<string, MangoOperator> = {\n  AND: \"$and\",\n  OR: \"$or\",\n};\n\nexport const CouchDBConst: Record<string, string> = {\n  NULL: \"null\",\n};\n","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\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\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","import type { ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { model, required } from \"@decaf-ts/decorator-validation\";\nimport { BaseModel, pk, index, table } from \"@decaf-ts/core\";\nimport { CouchDBKeys } from \"../constants\";\n\n@table(CouchDBKeys.SEQUENCE)\n@model()\nexport class Sequence extends BaseModel {\n  /**\n   * @summary the Primary key for the DBSequence\n   * @prop name\n   *\n   * @see pk\n   */\n  @pk()\n  id!: string;\n  /**\n   * @summary the current value for the DBSequence\n   * @prop current\n   *\n   * @see required\n   * @see index\n   */\n  @required()\n  @index()\n  current!: string | number;\n\n  constructor(seq?: ModelArg<Sequence>) {\n    super(seq);\n  }\n}\n","import { InternalError } from \"@decaf-ts/db-decorators\";\n\nexport function parseSequenceValue(\n  type: \"Number\" | \"BigInt\" | undefined,\n  value: string | number | bigint\n): string | number | bigint {\n  switch (type) {\n    case \"Number\":\n      return typeof value === \"string\"\n        ? parseInt(value)\n        : typeof value === \"number\"\n          ? value\n          : BigInt(value);\n    case \"BigInt\":\n      return BigInt(value);\n    default:\n      throw new InternalError(\"Should never happen\");\n  }\n}\n","import { sf } from \"@decaf-ts/decorator-validation\";\nimport { Sequence as Seq } from \"../model/CouchDBSequence\";\nimport { InternalError, NotFoundError } from \"@decaf-ts/db-decorators\";\nimport { Adapter, Repository, SequenceOptions } from \"@decaf-ts/core\";\nimport { Sequence } from \"@decaf-ts/core\";\nimport { parseSequenceValue } from \"./utils\";\nimport { MangoQuery } from \"../types\";\nimport { CouchDBRepository } from \"../interfaces\";\n\n/**\n * @summary Abstract implementation of a Sequence\n * @description provides the basic functionality for {@link Sequence}s\n *\n * @param {SequenceOptions} options\n *\n * @class CouchDBSequence\n * @implements Sequence\n *\n * @category Sequences\n */\nexport class CouchDBSequence extends Sequence {\n  protected repo: CouchDBRepository<Seq, any, any, any>;\n\n  constructor(\n    options: SequenceOptions,\n    adapter: Adapter<any, MangoQuery, any, any>\n  ) {\n    super(options);\n    this.repo = Repository.forModel(Seq, adapter.flavour);\n  }\n\n  /**\n   * @summary Retrieves the current value for the sequence\n   * @protected\n   */\n  async current(): Promise<string | number | bigint> {\n    const { name, startWith } = this.options;\n    try {\n      const sequence: Seq = await this.repo.read(name as string);\n      return this.parse(sequence.current as string | number);\n    } catch (e: any) {\n      if (e instanceof NotFoundError) {\n        if (typeof startWith === \"undefined\")\n          throw new InternalError(\n            \"Starting value is not defined for a non existing sequence\"\n          );\n        try {\n          return this.parse(startWith);\n        } catch (e: any) {\n          throw new InternalError(\n            sf(\n              \"Failed to parse initial value for sequence {0}: {1}\",\n              startWith.toString(),\n              e\n            )\n          );\n        }\n      }\n      throw new InternalError(\n        sf(\n          \"Failed to retrieve current value for sequence {0}: {1}\",\n          name as string,\n          e\n        )\n      );\n    }\n  }\n\n  /**\n   * @summary Parses the {@link Sequence} value\n   *\n   * @protected\n   * @param value\n   */\n  private parse(value: string | number | bigint): string | number | bigint {\n    return parseSequenceValue(this.options.type, value);\n  }\n\n  /**\n   * @summary increments the sequence\n   * @description Sequence specific implementation\n   *\n   * @param {string | number | bigint} current\n   * @param count\n   * @protected\n   */\n  private async increment(\n    current: string | number | bigint,\n    count?: number\n  ): Promise<string | number | bigint> {\n    const { type, incrementBy, name } = this.options;\n    let next: string | number | bigint;\n    const toIncrementBy = count || incrementBy;\n    if (toIncrementBy % incrementBy !== 0)\n      throw new InternalError(\n        `Value to increment does not consider the incrementBy setting: ${incrementBy}`\n      );\n    switch (type) {\n      case \"Number\":\n        next = (this.parse(current) as number) + toIncrementBy;\n        break;\n      case \"BigInt\":\n        next = (this.parse(current) as bigint) + BigInt(toIncrementBy);\n        break;\n      default:\n        throw new InternalError(\"Should never happen\");\n    }\n    let seq: Seq;\n    try {\n      seq = await this.repo.update(new Seq({ id: name, current: next }));\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) throw e;\n      seq = await this.repo.create(new Seq({ id: name, current: next }));\n    }\n\n    return seq.current as string | number | bigint;\n  }\n\n  /**\n   * @summary Generates the next value in th sequence\n   * @description calls {@link Sequence#parse} on the current value\n   * followed by {@link Sequence#increment}\n   *\n   */\n  async next(): Promise<number | string | bigint> {\n    const current = await this.current();\n    return this.increment(current);\n  }\n\n  async range(count: number): Promise<(number | string | bigint)[]> {\n    const current = (await this.current()) as number;\n    const incrementBy = this.parse(this.options.incrementBy) as number;\n    const next: string | number | bigint = await this.increment(\n      current,\n      (this.parse(count) as number) * incrementBy\n    );\n    const range: (number | string | bigint)[] = [];\n    for (let i: number = 1; i <= count; i++) {\n      range.push(current + incrementBy * (this.parse(i) as number));\n    }\n    if (range[range.length - 1] !== next)\n      throw new InternalError(\"Miscalculation of range\");\n    return range;\n  }\n}\n","import {\n  Paginator,\n  PagingError,\n  SequenceOptions,\n  Statement,\n} from \"@decaf-ts/core\";\nimport {\n  DefaultSeparator,\n  findPrimaryKey,\n  InternalError,\n} from \"@decaf-ts/db-decorators\";\nimport { parseSequenceValue } from \"../sequences/utils\";\nimport { MangoQuery, MangoResponse } from \"../types\";\n\nexport class CouchDBPaginator<V> extends Paginator<V, MangoQuery> {\n  private bookMark?: string;\n\n  get total(): number {\n    throw new InternalError(`The total pages api is not available for couchdb`);\n  }\n\n  get count(): number {\n    throw new InternalError(\n      `The record count api is not available for couchdb`\n    );\n  }\n\n  constructor(\n    statement: Statement<MangoQuery>,\n    size: number,\n    rawStatement: MangoQuery\n  ) {\n    super(statement, size, rawStatement);\n  }\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  async page(page: number = 1, ...args: any[]): Promise<V[]> {\n    const statement = Object.assign({}, this.statement);\n    const target = this.stat.getTarget();\n    // if (!this._recordCount || !this._totalPages) {\n    //   // this._recordCount = await this.adapter\n    //   //   .Query()\n    //   //   .count()\n    //   //   .from(target)\n    //   //   .execute<number>();\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      ...args\n    );\n\n    const { docs, bookmark, warning } = rawResult;\n    if (warning) console.warn(warning);\n    if (!target) throw new PagingError(\"No statement target defined\");\n    const pkDef = findPrimaryKey(new target()) as {\n      id: string;\n      props: SequenceOptions;\n    };\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            if (!target) throw new PagingError(\"No statement target defined\");\n            const pk = pkDef.id;\n            const originalId = d._id.split(DefaultSeparator);\n            originalId.splice(0, 1); // remove the table name\n            return this.adapter.revert(\n              d,\n              target,\n              pk,\n              parseSequenceValue(\n                pkDef.props.type,\n                originalId.join(DefaultSeparator)\n              )\n            );\n          });\n    this.bookMark = bookmark;\n    this._currentPage = page;\n    return results;\n  }\n}\n","import { Adapter, Statement } from \"@decaf-ts/core\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\nimport { Constructor } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBKeys } from \"../constants\";\nimport { parseSequenceValue } from \"../sequences/utils\";\nimport { Paginator } from \"@decaf-ts/core\";\nimport { CouchDBPaginator } from \"./Paginator\";\nimport { MangoQuery } from \"../types\";\n\nexport class CouchDBStatement<Y> extends Statement<MangoQuery> {\n  constructor(adapter: Adapter<Y, MangoQuery, any, any>) {\n    super(adapter);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  async execute<Y>(): Promise<Y> {\n    try {\n      const query: MangoQuery = this.build();\n      if (!query.limit) query.limit = Number.MAX_SAFE_INTEGER;\n      return this.raw(query);\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  async paginate<R>(size: number): Promise<Paginator<R, MangoQuery>> {\n    try {\n      const query: MangoQuery = this.build();\n      return new CouchDBPaginator(this, size, query);\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  private processRecord(\n    r: any,\n    pkAttr: string,\n    sequenceType: \"Number\" | \"BigInt\" | undefined\n  ) {\n    if (!r[CouchDBKeys.ID])\n      throw new InternalError(\n        `No CouchDB Id definition found. Should not be possible`\n      );\n    const [, ...keyArgs] = r[CouchDBKeys.ID].split(\"_\");\n\n    const id = keyArgs.join(\"_\");\n    return this.adapter.revert(\n      r,\n      this.target as Constructor<any>,\n      pkAttr,\n      parseSequenceValue(sequenceType, id)\n    ) as any;\n  }\n\n  async raw<R>(rawInput: MangoQuery, ...args: any[]): Promise<R> {\n    const results = await this.adapter.raw<R>(rawInput, true, ...args);\n    if (!this.fullRecord) return results;\n    if (!this.target)\n      throw new InternalError(\n        \"No target defined in statement. should never happen\"\n      );\n\n    const pkDef = findPrimaryKey(new this.target() as any);\n    const pkAttr = pkDef.id;\n    const type = pkDef.props.type;\n    if (Array.isArray(results))\n      return results.map((r) =>\n        this.processRecord(r, pkAttr as string, type)\n      ) as R;\n    return this.processRecord(results, pkAttr as string, type) as R;\n  }\n}\n","import { FromClause } from \"@decaf-ts/core\";\nimport { ModelArg, Model, Constructor } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBKeys } from \"../constants\";\nimport { Repository } from \"@decaf-ts/core\";\nimport { MangoQuery } from \"../types\";\n\n// noinspection JSAnnotator\nexport class CouchDBFromClause<M extends Model> extends FromClause<\n  MangoQuery,\n  M\n> {\n  constructor(clause: ModelArg<FromClause<MangoQuery, M>>) {\n    super(clause);\n  }\n\n  build(previous: MangoQuery): MangoQuery {\n    const selectors: any = {};\n    selectors[CouchDBKeys.TABLE] = {};\n    selectors[CouchDBKeys.TABLE] =\n      typeof this.selector === \"string\"\n        ? this.selector\n        : Repository.table(this.selector as Constructor<M>);\n    previous.selector = selectors;\n    return previous;\n  }\n}\n","import { InsertClause } from \"@decaf-ts/core\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { MangoQuery } from \"../types\";\n\n// noinspection JSAnnotator\nexport class CouchDBInsertClause<M extends Model> extends InsertClause<\n  MangoQuery,\n  M\n> {\n  constructor(clause: ModelArg<InsertClause<MangoQuery, M>>) {\n    super(clause);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  build(query: MangoQuery): MangoQuery {\n    throw new InternalError(\"Not supported\");\n  }\n}\n","import { Condition, WhereClause } from \"@decaf-ts/core\";\nimport { ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBGroupOperator } from \"./constants\";\nimport { sf } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBKeys } from \"../constants\";\nimport { MangoOperator, MangoQuery, MangoSelector } from \"../types\";\n\nexport class CouchDBWhereClause extends WhereClause<MangoQuery> {\n  constructor(clause: ModelArg<WhereClause<MangoQuery>>) {\n    super(clause);\n  }\n\n  build(query: MangoQuery): MangoQuery {\n    const condition: MangoSelector = this.adapter.parseCondition(\n      Condition.and(\n        this.condition as Condition,\n        Condition.attribute(CouchDBKeys.TABLE).eq(\n          query.selector[CouchDBKeys.TABLE]\n        )\n      )\n    ).selector;\n\n    const selectorKeys = Object.keys(condition) as MangoOperator[];\n    if (\n      selectorKeys.length === 1 &&\n      Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1\n    )\n      switch (selectorKeys[0]) {\n        case CouchDBGroupOperator.AND:\n          condition[CouchDBGroupOperator.AND] = [\n            ...Object.values(\n              condition[CouchDBGroupOperator.AND] as MangoSelector\n            ).reduce((accum: MangoSelector[], val: any) => {\n              const keys = Object.keys(val);\n              if (keys.length !== 1)\n                throw new Error(\n                  \"Too many keys in query selector. should be one\"\n                );\n              const k = keys[0];\n              if (k === CouchDBGroupOperator.AND)\n                accum.push(...(val[k] as any[]));\n              else accum.push(val);\n              return accum;\n            }, []),\n          ];\n          query.selector = condition;\n          break;\n        case CouchDBGroupOperator.OR: {\n          const s: Record<any, any> = {};\n          s[CouchDBGroupOperator.AND] = [\n            condition,\n            ...Object.entries(query.selector).map(([key, val]) => {\n              const result: Record<any, any> = {};\n              result[key] = val;\n              return result;\n            }),\n          ];\n          query.selector = s;\n          break;\n        }\n        default:\n          throw new Error(\"This should be impossible\");\n      }\n    else {\n      Object.entries(condition).forEach(([key, val]) => {\n        if (query.selector[key])\n          console.warn(\n            sf(\n              \"A {0} query param is about to be overridden: {1} by {2}\",\n              key,\n              query.selector[key] as unknown as string,\n              val as unknown as string\n            )\n          );\n        query.selector[key] = val;\n      });\n    }\n\n    return query;\n  }\n}\n","import { Const, SelectClause } from \"@decaf-ts/core\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { MangoQuery } from \"../types\";\n\nexport class CouchDBSelectClause<M extends Model> extends SelectClause<\n  MangoQuery,\n  M\n> {\n  constructor(clause: ModelArg<SelectClause<MangoQuery, M>>) {\n    super(clause);\n  }\n\n  build(query: MangoQuery): MangoQuery {\n    if (!this.selector || this.selector === Const.FULL_RECORD) return query;\n    query.fields =\n      typeof this.selector === \"string\"\n        ? [this.selector as string]\n        : (this.selector as string[]);\n    return query;\n  }\n}\n","import { ValuesClause } from \"@decaf-ts/core\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { MangoQuery } from \"../types\";\n\nexport class CouchDBValuesClause<M extends Model> extends ValuesClause<\n  MangoQuery,\n  M\n> {\n  constructor(clause: ModelArg<ValuesClause<MangoQuery, M>>) {\n    super(clause);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  build(previous: MangoQuery): MangoQuery {\n    throw new InternalError(\"Not implemented\");\n  }\n}\n","import {\n  ClauseFactory,\n  Condition,\n  FromClause,\n  FromSelector,\n  GroupBySelector,\n  LimitSelector,\n  OffsetSelector,\n  OrderBySelector,\n  QueryError,\n  SelectSelector,\n  Statement,\n} from \"@decaf-ts/core\";\nimport { LimitClause } from \"@decaf-ts/core\";\nimport { SelectClause } from \"@decaf-ts/core\";\nimport { WhereClause } from \"@decaf-ts/core\";\nimport { OffsetClause } from \"@decaf-ts/core\";\nimport { OrderByClause } from \"@decaf-ts/core\";\nimport { GroupByClause } from \"@decaf-ts/core\";\nimport { ValuesClause } from \"@decaf-ts/core\";\nimport { InsertClause } from \"@decaf-ts/core\";\nimport { CouchDBFromClause } from \"./FromClause\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport {\n  Context,\n  InternalError,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { CouchDBInsertClause } from \"./InsertClause\";\nimport { CouchDBStatement } from \"./Statement\";\nimport { CouchDBWhereClause } from \"./WhereClause\";\nimport { CouchDBSelectClause } from \"./SelectClause\";\nimport { CouchDBValuesClause } from \"./ValuesClause\";\nimport { CouchDBOperator } from \"./constants\";\nimport { CouchDBAdapter } from \"../adapter\";\nimport { MangoQuery, MangoSelector } from \"../types\";\n\nexport class Factory<\n  Y,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n> extends ClauseFactory<Y, MangoQuery, CouchDBAdapter<Y, F, C>> {\n  constructor(adapter: CouchDBAdapter<Y, F, C>) {\n    super(adapter);\n  }\n\n  from<M extends Model>(\n    statement: Statement<MangoQuery>,\n    selector: FromSelector<M>\n  ): FromClause<MangoQuery, M> {\n    return new CouchDBFromClause({ statement: statement, selector: selector });\n  }\n\n  groupBy(\n    statement: Statement<MangoQuery>,\n    selector: GroupBySelector\n  ): GroupByClause<MangoQuery> {\n    return new (class extends GroupByClause<MangoQuery> {\n      constructor(clause: ModelArg<GroupByClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      build(query: MangoQuery): MangoQuery {\n        throw new InternalError(\"Not implemented\");\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  insert<M extends Model>(): InsertClause<MangoQuery, M> {\n    return new CouchDBInsertClause({\n      statement: new CouchDBStatement(this.adapter),\n    });\n  }\n\n  limit(\n    statement: Statement<MangoQuery>,\n    selector: LimitSelector\n  ): LimitClause<MangoQuery> {\n    return new (class extends LimitClause<MangoQuery> {\n      constructor(clause: ModelArg<LimitClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        query.limit = this.selector as number;\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  offset(\n    statement: Statement<MangoQuery>,\n    selector: OffsetSelector\n  ): OffsetClause<MangoQuery> {\n    return new (class extends OffsetClause<MangoQuery> {\n      constructor(clause: ModelArg<OffsetClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        const skip: number = parseInt(this.selector as unknown as string);\n        if (isNaN(skip)) throw new QueryError(\"Failed to parse offset\");\n        query.skip = skip;\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  orderBy(\n    statement: Statement<MangoQuery>,\n    selector: OrderBySelector[]\n  ): OrderByClause<MangoQuery> {\n    return new (class extends OrderByClause<MangoQuery> {\n      constructor(clause: ModelArg<OrderByClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        query.sort = query.sort || [];\n        query.selector = query.selector || ({} as MangoSelector);\n        this.selector!.forEach((s) => {\n          const [selector, value] = s;\n          const rec: any = {};\n          rec[selector] = value;\n          (query.sort as any[]).push(rec as any);\n          if (!query.selector[selector]) {\n            query.selector[selector] = {} as MangoSelector;\n            (query.selector[selector] as MangoSelector)[\n              CouchDBOperator.BIGGER\n            ] = null;\n          }\n          // query.fields = query.fields || [];\n          // query.fields = [...new Set([...query.fields, selector]).keys()]\n        });\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  select<M extends Model>(\n    selector: SelectSelector | undefined\n  ): SelectClause<MangoQuery, M> {\n    return new CouchDBSelectClause({\n      statement: new CouchDBStatement(this.adapter),\n      selector: selector,\n    });\n  }\n\n  values<M extends Model>(\n    statement: Statement<MangoQuery>,\n    values: M[]\n  ): ValuesClause<MangoQuery, M> {\n    return new CouchDBValuesClause<M>({\n      statement: statement,\n      values: values,\n    });\n  }\n\n  where(\n    statement: Statement<MangoQuery>,\n    condition: Condition\n  ): WhereClause<MangoQuery> {\n    return new CouchDBWhereClause({\n      statement: statement,\n      condition: condition,\n    });\n  }\n}\n","import { GroupOperator, Operator } from \"@decaf-ts/core\";\nimport { CouchDBGroupOperator, CouchDBOperator } from \"./constants\";\nimport { QueryError } from \"@decaf-ts/core\";\nimport { MangoOperator } from \"../types\";\n\nexport function translateOperators(\n  operator: GroupOperator | Operator\n): MangoOperator {\n  for (const operators of [CouchDBOperator, CouchDBGroupOperator]) {\n    const el = Object.keys(operators).find((k) => k === operator);\n    if (el) return operators[el];\n  }\n  throw new QueryError(\n    `Could not find adapter translation for operator ${operator}`\n  );\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\nexport class IndexError extends BaseError {\n  constructor(msg: string | Error) {\n    super(IndexError.name, msg);\n  }\n}\n","import {\n  Adapter,\n  Sequence,\n  SequenceOptions,\n  PersistenceKeys,\n  Operator,\n  GroupOperator,\n  Statement,\n  Query,\n  ClauseFactory,\n  Condition,\n  ConnectionError,\n  Repository,\n} from \"@decaf-ts/core\";\nimport { CouchDBKeys, reservedAttributes } from \"./constants\";\nimport {\n  BaseError,\n  ConflictError,\n  Context,\n  InternalError,\n  NotFoundError,\n  prefixMethod,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport \"reflect-metadata\";\nimport { CouchDBStatement } from \"./query/Statement\";\nimport { Factory } from \"./query\";\nimport { translateOperators } from \"./query/translate\";\nimport { CouchDBSequence } from \"./sequences/Sequence\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { IndexError } from \"./errors\";\nimport { MangoOperator, MangoQuery, MangoSelector } from \"./types\";\n\nexport abstract class CouchDBAdapter<\n  Y,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n> extends Adapter<Y, MangoQuery, F, C> {\n  protected factory?: Factory<Y, F, C>;\n\n  protected constructor(scope: Y, flavour: string) {\n    super(scope, flavour);\n    [this.create, this.createAll, this.update, this.updateAll].forEach((m) => {\n      const name = m.name;\n      prefixMethod(this, m, (this as any)[name + \"Prefix\"]);\n    });\n  }\n\n  get Clauses(): ClauseFactory<Y, MangoQuery, typeof this> {\n    if (!this.factory) this.factory = new Factory(this);\n    return this.factory as ClauseFactory<Y, MangoQuery, typeof this>;\n  }\n\n  Query<M extends Model>(): Query<MangoQuery, M> {\n    return super.Query();\n  }\n\n  get Statement(): Statement<MangoQuery> {\n    return new CouchDBStatement(this);\n  }\n\n  parseCondition(condition: Condition): MangoQuery {\n    function merge(\n      op: MangoOperator,\n      obj1: MangoSelector,\n      obj2: MangoSelector\n    ): MangoQuery {\n      const result: MangoQuery = { selector: {} as MangoSelector };\n      result.selector[op] = [obj1, obj2];\n      return result;\n    }\n\n    const { attr1, operator, comparison } = condition as unknown as {\n      attr1: string | Condition;\n      operator: Operator | GroupOperator;\n      comparison: any;\n    };\n\n    let op: MangoSelector = {} as MangoSelector;\n    if (\n      [GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(\n        operator as GroupOperator\n      ) === -1\n    ) {\n      op[attr1 as string] = {} as MangoSelector;\n      (op[attr1 as string] as MangoSelector)[translateOperators(operator)] =\n        comparison;\n    } else if (operator === Operator.NOT) {\n      op = this.parseCondition(attr1 as Condition).selector as MangoSelector;\n      op[translateOperators(Operator.NOT)] = {} as MangoSelector;\n      (op[translateOperators(Operator.NOT)] as MangoSelector)[\n        (attr1 as unknown as { attr1: string }).attr1\n      ] = comparison;\n    } else {\n      const op1: any = this.parseCondition(attr1 as Condition).selector;\n      const op2: any = this.parseCondition(comparison as Condition).selector;\n      op = merge(translateOperators(operator), op1, op2).selector;\n    }\n\n    return { selector: op };\n  }\n\n  async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new CouchDBSequence(options, this);\n  }\n\n  async initialize(): Promise<void> {\n    const managedModels = Adapter.models(this.flavour);\n    return this.index(...managedModels);\n  }\n\n  protected abstract index<M extends Model>(\n    ...models: Constructor<M>[]\n  ): Promise<void>;\n\n  abstract raw<V>(rawInput: MangoQuery, process: boolean): Promise<V>;\n\n  protected assignMetadata(\n    model: Record<string, any>,\n    rev: string\n  ): Record<string, any> {\n    Object.defineProperty(model, PersistenceKeys.METADATA, {\n      enumerable: false,\n      configurable: false,\n      writable: false,\n      value: rev,\n    });\n    return model;\n  }\n\n  protected assignMultipleMetadata(\n    models: Record<string, any>[],\n    revs: string[]\n  ): Record<string, any>[] {\n    models.forEach((m, i) => {\n      Repository.setMetadata(m as any, revs[i]);\n      return m;\n    });\n    return models;\n  }\n\n  protected createPrefix(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ) {\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    Object.assign(record, model);\n    return [tableName, id, record];\n  }\n\n  abstract create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ): Promise<Record<string, any>>;\n\n  protected createAllPrefix(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ) {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      record[CouchDBKeys.ID] = this.generateId(tableName, id);\n      Object.assign(record, models[count]);\n      return record;\n    });\n    return [tableName, ids, records];\n  }\n\n  abstract createAll(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ): Promise<Record<string, any>[]>;\n\n  abstract read(\n    tableName: string,\n    id: string | number\n  ): Promise<Record<string, any>>;\n\n  abstract readAll(\n    tableName: string,\n    ids: (string | number | bigint)[]\n  ): Promise<Record<string, any>[]>;\n\n  updatePrefix(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ) {\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    const rev = model[PersistenceKeys.METADATA];\n    if (!rev)\n      throw new InternalError(\n        `No revision number found for record with id ${id}`\n      );\n    Object.assign(record, model);\n    record[CouchDBKeys.REV] = rev;\n    return [tableName, id, record];\n  }\n\n  abstract update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ): Promise<Record<string, any>>;\n\n  protected updateAllPrefix(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ) {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      record[CouchDBKeys.ID] = this.generateId(tableName, id);\n      const rev = models[count][PersistenceKeys.METADATA];\n      if (!rev)\n        throw new InternalError(\n          `No revision number found for record with id ${id}`\n        );\n      Object.assign(record, models[count]);\n      record[CouchDBKeys.REV] = rev;\n      return record;\n    });\n    return [tableName, ids, records];\n  }\n\n  abstract updateAll(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ): Promise<Record<string, any>[]>;\n\n  abstract delete(\n    tableName: string,\n    id: string | number\n  ): Promise<Record<string, any>>;\n\n  abstract deleteAll(\n    tableName: string,\n    ids: (string | number | bigint)[]\n  ): Promise<Record<string, any>[]>;\n\n  protected generateId(tableName: string, id: string | number) {\n    return [tableName, id].join(CouchDBKeys.SEPARATOR);\n  }\n\n  parseError(err: Error | string, reason?: string): BaseError {\n    return CouchDBAdapter.parseError(err, reason);\n  }\n\n  protected isReserved(attr: string): boolean {\n    return !!attr.match(reservedAttributes);\n  }\n\n  protected static parseError(err: Error | string, reason?: string): BaseError {\n    if (err instanceof BaseError) return err as any;\n    let code: string = \"\";\n    if (typeof err === \"string\") {\n      code = err;\n      if (code.match(/already exist|update conflict/g))\n        return new ConflictError(code);\n      if (code.match(/missing|deleted/g)) return new NotFoundError(code);\n    } else if ((err as any).code) {\n      code = (err as any).code;\n      reason = reason || err.message;\n    } else if ((err as any).statusCode) {\n      code = (err as any).statusCode;\n      reason = reason || err.message;\n    } else {\n      code = err.message;\n    }\n\n    switch (code.toString()) {\n      case \"401\":\n      case \"412\":\n      case \"409\":\n        return new ConflictError(reason as string);\n      case \"404\":\n        return new NotFoundError(reason as string);\n      case \"400\":\n        if (code.toString().match(/No\\sindex\\sexists/g))\n          return new IndexError(err);\n        return new InternalError(err);\n      default:\n        if (code.toString().match(/ECONNREFUSED/g))\n          return new ConnectionError(err);\n        return new InternalError(err);\n    }\n  }\n}\n","import { OrderDirection, PersistenceKeys } from \"@decaf-ts/core\";\nimport { CouchDBKeys } from \"./constants\";\nimport { DefaultSeparator } from \"@decaf-ts/db-decorators\";\nimport { CouchDBOperator } from \"./query/constants\";\nimport { CreateIndexRequest, MangoSelector, SortOrder } from \"./types\";\n\nexport async function reAuth(con: any, user: string, pass: string) {\n  return con.auth(user, pass);\n}\n\nexport function wrapDocumentScope(\n  con: any,\n  dbName: string,\n  user: string,\n  pass: string\n): any {\n  const db = con.use(dbName);\n  [\"insert\", \"get\", \"put\", \"destroy\", \"find\"].forEach((k) => {\n    const original = (db as Record<string, any>)[k];\n    Object.defineProperty(db, k, {\n      enumerable: false,\n      configurable: true,\n      value: async (...args: any[]) => {\n        await reAuth(con, user, pass);\n        return original.call(db, ...args);\n      },\n    });\n  });\n  Object.defineProperty(db, CouchDBKeys.NATIVE, {\n    enumerable: false,\n    configurable: false,\n    writable: false,\n    value: con,\n  });\n  return db;\n}\n\nexport function testReservedAttributes(attr: string) {\n  const regexp = /^_.*$/g;\n  return attr.match(regexp);\n}\n\nexport function generateIndexName(\n  attribute: string,\n  tableName: string,\n  compositions?: string[],\n  order?: OrderDirection,\n  separator = DefaultSeparator\n): string {\n  const attr = [PersistenceKeys.INDEX, tableName, attribute];\n  if (compositions) attr.push(...compositions);\n  if (order) attr.push(order);\n  return attr.join(separator);\n}\n\nexport function generateIndexDoc(\n  attribute: string,\n  tableName: string,\n  compositions?: string[],\n  order?: OrderDirection,\n  separator = DefaultSeparator\n): CreateIndexRequest {\n  const partialFilterSelector: MangoSelector = {};\n  partialFilterSelector[CouchDBKeys.TABLE] = {} as MangoSelector;\n  (partialFilterSelector[CouchDBKeys.TABLE] as MangoSelector)[\n    CouchDBOperator.EQUAL\n  ] = tableName;\n  let fields: SortOrder[];\n  if (order) {\n    const orderProp: SortOrder = {};\n    orderProp[attribute] = order as \"asc\" | \"desc\";\n    const sortedCompositions: SortOrder[] = (compositions || []).map((c) => {\n      const r: SortOrder = {};\n      r[c] = order as \"asc\" | \"desc\";\n      return r;\n    });\n    const sortedTable: SortOrder = {};\n    sortedTable[CouchDBKeys.TABLE] = order as \"asc\" | \"desc\";\n    fields = [orderProp, ...sortedCompositions, sortedTable];\n  } else {\n    fields = [attribute, ...(compositions || []), CouchDBKeys.TABLE];\n  }\n  const name = generateIndexName(\n    attribute,\n    tableName,\n    compositions,\n    order,\n    separator\n  );\n  return {\n    index: {\n      fields: fields,\n      // partial_filter_selector: partialFilterSelector,\n    },\n    ddoc: [name, CouchDBKeys.DDOC].join(separator),\n    name: name,\n  };\n}\n","export * from \"./indexes\";\nexport * from \"./interfaces\";\nexport * from \"./model\";\nexport * from \"./sequences\";\nexport * from \"./adapter\";\nexport * from \"./constants\";\nexport * from \"./errors\";\nexport * from \"./types\";\nexport * from \"./utils\";\n\n/**\n * @summary Module summary\n * @description Module description\n * @module ts-workspace\n */\n\n/**\n * @summary Namespace summary\n * @description Namespace description\n * @namespace Namespace\n * @memberOf module:ts-workspace\n */\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:ts-workspace\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["generateIndexName","Sequence","Seq"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-couchdb.esm.cjs","sources":["../src/constants.ts","../src/query/constants.ts","../src/indexes/generator.ts","../src/model/CouchDBSequence.ts","../src/sequences/Sequence.ts","../src/errors.ts","../src/query/Paginator.ts","../src/query/translate.ts","../src/query/Statement.ts","../src/adapter.ts","../src/utils.ts","../src/index.ts"],"sourcesContent":["/**\n * @description Regular expression to identify reserved attributes in CouchDB\n * @summary Matches any attribute that starts with an underscore\n * @const reservedAttributes\n * @memberOf module:for-couchdb\n */\nexport const reservedAttributes = /^_.*$/g;\n\n/**\n * @description Key constants used in CouchDB operations\n * @summary Collection of string constants for CouchDB document properties and operations\n * @typedef {Object} CouchDBKeysType\n * @property {string} SEPARATOR - Separator used for combining table name and ID\n * @property {string} ID - CouchDB document ID field\n * @property {string} REV - CouchDB document revision field\n * @property {string} DELETED - CouchDB deleted document marker\n * @property {string} TABLE - Table name marker\n * @property {string} SEQUENCE - Sequence marker\n * @property {string} DDOC - Design document marker\n * @property {string} NATIVE - Native marker\n * @property {string} INDEX - Index marker\n * @memberOf module:for-couchdb\n */\n\n/**\n * @description Key constants used in CouchDB operations\n * @summary Collection of string constants for CouchDB document properties and operations\n * @const CouchDBKeys\n * @type {CouchDBKeysType}\n * @memberOf module:for-couchdb\n */\nexport const CouchDBKeys = {\n  SEPARATOR: \"__\",\n  ID: \"_id\",\n  REV: \"_rev\",\n  DELETED: \"_deleted\",\n  TABLE: \"??table\",\n  SEQUENCE: \"??sequence\",\n  DDOC: \"ddoc\",\n  NATIVE: \"__native\",\n  INDEX: \"index\",\n};\n","import { MangoOperator } from \"../types\";\n\n/**\n * @description Default query limit for CouchDB queries\n * @summary Maximum number of documents to return in a single query\n * @const CouchDBQueryLimit\n * @memberOf module:for-couchdb\n */\nexport const CouchDBQueryLimit = 250;\n\n/**\n * @description Mapping of operator names to CouchDB Mango query operators\n * @summary Constants for CouchDB comparison operators used in Mango queries\n * @typedef {Object} CouchDBOperatorType\n * @property {string} EQUAL - Equality operator ($eq)\n * @property {string} DIFFERENT - Inequality operator ($ne)\n * @property {string} BIGGER - Greater than operator ($gt)\n * @property {string} BIGGER_EQ - Greater than or equal operator ($gte)\n * @property {string} SMALLER - Less than operator ($lt)\n * @property {string} SMALLER_EQ - Less than or equal operator ($lte)\n * @property {string} NOT - Negation operator ($not)\n * @property {string} IN - In array operator ($in)\n * @property {string} REGEXP - Regular expression operator ($regex)\n * @const CouchDBOperator\n * @type {CouchDBOperatorType}\n * @memberOf module:for-couchdb\n */\nexport const CouchDBOperator: Record<string, MangoOperator> = {\n  EQUAL: \"$eq\",\n  DIFFERENT: \"$ne\",\n  BIGGER: \"$gt\",\n  BIGGER_EQ: \"$gte\",\n  SMALLER: \"$lt\",\n  SMALLER_EQ: \"$lte\",\n  // BETWEEN = \"BETWEEN\",\n  NOT: \"$not\",\n  IN: \"$in\",\n  // IS = \"IS\",\n  REGEXP: \"$regex\",\n};\n\n/**\n * @description Mapping of logical operator names to CouchDB Mango query operators\n * @summary Constants for CouchDB logical operators used in Mango queries\n * @typedef {Object} CouchDBGroupOperatorType\n * @property {string} AND - Logical AND operator ($and)\n * @property {string} OR - Logical OR operator ($or)\n * @const CouchDBGroupOperator\n * @type {CouchDBGroupOperatorType}\n * @memberOf module:for-couchdb\n */\nexport const CouchDBGroupOperator: Record<string, MangoOperator> = {\n  AND: \"$and\",\n  OR: \"$or\",\n};\n\n/**\n * @description Special constant values used in CouchDB queries\n * @summary String constants representing special values in CouchDB\n * @typedef {Object} CouchDBConstType\n * @property {string} NULL - String representation of null value\n * @const CouchDBConst\n * @type {CouchDBConstType}\n * @memberOf module:for-couchdb\n */\nexport const CouchDBConst: Record<string, string> = {\n  NULL: \"null\",\n};\n","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","import type { ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { model, required } from \"@decaf-ts/decorator-validation\";\nimport { BaseModel, pk, index, table } from \"@decaf-ts/core\";\nimport { CouchDBKeys } from \"../constants\";\n\n/**\n * @description Model for CouchDB sequence records\n * @summary Represents a sequence in CouchDB used for generating sequential IDs\n * @param {ModelArg<Sequence>} [seq] - Optional initialization data for the sequence\n * @class\n * @example\n * // Example of creating and using a Sequence\n * const sequence = new Sequence({ id: 'user-seq', current: 1 });\n * // Increment the sequence\n * sequence.current = Number(sequence.current) + 1;\n */\n@table(CouchDBKeys.SEQUENCE)\n@model()\nexport class Sequence extends BaseModel {\n  /**\n   * @description The unique identifier for the sequence\n   * @summary Primary key for the sequence record\n   */\n  @pk()\n  id!: string;\n\n  /**\n   * @description The current value of the sequence\n   * @summary Current sequence value that can be incremented\n   */\n  @required()\n  @index()\n  current!: string | number;\n\n  constructor(seq?: ModelArg<Sequence>) {\n    super(seq);\n  }\n}\n","import { Sequence as Seq } from \"../model/CouchDBSequence\";\nimport { InternalError, NotFoundError } from \"@decaf-ts/db-decorators\";\nimport { Adapter, Repository, SequenceOptions } from \"@decaf-ts/core\";\nimport { Sequence } from \"@decaf-ts/core\";\nimport { MangoQuery } from \"../types\";\nimport { CouchDBRepository } from \"../interfaces\";\n\n/**\n * @summary Abstract implementation of a Sequence\n * @description provides the basic functionality for {@link Sequence}s\n *\n * @param {SequenceOptions} options\n *\n * @class CouchDBSequence\n * @implements Sequence\n */\nexport class CouchDBSequence extends Sequence {\n  protected repo: CouchDBRepository<Seq, any, any, any>;\n\n  constructor(\n    options: SequenceOptions,\n    adapter: Adapter<any, MangoQuery, any, any>\n  ) {\n    super(options);\n    this.repo = Repository.forModel(Seq, adapter.alias);\n  }\n\n  /**\n   * @summary Retrieves the current value for the sequence\n   * @protected\n   */\n  async current(): Promise<string | number | bigint> {\n    const { name, startWith } = this.options;\n    try {\n      const sequence: Seq = await this.repo.read(name as string);\n      return this.parse(sequence.current as string | number);\n    } catch (e: any) {\n      if (e instanceof NotFoundError) {\n        if (typeof startWith === \"undefined\")\n          throw new InternalError(\n            \"Starting value is not defined for a non existing sequence\"\n          );\n        try {\n          return this.parse(startWith);\n        } catch (e: unknown) {\n          throw new InternalError(\n            `Failed to parse initial value for sequence ${startWith}: ${e}`\n          );\n        }\n      }\n      throw new InternalError(\n        `Failed to retrieve current value for sequence ${name}: ${e}`\n      );\n    }\n  }\n\n  /**\n   * @summary Parses the {@link Sequence} value\n   *\n   * @protected\n   * @param value\n   */\n  private parse(value: string | number | bigint): string | number | bigint {\n    return Sequence.parseValue(this.options.type, value);\n  }\n\n  /**\n   * @summary increments the sequence\n   * @description Sequence specific implementation\n   *\n   * @param {string | number | bigint} current\n   * @param count\n   * @protected\n   */\n  private async increment(\n    current: string | number | bigint,\n    count?: number\n  ): Promise<string | number | bigint> {\n    const { type, incrementBy, name } = this.options;\n    let next: string | number | bigint;\n    const toIncrementBy = count || incrementBy;\n    if (toIncrementBy % incrementBy !== 0)\n      throw new InternalError(\n        `Value to increment does not consider the incrementBy setting: ${incrementBy}`\n      );\n    switch (type) {\n      case \"Number\":\n        next = (this.parse(current) as number) + toIncrementBy;\n        break;\n      case \"BigInt\":\n        next = (this.parse(current) as bigint) + BigInt(toIncrementBy);\n        break;\n      default:\n        throw new InternalError(\"Should never happen\");\n    }\n    let seq: Seq;\n    try {\n      seq = await this.repo.update(new Seq({ id: name, current: next }));\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) throw e;\n      seq = await this.repo.create(new Seq({ id: name, current: next }));\n    }\n\n    return seq.current as string | number | bigint;\n  }\n\n  /**\n   * @summary Generates the next value in th sequence\n   * @description calls {@link Sequence#parse} on the current value\n   * followed by {@link Sequence#increment}\n   *\n   */\n  async next(): Promise<number | string | bigint> {\n    const current = await this.current();\n    return this.increment(current);\n  }\n\n  async range(count: number): Promise<(number | string | bigint)[]> {\n    const current = (await this.current()) as number;\n    const incrementBy = this.parse(this.options.incrementBy) as number;\n    const next: string | number | bigint = await this.increment(\n      current,\n      (this.parse(count) as number) * incrementBy\n    );\n    const range: (number | string | bigint)[] = [];\n    for (let i: number = 1; i <= count; i++) {\n      range.push(current + incrementBy * (this.parse(i) as number));\n    }\n    if (range[range.length - 1] !== next)\n      throw new InternalError(\"Miscalculation of range\");\n    return range;\n  }\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Error thrown when there is an issue with CouchDB indexes\n * @summary Represents an error related to CouchDB index operations\n * @param {string|Error} msg - The error message or Error object\n * @class\n * @category Errors\n * @example\n * // Example of using IndexError\n * try {\n *   // Some code that might throw an index error\n *   throw new IndexError(\"Index not found\");\n * } catch (error) {\n *   if (error instanceof IndexError) {\n *     console.error(\"Index error occurred:\", error.message);\n *   }\n * }\n */\nexport class IndexError extends BaseError {\n  constructor(msg: string | Error) {\n    super(IndexError.name, msg, 404);\n  }\n}\n","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","import { GroupOperator, Operator } from \"@decaf-ts/core\";\nimport { CouchDBGroupOperator, CouchDBOperator } from \"./constants\";\nimport { QueryError } from \"@decaf-ts/core\";\nimport { MangoOperator } from \"../types\";\n\n/**\n * @description Translates core operators to CouchDB Mango operators\n * @summary Converts Decaf.ts core operators to their equivalent CouchDB Mango query operators\n * @param {GroupOperator | Operator} operator - The core operator to translate\n * @return {MangoOperator} The equivalent CouchDB Mango operator\n * @throws {QueryError} If no translation exists for the given operator\n * @function translateOperators\n * @memberOf module:for-couchdb\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant translateOperators\n *   participant CouchDBOperator\n *   participant CouchDBGroupOperator\n *   \n *   Caller->>translateOperators: operator\n *   \n *   translateOperators->>CouchDBOperator: Check for match\n *   alt Found in CouchDBOperator\n *     CouchDBOperator-->>translateOperators: Return matching operator\n *     translateOperators-->>Caller: Return MangoOperator\n *   else Not found\n *     translateOperators->>CouchDBGroupOperator: Check for match\n *     alt Found in CouchDBGroupOperator\n *       CouchDBGroupOperator-->>translateOperators: Return matching operator\n *       translateOperators-->>Caller: Return MangoOperator\n *     else Not found\n *       translateOperators-->>Caller: Throw QueryError\n *     end\n *   end\n */\nexport function translateOperators(\n  operator: GroupOperator | Operator\n): MangoOperator {\n  for (const operators of [CouchDBOperator, CouchDBGroupOperator]) {\n    const el = Object.keys(operators).find((k) => k === operator);\n    if (el) return operators[el];\n  }\n  throw new QueryError(\n    `Could not find adapter translation for operator ${operator}`\n  );\n}\n","import {\n  Condition,\n  GroupOperator,\n  Operator,\n  OrderDirection,\n  Paginator,\n  Repository,\n  Sequence,\n  Statement,\n} from \"@decaf-ts/core\";\nimport { MangoOperator, MangoQuery, MangoSelector } from \"../types\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBAdapter } from \"../adapter\";\nimport { translateOperators } from \"./translate\";\nimport { CouchDBKeys } from \"../constants\";\nimport {\n  CouchDBGroupOperator,\n  CouchDBOperator,\n  CouchDBQueryLimit,\n} from \"./constants\";\nimport { CouchDBPaginator } from \"./Paginator\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Statement builder for CouchDB Mango queries\n * @summary Provides a fluent interface for building CouchDB Mango queries with type safety\n * @template M - The model type that extends Model\n * @template R - The result type\n * @param adapter - The CouchDB adapter\n * @class CouchDBStatement\n * @example\n * // Example of using CouchDBStatement\n * const adapter = new MyCouchDBAdapter(scope);\n * const statement = new CouchDBStatement<User, User[]>(adapter);\n *\n * // Build a query\n * const users = await statement\n *   .from(User)\n *   .where(Condition.attribute<User>('age').gt(18))\n *   .orderBy('lastName', 'asc')\n *   .limit(10)\n *   .execute();\n */\nexport class CouchDBStatement<M extends Model, R> extends Statement<\n  MangoQuery,\n  M,\n  R\n> {\n  constructor(adapter: CouchDBAdapter<any, any, any>) {\n    super(adapter);\n  }\n\n  /**\n   * @description Builds a CouchDB Mango query from the statement\n   * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query\n   * @return {MangoQuery} The built Mango query\n   * @throws {Error} If there are invalid query conditions\n   * @mermaid\n   * sequenceDiagram\n   *   participant Statement\n   *   participant Repository\n   *   participant parseCondition\n   *\n   *   Statement->>Statement: build()\n   *   Note over Statement: Initialize selectors\n   *   Statement->>Repository: Get table name\n   *   Repository-->>Statement: Return table name\n   *   Statement->>Statement: Create base query\n   *\n   *   alt Has selectSelector\n   *     Statement->>Statement: Add fields to query\n   *   end\n   *\n   *   alt Has whereCondition\n   *     Statement->>Statement: Create combined condition with table\n   *     Statement->>parseCondition: Parse condition\n   *     parseCondition-->>Statement: Return parsed condition\n   *\n   *     alt Is group operator\n   *       alt Is AND operator\n   *         Statement->>Statement: Flatten nested AND conditions\n   *       else Is OR operator\n   *         Statement->>Statement: Combine with table condition\n   *       else\n   *         Statement->>Statement: Throw error\n   *       end\n   *     else\n   *       Statement->>Statement: Merge conditions with existing selector\n   *     end\n   *   end\n   *\n   *   alt Has orderBySelector\n   *     Statement->>Statement: Add sort to query\n   *     Statement->>Statement: Ensure field exists in selector\n   *   end\n   *\n   *   alt Has limitSelector\n   *     Statement->>Statement: Set limit\n   *   else\n   *     Statement->>Statement: Use default limit\n   *   end\n   *\n   *   alt Has offsetSelector\n   *     Statement->>Statement: Set skip\n   *   end\n   *\n   *   Statement-->>Statement: Return query\n   */\n  protected build(): MangoQuery {\n    const selectors: MangoSelector = {};\n    selectors[CouchDBKeys.TABLE] = {};\n    selectors[CouchDBKeys.TABLE] = Repository.table(this.fromSelector);\n    const query: MangoQuery = { selector: selectors };\n    if (this.selectSelector) query.fields = this.selectSelector as string[];\n\n    if (this.whereCondition) {\n      const condition: MangoSelector = this.parseCondition(\n        Condition.and(\n          this.whereCondition,\n          Condition.attribute<M>(CouchDBKeys.TABLE as keyof M).eq(\n            query.selector[CouchDBKeys.TABLE]\n          )\n        )\n      ).selector;\n      const selectorKeys = Object.keys(condition) as MangoOperator[];\n      if (\n        selectorKeys.length === 1 &&\n        Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1\n      )\n        switch (selectorKeys[0]) {\n          case CouchDBGroupOperator.AND:\n            condition[CouchDBGroupOperator.AND] = [\n              ...Object.values(\n                condition[CouchDBGroupOperator.AND] as MangoSelector\n              ).reduce((accum: MangoSelector[], val: any) => {\n                const keys = Object.keys(val);\n                if (keys.length !== 1)\n                  throw new Error(\n                    \"Too many keys in query selector. should be one\"\n                  );\n                const k = keys[0];\n                if (k === CouchDBGroupOperator.AND)\n                  accum.push(...(val[k] as any[]));\n                else accum.push(val);\n                return accum;\n              }, []),\n            ];\n            query.selector = condition;\n            break;\n          case CouchDBGroupOperator.OR: {\n            const s: Record<any, any> = {};\n            s[CouchDBGroupOperator.AND] = [\n              condition,\n              ...Object.entries(query.selector).map(([key, val]) => {\n                const result: Record<any, any> = {};\n                result[key] = val;\n                return result;\n              }),\n            ];\n            query.selector = s;\n            break;\n          }\n          default:\n            throw new Error(\"This should be impossible\");\n        }\n      else {\n        Object.entries(condition).forEach(([key, val]) => {\n          if (query.selector[key])\n            console.warn(\n              `A ${key} query param is about to be overridden: ${query.selector[key]} by ${val}`\n            );\n          query.selector[key] = val;\n        });\n      }\n    }\n\n    if (this.orderBySelector) {\n      query.sort = query.sort || [];\n      query.selector = query.selector || ({} as MangoSelector);\n      const [selector, value] = this.orderBySelector as [\n        string,\n        OrderDirection,\n      ];\n      const rec: any = {};\n      rec[selector] = value;\n      (query.sort as any[]).push(rec as any);\n      if (!query.selector[selector]) {\n        query.selector[selector] = {} as MangoSelector;\n        (query.selector[selector] as MangoSelector)[CouchDBOperator.BIGGER] =\n          null;\n      }\n    }\n\n    if (this.limitSelector) {\n      query.limit = this.limitSelector;\n    } else {\n      console.warn(\n        `No limit selector defined. Using default couchdb limit of ${CouchDBQueryLimit}`\n      );\n      query.limit = CouchDBQueryLimit;\n    }\n\n    if (this.offsetSelector) query.skip = this.offsetSelector;\n\n    return query;\n  }\n\n  /**\n   * @description Creates a paginator for the statement\n   * @summary Builds the query and returns a CouchDBPaginator for paginated results\n   * @template R - The result type\n   * @param {number} size - The page size\n   * @return {Promise<Paginator<M, R, MangoQuery>>} A promise that resolves to a paginator\n   * @throws {InternalError} If there's an error building the query\n   */\n  async paginate<R>(size: number): Promise<Paginator<M, R, MangoQuery>> {\n    try {\n      const query: MangoQuery = this.build();\n      return new CouchDBPaginator(\n        this.adapter as any,\n        query,\n        size,\n        this.fromSelector\n      );\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  /**\n   * @description Processes a record from CouchDB\n   * @summary Extracts the ID from a CouchDB document and reverts it to a model instance\n   * @param {any} r - The raw record from CouchDB\n   * @param pkAttr - The primary key attribute of the model\n   * @param {\"Number\" | \"BigInt\" | undefined} sequenceType - The type of the sequence\n   * @return {any} The processed record\n   */\n  private processRecord(\n    r: any,\n    pkAttr: keyof M,\n    sequenceType: \"Number\" | \"BigInt\" | undefined\n  ) {\n    if (r[CouchDBKeys.ID]) {\n      const [, ...keyArgs] = r[CouchDBKeys.ID].split(CouchDBKeys.SEPARATOR);\n\n      const id = keyArgs.join(\"_\");\n      return this.adapter.revert(\n        r,\n        this.fromSelector,\n        pkAttr,\n        Sequence.parseValue(sequenceType, id)\n      );\n    }\n    return r;\n  }\n\n  /**\n   * @description Executes a raw Mango query\n   * @summary Sends a raw Mango query to CouchDB and processes the results\n   * @template R - The result type\n   * @param {MangoQuery} rawInput - The raw Mango query to execute\n   * @return {Promise<R>} A promise that resolves to the query results\n   */\n  override async raw<R>(rawInput: MangoQuery): Promise<R> {\n    const results: any[] = await this.adapter.raw(rawInput, true);\n\n    const pkDef = findPrimaryKey(new this.fromSelector());\n    const pkAttr = pkDef.id;\n    const type = pkDef.props.type;\n\n    if (!this.selectSelector)\n      return results.map((r) => this.processRecord(r, pkAttr, type)) as R;\n    return results as R;\n  }\n\n  /**\n   * @description Parses a condition into a CouchDB Mango query selector\n   * @summary Converts a Condition object into a CouchDB Mango query selector structure\n   * @param {Condition<M>} condition - The condition to parse\n   * @return {MangoQuery} The Mango query with the parsed condition as its selector\n   * @mermaid\n   * sequenceDiagram\n   *   participant Statement\n   *   participant translateOperators\n   *   participant merge\n   *\n   *   Statement->>Statement: parseCondition(condition)\n   *\n   *   Note over Statement: Extract condition parts\n   *\n   *   alt Simple comparison operator\n   *     Statement->>translateOperators: translateOperators(operator)\n   *     translateOperators-->>Statement: Return CouchDB operator\n   *     Statement->>Statement: Create selector with attribute and operator\n   *   else NOT operator\n   *     Statement->>Statement: parseCondition(attr1)\n   *     Statement->>translateOperators: translateOperators(Operator.NOT)\n   *     translateOperators-->>Statement: Return CouchDB NOT operator\n   *     Statement->>Statement: Create negated selector\n   *   else AND/OR operator\n   *     Statement->>Statement: parseCondition(attr1)\n   *     Statement->>Statement: parseCondition(comparison)\n   *     Statement->>translateOperators: translateOperators(operator)\n   *     translateOperators-->>Statement: Return CouchDB group operator\n   *     Statement->>merge: merge(operator, op1, op2)\n   *     merge-->>Statement: Return merged selector\n   *   end\n   *\n   *   Statement-->>Statement: Return query with selector\n   */\n  protected parseCondition(condition: Condition<M>): MangoQuery {\n    /**\n     * @description Merges two selectors with a logical operator\n     * @summary Helper function to combine two selectors with a logical operator\n     * @param {MangoOperator} op - The operator to use for merging\n     * @param {MangoSelector} obj1 - The first selector\n     * @param {MangoSelector} obj2 - The second selector\n     * @return {MangoQuery} The merged query\n     */\n    function merge(\n      op: MangoOperator,\n      obj1: MangoSelector,\n      obj2: MangoSelector\n    ): MangoQuery {\n      const result: MangoQuery = { selector: {} as MangoSelector };\n      result.selector[op] = [obj1, obj2];\n      return result;\n    }\n\n    const { attr1, operator, comparison } = condition as unknown as {\n      attr1: string | Condition<M>;\n      operator: Operator | GroupOperator;\n      comparison: any;\n    };\n\n    let op: MangoSelector = {} as MangoSelector;\n    if (\n      [GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(\n        operator as GroupOperator\n      ) === -1\n    ) {\n      op[attr1 as string] = {} as MangoSelector;\n      (op[attr1 as string] as MangoSelector)[translateOperators(operator)] =\n        comparison;\n    } else if (operator === Operator.NOT) {\n      op = this.parseCondition(attr1 as Condition<M>).selector as MangoSelector;\n      op[translateOperators(Operator.NOT)] = {} as MangoSelector;\n      (op[translateOperators(Operator.NOT)] as MangoSelector)[\n        (attr1 as unknown as { attr1: string }).attr1\n      ] = comparison;\n    } else {\n      const op1: any = this.parseCondition(attr1 as Condition<M>).selector;\n      const op2: any = this.parseCondition(comparison as Condition<M>).selector;\n      op = merge(translateOperators(operator), op1, op2).selector;\n    }\n\n    return { selector: op };\n  }\n}\n","import {\n  Adapter,\n  Sequence,\n  type SequenceOptions,\n  PersistenceKeys,\n  ConnectionError,\n  Repository,\n} from \"@decaf-ts/core\";\nimport { CouchDBKeys, reservedAttributes } from \"./constants\";\nimport {\n  BaseError,\n  ConflictError,\n  Context,\n  InternalError,\n  NotFoundError,\n  prefixMethod,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport \"reflect-metadata\";\n\nimport { CouchDBSequence } from \"./sequences/Sequence\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { IndexError } from \"./errors\";\nimport { MangoQuery } from \"./types\";\nimport { CouchDBStatement } from \"./query\";\nimport { final } from \"@decaf-ts/core\";\n\n/**\n * @description Abstract adapter for CouchDB database operations\n * @summary Provides a base implementation for CouchDB database operations, including CRUD operations, sequence management, and error handling\n * @template Y - The scope type\n * @template F - The repository flags type\n * @template C - The context type\n * @param {Y} scope - The scope for the adapter\n * @param {string} flavour - The flavour of the adapter\n * @param {string} [alias] - Optional alias for the adapter\n * @class\n * @example\n * // Example of extending CouchDBAdapter\n * class MyCouchDBAdapter extends CouchDBAdapter<MyScope, MyFlags, MyContext> {\n *   constructor(scope: MyScope) {\n *     super(scope, 'my-couchdb', 'my-alias');\n *   }\n *\n *   // Implement abstract methods\n *   async index<M extends Model>(...models: Constructor<M>[]): Promise<void> {\n *     // Implementation\n *   }\n *\n *   async raw<R>(rawInput: MangoQuery, docsOnly: boolean): Promise<R> {\n *     // Implementation\n *   }\n *\n *   async create(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>> {\n *     // Implementation\n *   }\n *\n *   async read(tableName: string, id: string | number, ...args: any[]): Promise<Record<string, any>> {\n *     // Implementation\n *   }\n *\n *   async update(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>> {\n *     // Implementation\n *   }\n *\n *   async delete(tableName: string, id: string | number, ...args: any[]): Promise<Record<string, any>> {\n *     // Implementation\n *   }\n * }\n */\nexport abstract class CouchDBAdapter<\n  Y,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n> extends Adapter<Y, MangoQuery, F, C> {\n  protected constructor(scope: Y, flavour: string, alias?: string) {\n    super(scope, flavour, alias);\n    [this.create, this.createAll, this.update, this.updateAll].forEach((m) => {\n      const name = m.name;\n      prefixMethod(this, m, (this as any)[name + \"Prefix\"]);\n    });\n  }\n\n  /**\n   * @description Creates a new CouchDB statement for querying\n   * @summary Factory method that creates a new CouchDBStatement instance for building queries\n   * @template M - The model type\n   * @return {CouchDBStatement<M, any>} A new CouchDBStatement instance\n   */\n  @final()\n  Statement<M extends Model>(): CouchDBStatement<M, any> {\n    return new CouchDBStatement(this);\n  }\n\n  /**\n   * @description Creates a new CouchDB sequence\n   * @summary Factory method that creates a new CouchDBSequence instance for managing sequences\n   * @param {SequenceOptions} options - The options for the sequence\n   * @return {Promise<Sequence>} A promise that resolves to a new Sequence instance\n   */\n  @final()\n  async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new CouchDBSequence(options, this);\n  }\n\n  /**\n   * @description Initializes the adapter by creating indexes for all managed models\n   * @summary Sets up the necessary database indexes for all models managed by this adapter\n   * @return {Promise<void>} A promise that resolves when initialization is complete\n   */\n  async initialize(): Promise<void> {\n    const managedModels = Adapter.models(this.flavour);\n    return this.index(...managedModels);\n  }\n\n  /**\n   * @description Creates indexes for the given models\n   * @summary Abstract method that must be implemented to create database indexes for the specified models\n   * @template M - The model type\n   * @param {...Constructor<M>} models - The model constructors to create indexes for\n   * @return {Promise<void>} A promise that resolves when all indexes are created\n   */\n  protected abstract index<M extends Model>(\n    ...models: Constructor<M>[]\n  ): Promise<void>;\n\n  /**\n   * @description Executes a raw Mango query against the database\n   * @summary Abstract method that must be implemented to execute raw Mango queries\n   * @template R - The result type\n   * @param {MangoQuery} rawInput - The raw Mango query to execute\n   * @param {boolean} docsOnly - Whether to return only the documents or the full response\n   * @return {Promise<R>} A promise that resolves to the query result\n   */\n  abstract override raw<R>(rawInput: MangoQuery, docsOnly: boolean): Promise<R>;\n\n  /**\n   * @description Assigns metadata to a model\n   * @summary Adds revision metadata to a model as a non-enumerable property\n   * @param {Record<string, any>} model - The model to assign metadata to\n   * @param {string} rev - The revision string to assign\n   * @return {Record<string, any>} The model with metadata assigned\n   */\n  @final()\n  protected assignMetadata(\n    model: Record<string, any>,\n    rev: string\n  ): Record<string, any> {\n    Object.defineProperty(model, PersistenceKeys.METADATA, {\n      enumerable: false,\n      configurable: false,\n      writable: false,\n      value: rev,\n    });\n    return model;\n  }\n\n  /**\n   * @description Assigns metadata to multiple models\n   * @summary Adds revision metadata to multiple models as non-enumerable properties\n   * @param models - The models to assign metadata to\n   * @param {string[]} revs - The revision strings to assign\n   * @return The models with metadata assigned\n   */\n  @final()\n  protected assignMultipleMetadata(\n    models: Record<string, any>[],\n    revs: string[]\n  ): Record<string, any>[] {\n    models.forEach((m, i) => {\n      Repository.setMetadata(m as any, revs[i]);\n      return m;\n    });\n    return models;\n  }\n\n  /**\n   * @description Prepares a record for creation\n   * @summary Adds necessary CouchDB fields to a record before creation\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @param {Record<string, any>} model - The model to prepare\n   * @return A tuple containing the tableName, id, and prepared record\n   */\n  @final()\n  protected createPrefix(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ) {\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    Object.assign(record, model);\n    return [tableName, id, record];\n  }\n\n  /**\n   * @description Creates a new record in the database\n   * @summary Abstract method that must be implemented to create a new record\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @param {Record<string, any>} model - The model to create\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<Record<string, any>>} A promise that resolves to the created record\n   */\n  abstract override create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Prepares multiple records for creation\n   * @summary Adds necessary CouchDB fields to multiple records before creation\n   * @param {string} tableName - The name of the table\n   * @param {string[]|number[]} ids - The IDs of the records\n   * @param models - The models to prepare\n   * @return A tuple containing the tableName, ids, and prepared records\n   * @throws {InternalError} If ids and models arrays have different lengths\n   */\n  @final()\n  protected createAllPrefix(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ) {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      record[CouchDBKeys.ID] = this.generateId(tableName, id);\n      Object.assign(record, models[count]);\n      return record;\n    });\n    return [tableName, ids, records];\n  }\n\n  /**\n   * @description Reads a record from the database\n   * @summary Abstract method that must be implemented to read a record\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<Record<string, any>>} A promise that resolves to the read record\n   */\n  abstract override read(\n    tableName: string,\n    id: string | number,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Prepares a record for update\n   * @summary Adds necessary CouchDB fields to a record before update\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @param model - The model to prepare\n   * @return A tuple containing the tableName, id, and prepared record\n   * @throws {InternalError} If no revision number is found in the model\n   */\n  @final()\n  updatePrefix(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ) {\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    const rev = model[PersistenceKeys.METADATA];\n    if (!rev)\n      throw new InternalError(\n        `No revision number found for record with id ${id}`\n      );\n    Object.assign(record, model);\n    record[CouchDBKeys.REV] = rev;\n    return [tableName, id, record];\n  }\n\n  /**\n   * @description Updates a record in the database\n   * @summary Abstract method that must be implemented to update a record\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @param {Record<string, any>} model - The model to update\n   * @param {any[]} args - Additional arguments\n   * @return A promise that resolves to the updated record\n   */\n  abstract override update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Prepares multiple records for update\n   * @summary Adds necessary CouchDB fields to multiple records before update\n   * @param {string} tableName - The name of the table\n   * @param {string[]|number[]} ids - The IDs of the records\n   * @param models - The models to prepare\n   * @return A tuple containing the tableName, ids, and prepared records\n   * @throws {InternalError} If ids and models arrays have different lengths or if no revision number is found in a model\n   */\n  @final()\n  protected updateAllPrefix(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ) {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      record[CouchDBKeys.ID] = this.generateId(tableName, id);\n      const rev = models[count][PersistenceKeys.METADATA];\n      if (!rev)\n        throw new InternalError(\n          `No revision number found for record with id ${id}`\n        );\n      Object.assign(record, models[count]);\n      record[CouchDBKeys.REV] = rev;\n      return record;\n    });\n    return [tableName, ids, records];\n  }\n\n  /**\n   * @description Deletes a record from the database\n   * @summary Abstract method that must be implemented to delete a record\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @param {any[]} args - Additional arguments\n   * @return A promise that resolves to the deleted record\n   */\n  abstract override delete(\n    tableName: string,\n    id: string | number,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Generates a CouchDB document ID\n   * @summary Combines the table name and ID to create a CouchDB document ID\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @return {string} The generated CouchDB document ID\n   */\n  protected generateId(tableName: string, id: string | number) {\n    return [tableName, id].join(CouchDBKeys.SEPARATOR);\n  }\n\n  /**\n   * @description Parses an error and converts it to a BaseError\n   * @summary Converts various error types to appropriate BaseError subtypes\n   * @param {Error|string} err - The error to parse\n   * @param {string} [reason] - Optional reason for the error\n   * @return {BaseError} The parsed error as a BaseError\n   */\n  parseError(err: Error | string, reason?: string): BaseError {\n    return CouchDBAdapter.parseError(err, reason);\n  }\n\n  /**\n   * @description Checks if an attribute is reserved\n   * @summary Determines if an attribute name is reserved in CouchDB\n   * @param {string} attr - The attribute name to check\n   * @return {boolean} True if the attribute is reserved, false otherwise\n   */\n  protected override isReserved(attr: string): boolean {\n    return !!attr.match(reservedAttributes);\n  }\n\n  /**\n   * @description Static method to parse an error and convert it to a BaseError\n   * @summary Converts various error types to appropriate BaseError subtypes based on error codes and messages\n   * @param {Error|string} err - The error to parse\n   * @param {string} [reason] - Optional reason for the error\n   * @return {BaseError} The parsed error as a BaseError\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant parseError\n   *   participant ErrorTypes\n   *\n   *   Caller->>parseError: err, reason\n   *   Note over parseError: Check if err is already a BaseError\n   *   alt err is BaseError\n   *     parseError-->>Caller: return err\n   *   else err is string\n   *     Note over parseError: Extract code from string\n   *     alt code matches \"already exist|update conflict\"\n   *       parseError->>ErrorTypes: new ConflictError(code)\n   *       ErrorTypes-->>Caller: ConflictError\n   *     else code matches \"missing|deleted\"\n   *       parseError->>ErrorTypes: new NotFoundError(code)\n   *       ErrorTypes-->>Caller: NotFoundError\n   *     end\n   *   else err has code property\n   *     Note over parseError: Extract code and reason\n   *   else err has statusCode property\n   *     Note over parseError: Extract code and reason\n   *   else\n   *     Note over parseError: Use err.message as code\n   *   end\n   *\n   *   Note over parseError: Switch on code\n   *   alt code is 401, 412, or 409\n   *     parseError->>ErrorTypes: new ConflictError(reason)\n   *     ErrorTypes-->>Caller: ConflictError\n   *   else code is 404\n   *     parseError->>ErrorTypes: new NotFoundError(reason)\n   *     ErrorTypes-->>Caller: NotFoundError\n   *   else code is 400\n   *     alt code matches \"No index exists\"\n   *       parseError->>ErrorTypes: new IndexError(err)\n   *       ErrorTypes-->>Caller: IndexError\n   *     else\n   *       parseError->>ErrorTypes: new InternalError(err)\n   *       ErrorTypes-->>Caller: InternalError\n   *     end\n   *   else code matches \"ECONNREFUSED\"\n   *     parseError->>ErrorTypes: new ConnectionError(err)\n   *     ErrorTypes-->>Caller: ConnectionError\n   *   else\n   *     parseError->>ErrorTypes: new InternalError(err)\n   *     ErrorTypes-->>Caller: InternalError\n   *   end\n   */\n  protected static parseError(err: Error | string, reason?: string): BaseError {\n    if (err instanceof BaseError) return err as any;\n    let code: string = \"\";\n    if (typeof err === \"string\") {\n      code = err;\n      if (code.match(/already exist|update conflict/g))\n        return new ConflictError(code);\n      if (code.match(/missing|deleted/g)) return new NotFoundError(code);\n    } else if ((err as any).code) {\n      code = (err as any).code;\n      reason = reason || err.message;\n    } else if ((err as any).statusCode) {\n      code = (err as any).statusCode;\n      reason = reason || err.message;\n    } else {\n      code = err.message;\n    }\n\n    switch (code.toString()) {\n      case \"401\":\n      case \"412\":\n      case \"409\":\n        return new ConflictError(reason as string);\n      case \"404\":\n        return new NotFoundError(reason as string);\n      case \"400\":\n        if (code.toString().match(/No\\sindex\\sexists/g))\n          return new IndexError(err);\n        return new InternalError(err);\n      default:\n        if (code.toString().match(/ECONNREFUSED/g))\n          return new ConnectionError(err);\n        return new InternalError(err);\n    }\n  }\n}\n","import { OrderDirection, PersistenceKeys } from \"@decaf-ts/core\";\nimport { CouchDBKeys } from \"./constants\";\nimport { DefaultSeparator } from \"@decaf-ts/db-decorators\";\nimport { CouchDBOperator } from \"./query/constants\";\nimport { CreateIndexRequest, MangoSelector, SortOrder } from \"./types\";\n\n/**\n * @description Re-authenticates a connection to CouchDB\n * @summary Refreshes the authentication for a CouchDB connection using the provided credentials\n * @param {any} con - The CouchDB connection object\n * @param {string} user - The username for authentication\n * @param {string} pass - The password for authentication\n * @return {Promise<any>} A promise that resolves to the authentication result\n * @function reAuth\n * @memberOf module:for-couchdb\n */\nexport async function reAuth(con: any, user: string, pass: string) {\n  return con.auth(user, pass);\n}\n\n/**\n * @description Wraps a CouchDB database connection with automatic re-authentication\n * @summary Creates a proxy around a CouchDB database connection that automatically re-authenticates before each operation\n * @param {any} con - The CouchDB connection object\n * @param {string} dbName - The name of the database to use\n * @param {string} user - The username for authentication\n * @param {string} pass - The password for authentication\n * @return {any} The wrapped database connection object\n * @function wrapDocumentScope\n * @memberOf module:for-couchdb\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant wrapDocumentScope\n *   participant DB\n *   participant reAuth\n *   \n *   Client->>wrapDocumentScope: con, dbName, user, pass\n *   wrapDocumentScope->>DB: con.use(dbName)\n *   Note over wrapDocumentScope: Wrap DB methods with re-auth\n *   \n *   loop For each method (insert, get, put, destroy, find)\n *     wrapDocumentScope->>wrapDocumentScope: Store original method\n *     wrapDocumentScope->>wrapDocumentScope: Define new method with re-auth\n *   end\n *   \n *   wrapDocumentScope->>wrapDocumentScope: Add NATIVE property with con value\n *   wrapDocumentScope-->>Client: Return wrapped DB\n *   \n *   Note over Client: Later when client uses DB methods\n *   Client->>DB: Any wrapped method call\n *   DB->>reAuth: Authenticate before operation\n *   reAuth-->>DB: Authentication complete\n *   DB->>DB: Call original method\n *   DB-->>Client: Return result\n */\nexport function wrapDocumentScope(\n  con: any,\n  dbName: string,\n  user: string,\n  pass: string\n): any {\n  const db = con.use(dbName);\n  [\"insert\", \"get\", \"put\", \"destroy\", \"find\"].forEach((k) => {\n    const original = (db as Record<string, any>)[k];\n    Object.defineProperty(db, k, {\n      enumerable: false,\n      configurable: true,\n      value: async (...args: any[]) => {\n        await reAuth(con, user, pass);\n        return original.call(db, ...args);\n      },\n    });\n  });\n  Object.defineProperty(db, CouchDBKeys.NATIVE, {\n    enumerable: false,\n    configurable: false,\n    writable: false,\n    value: con,\n  });\n  return db;\n}\n\n/**\n * @description Tests if an attribute name is reserved in CouchDB\n * @summary Checks if an attribute name starts with an underscore, which indicates it's a reserved attribute in CouchDB\n * @param {string} attr - The attribute name to test\n * @return {RegExpMatchArray|null} The match result or null if no match\n * @function testReservedAttributes\n * @memberOf module:for-couchdb\n */\nexport function testReservedAttributes(attr: string) {\n  const regexp = /^_.*$/g;\n  return attr.match(regexp);\n}\n\n/**\n * @description Generates a name for a CouchDB index\n * @summary Creates a standardized name for a CouchDB index based on the table, attribute, compositions, and order\n * @param {string} attribute - The primary attribute for the index\n * @param {string} tableName - The name of the table\n * @param {string[]} [compositions] - Optional additional attributes to include in the index\n * @param {OrderDirection} [order] - Optional sort order for the index\n * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name\n * @return {string} The generated index name\n * @function generateIndexName\n * @memberOf module:for-couchdb\n */\nexport function generateIndexName(\n  attribute: string,\n  tableName: string,\n  compositions?: string[],\n  order?: OrderDirection,\n  separator = DefaultSeparator\n): string {\n  const attr = [PersistenceKeys.INDEX, tableName, attribute];\n  if (compositions) attr.push(...compositions);\n  if (order) attr.push(order);\n  return attr.join(separator);\n}\n\n/**\n * @description Generates a CouchDB index configuration\n * @summary Creates a complete CreateIndexRequest object for defining a CouchDB index based on specified parameters\n * @param {string} attribute - The primary attribute for the index\n * @param {string} tableName - The name of the table\n * @param {string[]} [compositions] - Optional additional attributes to include in the index\n * @param {OrderDirection} [order] - Optional sort order for the index\n * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name\n * @return {CreateIndexRequest} The complete index configuration object\n * @function generateIndexDoc\n * @memberOf module:for-couchdb\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant generateIndexDoc\n *   participant generateIndexName\n *   \n *   Caller->>generateIndexDoc: attribute, tableName, compositions, order, separator\n *   \n *   Note over generateIndexDoc: Create partial filter selector\n *   generateIndexDoc->>generateIndexDoc: Set up filter for tableName\n *   \n *   alt order is specified\n *     Note over generateIndexDoc: Create ordered fields array\n *     generateIndexDoc->>generateIndexDoc: Create orderProp for attribute\n *     generateIndexDoc->>generateIndexDoc: Map compositions to ordered props\n *     generateIndexDoc->>generateIndexDoc: Create sortedTable for table field\n *     generateIndexDoc->>generateIndexDoc: Combine all ordered fields\n *   else\n *     Note over generateIndexDoc: Create simple fields array\n *     generateIndexDoc->>generateIndexDoc: Use attribute, compositions, and table as strings\n *   end\n *   \n *   generateIndexDoc->>generateIndexName: Generate index name\n *   generateIndexName-->>generateIndexDoc: Return name\n *   \n *   Note over generateIndexDoc: Create final index request\n *   generateIndexDoc-->>Caller: Return CreateIndexRequest\n */\nexport function generateIndexDoc(\n  attribute: string,\n  tableName: string,\n  compositions?: string[],\n  order?: OrderDirection,\n  separator = DefaultSeparator\n): CreateIndexRequest {\n  const partialFilterSelector: MangoSelector = {};\n  partialFilterSelector[CouchDBKeys.TABLE] = {} as MangoSelector;\n  (partialFilterSelector[CouchDBKeys.TABLE] as MangoSelector)[\n    CouchDBOperator.EQUAL\n  ] = tableName;\n  let fields: SortOrder[];\n  if (order) {\n    const orderProp: SortOrder = {};\n    orderProp[attribute] = order as \"asc\" | \"desc\";\n    const sortedCompositions: SortOrder[] = (compositions || []).map((c) => {\n      const r: SortOrder = {};\n      r[c] = order as \"asc\" | \"desc\";\n      return r;\n    });\n    const sortedTable: SortOrder = {};\n    sortedTable[CouchDBKeys.TABLE] = order as \"asc\" | \"desc\";\n    fields = [orderProp, ...sortedCompositions, sortedTable];\n  } else {\n    fields = [attribute, ...(compositions || []), CouchDBKeys.TABLE];\n  }\n  const name = generateIndexName(\n    attribute,\n    tableName,\n    compositions,\n    order,\n    separator\n  );\n  return {\n    index: {\n      fields: fields,\n      // partial_filter_selector: partialFilterSelector,\n    },\n    ddoc: [name, CouchDBKeys.DDOC].join(separator),\n    name: name,\n  };\n}\n","export * from \"./indexes\";\nexport * from \"./interfaces\";\nexport * from \"./model\";\nexport * from \"./sequences\";\nexport * from \"./adapter\";\nexport * from \"./constants\";\nexport * from \"./errors\";\nexport * from \"./types\";\nexport * from \"./utils\";\n\n/**\n * @description CouchDB adapter for Decaf.ts\n * @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.\n * @module for-couchdb\n */\n\n/**\n * @description Stores the current package version\n * @summary The version string of the for-couchdb package\n * @const VERSION\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["generateIndexName","Sequence","Seq"],"mappings":"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"}