@decaf-ts/for-couchdb 0.3.1 → 0.3.2

package/lib/sequences/Sequence.cjs

@@ -13,13 +13,11 @@ const core_2 = require("@decaf-ts/core");
  *
  * @class CouchDBSequence
  * @implements Sequence
- *
- * @category Sequences
  */
 class CouchDBSequence extends core_2.Sequence {
     constructor(options, adapter) {
         super(options);
-        this.repo = core_1.Repository.forModel(CouchDBSequence_1.Sequence, adapter.flavour);
+        this.repo = core_1.Repository.forModel(CouchDBSequence_1.Sequence, adapter.alias);
     }
     /**
      * @summary Retrieves the current value for the sequence
@@ -113,4 +111,4 @@ class CouchDBSequence extends core_2.Sequence {
     }
 }
 exports.CouchDBSequence = CouchDBSequence;
-//# 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 *\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: 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"]}
+//# 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/sequences/Sequence.d.ts

@@ -11,8 +11,6 @@ import { CouchDBRepository } from "../interfaces";
  *
  * @class CouchDBSequence
  * @implements Sequence
- *
- * @category Sequences
  */
 export declare class CouchDBSequence extends Sequence {
     protected repo: CouchDBRepository<Seq, any, any, any>;

package/lib/types.cjs

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# 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/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/utils.cjs

@@ -9,9 +9,55 @@ const core_1 = require("@decaf-ts/core");
 const constants_1 = require("./constants.cjs");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
 const constants_2 = require("./query/constants.cjs");
+/**
+ * @description Re-authenticates a connection to CouchDB
+ * @summary Refreshes the authentication for a CouchDB connection using the provided credentials
+ * @param {any} con - The CouchDB connection object
+ * @param {string} user - The username for authentication
+ * @param {string} pass - The password for authentication
+ * @return {Promise<any>} A promise that resolves to the authentication result
+ * @function reAuth
+ * @memberOf module:for-couchdb
+ */
 async function reAuth(con, user, pass) {
     return con.auth(user, pass);
 }
+/**
+ * @description Wraps a CouchDB database connection with automatic re-authentication
+ * @summary Creates a proxy around a CouchDB database connection that automatically re-authenticates before each operation
+ * @param {any} con - The CouchDB connection object
+ * @param {string} dbName - The name of the database to use
+ * @param {string} user - The username for authentication
+ * @param {string} pass - The password for authentication
+ * @return {any} The wrapped database connection object
+ * @function wrapDocumentScope
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant wrapDocumentScope
+ *   participant DB
+ *   participant reAuth
+ *
+ *   Client->>wrapDocumentScope: con, dbName, user, pass
+ *   wrapDocumentScope->>DB: con.use(dbName)
+ *   Note over wrapDocumentScope: Wrap DB methods with re-auth
+ *
+ *   loop For each method (insert, get, put, destroy, find)
+ *     wrapDocumentScope->>wrapDocumentScope: Store original method
+ *     wrapDocumentScope->>wrapDocumentScope: Define new method with re-auth
+ *   end
+ *
+ *   wrapDocumentScope->>wrapDocumentScope: Add NATIVE property with con value
+ *   wrapDocumentScope-->>Client: Return wrapped DB
+ *
+ *   Note over Client: Later when client uses DB methods
+ *   Client->>DB: Any wrapped method call
+ *   DB->>reAuth: Authenticate before operation
+ *   reAuth-->>DB: Authentication complete
+ *   DB->>DB: Call original method
+ *   DB-->>Client: Return result
+ */
 function wrapDocumentScope(con, dbName, user, pass) {
     const db = con.use(dbName);
     ["insert", "get", "put", "destroy", "find"].forEach((k) => {
@@ -33,10 +79,30 @@ function wrapDocumentScope(con, dbName, user, pass) {
     });
     return db;
 }
+/**
+ * @description Tests if an attribute name is reserved in CouchDB
+ * @summary Checks if an attribute name starts with an underscore, which indicates it's a reserved attribute in CouchDB
+ * @param {string} attr - The attribute name to test
+ * @return {RegExpMatchArray|null} The match result or null if no match
+ * @function testReservedAttributes
+ * @memberOf module:for-couchdb
+ */
 function testReservedAttributes(attr) {
     const regexp = /^_.*$/g;
     return attr.match(regexp);
 }
+/**
+ * @description Generates a name for a CouchDB index
+ * @summary Creates a standardized name for a CouchDB index based on the table, attribute, compositions, and order
+ * @param {string} attribute - The primary attribute for the index
+ * @param {string} tableName - The name of the table
+ * @param {string[]} [compositions] - Optional additional attributes to include in the index
+ * @param {OrderDirection} [order] - Optional sort order for the index
+ * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
+ * @return {string} The generated index name
+ * @function generateIndexName
+ * @memberOf module:for-couchdb
+ */
 function generateIndexName(attribute, tableName, compositions, order, separator = db_decorators_1.DefaultSeparator) {
     const attr = [core_1.PersistenceKeys.INDEX, tableName, attribute];
     if (compositions)
@@ -45,6 +111,45 @@ function generateIndexName(attribute, tableName, compositions, order, separator
         attr.push(order);
     return attr.join(separator);
 }
+/**
+ * @description Generates a CouchDB index configuration
+ * @summary Creates a complete CreateIndexRequest object for defining a CouchDB index based on specified parameters
+ * @param {string} attribute - The primary attribute for the index
+ * @param {string} tableName - The name of the table
+ * @param {string[]} [compositions] - Optional additional attributes to include in the index
+ * @param {OrderDirection} [order] - Optional sort order for the index
+ * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
+ * @return {CreateIndexRequest} The complete index configuration object
+ * @function generateIndexDoc
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant generateIndexDoc
+ *   participant generateIndexName
+ *
+ *   Caller->>generateIndexDoc: attribute, tableName, compositions, order, separator
+ *
+ *   Note over generateIndexDoc: Create partial filter selector
+ *   generateIndexDoc->>generateIndexDoc: Set up filter for tableName
+ *
+ *   alt order is specified
+ *     Note over generateIndexDoc: Create ordered fields array
+ *     generateIndexDoc->>generateIndexDoc: Create orderProp for attribute
+ *     generateIndexDoc->>generateIndexDoc: Map compositions to ordered props
+ *     generateIndexDoc->>generateIndexDoc: Create sortedTable for table field
+ *     generateIndexDoc->>generateIndexDoc: Combine all ordered fields
+ *   else
+ *     Note over generateIndexDoc: Create simple fields array
+ *     generateIndexDoc->>generateIndexDoc: Use attribute, compositions, and table as strings
+ *   end
+ *
+ *   generateIndexDoc->>generateIndexName: Generate index name
+ *   generateIndexName-->>generateIndexDoc: Return name
+ *
+ *   Note over generateIndexDoc: Create final index request
+ *   generateIndexDoc-->>Caller: Return CreateIndexRequest
+ */
 function generateIndexDoc(attribute, tableName, compositions, order, separator = db_decorators_1.DefaultSeparator) {
     const partialFilterSelector = {};
     partialFilterSelector[constants_1.CouchDBKeys.TABLE] = {};
@@ -75,4 +180,4 @@ function generateIndexDoc(attribute, tableName, compositions, order, separator =
         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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/for-couchdb",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "template for ts projects",
   "type": "module",
   "exports": {
@@ -73,7 +73,7 @@
     "ts"
   ],
   "author": "Tiago Venceslau",
-  "license": "LGPL-3.0-or-later",
+  "license": "AGPL-3.0-or-later",
   "bugs": {
     "url": "https://github.com/decaf-ts/for-couchdb/issues"
   },