@decaf-ts/for-pouch 0.7.0 → 0.8.0

package/lib/cjs/index.cjs

@@ -34,7 +34,7 @@ __exportStar(require("./adapter.cjs"), exports);
  * @const VERSION
  * @memberOf module:for-pouch
  */
-exports.VERSION = "0.6.0";
+exports.VERSION = "0.7.0";
 /**
  * @description Package version identifier
  * @summary Stores the current version of the for-pouch package

package/lib/esm/index.js

@@ -17,7 +17,7 @@ export * from "./adapter.js";
  * @const VERSION
  * @memberOf module:for-pouch
  */
-export const VERSION = "0.6.0";
+export const VERSION = "0.7.0";
 /**
  * @description Package version identifier
  * @summary Stores the current version of the for-pouch package

package/lib/types/PouchRepository.d.cts

@@ -2,7 +2,7 @@ import { Model } from "@decaf-ts/decorator-validation";
 import { CouchDBRepository } from "@decaf-ts/for-couchdb";
 import { ContextOf, FlagsOf } from "@decaf-ts/core";
 import { Constructor } from "@decaf-ts/decoration";
-import { PouchAdapter } from "./adapter.cjs";
+import { PouchAdapter } from "./adapter.d.cts";
 /**
  * @description Repository implementation for PouchDB-backed models
  * @summary Extends the CouchDBRepository with PouchAdapter-specific overrides so the repository can be proxied with the correct flags.

package/lib/types/PouchRepository.d.mts

@@ -2,7 +2,7 @@ import { Model } from "@decaf-ts/decorator-validation";
 import { CouchDBRepository } from "@decaf-ts/for-couchdb";
 import { ContextOf, FlagsOf } from "@decaf-ts/core";
 import { Constructor } from "@decaf-ts/decoration";
-import { PouchAdapter } from "./adapter.js";
+import { PouchAdapter } from "./adapter.d.mts";
 /**
  * @description Repository implementation for PouchDB-backed models
  * @summary Extends the CouchDBRepository with PouchAdapter-specific overrides so the repository can be proxied with the correct flags.

package/lib/types/adapter.d.cts

@@ -4,8 +4,8 @@ import { BaseError, OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorator
 import { Adapter, Context, ContextOf, ContextualArgs, RelationsMetadata, Repository } from "@decaf-ts/core";
 import Database = PouchDB.Database;
 import { Model } from "@decaf-ts/decorator-validation";
-import { PouchConfig, PouchFlags } from "./types.cjs";
-import { PouchRepository } from "./PouchRepository.cjs";
+import { PouchConfig, PouchFlags } from "./types.d.cts";
+import { PouchRepository } from "./PouchRepository.d.cts";
 import { Constructor } from "@decaf-ts/decoration";
 /**
  * @description Sets the creator ID on a model during creation or update operations

package/lib/types/adapter.d.mts

@@ -4,8 +4,8 @@ import { BaseError, OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorator
 import { Adapter, Context, ContextOf, ContextualArgs, RelationsMetadata, Repository } from "@decaf-ts/core";
 import Database = PouchDB.Database;
 import { Model } from "@decaf-ts/decorator-validation";
-import { PouchConfig, PouchFlags } from "./types.js";
-import { PouchRepository } from "./PouchRepository.js";
+import { PouchConfig, PouchFlags } from "./types.d.mts";
+import { PouchRepository } from "./PouchRepository.d.mts";
 import { Constructor } from "@decaf-ts/decoration";
 /**
  * @description Sets the creator ID on a model during creation or update operations

package/lib/types/index.d.cts

@@ -1,7 +1,7 @@
-export * from "./constants.cjs";
-export * from "./PouchRepository.cjs";
-export * from "./types.cjs";
-export * from "./adapter.cjs";
+export * from "./constants.d.cts";
+export * from "./PouchRepository.d.cts";
+export * from "./types.d.cts";
+export * from "./adapter.d.cts";
 /**
  * @description A TypeScript adapter for PouchDB integration
  * @summary Provides a repository-pattern implementation backed by PouchDB, exposing the {@link PouchAdapter} to interface with databases, the {@link PouchRepository} for typed data access, configuration {@link module:for-pouch|constants} like {@link PouchFlavour} and {@link DefaultLocalStoragePath}, and related {@link module:for-pouch|types}. This module wires up decorators on load to support created/updated-by fields.
@@ -13,7 +13,7 @@ export * from "./adapter.cjs";
  * @const VERSION
  * @memberOf module:for-pouch
  */
-export declare const VERSION = "0.6.0";
+export declare const VERSION = "0.7.0";
 /**
  * @description Package version identifier
  * @summary Stores the current version of the for-pouch package

package/lib/types/index.d.mts

@@ -1,7 +1,7 @@
-export * from "./constants.js";
-export * from "./PouchRepository.js";
-export * from "./types.js";
-export * from "./adapter.js";
+export * from "./constants.d.mts";
+export * from "./PouchRepository.d.mts";
+export * from "./types.d.mts";
+export * from "./adapter.d.mts";
 /**
  * @description A TypeScript adapter for PouchDB integration
  * @summary Provides a repository-pattern implementation backed by PouchDB, exposing the {@link PouchAdapter} to interface with databases, the {@link PouchRepository} for typed data access, configuration {@link module:for-pouch|constants} like {@link PouchFlavour} and {@link DefaultLocalStoragePath}, and related {@link module:for-pouch|types}. This module wires up decorators on load to support created/updated-by fields.
@@ -13,7 +13,7 @@ export * from "./adapter.js";
  * @const VERSION
  * @memberOf module:for-pouch
  */
-export declare const VERSION = "0.6.0";
+export declare const VERSION = "0.7.0";
 /**
  * @description Package version identifier
  * @summary Stores the current version of the for-pouch package

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/for-pouch",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "decaf-ts persistence adapter for PouchDB",
   "type": "module",
   "exports": {

package/lib/types/PouchRepository.d.ts

@@ -1,15 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { CouchDBRepository } from "@decaf-ts/for-couchdb";
-import { ContextOf, FlagsOf } from "@decaf-ts/core";
-import { Constructor } from "@decaf-ts/decoration";
-import { PouchAdapter } from "./adapter";
-/**
- * @description Repository implementation for PouchDB-backed models
- * @summary Extends the CouchDBRepository with PouchAdapter-specific overrides so the repository can be proxied with the correct flags.
- * @template M - Model type managed by this repository
- * @memberOf module:for-pouch
- */
-export declare class PouchRepository<M extends Model> extends CouchDBRepository<M, PouchAdapter> {
-    constructor(adapter: PouchAdapter, model: Constructor<M>, force?: boolean);
-    override(flags: Partial<FlagsOf<ContextOf<PouchAdapter>>>): this;
-}

package/lib/types/adapter.d.ts

@@ -1,427 +0,0 @@
-import "reflect-metadata";
-import { CouchDBAdapter, MangoQuery, ViewResponse } from "@decaf-ts/for-couchdb";
-import { BaseError, OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
-import { Adapter, Context, ContextOf, ContextualArgs, RelationsMetadata, Repository } from "@decaf-ts/core";
-import Database = PouchDB.Database;
-import { Model } from "@decaf-ts/decorator-validation";
-import { PouchConfig, PouchFlags } from "./types";
-import { PouchRepository } from "./PouchRepository";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @description Sets the creator ID on a model during creation or update operations
- * @summary This function is used as a decorator handler to automatically set the creator ID field on a model
- * when it's being created or updated. It extracts the UUID from the context and assigns it to the specified key.
- * @template M - The model type that extends Model
- * @template R - The repository type that extends PouchRepository<M>
- * @template V - The relations metadata type that extends RelationsMetadata
- * @param {R} this - The repository instance
- * @param {Context<PouchFlags>} context - The operation context containing flags
- * @param {V} data - The relations metadata
- * @param key - The property key to set on the model
- * @param {M} model - The model instance to modify
- * @return {Promise<void>} A promise that resolves when the operation is complete
- * @function createdByOnPouchCreateUpdate
- * @memberOf module:for-pouch
- */
-export declare function createdByOnPouchCreateUpdate<M extends Model, R extends PouchRepository<M>, V extends RelationsMetadata>(this: R, context: ContextOf<R>, data: V, key: keyof M, model: M): Promise<void>;
-/**
- * @description PouchDB implementation of the CouchDBAdapter
- * @summary Concrete adapter that bridges the generic CouchDBAdapter to a PouchDB backend. It supports CRUD (single and bulk), indexing and Mango queries, and wires flavour-specific decorations.
- * @template PouchFlags - The flags specific to PouchDB operations
- * @template Context<PouchFlags> - The context type with PouchDB flags
- * @param {PouchConfig} config - Adapter configuration (remote credentials or local storage path, db name, plugins)
- * @param {string} [alias] - Optional alias for the database
- * @class PouchAdapter
- * @example
- * ```typescript
- * import { PouchAdapter } from '@decaf-ts/for-pouch';
- *
- * // Create a PouchAdapter with config
- * const adapter = new PouchAdapter({
- *   protocol: 'http',
- *   host: 'localhost:5984',
- *   user: 'admin',
- *   password: 'secret',
- *   dbName: 'my-database',
- *   plugins: []
- * });
- *
- * // Or use local storage
- * const localAdapter = new PouchAdapter({
- *   protocol: 'http', // ignored for local
- *   dbName: 'local-db',
- *   storagePath: 'local_dbs',
- *   plugins: []
- * });
- *
- * // Use the adapter for database operations
- * const result = await adapter.read('users', 'user-123');
- * ```
- * @mermaid
- * sequenceDiagram
- *   participant Client
- *   participant PouchAdapter
- *   participant PouchDB
- *   participant CouchDB
- *
- *   Client->>PouchAdapter: new PouchAdapter(config, alias?)
- *   PouchAdapter->>CouchDBAdapter: super(config, PouchFlavour, alias)
- *
- *   Client->>PouchAdapter: create(table, id, model)
- *   PouchAdapter->>PouchDB: put(model)
- *   PouchDB->>CouchDB: HTTP PUT
- *   CouchDB-->>PouchDB: Response
- *   PouchDB-->>PouchAdapter: Response
- *   PouchAdapter-->>Client: Updated model
- *
- *   Client->>PouchAdapter: read(table, id)
- *   PouchAdapter->>PouchDB: get(id)
- *   PouchDB->>CouchDB: HTTP GET
- *   CouchDB-->>PouchDB: Document
- *   PouchDB-->>PouchAdapter: Document
- *   PouchAdapter-->>Client: Model
- */
-export declare class PouchAdapter extends CouchDBAdapter<PouchConfig, Database, Context<PouchFlags>> {
-    constructor(config: PouchConfig, alias?: string);
-    private _adminClient?;
-    private _pluginsRegistered;
-    private registerPlugins;
-    private buildClient;
-    protected getAdminClient(): Database;
-    /**
-     * @description Lazily initializes and returns the underlying PouchDB client
-     * @summary Loads required PouchDB plugins once, builds the connection URL or local storage path from config, and caches the Database instance for reuse. Throws InternalError if client creation fails.
-     * @return {Database} A PouchDB Database instance ready to perform operations
-     * @mermaid
-     * sequenceDiagram
-     *   participant Caller
-     *   participant PouchAdapter
-     *   participant PouchDB
-     *   Caller->>PouchAdapter: getClient()
-     *   alt client not initialized
-     *     PouchAdapter->>PouchAdapter: register plugins
-     *     PouchAdapter->>PouchDB: new PouchDB(url or path)
-     *     alt creation fails
-     *       PouchDB-->>PouchAdapter: Error
-     *       PouchAdapter-->>Caller: throws InternalError
-     *     else success
-     *       PouchDB-->>PouchAdapter: Database
-     *       PouchAdapter-->>Caller: cached client
-     *     end
-     *   else client initialized
-     *     PouchAdapter-->>Caller: cached client
-     *   end
-     */
-    getClient(): Database;
-    /**
-     * @description Generates operation flags for PouchDB operations
-     * @summary Creates a set of flags for a specific operation, including a UUID for identification.
-     * This method extracts the user ID from the database URL or generates a random UUID if not available.
-     * @template M - The model type that extends Model
-     * @param {OperationKeys} operation - The operation key (create, read, update, delete)
-     * @param {Constructor<M>} model - The model constructor
-     * @param {Partial<PouchFlags>} flags - Partial flags to be merged
-     * @return {Promise<PouchFlags>} The complete set of flags for the operation
-     */
-    protected flags<M extends Model>(operation: OperationKeys, model: Constructor<M>, flags: Partial<PouchFlags>, ...args: any[]): Promise<PouchFlags>;
-    repository<R extends Repository<any, Adapter<PouchConfig, Database, MangoQuery, Context<PouchFlags>>>>(): Constructor<R>;
-    /**
-     * @description Creates database indexes for the given models
-     * @summary Generates and creates indexes in the PouchDB database based on the provided model constructors.
-     * This method uses the generateIndexes utility to create index definitions and then creates them in the database.
-     * @template M - The model type that extends Model
-     * @param models - The model constructors to create indexes for
-     * @return {Promise<void>} A promise that resolves when all indexes are created
-     */
-    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 PouchDB database using the put operation.
-     * This method handles error parsing and ensures the operation was successful.
-     * @param {string} tableName - The name of the table/collection
-     * @param {string|number} id - The document ID
-     * @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 Client
-     *   participant PouchAdapter
-     *   participant PouchDB
-     *
-     *   Client->>PouchAdapter: create(tableName, id, model)
-     *   PouchAdapter->>PouchDB: put(model)
-     *   alt Success
-     *     PouchDB-->>PouchAdapter: Response with ok=true
-     *     PouchAdapter->>PouchAdapter: assignMetadata(model, response.rev)
-     *     PouchAdapter-->>Client: Updated model with metadata
-     *   else Error
-     *     PouchDB-->>PouchAdapter: Error
-     *     PouchAdapter->>PouchAdapter: parseError(e)
-     *     PouchAdapter-->>Client: Throws error
-     *   end
-     */
-    create<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<Context<PouchFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Creates multiple documents in the database in a single operation
-     * @summary Inserts multiple documents into the PouchDB database using the bulkDocs operation.
-     * This method handles error parsing and ensures all operations were successful.
-     * @param {string} tableName - The name of the table/collection
-     * @param {string[]|number[]} ids - The document IDs
-     * @param  models - The document data to insert
-     * @return A promise that resolves to the created documents with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant Client
-     *   participant PouchAdapter
-     *   participant PouchDB
-     *
-     *   Client->>PouchAdapter: createAll(tableName, ids, models)
-     *   PouchAdapter->>PouchDB: bulkDocs(models)
-     *   alt Success
-     *     PouchDB-->>PouchAdapter: Array of responses with ok=true
-     *     PouchAdapter->>PouchAdapter: assignMultipleMetadata(models, revs)
-     *     PouchAdapter-->>Client: Updated models with metadata
-     *   else Error
-     *     PouchDB-->>PouchAdapter: Array with errors
-     *     PouchAdapter->>PouchAdapter: Check for errors
-     *     PouchAdapter-->>Client: Throws InternalError
-     *   end
-     */
-    createAll<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], models: Record<string, any>[], ...args: ContextualArgs<Context<PouchFlags>>): Promise<Record<string, any>[]>;
-    /**
-     * @description Retrieves a document from the database by ID
-     * @summary Fetches a document from the PouchDB database using the get operation.
-     * This method generates the document ID based on the table name and ID, then retrieves the document.
-     * @param {string} tableName - The name of the table/collection
-     * @param {string|number} id - The document ID
-     * @return {Promise<Record<string, any>>} A promise that resolves to the retrieved document with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant Client
-     *   participant PouchAdapter
-     *   participant PouchDB
-     *
-     *   Client->>PouchAdapter: read(tableName, id)
-     *   PouchAdapter->>PouchAdapter: generateId(tableName, id)
-     *   PouchAdapter->>PouchDB: get(_id)
-     *   alt Success
-     *     PouchDB-->>PouchAdapter: Document
-     *     PouchAdapter->>PouchAdapter: assignMetadata(record, record._rev)
-     *     PouchAdapter-->>Client: Document with metadata
-     *   else Error
-     *     PouchDB-->>PouchAdapter: Error
-     *     PouchAdapter->>PouchAdapter: parseError(e)
-     *     PouchAdapter-->>Client: Throws error
-     *   end
-     */
-    read<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<Context<PouchFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Retrieves multiple documents from the database by their IDs
-     * @summary Fetches multiple documents from the PouchDB database using the bulkGet operation.
-     * This method generates document IDs based on the table name and IDs, then retrieves the documents.
-     * @param {string} tableName - The name of the table/collection
-     * @param {Array<string|number|bigint>} ids - The document IDs
-     * @return A promise that resolves to the retrieved documents with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant Client
-     *   participant PouchAdapter
-     *   participant PouchDB
-     *
-     *   Client->>PouchAdapter: readAll(tableName, ids)
-     *   PouchAdapter->>PouchAdapter: Map ids to generateId(tableName, id)
-     *   PouchAdapter->>PouchDB: bulkGet({docs})
-     *   alt Success
-     *     PouchDB-->>PouchAdapter: BulkGetResponse
-     *     PouchAdapter->>PouchAdapter: Process results
-     *     PouchAdapter->>PouchAdapter: assignMetadata for each doc
-     *     PouchAdapter-->>Client: Documents with metadata
-     *   else Error
-     *     PouchAdapter->>PouchAdapter: parseError(error)
-     *     PouchAdapter-->>Client: Throws error
-     *   end
-     */
-    readAll<M extends Model>(tableName: Constructor<M>, ids: (string | number | bigint)[], ...args: ContextualArgs<Context<PouchFlags>>): Promise<Record<string, any>[]>;
-    /**
-     * @description Updates an existing document in the database
-     * @summary Updates a document in the PouchDB database using the put operation.
-     * This method handles error parsing and ensures the operation was successful.
-     * @param {string} tableName - The name of the table/collection
-     * @param {string|number} id - The document ID
-     * @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 Client
-     *   participant PouchAdapter
-     *   participant PouchDB
-     *
-     *   Client->>PouchAdapter: update(tableName, id, model)
-     *   PouchAdapter->>PouchDB: put(model)
-     *   alt Success
-     *     PouchDB-->>PouchAdapter: Response with ok=true
-     *     PouchAdapter->>PouchAdapter: assignMetadata(model, response.rev)
-     *     PouchAdapter-->>Client: Updated model with metadata
-     *   else Error
-     *     PouchDB-->>PouchAdapter: Error
-     *     PouchAdapter->>PouchAdapter: parseError(e)
-     *     PouchAdapter-->>Client: Throws error
-     *   end
-     */
-    update<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<Context<PouchFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Updates multiple documents in the database in a single operation
-     * @summary Updates multiple documents in the PouchDB database using the bulkDocs operation.
-     * This method handles error parsing and ensures all operations were successful.
-     * @param {string} tableName - The name of the table/collection
-     * @param {string[]|number[]} ids - The document IDs
-     * @param models - The updated document data
-     * @return A promise that resolves to the updated documents with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant Client
-     *   participant PouchAdapter
-     *   participant PouchDB
-     *
-     *   Client->>PouchAdapter: updateAll(tableName, ids, models)
-     *   PouchAdapter->>PouchDB: bulkDocs(models)
-     *   alt Success
-     *     PouchDB-->>PouchAdapter: Array of responses with ok=true
-     *     PouchAdapter->>PouchAdapter: assignMultipleMetadata(models, revs)
-     *     PouchAdapter-->>Client: Updated models with metadata
-     *   else Error
-     *     PouchDB-->>PouchAdapter: Array with errors
-     *     PouchAdapter->>PouchAdapter: Check for errors
-     *     PouchAdapter-->>Client: Throws InternalError
-     *   end
-     */
-    updateAll<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], models: Record<string, any>[], ...args: ContextualArgs<Context<PouchFlags>>): Promise<Record<string, any>[]>;
-    /**
-     * @description Deletes a document from the database by ID
-     * @summary Removes a document from the PouchDB database using the remove operation.
-     * This method first retrieves the document to get its revision, then deletes it.
-     * @param {string} tableName - The name of the table/collection
-     * @param {string|number} id - The document ID
-     * @return {Promise<Record<string, any>>} A promise that resolves to the deleted document with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant Client
-     *   participant PouchAdapter
-     *   participant PouchDB
-     *
-     *   Client->>PouchAdapter: delete(tableName, id)
-     *   PouchAdapter->>PouchAdapter: generateId(tableName, id)
-     *   PouchAdapter->>PouchDB: get(_id)
-     *   PouchDB-->>PouchAdapter: Document with _rev
-     *   PouchAdapter->>PouchDB: remove(_id, record._rev)
-     *   alt Success
-     *     PouchDB-->>PouchAdapter: Success response
-     *     PouchAdapter->>PouchAdapter: assignMetadata(record, record._rev)
-     *     PouchAdapter-->>Client: Deleted document with metadata
-     *   else Error
-     *     PouchDB-->>PouchAdapter: Error
-     *     PouchAdapter->>PouchAdapter: parseError(e)
-     *     PouchAdapter-->>Client: Throws error
-     *   end
-     */
-    delete<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<Context<PouchFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Deletes multiple documents from the database by their IDs
-     * @summary Removes multiple documents from the PouchDB database in a single operation.
-     * This method first retrieves all documents to get their revisions, then marks them as deleted.
-     * @param {string} tableName - The name of the table/collection
-     * @param {Array<string|number|bigint>} ids - The document IDs
-     * @return A promise that resolves to the deleted documents with metadata
-     * @mermaid
-     * sequenceDiagram
-     *   participant Client
-     *   participant PouchAdapter
-     *   participant PouchDB
-     *
-     *   Client->>PouchAdapter: deleteAll(tableName, ids)
-     *   PouchAdapter->>PouchAdapter: Map ids to generateId(tableName, id)
-     *   PouchAdapter->>PouchDB: bulkGet({docs})
-     *   PouchDB-->>PouchAdapter: BulkGetResponse with documents
-     *   PouchAdapter->>PouchAdapter: Mark documents as deleted
-     *   PouchAdapter->>PouchDB: bulkDocs(marked documents)
-     *   alt Success
-     *     PouchDB-->>PouchAdapter: Success responses
-     *     PouchAdapter->>PouchAdapter: Process results
-     *     PouchAdapter->>PouchAdapter: assignMetadata for each doc
-     *     PouchAdapter-->>Client: Deleted documents with metadata
-     *   else Error
-     *     PouchAdapter->>PouchAdapter: Check for errors
-     *     PouchAdapter-->>Client: Throws InternalError
-     *   end
-     */
-    deleteAll<M extends Model>(tableName: Constructor<M>, ids: (string | number | bigint)[], ...args: ContextualArgs<Context<PouchFlags>>): Promise<Record<string, any>[]>;
-    /**
-     * @description Executes a raw Mango query against the database
-     * @summary Runs a Mango query and optionally returns only the documents array or the entire response
-     * @template V - The return value type
-     * @param {MangoQuery} rawInput - The Mango query to execute
-     * @param {boolean} [docsOnly=true] - Whether to return only the documents array
-     * @return {Promise<V>} A promise resolving the query result
-     */
-    raw<V>(rawInput: MangoQuery, docsOnly?: boolean, ...args: ContextualArgs<Context<PouchFlags>>): Promise<V>;
-    view<R>(ddoc: string, viewName: string, options: Record<string, any>, ..._args: ContextualArgs<Context<PouchFlags>>): Promise<ViewResponse<R>>;
-    /**
-     * @description Parses and converts errors from PouchDB to application-specific errors
-     * @summary Converts PouchDB errors to the application's error hierarchy.
-     * This instance method delegates to the static parseError method.
-     * @param {Error|string} err - The error object or message to parse
-     * @param {string} [reason] - Optional reason for the error
-     * @return {BaseError} The converted error object
-     */
-    parseError<E extends BaseError>(err: Error | string, reason?: string): E;
-    /**
-     * @description Static method to parse and convert errors from PouchDB to application-specific errors
-     * @summary Converts PouchDB errors to the application's error hierarchy based on error codes and messages.
-     * This method analyzes the error type, status code, or message to determine the appropriate error class.
-     * @param {Error|string} err - The error object or message to parse
-     * @param {string} [reason] - Optional reason for the error
-     * @return {BaseError} The converted error object
-     * @mermaid
-     * sequenceDiagram
-     *   participant Caller
-     *   participant PouchAdapter
-     *
-     *   Caller->>PouchAdapter: parseError(err, reason)
-     *   alt err is BaseError
-     *     PouchAdapter-->>Caller: Return err as is
-     *   else err is string
-     *     alt contains "already exist" or "update conflict"
-     *       PouchAdapter-->>Caller: ConflictError
-     *     else contains "missing" or "deleted"
-     *       PouchAdapter-->>Caller: NotFoundError
-     *     end
-     *   else err has status/statusCode/code
-     *     Note over PouchAdapter: Extract code and reason
-     *   else
-     *     Note over PouchAdapter: Use err.message as code
-     *   end
-     *
-     *   Note over PouchAdapter: Switch on code
-     *   alt code is 401, 412, or 409
-     *     PouchAdapter->>ErrorTypes: ConflictError
-     *   else code is 404
-     *     PouchAdapter->>ErrorTypes: NotFoundError
-     *   else code is 400
-     *     alt code contains "No index exists"
-     *       PouchAdapter->>ErrorTypes: IndexError
-     *     else
-     *       PouchAdapter->>ErrorTypes: InternalError
-     *   else code contains "ECONNREFUSED"
-     *     PouchAdapter->>ErrorTypes: ConnectionError
-     *   else
-     *     PouchAdapter->>ErrorTypes: InternalError
-     *   end
-     */
-    static parseError<E extends BaseError>(err: Error | string, reason?: string): E;
-    /**
-     * @description Sets up decorations for PouchDB-specific model properties
-     * @summary Configures decorators for createdBy and updatedBy fields in models.
-     * This method defines how these fields should be automatically populated during create and update operations.
-     */
-    static decoration(): void;
-}

package/lib/types/constants.d.ts

@@ -1,15 +0,0 @@
-/**
- * @description Identifier for PouchDB flavor in the decorator system
- * @summary A string constant that identifies the PouchDB implementation in the decorator system.
- * This is used to target decorators specifically for PouchDB adapters.
- * @const PouchFlavour
- * @memberOf module:for-pouch
- */
-export declare const PouchFlavour = "pouch";
-/**
- * @description Default relative path where local PouchDB databases are stored
- * @summary Used when creating a local PouchDB instance without a remote host; combined with dbName to form the filesystem path.
- * @const DefaultLocalStoragePath
- * @memberOf module:for-pouch
- */
-export declare const DefaultLocalStoragePath = "local_dbs";

package/lib/types/index.d.ts

@@ -1,23 +0,0 @@
-export * from "./constants";
-export * from "./PouchRepository";
-export * from "./types";
-export * from "./adapter";
-/**
- * @description A TypeScript adapter for PouchDB integration
- * @summary Provides a repository-pattern implementation backed by PouchDB, exposing the {@link PouchAdapter} to interface with databases, the {@link PouchRepository} for typed data access, configuration {@link module:for-pouch|constants} like {@link PouchFlavour} and {@link DefaultLocalStoragePath}, and related {@link module:for-pouch|types}. This module wires up decorators on load to support created/updated-by fields.
- * @module for-pouch
- */
-/**
- * @description Package version identifier
- * @summary Stores the current version of the for-pouch package
- * @const VERSION
- * @memberOf module:for-pouch
- */
-export declare const VERSION = "0.6.0";
-/**
- * @description Package version identifier
- * @summary Stores the current version of the for-pouch package
- * @const VERSION
- * @memberOf module:for-pouch
- */
-export declare const PACKAGE_NAME = "@decaf-ts/for-pouch";

package/lib/types/types.d.ts

@@ -1,41 +0,0 @@
-import { AdapterFlags } from "@decaf-ts/core";
-/**
- * @description Flags specific to PouchDB repository operations
- * @summary Extends the base repository flags with PouchDB-specific properties.
- * These flags are used to pass additional information during repository operations.
- * @interface PouchFlags
- * @memberOf module:for-pouch
- */
-export interface PouchFlags extends AdapterFlags {
-    /**
-     * @description Unique identifier for the current user or operation
-     */
-    UUID: string;
-}
-/**
- * @description Configuration options for initializing a PouchDB adapter
- * @summary Defines connection credentials, local storage options, database name, and a list of PouchDB plugins to register before client creation.
- * @template
- * @property {string} [user] - Username for remote HTTP/S connections
- * @property {string} [password] - Password for remote HTTP/S connections
- * @property {string} [host] - Host (and optional port) of the remote CouchDB-compatible server
- * @property {("http"|"https")} [protocol] - Network protocol to use when connecting remotely
- * @property {number} [port] - Optional explicit port number; if provided may be part of host instead
- * @property {string} dbName - Database name used in the URL or local path
- * @property {string} [storagePath] - Relative base path for local databases; defaults to {@link DefaultLocalStoragePath}
- * @property {any[]} plugins - List of PouchDB plugins (modules) to register with the client
- * @typeDef PouchConfig
- * @memberOf module:for-pouch
- */
-export type PouchConfig = {
-    user?: string;
-    password?: string;
-    adminUser?: string;
-    adminPassword?: string;
-    host?: string;
-    protocol?: "http" | "https";
-    port?: number;
-    dbName: string;
-    storagePath?: string;
-    plugins: any[];
-};