@decaf-ts/for-couchdb 0.3.0 → 0.3.2

package/lib/esm/sequences/Sequence.js

@@ -1,9 +1,7 @@
-import { sf } from "@decaf-ts/decorator-validation";
 import { Sequence as Seq } from "../model/CouchDBSequence";
 import { InternalError, NotFoundError } from "@decaf-ts/db-decorators";
 import { Repository } from "@decaf-ts/core";
 import { Sequence } from "@decaf-ts/core";
-import { parseSequenceValue } from "./utils";
 /**
  * @summary Abstract implementation of a Sequence
  * @description provides the basic functionality for {@link Sequence}s
@@ -12,13 +10,11 @@ import { parseSequenceValue } from "./utils";
  *
  * @class CouchDBSequence
  * @implements Sequence
- *
- * @category Sequences
  */
 export class CouchDBSequence extends Sequence {
     constructor(options, adapter) {
         super(options);
-        this.repo = Repository.forModel(Seq, adapter.flavour);
+        this.repo = Repository.forModel(Seq, adapter.alias);
     }
     /**
      * @summary Retrieves the current value for the sequence
@@ -38,10 +34,10 @@ export class CouchDBSequence extends Sequence {
                     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}`);
         }
     }
     /**
@@ -51,7 +47,7 @@ export class CouchDBSequence extends Sequence {
      * @param value
      */
     parse(value) {
-        return parseSequenceValue(this.options.type, value);
+        return Sequence.parseValue(this.options.type, value);
     }
     /**
      * @summary increments the sequence
@@ -111,4 +107,4 @@ export class CouchDBSequence extends Sequence {
         return range;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Sequence.js","sourceRoot":"","sources":["../../../src/sequences/Sequence.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Sequence.js","sourceRoot":"","sources":["../../../src/sequences/Sequence.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}

package/lib/esm/types.d.ts

@@ -1,5 +1,11 @@
-/** Mango response.
- * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}  */
+/**
+ * @description Response from a CouchDB Mango query
+ * @summary Contains the matching documents and additional metadata about the query execution
+ * @interface MangoResponse
+ * @template D - The document type
+ * @memberOf module:for-couchdb
+ * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}
+ */
 export interface MangoResponse<D> {
     /** Array of documents matching the search.
      *
@@ -18,8 +24,13 @@ export interface MangoResponse<D> {
     /** Basic execution statistics for a specific request. */
     execution_stats?: MangoExecutionStats;
 }
-/** Mango execution stats.
- * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#execution-statistics} */
+/**
+ * @description Statistics about the execution of a Mango query
+ * @summary Provides detailed metrics about query execution including document and key examination counts
+ * @interface MangoExecutionStats
+ * @memberOf module:for-couchdb
+ * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#execution-statistics}
+ */
 export interface MangoExecutionStats {
     /** Number of index keys examined. Currently always 0. */
     total_keys_examined: number;
@@ -36,8 +47,13 @@ export interface MangoExecutionStats {
     /** Total execution time in milliseconds as measured by the database. */
     execution_time_ms: number;
 }
-/** Mango create index parameters.
- * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */
+/**
+ * @description Parameters for creating a CouchDB Mango index
+ * @summary Defines the structure and configuration for a new Mango index
+ * @interface CreateIndexRequest
+ * @memberOf module:for-couchdb
+ * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index}
+ */
 export interface CreateIndexRequest {
     /** JSON object describing the index to create */
     index: {
@@ -57,20 +73,47 @@ export interface CreateIndexRequest {
     /** This field sets whether the created index will be a partitioned or global index. */
     partitioned?: boolean;
 }
+/**
+ * @description Represents the possible value types in a Mango query
+ * @summary Union type of all possible value types that can be used in Mango queries
+ * @typedef {(number|string|Date|boolean|object|null)} MangoValue
+ * @memberOf module:for-couchdb
+ */
 export type MangoValue = number | string | Date | boolean | object | null;
+/**
+ * @description Operators available in Mango queries
+ * @summary Union type of all possible operators that can be used in Mango queries
+ * @typedef {string} MangoOperator
+ * @memberOf module:for-couchdb
+ */
 export type MangoOperator = "$lt" | "$lte" | "$eq" | "$ne" | "$gte" | "$gt" | "$exists" | "$type" | "$in" | "$nin" | "$size" | "$mod" | "$regex" | "$or" | "$and" | "$nor" | "$not" | "$all" | "$allMatch" | "$elemMatch";
-/** Mango selector syntax.
- * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#selector-syntax} */
+/**
+ * @description Represents a CouchDB Mango query selector
+ * @summary Type for defining query conditions in Mango queries
+ * @typedef {Object} MangoSelector
+ * @memberOf module:for-couchdb
+ * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#selector-syntax}
+ */
 export type MangoSelector = {
     [K in MangoOperator | string]: MangoSelector | MangoSelector[] | MangoValue | MangoValue[];
 };
-/** Mango sort syntax
- * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#sort-syntax} */
+/**
+ * @description Represents a sort order specification in Mango queries
+ * @summary Type for defining sort order in Mango queries
+ * @typedef {(string|string[]|Object)} SortOrder
+ * @memberOf module:for-couchdb
+ * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#sort-syntax}
+ */
 export type SortOrder = string | string[] | {
     [key: string]: "asc" | "desc";
 };
-/** Mango query syntax.
- * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}  */
+/**
+ * @description Represents a CouchDB Mango query
+ * @summary Interface for defining complete Mango queries with selectors, sorting, pagination, and other options
+ * @interface MangoQuery
+ * @memberOf module:for-couchdb
+ * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}
+ */
 export interface MangoQuery {
     /** JSON object describing criteria used to select documents. */
     selector: MangoSelector;

package/lib/esm/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * @description Response from a CouchDB Mango query\n * @summary Contains the matching documents and additional metadata about the query execution\n * @interface MangoResponse\n * @template D - The document type\n * @memberOf module:for-couchdb\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}\n */\nexport interface MangoResponse<D> {\n  /** Array of documents matching the search.\n   *\n   * In each matching document, the fields specified in the fields part of the request body are listed, along with\n   * their values. */\n  docs: (D & { _id: string; _rev: string })[];\n\n  /** A string that enables you to specify which page of results you require.\n   *\n   * Used for paging through result sets. */\n  bookmark?: string;\n\n  /** Execution warnings */\n  warning?: string;\n\n  /** Basic execution statistics for a specific request. */\n  execution_stats?: MangoExecutionStats;\n}\n\n/**\n * @description Statistics about the execution of a Mango query\n * @summary Provides detailed metrics about query execution including document and key examination counts\n * @interface MangoExecutionStats\n * @memberOf module:for-couchdb\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#execution-statistics}\n */\nexport interface MangoExecutionStats {\n  /** Number of index keys examined. Currently always 0. */\n  total_keys_examined: number;\n\n  /** Number of documents fetched from the database / index.\n   *\n   * Equivalent to using include_docs = true in a view. */\n  total_docs_examined: number;\n\n  /** Number of documents fetched from the database using an out-of-band document fetch.\n   *\n   * This is only non-zero when read quorum > 1 is specified in the query parameters. */\n  total_quorum_docs_examined: number;\n\n  /** Number of results returned from the query. */\n  results_returned: number;\n\n  /** Total execution time in milliseconds as measured by the database. */\n  execution_time_ms: number;\n}\n\n/**\n * @description Parameters for creating a CouchDB Mango index\n * @summary Defines the structure and configuration for a new Mango index\n * @interface CreateIndexRequest\n * @memberOf module:for-couchdb\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index}\n */\nexport interface CreateIndexRequest {\n  /** JSON object describing the index to create */\n  index: {\n    /** Array of field names following the sort syntax. */\n    fields: SortOrder[];\n\n    /** A selector to apply to documents at indexing time, creating a partial index. */\n    partial_filter_selector?: MangoSelector;\n  };\n\n  /** Name of the design document in which the index will be created. */\n  ddoc?: string;\n\n  /** Name of the index. If no name is provided, a name will be generated automatically. */\n  name?: string;\n\n  /** Can be \"json\" or \"text\".\n   *\n   * @default \"json\" */\n  type?: \"json\" | \"text\";\n\n  /** This field sets whether the created index will be a partitioned or global index. */\n  partitioned?: boolean;\n}\n\n/**\n * @description Represents the possible value types in a Mango query\n * @summary Union type of all possible value types that can be used in Mango queries\n * @typedef {(number|string|Date|boolean|object|null)} MangoValue\n * @memberOf module:for-couchdb\n */\nexport type MangoValue = number | string | Date | boolean | object | null;\n\n/**\n * @description Operators available in Mango queries\n * @summary Union type of all possible operators that can be used in Mango queries\n * @typedef {string} MangoOperator\n * @memberOf module:for-couchdb\n */\nexport type MangoOperator =\n  | \"$lt\"\n  | \"$lte\"\n  | \"$eq\"\n  | \"$ne\"\n  | \"$gte\"\n  | \"$gt\"\n  | \"$exists\"\n  | \"$type\"\n  | \"$in\"\n  | \"$nin\"\n  | \"$size\"\n  | \"$mod\"\n  | \"$regex\"\n  | \"$or\"\n  | \"$and\"\n  | \"$nor\"\n  | \"$not\"\n  | \"$all\"\n  | \"$allMatch\"\n  | \"$elemMatch\";\n/**\n * @description Represents a CouchDB Mango query selector\n * @summary Type for defining query conditions in Mango queries\n * @typedef {Object} MangoSelector\n * @memberOf module:for-couchdb\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#selector-syntax}\n */\nexport type MangoSelector = {\n  [K in MangoOperator | string]:\n    | MangoSelector\n    | MangoSelector[]\n    | MangoValue\n    | MangoValue[];\n};\n\n/**\n * @description Represents a sort order specification in Mango queries\n * @summary Type for defining sort order in Mango queries\n * @typedef {(string|string[]|Object)} SortOrder\n * @memberOf module:for-couchdb\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#sort-syntax}\n */\nexport type SortOrder = string | string[] | { [key: string]: \"asc\" | \"desc\" };\n\n/**\n * @description Represents a CouchDB Mango query\n * @summary Interface for defining complete Mango queries with selectors, sorting, pagination, and other options\n * @interface MangoQuery\n * @memberOf module:for-couchdb\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}\n */\nexport interface MangoQuery {\n  /** JSON object describing criteria used to select documents. */\n  selector: MangoSelector;\n\n  /** Maximum number of results returned. @default 25 */\n  limit?: number;\n\n  /** Skip the first 'n' results, where 'n' is the value specified. */\n  skip?: number;\n\n  /** JSON array following sort syntax. */\n  sort?: SortOrder[];\n\n  /** JSON array specifying which fields of each object should be returned.\n   *\n   * If it is omitted, the entire object is returned.\n   *\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#filtering-fields} */\n  fields?: string[];\n\n  /* Instruct a query to use a specific index.\n   *\n   * Specified either as \"<design_document>\" or [\"<design_document>\", \"<index_name>\"]. */\n  use_index?: string | [string, string];\n\n  /** Read quorum needed for the result.\n   *\n   * @default 1 */\n  r?: number;\n\n  /** A string that enables you to specify which page of results you require.\n   *\n   * Used for paging through result sets. */\n  bookmark?: string;\n\n  /** Whether to update the index prior to returning the result.\n   *\n   * @default true */\n  update?: boolean;\n\n  /** Whether or not the view results should be returned from a “stable” set of shards. */\n  stable?: boolean;\n\n  /** Combination of update = false and stable = true options.\n   *\n   * Possible options: \"ok\", false (default). */\n  stale?: \"ok\" | false;\n\n  /** Include execution statistics in the query response.\n   *\n   * Optional, default: false. */\n  execution_stats?: boolean;\n}\n"]}

package/lib/esm/utils.d.ts

@@ -1,7 +1,112 @@
 import { OrderDirection } from "@decaf-ts/core";
 import { CreateIndexRequest } from "./types";
+/**
+ * @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
+ */
 export declare function reAuth(con: any, user: string, pass: string): Promise<any>;
+/**
+ * @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
+ */
 export declare function wrapDocumentScope(con: any, dbName: string, user: string, pass: string): any;
+/**
+ * @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
+ */
 export declare function testReservedAttributes(attr: string): RegExpMatchArray | null;
+/**
+ * @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
+ */
 export declare function generateIndexName(attribute: string, tableName: string, compositions?: string[], order?: OrderDirection, separator?: string): string;
+/**
+ * @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
+ */
 export declare function generateIndexDoc(attribute: string, tableName: string, compositions?: string[], order?: OrderDirection, separator?: string): CreateIndexRequest;

package/lib/esm/utils.js

@@ -2,9 +2,55 @@ import { PersistenceKeys } from "@decaf-ts/core";
 import { CouchDBKeys } from "./constants";
 import { DefaultSeparator } from "@decaf-ts/db-decorators";
 import { CouchDBOperator } from "./query/constants";
+/**
+ * @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
+ */
 export 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
+ */
 export function wrapDocumentScope(con, dbName, user, pass) {
     const db = con.use(dbName);
     ["insert", "get", "put", "destroy", "find"].forEach((k) => {
@@ -26,10 +72,30 @@ export 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
+ */
 export 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
+ */
 export function generateIndexName(attribute, tableName, compositions, order, separator = DefaultSeparator) {
     const attr = [PersistenceKeys.INDEX, tableName, attribute];
     if (compositions)
@@ -38,6 +104,45 @@ export function generateIndexName(attribute, tableName, compositions, order, sep
         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
+ */
 export function generateIndexDoc(attribute, tableName, compositions, order, separator = DefaultSeparator) {
     const partialFilterSelector = {};
     partialFilterSelector[CouchDBKeys.TABLE] = {};
@@ -68,4 +173,4 @@ export function generateIndexDoc(attribute, tableName, compositions, order, sepa
         name: name,
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}

package/lib/index.cjs

@@ -25,21 +25,14 @@ __exportStar(require("./errors.cjs"), exports);
 __exportStar(require("./types.cjs"), exports);
 __exportStar(require("./utils.cjs"), exports);
 /**
- * @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
  */
-exports.VERSION = "0.3.0";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxzREFBMEI7QUFDMUIseURBQTZCO0FBQzdCLG9EQUF3QjtBQUN4Qix3REFBNEI7QUFDNUIsZ0RBQTBCO0FBQzFCLGtEQUE0QjtBQUM1QiwrQ0FBeUI7QUFDekIsOENBQXdCO0FBQ3hCLDhDQUF3QjtBQUV4Qjs7OztHQUlHO0FBRUg7Ozs7O0dBS0c7QUFFSDs7Ozs7R0FLRztBQUNVLFFBQUEsT0FBTyxHQUFHLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2luZGV4ZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ludGVyZmFjZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL21vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZXF1ZW5jZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2FkYXB0ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZXJyb3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcblxuLyoqXG4gKiBAc3VtbWFyeSBNb2R1bGUgc3VtbWFyeVxuICogQGRlc2NyaXB0aW9uIE1vZHVsZSBkZXNjcmlwdGlvblxuICogQG1vZHVsZSB0cy13b3Jrc3BhY2VcbiAqL1xuXG4vKipcbiAqIEBzdW1tYXJ5IE5hbWVzcGFjZSBzdW1tYXJ5XG4gKiBAZGVzY3JpcHRpb24gTmFtZXNwYWNlIGRlc2NyaXB0aW9uXG4gKiBAbmFtZXNwYWNlIE5hbWVzcGFjZVxuICogQG1lbWJlck9mIG1vZHVsZTp0cy13b3Jrc3BhY2VcbiAqL1xuXG4vKipcbiAqIEBzdW1tYXJ5IHN0b3JlcyB0aGUgY3VycmVudCBwYWNrYWdlIHZlcnNpb25cbiAqIEBkZXNjcmlwdGlvbiB0aGlzIGlzIGhvdyB5b3Ugc2hvdWxkIGRvY3VtZW50IGEgY29uc3RhbnRcbiAqIEBjb25zdCBWRVJTSU9OXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnRzLXdvcmtzcGFjZVxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcbiJdfQ==
+exports.VERSION = "0.3.2";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxzREFBMEI7QUFDMUIseURBQTZCO0FBQzdCLG9EQUF3QjtBQUN4Qix3REFBNEI7QUFDNUIsZ0RBQTBCO0FBQzFCLGtEQUE0QjtBQUM1QiwrQ0FBeUI7QUFDekIsOENBQXdCO0FBQ3hCLDhDQUF3QjtBQUV4Qjs7OztHQUlHO0FBRUg7Ozs7R0FJRztBQUNVLFFBQUEsT0FBTyxHQUFHLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2luZGV4ZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ludGVyZmFjZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL21vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZXF1ZW5jZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2FkYXB0ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZXJyb3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gQ291Y2hEQiBhZGFwdGVyIGZvciBEZWNhZi50c1xuICogQHN1bW1hcnkgQSBUeXBlU2NyaXB0IGFkYXB0ZXIgZm9yIENvdWNoREIgZGF0YWJhc2Ugb3BlcmF0aW9ucywgcHJvdmlkaW5nIGEgc2VhbWxlc3MgaW50ZWdyYXRpb24gd2l0aCB0aGUgRGVjYWYudHMgZnJhbWV3b3JrLiBUaGlzIG1vZHVsZSBpbmNsdWRlcyBjbGFzc2VzLCBpbnRlcmZhY2VzLCBhbmQgdXRpbGl0aWVzIGZvciB3b3JraW5nIHdpdGggQ291Y2hEQiBkYXRhYmFzZXMsIGluY2x1ZGluZyBzdXBwb3J0IGZvciBNYW5nbyBxdWVyaWVzLCBkb2N1bWVudCBvcGVyYXRpb25zLCBhbmQgc2VxdWVuY2UgbWFuYWdlbWVudC5cbiAqIEBtb2R1bGUgZm9yLWNvdWNoZGJcbiAqL1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBTdG9yZXMgdGhlIGN1cnJlbnQgcGFja2FnZSB2ZXJzaW9uXG4gKiBAc3VtbWFyeSBUaGUgdmVyc2lvbiBzdHJpbmcgb2YgdGhlIGZvci1jb3VjaGRiIHBhY2thZ2VcbiAqIEBjb25zdCBWRVJTSU9OXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuIl19

package/lib/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";