@decaf-ts/for-nano 0.9.0 → 0.11.0

package/lib/cjs/index.cjs

@@ -35,7 +35,7 @@ __exportStar(require("./adapter.cjs"), exports);
  * @const VERSION
  * @memberOf module:for-nano
  */
-exports.VERSION = "0.8.0";
+exports.VERSION = "0.10.0";
 /**
  * @description Package version identifier
  * @summary Stores the current package version string for the for-nano module

package/lib/esm/index.js

@@ -18,7 +18,7 @@ export * from "./adapter.js";
  * @const VERSION
  * @memberOf module:for-nano
  */
-export const VERSION = "0.8.0";
+export const VERSION = "0.10.0";
 /**
  * @description Package version identifier
  * @summary Stores the current package version string for the for-nano module

package/lib/types/NanoDispatch.d.cts

@@ -1,7 +1,7 @@
 import { Adapter, Context, ContextualArgs, Dispatch } from "@decaf-ts/core";
 import { DatabaseChangesResponse, DatabaseChangesResultItem, DocumentScope, RequestError } from "nano";
 import { MangoQuery } from "@decaf-ts/for-couchdb";
-import { NanoConfig, NanoFlags } from "./types.cjs";
+import { NanoConfig, NanoFlags } from "./types.d.cts";
 /**
  * @description Dispatcher for Nano database change events
  * @summary Handles the subscription to and processing of database change events from a Nano database,

package/lib/types/NanoDispatch.d.mts

@@ -1,7 +1,7 @@
 import { Adapter, Context, ContextualArgs, Dispatch } from "@decaf-ts/core";
 import { DatabaseChangesResponse, DatabaseChangesResultItem, DocumentScope, RequestError } from "nano";
 import { MangoQuery } from "@decaf-ts/for-couchdb";
-import { NanoConfig, NanoFlags } from "./types.js";
+import { NanoConfig, NanoFlags } from "./types.d.mts";
 /**
  * @description Dispatcher for Nano database change events
  * @summary Handles the subscription to and processing of database change events from a Nano database,

package/lib/types/NanoRepository.d.cts

@@ -1,6 +1,6 @@
 import { Model } from "@decaf-ts/decorator-validation";
 import { CouchDBRepository } from "@decaf-ts/for-couchdb";
-import { NanoAdapter } from "./adapter.cjs";
+import { NanoAdapter } from "./adapter.d.cts";
 import { Constructor } from "@decaf-ts/decoration";
 import { ContextOf, FlagsOf } from "@decaf-ts/core";
 /**

package/lib/types/NanoRepository.d.mts

@@ -1,6 +1,6 @@
 import { Model } from "@decaf-ts/decorator-validation";
 import { CouchDBRepository } from "@decaf-ts/for-couchdb";
-import { NanoAdapter } from "./adapter.js";
+import { NanoAdapter } from "./adapter.d.mts";
 import { Constructor } from "@decaf-ts/decoration";
 import { ContextOf, FlagsOf } from "@decaf-ts/core";
 /**

package/lib/types/adapter.d.cts

@@ -2,10 +2,10 @@ import { OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
 import { CouchDBAdapter, MangoQuery, ViewResponse } from "@decaf-ts/for-couchdb";
 import { DocumentScope, ServerScope } from "nano";
 import { Model } from "@decaf-ts/decorator-validation";
-import { NanoConfig, NanoFlags } from "./types.cjs";
+import { NanoConfig, NanoFlags } from "./types.d.cts";
 import { Adapter, Context, ContextOf, ContextualArgs, MaybeContextualArg, RelationsMetadata, Repository } from "@decaf-ts/core";
-import { NanoRepository } from "./NanoRepository.cjs";
-import { NanoDispatch } from "./NanoDispatch.cjs";
+import { NanoRepository } from "./NanoRepository.d.cts";
+import { NanoDispatch } from "./NanoDispatch.d.cts";
 import { Constructor } from "@decaf-ts/decoration";
 /**
  * @description Sets the creator or updater field in a model based on the user in the context

package/lib/types/adapter.d.mts

@@ -2,10 +2,10 @@ import { OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
 import { CouchDBAdapter, MangoQuery, ViewResponse } from "@decaf-ts/for-couchdb";
 import { DocumentScope, ServerScope } from "nano";
 import { Model } from "@decaf-ts/decorator-validation";
-import { NanoConfig, NanoFlags } from "./types.js";
+import { NanoConfig, NanoFlags } from "./types.d.mts";
 import { Adapter, Context, ContextOf, ContextualArgs, MaybeContextualArg, RelationsMetadata, Repository } from "@decaf-ts/core";
-import { NanoRepository } from "./NanoRepository.js";
-import { NanoDispatch } from "./NanoDispatch.js";
+import { NanoRepository } from "./NanoRepository.d.mts";
+import { NanoDispatch } from "./NanoDispatch.d.mts";
 import { Constructor } from "@decaf-ts/decoration";
 /**
  * @description Sets the creator or updater field in a model based on the user in the context

package/lib/types/index.d.cts

@@ -1,7 +1,7 @@
-export * from "./constants.cjs";
-export * from "./NanoRepository.cjs";
-export * from "./types.cjs";
-export * from "./adapter.cjs";
+export * from "./constants.d.cts";
+export * from "./NanoRepository.d.cts";
+export * from "./types.d.cts";
+export * from "./adapter.d.cts";
 /**
  * @description A TypeScript module for interacting with Nano databases
  * @summary This module provides a set of utilities, classes, and types for working with Nano databases. It includes repository patterns, adapters, and type definitions to simplify database operations. Key exports include {@link NanoAdapter}, {@link NanoRepository}, {@link NanoFlags}, and {@link NanoFlavour}.
@@ -13,7 +13,7 @@ export * from "./adapter.cjs";
  * @const VERSION
  * @memberOf module:for-nano
  */
-export declare const VERSION = "0.8.0";
+export declare const VERSION = "0.10.0";
 /**
  * @description Package version identifier
  * @summary Stores the current package version string for the for-nano module

package/lib/types/index.d.mts

@@ -1,7 +1,7 @@
-export * from "./constants.js";
-export * from "./NanoRepository.js";
-export * from "./types.js";
-export * from "./adapter.js";
+export * from "./constants.d.mts";
+export * from "./NanoRepository.d.mts";
+export * from "./types.d.mts";
+export * from "./adapter.d.mts";
 /**
  * @description A TypeScript module for interacting with Nano databases
  * @summary This module provides a set of utilities, classes, and types for working with Nano databases. It includes repository patterns, adapters, and type definitions to simplify database operations. Key exports include {@link NanoAdapter}, {@link NanoRepository}, {@link NanoFlags}, and {@link NanoFlavour}.
@@ -13,7 +13,7 @@ export * from "./adapter.js";
  * @const VERSION
  * @memberOf module:for-nano
  */
-export declare const VERSION = "0.8.0";
+export declare const VERSION = "0.10.0";
 /**
  * @description Package version identifier
  * @summary Stores the current package version string for the for-nano module

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/for-nano",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "decaf-ts persistence adapter for CouchDB via nano",
   "type": "module",
   "exports": {

package/lib/types/NanoDispatch.d.ts

@@ -1,119 +0,0 @@
-import { Adapter, Context, ContextualArgs, Dispatch } from "@decaf-ts/core";
-import { DatabaseChangesResponse, DatabaseChangesResultItem, DocumentScope, RequestError } from "nano";
-import { MangoQuery } from "@decaf-ts/for-couchdb";
-import { NanoConfig, NanoFlags } from "./types";
-/**
- * @description Dispatcher for Nano database change events
- * @summary Handles the subscription to and processing of database change events from a Nano database,
- * notifying observers when documents are created, updated, or deleted
- * @template DocumentScope - The Nano document scope type
- * @param {number} [timeout=5000] - Timeout in milliseconds for change feed requests
- * @class NanoDispatch
- * @example
- * ```typescript
- * // Create a dispatcher for a Nano database
- * const db = server.db.use('my_database');
- * const adapter = new NanoAdapter(db);
- * const dispatch = new NanoDispatch();
- *
- * // The dispatcher will automatically subscribe to changes
- * // and notify observers when documents change
- * ```
- * @mermaid
- * classDiagram
- *   class Dispatch {
- *     +initialize()
- *     +updateObservers()
- *   }
- *   class NanoDispatch {
- *     -observerLastUpdate?: string
- *     -attemptCounter: number
- *     -timeout: number
- *     +constructor(timeout)
- *     #changeHandler()
- *     #initialize()
- *   }
- *   Dispatch <|-- NanoDispatch
- */
-export declare class NanoDispatch extends Dispatch<Adapter<NanoConfig, DocumentScope<any>, MangoQuery, Context<NanoFlags>>> {
-    private timeout;
-    private observerLastUpdate?;
-    private attemptCounter;
-    private active;
-    private changeFeed?;
-    constructor(timeout?: number);
-    /**
-     * @description Closes the dispatcher
-     * @summary Stops the dispatcher and cleans up any active subscriptions or resources
-     * @return {Promise<void>} A promise that resolves when the dispatcher has been closed
-     */
-    close(...args: ContextualArgs<Context<NanoFlags>>): Promise<void>;
-    /**
-     * @description Processes database change events
-     * @summary Handles the response from the Nano changes feed, processes the changes,
-     * and notifies observers about document changes
-     * @param {RequestError | null} error - Error object if the request failed
-     * @param response - The changes response from Nano
-     * @param {any} [headers] - Response headers (unused)
-     * @return {Promise<void>} A promise that resolves when all changes have been processed
-     * @mermaid
-     * sequenceDiagram
-     *   participant D as NanoDispatch
-     *   participant L as Logger
-     *   participant O as Observers
-     *   Note over D: Receive changes from Nano
-     *   alt Error in response
-     *     D->>L: Log error
-     *     D-->>D: Return early
-     *   end
-     *   alt Response is string
-     *     D->>D: Parse JSON from string
-     *   end
-     *   D->>D: Process changes
-     *   D->>D: Group changes by table and operation
-     *   loop For each table
-     *     loop For each operation
-     *       D->>O: updateObservers(table, operation, ids)
-     *       D->>D: Update observerLastUpdate
-     *       D->>L: Log successful dispatch
-     *     end
-     *   end
-     */
-    protected changeHandler(error: RequestError | null, response: (DatabaseChangesResponse | DatabaseChangesResultItem)[] | string, headers?: any, ctxArg?: Context<NanoFlags>): Promise<void>;
-    /**
-     * @description Initializes the dispatcher and subscribes to database changes
-     * @summary Sets up the continuous changes feed subscription to the Nano database
-     * and handles reconnection attempts if the connection fails
-     * @return {Promise<void>} A promise that resolves when the subscription is established
-     * @mermaid
-     * sequenceDiagram
-     *   participant D as NanoDispatch
-     *   participant S as subscribeToCouch
-     *   participant DB as Nano Database
-     *   participant L as Logger
-     *   D->>S: Call subscribeToCouch
-     *   S->>S: Check adapter and native
-     *   alt No adapter or native
-     *     S-->>S: throw InternalError
-     *   end
-     *   S->>DB: changes(options, changeHandler)
-     *   alt Success
-     *     DB-->>S: Subscription established
-     *     S-->>D: Promise resolves
-     *     D->>L: Log successful subscription
-     *   else Error
-     *     DB-->>S: Error
-     *     S->>S: Increment attemptCounter
-     *     alt attemptCounter > 3
-     *       S->>L: Log error
-     *       S-->>D: Promise rejects
-     *     else attemptCounter <= 3
-     *       S->>L: Log retry
-     *       S->>S: Wait timeout
-     *       S->>S: Recursive call to subscribeToCouch
-     *     end
-     *   end
-     */
-    protected initialize(): Promise<void>;
-    private disposeChangeFeed;
-}

package/lib/types/NanoRepository.d.ts

@@ -1,17 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { CouchDBRepository } from "@decaf-ts/for-couchdb";
-import { NanoAdapter } from "./adapter";
-import { Constructor } from "@decaf-ts/decoration";
-import { ContextOf, FlagsOf } from "@decaf-ts/core";
-/**
- * @description Type for Nano database repositories
- * @summary A specialized repository type for working with Nano databases, extending the base Repository
- * with Nano-specific adapter, flags, and context types
- * @template M - Type extending Model that this repository will manage
- * @typedef {Repository<M, MangoQuery, NanoAdapter, NanoFlags, Context<NanoFlags>>} NanoRepository
- * @memberOf module:for-nano
- */
-export declare class NanoRepository<M extends Model> extends CouchDBRepository<M, NanoAdapter> {
-    constructor(adapter: NanoAdapter, model: Constructor<M>, force?: boolean);
-    override(flags: Partial<FlagsOf<ContextOf<NanoAdapter>>>): this;
-}

package/lib/types/adapter.d.ts

@@ -1,449 +0,0 @@
-import { OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
-import { CouchDBAdapter, MangoQuery, ViewResponse } from "@decaf-ts/for-couchdb";
-import { DocumentScope, ServerScope } from "nano";
-import { Model } from "@decaf-ts/decorator-validation";
-import { NanoConfig, NanoFlags } from "./types";
-import { Adapter, Context, ContextOf, ContextualArgs, MaybeContextualArg, RelationsMetadata, Repository } from "@decaf-ts/core";
-import { NanoRepository } from "./NanoRepository";
-import { NanoDispatch } from "./NanoDispatch";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @description Sets the creator or updater field in a model based on the user in the context
- * @summary Callback function used in decorators to automatically set the created_by or updated_by fields
- * with the username from the context when a document is created or updated
- * @template M - Type extending Model
- * @template R - Type extending NanoRepository<M>
- * @template V - Type extending RelationsMetadata
- * @param {R} this - The repository instance
- * @param {Context<NanoFlags>} context - The operation context containing user information
- * @param {V} data - The relation metadata
- * @param key - The property key to set with the username
- * @param {M} model - The model instance being created or updated
- * @return {Promise<void>} A promise that resolves when the operation is complete
- * @function createdByOnNanoCreateUpdate
- * @memberOf module:for-nano
- * @mermaid
- * sequenceDiagram
- *   participant F as createdByOnNanoCreateUpdate
- *   participant C as Context
- *   participant M as Model
- *   F->>C: get("user")
- *   C-->>F: user object
- *   F->>M: set key to user.name
- *   Note over F: If no user in context
- *   F-->>F: throw UnsupportedError
- */
-export declare function createdByOnNanoCreateUpdate<M extends Model, R extends NanoRepository<M>, V extends RelationsMetadata>(this: R, context: ContextOf<R>, data: V, key: keyof M, model: M): Promise<void>;
-/**
- * @description Adapter for interacting with Nano databases
- * @summary Provides a standardized interface for performing CRUD operations on Nano databases,
- * extending the CouchDB adapter with Nano-specific functionality. This adapter handles document
- * creation, reading, updating, and deletion, as well as bulk operations and index management.
- * @template DocumentScope - The Nano document scope type
- * @template NanoFlags - Configuration flags for Nano operations
- * @template Context - Context type for operations
- * @param {DocumentScope<any>} scope - The Nano document scope to use for database operations
- * @param {string} [alias] - Optional alias for the adapter
- * @class NanoAdapter
- * @example
- * ```typescript
- * // Connect to a Nano database
- * const server = NanoAdapter.connect('admin', 'password', 'localhost:5984');
- * const db = server.db.use('my_database');
- *
- * // Create an adapter instance
- * const adapter = new NanoAdapter(db);
- *
- * // Use the adapter for database operations
- * const document = await adapter.read('users', '123');
- * ```
- * @mermaid
- * classDiagram
- *   class CouchDBAdapter {
- *     +flags()
- *     +Dispatch()
- *     +index()
- *     +create()
- *     +read()
- *     +update()
- *     +delete()
- *   }
- *   class NanoAdapter {
- *     +flags()
- *     +Dispatch()
- *     +index()
- *     +create()
- *     +createAll()
- *     +read()
- *     +readAll()
- *     +update()
- *     +updateAll()
- *     +delete()
- *     +deleteAll()
- *     +raw()
- *     +static connect()
- *     +static createDatabase()
- *     +static deleteDatabase()
- *     +static createUser()
- *     +static deleteUser()
- *     +static decoration()
- *   }
- *   CouchDBAdapter <|-- NanoAdapter
- */
-export declare class NanoAdapter extends CouchDBAdapter<NanoConfig, DocumentScope<any>, Context<NanoFlags>> {
-    constructor(scope: NanoConfig, alias?: string);
-    /**
-     * @description Shuts down the adapter instance
-     * @summary Cleans up internal resources and clears the cached Nano client instance
-     * @return {Promise<void>} A promise that resolves when shutdown completes
-     */
-    shutdown(...args: MaybeContextualArg<Context<NanoFlags>>): Promise<void>;
-    /**
-     * @description Lazily creates and returns the Nano DocumentScope client
-     * @summary Uses the adapter configuration to establish a connection and wrap a database scope with credentials
-     * @return {DocumentScope<any>} The ready-to-use Nano DocumentScope for the configured database
-     */
-    protected getClient(): any;
-    /**
-     * @description Generates flags for database operations
-     * @summary Creates a set of flags for a specific operation, including user information
-     * @template M - Type extending Model
-     * @param {OperationKeys} operation - The operation being performed (create, read, update, delete)
-     * @param {Constructor<M>} model - The model constructor
-     * @param {Partial<NanoFlags>} flags - Partial flags to be merged
-     * @return {Promise<NanoFlags>} Complete flags for the operation
-     */
-    protected flags<M extends Model>(operation: OperationKeys, model: Constructor<M>, flags: Partial<NanoFlags>, ...args: any[]): Promise<NanoFlags>;
-    /**
-     * @description Creates a new NanoDispatch instance
-     * @summary Returns a dispatcher for handling Nano-specific operations
-     * @return {NanoDispatch} A new NanoDispatch instance
-     */
-    protected Dispatch(): NanoDispatch;
-    repository<R extends Repository<any, Adapter<NanoConfig, DocumentScope<any>, MangoQuery, Context<NanoFlags>>>>(): Constructor<R>;
-    /**
-     * @description Creates database indexes for models
-     * @summary Generates and creates indexes in the Nano database based on the provided models
-     * @template M - Type extending Model
-     * @param models - Model constructors to create indexes for
-     * @return {Promise<void>} A promise that resolves when all indexes are created
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant G as generateIndexes
-     *   participant DB as Nano Database
-     *   A->>G: generateIndexes(models)
-     *   G-->>A: indexes
-     *   loop For each index
-     *     A->>DB: createIndex(index)
-     *     DB-->>A: response
-     *     Note over A: Check if index already exists
-     *     alt Index exists
-     *       A-->>A: throw ConflictError
-     *     end
-     *   end
-     */
-    protected index<M extends Model>(...models: Constructor<M>[]): Promise<void>;
-    /**
-     * @description Creates a new document in the database
-     * @summary Inserts a new document into the Nano database with the provided data
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The document identifier
-     * @param {Record<string, any>} model - The document data to insert
-     * @return {Promise<Record<string, any>>} A promise that resolves to the created document with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant DB as Nano Database
-     *   A->>DB: insert(model)
-     *   alt Success
-     *     DB-->>A: response with ok=true
-     *     A->>A: assignMetadata(model, response.rev)
-     *     A-->>A: return document with metadata
-     *   else Error
-     *     DB-->>A: error
-     *     A-->>A: throw parseError(e)
-     *   else Not OK
-     *     DB-->>A: response with ok=false
-     *     A-->>A: throw InternalError
-     *   end
-     */
-    create<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<Context<NanoFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Creates multiple documents in the database
-     * @summary Inserts multiple documents into the Nano database in a single bulk operation
-     * @param {string} tableName - The name of the table/collection
-     * @param {string[] | number[]} ids - Array of document identifiers
-     * @param models - Array of document data to insert
-     * @return A promise that resolves to an array of created documents with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant DB as Nano Database
-     *   A->>DB: bulk({docs: models})
-     *   alt Success
-     *     DB-->>A: response array
-     *     A->>A: Check if all responses have no errors
-     *     alt All OK
-     *       A->>A: assignMultipleMetadata(models, revs)
-     *       A-->>A: return documents with metadata
-     *     else Some errors
-     *       A->>A: Collect error messages
-     *       A-->>A: throw InternalError with collected messages
-     *     end
-     *   else Error
-     *     DB-->>A: error
-     *     A-->>A: throw parseError(e)
-     *   end
-     */
-    createAll<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], models: Record<string, any>[], ...args: ContextualArgs<Context<NanoFlags>>): Promise<Record<string, any>[]>;
-    /**
-     * @description Retrieves a document from the database
-     * @summary Fetches a single document from the Nano database by its ID
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The document identifier
-     * @return {Promise<Record<string, any>>} A promise that resolves to the retrieved document with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant DB as Nano Database
-     *   A->>A: generateId(tableName, id)
-     *   A->>DB: get(_id)
-     *   alt Success
-     *     DB-->>A: record
-     *     A->>A: assignMetadata(record, record._rev)
-     *     A-->>A: return document with metadata
-     *   else Error
-     *     DB-->>A: error
-     *     A-->>A: throw parseError(e)
-     *   end
-     */
-    read<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<Context<NanoFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Retrieves multiple documents from the database
-     * @summary Fetches multiple documents from the Nano database by their IDs in a single operation
-     * @param {string} tableName - The name of the table/collection
-     * @param {Array<string | number | bigint>} ids - Array of document identifiers
-     * @return A promise that resolves to an array of retrieved documents with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant DB as Nano Database
-     *   A->>A: Map ids to generateId(tableName, id)
-     *   A->>DB: fetch({keys: mappedIds}, {})
-     *   DB-->>A: results
-     *   A->>A: Process each result row
-     *   loop For each row
-     *     alt Row has error
-     *       A-->>A: throw InternalError
-     *     else Row has document
-     *       A->>A: assignMetadata(doc, doc._rev)
-     *     else No document
-     *       A-->>A: throw InternalError
-     *     end
-     *   end
-     *   A-->>A: return documents with metadata
-     */
-    readAll<M extends Model>(tableName: Constructor<M>, ids: (string | number | bigint)[], ...args: ContextualArgs<Context<NanoFlags>>): Promise<Record<string, any>[]>;
-    /**
-     * @description Updates a document in the database
-     * @summary Updates an existing document in the Nano database with the provided data
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The document identifier
-     * @param {Record<string, any>} model - The updated document data
-     * @return {Promise<Record<string, any>>} A promise that resolves to the updated document with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant DB as Nano Database
-     *   A->>DB: insert(model)
-     *   alt Success
-     *     DB-->>A: response with ok=true
-     *     A->>A: assignMetadata(model, response.rev)
-     *     A-->>A: return document with metadata
-     *   else Error
-     *     DB-->>A: error
-     *     A-->>A: throw parseError(e)
-     *   else Not OK
-     *     DB-->>A: response with ok=false
-     *     A-->>A: throw InternalError
-     *   end
-     */
-    update<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<Context<NanoFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Updates multiple documents in the database
-     * @summary Performs a bulk update operation on the Nano database for the provided documents
-     * @param {string} tableName - The name of the table/collection
-     * @param {Array<string|number>} ids - Array of document identifiers
-     * @param {Promise<Array<Record<string, any>>>} models - Array of updated document data
-     * @return {Promise<Promise<Array<Record<string, any>>>>} A promise that resolves to the updated documents with metadata
-     */
-    updateAll<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], models: Record<string, any>[], ...args: ContextualArgs<Context<NanoFlags>>): Promise<Record<string, any>[]>;
-    /**
-     * @description Deletes a document from the database
-     * @summary Removes a single document from the Nano database by its ID and returns the deleted document metadata
-     * @param {string} tableName - The name of the table/collection
-     * @param {string|number} id - The document identifier
-     * @return {Promise<Record<string, any>>} A promise that resolves to the deleted document with metadata
-     */
-    delete<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<Context<NanoFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Deletes multiple documents from the database
-     * @summary Performs a bulk delete operation for the provided IDs and returns the deleted documents metadata
-     * @param {string} tableName - The name of the table/collection
-     * @param {Array<string|number|bigint>} ids - Array of document identifiers to delete
-     * @return {Promise<Array<Record<string, any>>>} A promise resolving to the deleted documents with metadata
-     */
-    deleteAll<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], ...args: ContextualArgs<Context<NanoFlags>>): Promise<Record<string, any>[]>;
-    /**
-     * @description Executes a raw Mango query against the database
-     * @summary Runs a Mango query using Nano's find API and optionally returns only the documents array
-     * @template R - The expected response or document array type
-     * @param {MangoQuery} rawInput - The Mango query to execute
-     * @param {boolean} [docsOnly=true] - Whether to return only the docs array or the full response
-     * @return {Promise<R>} A promise that resolves to the query result, shaped according to docsOnly
-     */
-    raw<R>(rawInput: MangoQuery, docsOnly?: boolean, ...args: ContextualArgs<Context<NanoFlags>>): Promise<R>;
-    view<R>(ddoc: string, viewName: string, options: Record<string, any>, ..._args: ContextualArgs<Context<NanoFlags>>): Promise<ViewResponse<R>>;
-    /**
-     * @description Establishes a connection to a Nano (CouchDB) server
-     * @summary Creates and returns a Nano ServerScope using the given credentials, host, and protocol
-     * @param {string} user - Username used for authentication
-     * @param {string} pass - Password used for authentication
-     * @param {string} [host="localhost:5984"] - Host and port of the CouchDB server
-     * @param {("http"|"https")} [protocol="http"] - Protocol to use for the connection
-     * @return {ServerScope} The Nano ServerScope connection
-     */
-    static connect(user: string, pass: string, host?: string, protocol?: "http" | "https", agent?: any): ServerScope;
-    /**
-     * @description Creates a new database on the Nano server
-     * @summary Creates a new database with the specified name on the connected Nano server
-     * @param {ServerScope} con - The Nano server connection
-     * @param {string} name - The name of the database to create
-     * @return {Promise<void>} A promise that resolves when the database is created
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant DB as Nano Server
-     *   A->>DB: db.create(name)
-     *   alt Success
-     *     DB-->>A: result with ok=true
-     *   else Error
-     *     DB-->>A: error
-     *     A-->>A: throw parseError(e)
-     *   else Not OK
-     *     DB-->>A: result with ok=false
-     *     A-->>A: throw parseError(error, reason)
-     *   end
-     */
-    static createDatabase(con: ServerScope, name: string): Promise<void>;
-    /**
-     * @description Deletes a database from the Nano server
-     * @summary Removes an existing database with the specified name from the connected Nano server
-     * @param {ServerScope} con - The Nano server connection
-     * @param {string} name - The name of the database to delete
-     * @return {Promise<void>} A promise that resolves when the database is deleted
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant DB as Nano Server
-     *   A->>DB: db.destroy(name)
-     *   alt Success
-     *     DB-->>A: result with ok=true
-     *   else Error
-     *     DB-->>A: error
-     *     A-->>A: throw parseError(e)
-     *   else Not OK
-     *     DB-->>A: result with ok=false
-     *     A-->>A: throw InternalError
-     *   end
-     */
-    static deleteDatabase(con: ServerScope, name: string): Promise<void>;
-    /**
-     * @description Closes the keep-alive agent associated with a Nano connection
-     * @summary Destroys the custom HTTP/HTTPS agent that was created during connection setup
-     * @param {ServerScope} con - The Nano server connection whose agent should be destroyed
-     */
-    static closeConnection(con?: ServerScope | null): void;
-    /**
-     * @description Creates a new user and grants access to a database
-     * @summary Creates a new user in the Nano server and configures security to grant the user access to a specific database
-     * @param {ServerScope} con - The Nano server connection
-     * @param {string} dbName - The name of the database to grant access to
-     * @param {string} user - The username to create
-     * @param {string} pass - The password for the new user
-     * @param {string[]} [roles=["reader", "writer"]] - The roles to assign to the user
-     * @return {Promise<void>} A promise that resolves when the user is created and granted access
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant U as _users Database
-     *   participant S as Security API
-     *   A->>A: Create user object
-     *   A->>U: insert(user)
-     *   alt Success
-     *     U-->>A: response with ok=true
-     *     A->>S: PUT _security with user permissions
-     *     alt Security Success
-     *       S-->>A: security response with ok=true
-     *     else Security Failure
-     *       S-->>A: security response with ok=false
-     *       A-->>A: throw InternalError
-     *     end
-     *   else Error
-     *     U-->>A: error
-     *     A-->>A: throw parseError(e)
-     *   else Not OK
-     *     U-->>A: response with ok=false
-     *     A-->>A: throw InternalError
-     *   end
-     */
-    static createUser(con: ServerScope, dbName: string, user: string, pass: string, roles?: string[]): Promise<void>;
-    /**
-     * @description Deletes a user from the Nano server
-     * @summary Removes an existing user from the Nano server
-     * @param {ServerScope} con - The Nano server connection
-     * @param {string} dbName - The name of the database (used for logging purposes)
-     * @param {string} user - The username to delete
-     * @return {Promise<void>} A promise that resolves when the user is deleted
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant U as _users Database
-     *   A->>A: Generate user ID
-     *   A->>U: get(id)
-     *   U-->>A: user document
-     *   A->>U: destroy(id, user._rev)
-     *   alt Success
-     *     U-->>A: success response
-     *   else Error
-     *     U-->>A: error
-     *     A-->>A: throw parseError(e)
-     *   end
-     */
-    static deleteUser(con: ServerScope, dbName: string, user: string): Promise<void>;
-    /**
-     * @description Sets up decorations for Nano-specific model properties
-     * @summary Configures decorators for created_by and updated_by fields in models to be automatically
-     * populated with the user from the context when documents are created or updated
-     * @return {void}
-     * @mermaid
-     * sequenceDiagram
-     *   participant A as NanoAdapter
-     *   participant D as Decoration
-     *   participant R as Repository
-     *   A->>R: key(PersistenceKeys.CREATED_BY)
-     *   R-->>A: createdByKey
-     *   A->>D: flavouredAs("nano")
-     *   A->>D: for(createdByKey)
-     *   A->>D: define(onCreate(createdByOnNanoCreateUpdate), propMetadata)
-     *   A->>D: apply()
-     *   A->>R: key(PersistenceKeys.UPDATED_BY)
-     *   R-->>A: updatedByKey
-     *   A->>D: flavouredAs("nano")
-     *   A->>D: for(updatedByKey)
-     *   A->>D: define(onCreate(createdByOnNanoCreateUpdate), propMetadata)
-     *   A->>D: apply()
-     */
-    static decoration(): void;
-}

package/lib/types/constants.d.ts

@@ -1,7 +0,0 @@
-/**
- * @description Identifier for the Nano database flavor
- * @summary Constant string that identifies the database type as "nano" for use in adapter selection and configuration
- * @const NanoFlavour
- * @memberOf module:for-nano
- */
-export declare const NanoFlavour = "nano";

package/lib/types/index.d.ts

@@ -1,23 +0,0 @@
-export * from "./constants";
-export * from "./NanoRepository";
-export * from "./types";
-export * from "./adapter";
-/**
- * @description A TypeScript module for interacting with Nano databases
- * @summary This module provides a set of utilities, classes, and types for working with Nano databases. It includes repository patterns, adapters, and type definitions to simplify database operations. Key exports include {@link NanoAdapter}, {@link NanoRepository}, {@link NanoFlags}, and {@link NanoFlavour}.
- * @module for-nano
- */
-/**
- * @description Package version identifier
- * @summary Stores the current package version string for the for-nano module
- * @const VERSION
- * @memberOf module:for-nano
- */
-export declare const VERSION = "0.8.0";
-/**
- * @description Package version identifier
- * @summary Stores the current package version string for the for-nano module
- * @const PACKAGE_NAME
- * @memberOf module:for-nano
- */
-export declare const PACKAGE_NAME = "@decaf-ts/for-nano";

package/lib/types/types.d.ts

@@ -1,39 +0,0 @@
-import { AdapterFlags } from "@decaf-ts/core";
-/**
- * @description Configuration flags for Nano database operations
- * @summary Extended repository flags that include user authentication information for Nano database connections
- * @interface NanoFlags
- * @memberOf module:for-nano
- */
-export interface NanoFlags extends AdapterFlags {
-    /**
-     * @description User authentication information for Nano database connections
-     */
-    user: {
-        /**
-         * @description Username for authentication with the Nano database
-         */
-        name: string;
-        /**
-         * @description Optional array of roles assigned to the user
-         */
-        roles?: string[];
-    };
-}
-/**
- * @description Connection configuration for Nano
- * @summary Defines the necessary parameters to establish a connection to a Nano (CouchDB) server and select a database
- * @property {string} user - Username to authenticate against the server
- * @property {string} password - Password to authenticate the user
- * @property {string} host - Host and port of the server (e.g., "localhost:5984") or full URL host without protocol
- * @property {string} dbName - The database name to use on the server
- * @typeDef NanoConfig
- * @memberOf module:for-nano
- */
-export type NanoConfig = {
-    user: string;
-    password: string;
-    host: string;
-    dbName: string;
-    protocol: "http" | "https";
-};