@decaf-ts/for-couchdb 0.12.0 → 0.13.0

package/lib/types/query/Statement.d.ts

@@ -1,195 +0,0 @@
-import { Adapter, AdapterFlags, Condition, ContextOf, SelectSelector, Statement, UnsupportedError, ViewKind } from "@decaf-ts/core";
-import { MangoQuery, MangoSelector, ViewResponse } from "../types";
-import { Model } from "@decaf-ts/decorator-validation";
-import { CouchDBViewMetadata } from "../views/types";
-import { CouchDBAdapter } from "../adapter";
-type CouchDBViewDescriptor = {
-    ddoc: string;
-    view: string;
-    options: Record<string, any>;
-};
-type CouchDBAggregateInfo = {
-    kind: ViewKind;
-    meta: CouchDBViewMetadata;
-    descriptor: CouchDBViewDescriptor;
-    countDistinct?: boolean;
-} | {
-    kind: "avg";
-    attribute: string;
-    sumDescriptor: CouchDBViewDescriptor;
-    countDescriptor: CouchDBViewDescriptor;
-};
-/**
- * @description Statement builder for CouchDB Mango queries
- * @summary Provides a fluent interface for building CouchDB Mango queries with type safety
- * @template M - The model type that extends Model
- * @template R - The result type
- * @param adapter - The CouchDB adapter
- * @class CouchDBStatement
- * @example
- * // Example of using CouchDBStatement
- * const adapter = new MyCouchDBAdapter(scope);
- * const statement = new CouchDBStatement<User, User[]>(adapter);
- *
- * // Build a query
- * const users = await statement
- *   .from(User)
- *   .where(Condition.attribute<User>('age').gt(18))
- *   .orderBy('lastName', 'asc')
- *   .limit(10)
- *   .execute();
- */
-export declare class CouchDBStatement<M extends Model, A extends Adapter<any, any, MangoQuery, any>, R> extends Statement<M, A, R, MangoQuery> {
-    protected manualAggregation?: CouchDBAggregateInfo;
-    protected attributeTypeCache: Map<string, string | undefined>;
-    constructor(adapter: A, overrides?: Partial<AdapterFlags>);
-    /**
-     * @description Builds a CouchDB Mango query from the statement
-     * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query
-     * @return {MangoQuery} The built Mango query
-     * @throws {Error} If there are invalid query conditions
-     * @mermaid
-     * sequenceDiagram
-     *   participant Statement
-     *   participant Repository
-     *   participant parseCondition
-     *
-     *   Statement->>Statement: build()
-     *   Note over Statement: Initialize selectors
-     *   Statement->>Repository: Get table name
-     *   Repository-->>Statement: Return table name
-     *   Statement->>Statement: Create base query
-     *
-     *   alt Has selectSelector
-     *     Statement->>Statement: Add fields to query
-     *   end
-     *
-     *   alt Has whereCondition
-     *     Statement->>Statement: Create combined condition with table
-     *     Statement->>parseCondition: Parse condition
-     *     parseCondition-->>Statement: Return parsed condition
-     *
-     *     alt Is group operator
-     *       alt Is AND operator
-     *         Statement->>Statement: Flatten nested AND conditions
-     *       else Is OR operator
-     *         Statement->>Statement: Combine with table condition
-     *       else
-     *         Statement->>Statement: Throw error
-     *       end
-     *     else
-     *       Statement->>Statement: Merge conditions with existing selector
-     *     end
-     *   end
-     *
-     *   alt Has orderBySelector
-     *     Statement->>Statement: Add sort to query
-     *     Statement->>Statement: Ensure field exists in selector
-     *   end
-     *
-     *   alt Has limitSelector
-     *     Statement->>Statement: Set limit
-     *   else
-     *     Statement->>Statement: Use default limit
-     *   end
-     *
-     *   alt Has offsetSelector
-     *     Statement->>Statement: Set skip
-     *   end
-     *
-     *   Statement-->>Statement: Return query
-     */
-    protected build(): MangoQuery;
-    protected attachDefaultQueryIndex(query: MangoQuery): void;
-    protected collectStartsWithRangeAttrs(selector: MangoSelector): Set<string>;
-    /**
-     * @description Processes a record from CouchDB
-     * @summary Extracts the ID from a CouchDB document and reverts it to a model instance
-     * @param {any} r - The raw record from CouchDB
-     * @param pkAttr - The primary key attribute of the model
-     * @param {"Number" | "BigInt" | undefined} sequenceType - The type of the sequence
-     * @return {any} The processed record
-     */
-    protected processRecord(record: any, ctx: ContextOf<A>): M;
-    /**
-     * @description Executes a raw Mango query
-     * @summary Sends a raw Mango query to CouchDB and processes the results
-     * @template R - The result type
-     * @param {MangoQuery} rawInput - The raw Mango query to execute
-     * @return {Promise<R>} A promise that resolves to the query results
-     */
-    raw<R>(rawInput: MangoQuery, ...args: any[]): Promise<R>;
-    /**
-     * @description Parses a condition into a CouchDB Mango query selector
-     * @summary Converts a Condition object into a CouchDB Mango query selector structure
-     * @param {Condition<M>} condition - The condition to parse
-     * @return {MangoQuery} The Mango query with the parsed condition as its selector
-     * @mermaid
-     * sequenceDiagram
-     *   participant Statement
-     *   participant translateOperators
-     *   participant merge
-     *
-     *   Statement->>Statement: parseCondition(condition)
-     *
-     *   Note over Statement: Extract condition parts
-     *
-     *   alt Simple comparison operator
-     *     Statement->>translateOperators: translateOperators(operator)
-     *     translateOperators-->>Statement: Return CouchDB operator
-     *     Statement->>Statement: Create selector with attribute and operator
-     *   else NOT operator
-     *     Statement->>Statement: parseCondition(attr1)
-     *     Statement->>translateOperators: translateOperators(Operator.NOT)
-     *     translateOperators-->>Statement: Return CouchDB NOT operator
-     *     Statement->>Statement: Create negated selector
-     *   else AND/OR operator
-     *     Statement->>Statement: parseCondition(attr1)
-     *     Statement->>Statement: parseCondition(comparison)
-     *     Statement->>translateOperators: translateOperators(operator)
-     *     translateOperators-->>Statement: Return CouchDB group operator
-     *     Statement->>merge: merge(operator, op1, op2)
-     *     merge-->>Statement: Return merged selector
-     *   end
-     *
-     *   Statement-->>Statement: Return query with selector
-     */
-    protected buildAggregateInfo(): CouchDBAggregateInfo | undefined;
-    protected createAggregateDescriptor(kind: ViewKind, attribute?: string): Extract<CouchDBAggregateInfo, {
-        kind: ViewKind;
-    }> | undefined;
-    protected createAggregateQuery(info: CouchDBAggregateInfo): MangoQuery & {
-        aggregate: true;
-        aggregateInfo: CouchDBAggregateInfo;
-    };
-    protected shouldUseManualAggregation(): boolean;
-    protected executeAggregate<R>(info: CouchDBAggregateInfo, ctx: ContextOf<A>): Promise<R>;
-    protected handleAverage<R>(info: CouchDBAggregateInfo, ctx: ContextOf<A>): Promise<R>;
-    protected executeManualAggregation<R>(docs: any[], info: CouchDBAggregateInfo, ctx: ContextOf<A>): R;
-    protected computeCount<R>(docs: any[], attribute?: string): R;
-    protected computeDistinctCount<R>(docs: any[], attribute?: string): R;
-    protected computeDistinctValues<R>(docs: any[], attribute?: string): R;
-    protected computeSum<R>(docs: any[], attribute?: string): R;
-    protected computeAverage<R>(docs: any[], attribute?: string): R;
-    protected computeMinMax<R>(docs: any[], attribute: string | undefined, mode: "min" | "max"): R;
-    protected computeGroupBy<R>(docs: any[], attribute: string): R;
-    protected groupSelectResults(docs: any[]): Record<string, any[]>;
-    protected collectValues(docs: any[], attribute: string): any[];
-    protected convertValueByAttribute(attribute: string, value: any): any;
-    protected getAttributeType(attribute?: string): string | undefined;
-    protected normalizeMetaType(metaType: any): string | undefined;
-    protected normalizeComparable(value: any): number | null;
-    protected groupKey(value: any): string;
-    protected toNumericValue(value: any, field: string, context: string): number;
-    protected convertAggregateValue(attribute: string | undefined, value: any): any;
-    protected resolveSelectorAttribute(selector?: SelectSelector<M> | null): string | undefined;
-    protected missingDecorator(kind: ViewKind | "avg", attribute?: string): UnsupportedError;
-    protected decoratorForKind(kind: ViewKind | "avg"): string;
-    protected processViewResponse<R>(info: CouchDBAggregateInfo, response: ViewResponse): R;
-    protected isViewAggregate(info: CouchDBAggregateInfo): info is Extract<CouchDBAggregateInfo, {
-        kind: ViewKind;
-    }>;
-    protected getCouchAdapter(): CouchDBAdapter<any, any, any>;
-    protected parseCondition(condition: Condition<M>): MangoQuery;
-}
-export {};

package/lib/types/query/constants.d.ts

@@ -1,47 +0,0 @@
-import { MangoOperator } from "../types";
-/**
- * @description Default query limit for CouchDB queries
- * @summary Maximum number of documents to return in a single query
- * @const CouchDBQueryLimit
- * @memberOf module:for-couchdb
- */
-export declare const CouchDBQueryLimit = 250;
-/**
- * @description Mapping of operator names to CouchDB Mango query operators
- * @summary Constants for CouchDB comparison operators used in Mango queries
- * @typedef {Object} CouchDBOperatorType
- * @property {string} EQUAL - Equality operator ($eq)
- * @property {string} DIFFERENT - Inequality operator ($ne)
- * @property {string} BIGGER - Greater than operator ($gt)
- * @property {string} BIGGER_EQ - Greater than or equal operator ($gte)
- * @property {string} SMALLER - Less than operator ($lt)
- * @property {string} SMALLER_EQ - Less than or equal operator ($lte)
- * @property {string} NOT - Negation operator ($not)
- * @property {string} IN - In array operator ($in)
- * @property {string} REGEXP - Regular expression operator ($regex)
- * @const CouchDBOperator
- * @type {CouchDBOperatorType}
- * @memberOf module:for-couchdb
- */
-export declare const CouchDBOperator: Record<string, MangoOperator>;
-/**
- * @description Mapping of logical operator names to CouchDB Mango query operators
- * @summary Constants for CouchDB logical operators used in Mango queries
- * @typedef {Object} CouchDBGroupOperatorType
- * @property {string} AND - Logical AND operator ($and)
- * @property {string} OR - Logical OR operator ($or)
- * @const CouchDBGroupOperator
- * @type {CouchDBGroupOperatorType}
- * @memberOf module:for-couchdb
- */
-export declare const CouchDBGroupOperator: Record<string, MangoOperator>;
-/**
- * @description Special constant values used in CouchDB queries
- * @summary String constants representing special values in CouchDB
- * @typedef {Object} CouchDBConstType
- * @property {string} NULL - String representation of null value
- * @const CouchDBConst
- * @type {CouchDBConstType}
- * @memberOf module:for-couchdb
- */
-export declare const CouchDBConst: Record<string, string>;

package/lib/types/query/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./constants";
-export * from "./Paginator";
-export * from "./Statement";
-export * from "./translate";

package/lib/types/query/translate.d.ts

@@ -1,34 +0,0 @@
-import { GroupOperator, Operator } from "@decaf-ts/core";
-import { MangoOperator } from "../types";
-/**
- * @description Translates core operators to CouchDB Mango operators
- * @summary Converts Decaf.ts core operators to their equivalent CouchDB Mango query operators
- * @param {GroupOperator | Operator} operator - The core operator to translate
- * @return {MangoOperator} The equivalent CouchDB Mango operator
- * @throws {QueryError} If no translation exists for the given operator
- * @function translateOperators
- * @memberOf module:for-couchdb
- * @mermaid
- * sequenceDiagram
- *   participant Caller
- *   participant translateOperators
- *   participant CouchDBOperator
- *   participant CouchDBGroupOperator
- *
- *   Caller->>translateOperators: operator
- *
- *   translateOperators->>CouchDBOperator: Check for match
- *   alt Found in CouchDBOperator
- *     CouchDBOperator-->>translateOperators: Return matching operator
- *     translateOperators-->>Caller: Return MangoOperator
- *   else Not found
- *     translateOperators->>CouchDBGroupOperator: Check for match
- *     alt Found in CouchDBGroupOperator
- *       CouchDBGroupOperator-->>translateOperators: Return matching operator
- *       translateOperators-->>Caller: Return MangoOperator
- *     else Not found
- *       translateOperators-->>Caller: Throw QueryError
- *     end
- *   end
- */
-export declare function translateOperators(operator: GroupOperator | Operator): MangoOperator;

package/lib/types/repository.d.ts

@@ -1,39 +0,0 @@
-import { MaybeContextualArg, Repository } from "@decaf-ts/core";
-import { Model } from "@decaf-ts/decorator-validation";
-import { Constructor } from "@decaf-ts/decoration";
-import type { CouchDBAdapter } from "./adapter";
-import { ContextOf } from "@decaf-ts/core";
-import type { PrimaryKeyType } from "@decaf-ts/db-decorators";
-export declare class CouchDBRepository<M extends Model, A extends CouchDBAdapter<any, any, any>> extends Repository<M, A> {
-    constructor(adapter: A, model: Constructor<M>, force?: boolean);
-    protected assignMetadata(model: M, source?: M): M;
-    protected assignMetadata(models: M[], source?: M[]): M[];
-    create(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
-    createAll(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
-    read(id: PrimaryKeyType, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
-    readAll(ids: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
-    update(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
-    updateAll(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
-    delete(id: PrimaryKeyType, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
-    deleteAll(ids: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
-    /**
-     * @description Prepares a model for update.
-     * @summary Validates the model and prepares it for update in the database.
-     * @param {M} model - The model to update.
-     * @param {...any[]} args - Additional arguments.
-     * @return The prepared model and context arguments.
-     * @throws {InternalError} If the model has no primary key value.
-     * @throws {ValidationError} If the model fails validation.
-     */
-    protected updatePrefix(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<[M, ...args: any[], ContextOf<A>, M | undefined]>;
-    /**
-     * @description Prepares multiple models for update.
-     * @summary Validates multiple models and prepares them for update in the database.
-     * @param {M[]} models - The models to update.
-     * @param {...any[]} args - Additional arguments.
-     * @return {Promise<any[]>} The prepared models and context arguments.
-     * @throws {InternalError} If any model has no primary key value.
-     * @throws {ValidationError} If any model fails validation.
-     */
-    protected updateAllPrefix(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<[M[], ...args: any[], ContextOf<A>, M[] | undefined]>;
-}

package/lib/types/types.d.ts

@@ -1,166 +0,0 @@
-/**
- * @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.
-     *
-     * In each matching document, the fields specified in the fields part of the request body are listed, along with
-     * their values. */
-    docs: (D & {
-        _id: string;
-        _rev: string;
-    })[];
-    /** A string that enables you to specify which page of results you require.
-     *
-     * Used for paging through result sets. */
-    bookmark?: string;
-    /** Execution warnings */
-    warning?: string;
-    /** Basic execution statistics for a specific request. */
-    execution_stats?: MangoExecutionStats;
-}
-/**
- * @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;
-    /** Number of documents fetched from the database / index.
-     *
-     * Equivalent to using include_docs = true in a view. */
-    total_docs_examined: number;
-    /** Number of documents fetched from the database using an out-of-band document fetch.
-     *
-     * This is only non-zero when read quorum > 1 is specified in the query parameters. */
-    total_quorum_docs_examined: number;
-    /** Number of results returned from the query. */
-    results_returned: number;
-    /** Total execution time in milliseconds as measured by the database. */
-    execution_time_ms: number;
-}
-/**
- * @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: {
-        /** Array of field names following the sort syntax. */
-        fields: SortOrder[];
-        /** A selector to apply to documents at indexing time, creating a partial index. */
-        partial_filter_selector?: MangoSelector;
-    };
-    /** Name of the design document in which the index will be created. */
-    ddoc?: string;
-    /** Name of the index. If no name is provided, a name will be generated automatically. */
-    name?: string;
-    /** Can be "json" or "text".
-     *
-     * @default "json" */
-    type?: "json" | "text";
-    /** 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";
-/**
- * @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[];
-};
-/**
- * @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";
-};
-/**
- * @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;
-    /** Maximum number of results returned. @default 25 */
-    limit?: number;
-    /** Skip the first 'n' results, where 'n' is the value specified. */
-    skip?: number;
-    /** JSON array following sort syntax. */
-    sort?: SortOrder[];
-    /** JSON array specifying which fields of each object should be returned.
-     *
-     * If it is omitted, the entire object is returned.
-     *
-     * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#filtering-fields} */
-    fields?: string[];
-    use_index?: string | [string, string];
-    /** Read quorum needed for the result.
-     *
-     * @default 1 */
-    r?: number;
-    /** A string that enables you to specify which page of results you require.
-     *
-     * Used for paging through result sets. */
-    bookmark?: string;
-    /** Whether to update the index prior to returning the result.
-     *
-     * @default true */
-    update?: boolean;
-    /** Whether or not the view results should be returned from a “stable” set of shards. */
-    stable?: boolean;
-    /** Combination of update = false and stable = true options.
-     *
-     * Possible options: "ok", false (default). */
-    stale?: "ok" | false;
-    /** Include execution statistics in the query response.
-     *
-     * Optional, default: false. */
-    execution_stats?: boolean;
-}
-export interface ViewRow<D = any> {
-    id?: string;
-    key?: any;
-    value?: any;
-    doc?: D;
-}
-export interface ViewResponse<D = any> {
-    total_rows?: number;
-    offset?: number;
-    rows: ViewRow<D>[];
-}

package/lib/types/utils.d.ts

@@ -1,112 +0,0 @@
-import { OrderDirection } from "@decaf-ts/core";
-import { CreateIndexRequest } from "./types";
-/**
- * @description Re-authenticates a connection to CouchDB
- * @summary Refreshes the authentication for a CouchDB connection using the provided credentials
- * @param {any} con - The CouchDB connection object
- * @param {string} user - The username for authentication
- * @param {string} pass - The password for authentication
- * @return {Promise<any>} A promise that resolves to the authentication result
- * @function reAuth
- * @memberOf module:for-couchdb
- */
-export declare function reAuth(con: any, user: string, pass: string): Promise<any>;
-/**
- * @description Wraps a CouchDB database connection with automatic re-authentication
- * @summary Creates a proxy around a CouchDB database connection that automatically re-authenticates before each operation
- * @param {any} con - The CouchDB connection object
- * @param {string} dbName - The name of the database to use
- * @param {string} user - The username for authentication
- * @param {string} pass - The password for authentication
- * @return {any} The wrapped database connection object
- * @function wrapDocumentScope
- * @memberOf module:for-couchdb
- * @mermaid
- * sequenceDiagram
- *   participant Client
- *   participant wrapDocumentScope
- *   participant DB
- *   participant reAuth
- *
- *   Client->>wrapDocumentScope: con, dbName, user, pass
- *   wrapDocumentScope->>DB: con.use(dbName)
- *   Note over wrapDocumentScope: Wrap DB methods with re-auth
- *
- *   loop For each method (insert, get, put, destroy, find)
- *     wrapDocumentScope->>wrapDocumentScope: Store original method
- *     wrapDocumentScope->>wrapDocumentScope: Define new method with re-auth
- *   end
- *
- *   wrapDocumentScope->>wrapDocumentScope: Add NATIVE property with con value
- *   wrapDocumentScope-->>Client: Return wrapped DB
- *
- *   Note over Client: Later when client uses DB methods
- *   Client->>DB: Any wrapped method call
- *   DB->>reAuth: Authenticate before operation
- *   reAuth-->>DB: Authentication complete
- *   DB->>DB: Call original method
- *   DB-->>Client: Return result
- */
-export declare function wrapDocumentScope(con: any, dbName: string, user: string, pass: string): any;
-/**
- * @description Tests if an attribute name is reserved in CouchDB
- * @summary Checks if an attribute name starts with an underscore, which indicates it's a reserved attribute in CouchDB
- * @param {string} attr - The attribute name to test
- * @return {RegExpMatchArray|null} The match result or null if no match
- * @function testReservedAttributes
- * @memberOf module:for-couchdb
- */
-export declare function testReservedAttributes(attr: string): RegExpMatchArray | null;
-/**
- * @description Generates a name for a CouchDB index
- * @summary Creates a standardized name for a CouchDB index based on the table, attribute, compositions, and order
- * @param {string} attribute - The primary attribute for the index
- * @param {string} tableName - The name of the table
- * @param {string[]} [compositions] - Optional additional attributes to include in the index
- * @param {OrderDirection} [order] - Optional sort order for the index
- * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
- * @return {string} The generated index name
- * @function generateIndexName
- * @memberOf module:for-couchdb
- */
-export declare function generateIndexName(attribute: string, tableName: string, compositions?: string[], order?: OrderDirection, separator?: string): string;
-/**
- * @description Generates a CouchDB index configuration
- * @summary Creates a complete CreateIndexRequest object for defining a CouchDB index based on specified parameters
- * @param {string} attribute - The primary attribute for the index
- * @param {string} tableName - The name of the table
- * @param {string[]} [compositions] - Optional additional attributes to include in the index
- * @param {OrderDirection} [order] - Optional sort order for the index
- * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
- * @return {CreateIndexRequest} The complete index configuration object
- * @function generateIndexDoc
- * @memberOf module:for-couchdb
- * @mermaid
- * sequenceDiagram
- *   participant Caller
- *   participant generateIndexDoc
- *   participant generateIndexName
- *
- *   Caller->>generateIndexDoc: attribute, tableName, compositions, order, separator
- *
- *   Note over generateIndexDoc: Create partial filter selector
- *   generateIndexDoc->>generateIndexDoc: Set up filter for tableName
- *
- *   alt order is specified
- *     Note over generateIndexDoc: Create ordered fields array
- *     generateIndexDoc->>generateIndexDoc: Create orderProp for attribute
- *     generateIndexDoc->>generateIndexDoc: Map compositions to ordered props
- *     generateIndexDoc->>generateIndexDoc: Create sortedTable for table field
- *     generateIndexDoc->>generateIndexDoc: Combine all ordered fields
- *   else
- *     Note over generateIndexDoc: Create simple fields array
- *     generateIndexDoc->>generateIndexDoc: Use attribute, compositions, and table as strings
- *   end
- *
- *   generateIndexDoc->>generateIndexName: Generate index name
- *   generateIndexName-->>generateIndexDoc: Return name
- *
- *   Note over generateIndexDoc: Create final index request
- *   generateIndexDoc-->>Caller: Return CreateIndexRequest
- */
-export declare function generateIndexDoc(attribute: string, tableName: string, compositions?: string[], order?: OrderDirection, separator?: string): CreateIndexRequest;

package/lib/types/views/generator.d.ts

@@ -1,13 +0,0 @@
-import { ViewKind } from "@decaf-ts/core";
-import { Model } from "@decaf-ts/decorator-validation";
-import { Constructor } from "@decaf-ts/decoration";
-import { CreateIndexRequest } from "../types";
-import { Operator } from "@decaf-ts/core";
-import { CouchDBDesignDoc, CouchDBViewMetadata, ViewIndexDefinition } from "./types";
-export declare function generateViewName(tableName: string, attr: string, kind: ViewKind, meta: CouchDBViewMetadata, separator?: string): string;
-export declare function generateDesignDocName(tableName: string, viewName: string, separator?: string): string;
-export declare function findViewMetadata<M extends Model>(model: Constructor<M>, kind: ViewKind, attribute?: string): CouchDBViewMetadata[];
-export declare function collectViewMetadata(model: Constructor<Model>, key: Operator, kind: ViewKind): CouchDBViewMetadata[];
-export declare function generateViews<M extends Model>(models: Constructor<M>[]): CouchDBDesignDoc[];
-export declare function generateViewIndexes<M extends Model>(models: Constructor<M>[]): CreateIndexRequest[];
-export declare function viewIndexDefinition(meta: CouchDBViewMetadata): ViewIndexDefinition;

package/lib/types/views/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./types";
-export * from "./generator";

package/lib/types/views/types.d.ts

@@ -1,30 +0,0 @@
-import { OrderDirection, ViewOptions, ViewKey, ViewKind } from "@decaf-ts/core";
-export interface CouchDBViewOptions extends ViewOptions {
-    ddoc?: string;
-    value?: ViewKey | "doc" | null;
-    map?: string | ((doc: any) => void);
-    reduce?: string | ((keys: any, values: any, rereduce: boolean) => any);
-    returnDocs?: boolean;
-}
-export interface CouchDBViewMetadata extends CouchDBViewOptions {
-    kind: ViewKind;
-    attribute: string;
-}
-export interface CouchDBViewDefinition {
-    map: string;
-    reduce?: string;
-}
-export interface AggregateOptions extends CouchDBViewOptions {
-    value?: any;
-}
-export interface CouchDBDesignDoc {
-    _id: string;
-    _rev?: string;
-    language?: "javascript";
-    views: Record<string, CouchDBViewDefinition>;
-}
-export interface ViewIndexDefinition {
-    attribute: string;
-    compositions?: string[];
-    directions?: OrderDirection[];
-}