@decaf-ts/for-couchdb 0.3.0 → 0.3.2

package/lib/esm/adapter.js

@@ -1,63 +1,105 @@
-import { Adapter, PersistenceKeys, Operator, GroupOperator, ConnectionError, Repository, } from "@decaf-ts/core";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Adapter, PersistenceKeys, ConnectionError, Repository, } from "@decaf-ts/core";
 import { CouchDBKeys, reservedAttributes } from "./constants";
 import { BaseError, ConflictError, InternalError, NotFoundError, prefixMethod, } from "@decaf-ts/db-decorators";
 import "reflect-metadata";
-import { CouchDBStatement } from "./query/Statement";
-import { Factory } from "./query";
-import { translateOperators } from "./query/translate";
 import { CouchDBSequence } from "./sequences/Sequence";
 import { IndexError } from "./errors";
+import { CouchDBStatement } from "./query";
+import { final } from "@decaf-ts/core";
+/**
+ * @description Abstract adapter for CouchDB database operations
+ * @summary Provides a base implementation for CouchDB database operations, including CRUD operations, sequence management, and error handling
+ * @template Y - The scope type
+ * @template F - The repository flags type
+ * @template C - The context type
+ * @param {Y} scope - The scope for the adapter
+ * @param {string} flavour - The flavour of the adapter
+ * @param {string} [alias] - Optional alias for the adapter
+ * @class
+ * @example
+ * // Example of extending CouchDBAdapter
+ * class MyCouchDBAdapter extends CouchDBAdapter<MyScope, MyFlags, MyContext> {
+ *   constructor(scope: MyScope) {
+ *     super(scope, 'my-couchdb', 'my-alias');
+ *   }
+ *
+ *   // Implement abstract methods
+ *   async index<M extends Model>(...models: Constructor<M>[]): Promise<void> {
+ *     // Implementation
+ *   }
+ *
+ *   async raw<R>(rawInput: MangoQuery, docsOnly: boolean): Promise<R> {
+ *     // Implementation
+ *   }
+ *
+ *   async create(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>> {
+ *     // Implementation
+ *   }
+ *
+ *   async read(tableName: string, id: string | number, ...args: any[]): Promise<Record<string, any>> {
+ *     // Implementation
+ *   }
+ *
+ *   async update(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>> {
+ *     // Implementation
+ *   }
+ *
+ *   async delete(tableName: string, id: string | number, ...args: any[]): Promise<Record<string, any>> {
+ *     // Implementation
+ *   }
+ * }
+ */
 export class CouchDBAdapter extends Adapter {
-    constructor(scope, flavour) {
-        super(scope, flavour);
+    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"]);
         });
     }
-    get Clauses() {
-        if (!this.factory)
-            this.factory = new Factory(this);
-        return this.factory;
-    }
-    Query() {
-        return super.Query();
-    }
-    get Statement() {
+    /**
+     * @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);
     }
-    parseCondition(condition) {
-        function merge(op, obj1, obj2) {
-            const result = { selector: {} };
-            result.selector[op] = [obj1, obj2];
-            return result;
-        }
-        const { attr1, operator, comparison } = condition;
-        let op = {};
-        if ([GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(operator) === -1) {
-            op[attr1] = {};
-            op[attr1][translateOperators(operator)] =
-                comparison;
-        }
-        else if (operator === Operator.NOT) {
-            op = this.parseCondition(attr1).selector;
-            op[translateOperators(Operator.NOT)] = {};
-            op[translateOperators(Operator.NOT)][attr1.attr1] = comparison;
-        }
-        else {
-            const op1 = this.parseCondition(attr1).selector;
-            const op2 = this.parseCondition(comparison).selector;
-            op = merge(translateOperators(operator), op1, op2).selector;
-        }
-        return { selector: op };
-    }
+    /**
+     * @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,
@@ -67,6 +109,13 @@ export 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]);
@@ -74,6 +123,14 @@ export 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;
@@ -81,6 +138,15 @@ export 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");
@@ -93,6 +159,15 @@ export 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;
@@ -104,6 +179,15 @@ export 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");
@@ -120,15 +204,91 @@ export 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;
@@ -169,4 +329,52 @@ export class CouchDBAdapter extends Adapter {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/adapter.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}
+__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);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/adapter.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}

package/lib/esm/constants.d.ts

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

package/lib/esm/constants.js

@@ -1,6 +1,34 @@
+/**
+ * @description Regular expression to identify reserved attributes in CouchDB
+ * @summary Matches any attribute that starts with an underscore
+ * @const reservedAttributes
+ * @memberOf module:for-couchdb
+ */
 export 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
+ */
 export const CouchDBKeys = {
-    SEPARATOR: "_",
+    SEPARATOR: "__",
     ID: "_id",
     REV: "_rev",
     DELETED: "_deleted",
@@ -10,4 +38,4 @@ export const CouchDBKeys = {
     NATIVE: "__native",
     INDEX: "index",
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxRQUFRLENBQUM7QUFFM0MsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHO0lBQ3pCLFNBQVMsRUFBRSxHQUFHO0lBQ2QsRUFBRSxFQUFFLEtBQUs7SUFDVCxHQUFHLEVBQUUsTUFBTTtJQUNYLE9BQU8sRUFBRSxVQUFVO0lBQ25CLEtBQUssRUFBRSxTQUFTO0lBQ2hCLFFBQVEsRUFBRSxZQUFZO0lBQ3RCLElBQUksRUFBRSxNQUFNO0lBQ1osTUFBTSxFQUFFLFVBQVU7SUFDbEIsS0FBSyxFQUFFLE9BQU87Q0FDZixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IHJlc2VydmVkQXR0cmlidXRlcyA9IC9eXy4qJC9nO1xuXG5leHBvcnQgY29uc3QgQ291Y2hEQktleXMgPSB7XG4gIFNFUEFSQVRPUjogXCJfXCIsXG4gIElEOiBcIl9pZFwiLFxuICBSRVY6IFwiX3JldlwiLFxuICBERUxFVEVEOiBcIl9kZWxldGVkXCIsXG4gIFRBQkxFOiBcIj8/dGFibGVcIixcbiAgU0VRVUVOQ0U6IFwiPz9zZXF1ZW5jZVwiLFxuICBERE9DOiBcImRkb2NcIixcbiAgTkFUSVZFOiBcIl9fbmF0aXZlXCIsXG4gIElOREVYOiBcImluZGV4XCIsXG59O1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/errors.d.ts

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

package/lib/esm/errors.js

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

package/lib/esm/index.d.ts

@@ -8,20 +8,13 @@ export * from "./errors";
 export * from "./types";
 export * from "./utils";
 /**
- * @summary Module summary
- * @description Module description
- * @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 Namespace summary
- * @description Namespace description
- * @namespace Namespace
- * @memberOf module:ts-workspace
- */
-/**
- * @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
  */
-export declare const VERSION = "0.3.0";
+export declare const VERSION = "0.3.2";