elseware-nodejs 1.8.7 → 1.9.1

package/dist/index.d.cts

@@ -1,86 +1,13 @@
-import * as express from 'express';
-import { Request, Response, NextFunction } from 'express';
-import { Model, PopulateOptions, Query, UpdateQuery } from 'mongoose';
-import { ZodTypeAny, infer } from 'zod';
+import { ZodTypeAny, infer, ZodSchema } from 'zod';
 import { CorsOptions } from 'cors';
+import * as express from 'express';
+import { Request, Response, NextFunction, RequestHandler } from 'express';
+import * as qs from 'qs';
+import * as express_serve_static_core from 'express-serve-static-core';
 import { Schema } from 'joi';
+import { Model, UpdateQuery } from 'mongoose';
 import { SignOptions, JwtPayload } from 'jsonwebtoken';
 
-/**
- * Options for API factory methods
- */
-interface ApiFactoryOptions<T = unknown> {
-    message?: string;
-    notFoundMessage?: string;
-    populate?: PopulateOptions | PopulateOptions[];
-    filter?: (req: Request) => Record<string, unknown>;
-}
-/**
- * Generic API Factory (Hybrid Pattern)
- * For simple CRUD operations without business logic
- */
-declare class APIFactory {
-    static getAll<T>(Model: Model<T>, options?: ApiFactoryOptions<T>): (req: Request, res: express.Response, next: express.NextFunction) => Promise<void>;
-    static getOne<T>(Model: Model<T>, options?: ApiFactoryOptions<T>): (req: Request, res: express.Response, next: express.NextFunction) => Promise<void>;
-    static createOne<T>(Model: Model<T>, options?: ApiFactoryOptions<T>): (req: Request, res: express.Response, next: express.NextFunction) => Promise<void>;
-    static updateOne<T>(Model: Model<T>, options?: ApiFactoryOptions<T>): (req: Request, res: express.Response, next: express.NextFunction) => Promise<void>;
-    static deleteOne<T>(Model: Model<T>, options?: ApiFactoryOptions<T>): (req: Request, res: express.Response, next: express.NextFunction) => Promise<void>;
-}
-
-/**
- * Generic API Features helper for Mongoose queries
- */
-declare class APIFeatures<T> {
-    query: Query<T[], T>;
-    queryString: Record<string, unknown>;
-    page: number;
-    limit: number;
-    constructor(query: Query<T[], T>, queryString: Record<string, unknown>);
-    filter(): this;
-    sort(): this;
-    limitFields(): this;
-    paginate(): this;
-    populate(populateOptions?: PopulateOptions | PopulateOptions[]): this;
-}
-
-declare class APIResponse {
-    static send(res: Response, options: {
-        statusCode?: number;
-        success?: boolean;
-        message?: string;
-        data?: unknown;
-        meta?: Record<string, unknown>;
-    }): Response<any, Record<string, any>>;
-    static ok(res: Response, data?: unknown, message?: string, meta?: Record<string, unknown>): Response<any, Record<string, any>>;
-    static created(res: Response, data?: unknown, message?: string): Response<any, Record<string, any>>;
-    static noContent(res: Response): Response<any, Record<string, any>>;
-    static error(res: Response, message?: string, statusCode?: number, meta?: Record<string, unknown>): Response<any, Record<string, any>>;
-    static paginated(res: Response, data: unknown, options: {
-        total: number;
-        page: number;
-        limit: number;
-    }, message?: string): Response<any, Record<string, any>>;
-}
-
-declare const asyncHandler: (fn: (req: Request, res: Response, next: NextFunction) => Promise<void>) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
-
-type FieldTransform<T> = (value: T) => any;
-type PickOptions<T extends Record<string, any>, K extends keyof T> = {
-    removeUndefined?: boolean;
-    removeNull?: boolean;
-    removeEmptyString?: boolean;
-    strict?: boolean;
-    defaults?: Partial<Record<K, any>>;
-    rename?: Partial<Record<K, string>>;
-    transform?: Partial<Record<K, FieldTransform<T[K]>>>;
-};
-declare function pickFields<T extends Record<string, any>, K extends keyof T>(obj: T, fields: readonly K[], options?: PickOptions<T, K>): Partial<Record<K | string, any>>;
-
-interface DatabaseConfig {
-    uri: string;
-}
-declare function connectMongoDB(config: DatabaseConfig): Promise<void>;
-
 declare function loadEnv<TSchema extends ZodTypeAny, TTransform = undefined>(options: {
     schema: TSchema;
     transform?: (env: infer<TSchema>) => TTransform;
@@ -1804,6 +1731,41 @@ declare class SegmentTree<T> {
     private updatePoint;
 }
 
+interface DatabaseProvider {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getConnectionState(): string;
+}
+
+interface DatabaseConnectionOptions {
+    enableShutdownHooks?: boolean;
+}
+interface MongoDatabaseConfig {
+    uri: string;
+    strictQuery?: boolean;
+}
+
+declare class DatabaseManager {
+    private readonly provider;
+    private readonly options;
+    constructor(provider: DatabaseProvider, options?: DatabaseConnectionOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getConnectionState(): string;
+    private registerShutdownHooks;
+}
+
+declare class MongoDatabaseProvider implements DatabaseProvider {
+    private readonly config;
+    constructor(config: MongoDatabaseConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getConnectionState(): string;
+}
+
 declare class AppError extends Error {
     statusCode: number;
     status: string;
@@ -1816,31 +1778,25 @@ declare class AppError extends Error {
     });
 }
 
-declare const authMiddleware: (_req: Request, _res: Response, next: NextFunction) => void;
-
-declare const GlobalErrorHandler: (isProd?: boolean) => (err: unknown, _req: Request, res: Response, _next: NextFunction) => Response;
-
-declare const validate: (schema: Schema) => (req: Request, _res: Response, next: NextFunction) => void;
-
 type Filter<T> = Partial<Record<keyof T, unknown>>;
 type Field<T> = Extract<keyof T, string>;
 type PrefixedField<T> = `+${Field<T>}` | `-${Field<T>}`;
 type Select<T> = (Field<T> | PrefixedField<T>)[] | Partial<Record<Field<T>, 0 | 1>>;
 type Sort<T> = Partial<Record<keyof T, 1 | -1>>;
 
-interface IQueryOptions<T> {
+interface QueryOptions<T> {
     select?: Select<T>;
     sort?: Sort<T>;
     limit?: number;
     skip?: number;
     populate?: string | string[];
 }
-interface IUpdateQueryOptions {
+interface UpdateQueryOptions {
     new?: boolean;
     runValidators: boolean;
     upsert?: boolean;
 }
-interface IRepository<T> {
+interface Repository<T> {
     /**
      * Create
      */
@@ -1849,17 +1805,17 @@ interface IRepository<T> {
     /**
      * Read
      */
-    findAll(filter?: Filter<T>, options?: IQueryOptions<T>): Promise<T[]>;
-    findById(id: string, options?: IQueryOptions<T>): Promise<T | null>;
-    findOne(filter: Filter<T>, options?: IQueryOptions<T>): Promise<T | null>;
-    findManyByIds(ids: string[], options?: IQueryOptions<T>): Promise<T[]>;
+    findAll(filter?: Filter<T>, options?: QueryOptions<T>): Promise<T[]>;
+    findById(id: string, options?: QueryOptions<T>): Promise<T | null>;
+    findOne(filter: Filter<T>, options?: QueryOptions<T>): Promise<T | null>;
+    findManyByIds(ids: string[], options?: QueryOptions<T>): Promise<T[]>;
     count(filter?: Filter<T>): Promise<number>;
     exists(filter?: Filter<T>): Promise<boolean>;
     /**
      * Update
      */
-    updateById(id: string, data: Partial<T>, options?: IUpdateQueryOptions): Promise<T | null>;
-    updateOne(filter: Filter<T>, data: Partial<T>, options?: IUpdateQueryOptions): Promise<T | null>;
+    updateById(id: string, data: Partial<T>, options?: UpdateQueryOptions): Promise<T | null>;
+    updateOne(filter: Filter<T>, data: Partial<T>, options?: UpdateQueryOptions): Promise<T | null>;
     updateMany(filter: Filter<T>, data: Partial<T>): Promise<number>;
     /**
      * Delete
@@ -1869,12 +1825,182 @@ interface IRepository<T> {
     deleteMany(filter: Filter<T>): Promise<number>;
 }
 
-declare class BaseMongoRepository<T> implements IRepository<T> {
+interface CrudControllerOptions<T> {
+    resourceName?: string;
+    filter?: (req: Request) => Filter<T>;
+}
+declare class CrudControllerFactory {
+    static create<T>(repository: Repository<T>, options?: CrudControllerOptions<T>): {
+        /**
+         * GET /
+         */
+        getAll: express.RequestHandler<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
+        /**
+         * GET /:id
+         */
+        getOne: express.RequestHandler<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
+        /**
+         * POST /
+         */
+        create: express.RequestHandler<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
+        /**
+         * PATCH /:id
+         */
+        update: express.RequestHandler<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
+        /**
+         * DELETE /:id
+         */
+        delete: express.RequestHandler<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
+    };
+}
+
+type AsyncRequestHandler = (req: Request, res: Response, next: NextFunction) => Promise<unknown>;
+declare const AsyncHandler: (fn: AsyncRequestHandler) => RequestHandler;
+
+interface AuthenticatedUser {
+    id: string;
+    email?: string;
+    username?: string;
+    roles?: string[];
+    permissions?: string[];
+}
+declare global {
+    namespace Express {
+        interface Request {
+            user?: AuthenticatedUser;
+        }
+    }
+}
+declare const authMiddleware: (_req: Request, _res: Response, next: NextFunction) => void;
+
+/**
+ * Global Error Middleware
+ */
+declare const ErrorMiddleware: (isProduction?: boolean) => (err: unknown, _req: Request, res: Response, _next: NextFunction) => Response<any, Record<string, any>>;
+
+declare const validate: (schema: unknown) => (req: Request, _res: Response, next: NextFunction) => void;
+
+type QueryOperator = "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "contains" | "startsWith" | "endsWith";
+interface QueryFilter {
+    field: string;
+    operator: QueryOperator;
+    value: unknown;
+}
+interface QuerySort {
+    field: string;
+    direction: "asc" | "desc";
+}
+interface PaginationQuery {
+    page: number;
+    limit: number;
+}
+interface ParsedQuery {
+    filters: QueryFilter[];
+    sort: QuerySort[];
+    fields: string[];
+    pagination: PaginationQuery;
+    populate: string[];
+}
+
+declare class ApiFeatures {
+    static parse(query: Record<string, unknown>): ParsedQuery;
+    private static parseFilters;
+    private static parseSort;
+    private static parseFields;
+    private static parsePopulate;
+    private static parsePagination;
+}
+
+declare const QUERY_RESERVED_FIELDS: readonly ["page", "limit", "sort", "fields", "populate"];
+declare const DEFAULT_PAGE = 1;
+declare const DEFAULT_LIMIT = 100;
+declare const DEFAULT_SORT_DIRECTION = "asc";
+declare const SUPPORTED_OPERATORS: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "contains", "startsWith", "endsWith"];
+
+interface ApiResponseOptions<T = unknown> {
+    statusCode?: number;
+    success?: boolean;
+    message?: string;
+    data?: T;
+    meta?: ApiMeta;
+}
+interface ApiMeta {
+    [key: string]: unknown;
+}
+interface PaginationMeta extends ApiMeta {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface ErrorMeta {
+    errors?: Record<string, unknown>;
+}
+interface StandardApiResponse<T = unknown> {
+    success: boolean;
+    message: string;
+    data?: T;
+    meta?: Record<string, unknown>;
+}
+
+declare class ApiResponse {
+    static send<T = unknown>(res: Response, options: ApiResponseOptions<T>): Response<any, Record<string, any>>;
+    static ok<T = unknown>(res: Response, data?: T, message?: string, meta?: ApiMeta): Response<any, Record<string, any>>;
+    static created<T = unknown>(res: Response, data?: T, message?: string): Response<any, Record<string, any>>;
+    static accepted<T = unknown>(res: Response, data?: T, message?: string): Response<any, Record<string, any>>;
+    static noContent(res: Response): Response<any, Record<string, any>>;
+    static error(res: Response, message?: string, statusCode?: number, meta?: ApiMeta): Response<any, Record<string, any>>;
+    static paginated<T = unknown>(res: Response, data: T, options: {
+        total: number;
+        page: number;
+        limit: number;
+    }, message?: string): Response<any, Record<string, any>>;
+}
+
+type ValidationSchema = Schema | ZodSchema;
+interface ValidationResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    errors?: Record<string, unknown>;
+}
+
+type FieldTransform<T> = (value: T) => any;
+type PickOptions<T extends Record<string, any>, K extends keyof T> = {
+    removeUndefined?: boolean;
+    removeNull?: boolean;
+    removeEmptyString?: boolean;
+    strict?: boolean;
+    defaults?: Partial<Record<K, any>>;
+    rename?: Partial<Record<K, string>>;
+    transform?: Partial<Record<K, FieldTransform<T[K]>>>;
+};
+declare function pickFields<T extends Record<string, any>, K extends keyof T>(obj: T, fields: readonly K[], options?: PickOptions<T, K>): Partial<Record<K | string, any>>;
+
+interface IValidator {
+    validate<T = unknown>(data: unknown): ValidationResult<T>;
+}
+declare const isJoiSchema: (schema: unknown) => schema is Schema;
+declare const isZodSchema: (schema: unknown) => schema is ZodSchema;
+
+declare class JoiValidator implements IValidator {
+    private readonly schema;
+    constructor(schema: Schema);
+    validate<T = unknown>(data: unknown): ValidationResult<T>;
+}
+
+declare class ZodValidator implements IValidator {
+    private readonly schema;
+    constructor(schema: ZodSchema);
+    validate<T = unknown>(data: unknown): ValidationResult<T>;
+}
+
+declare class MongoRepository<T> implements Repository<T> {
     protected model: Model<T>;
     constructor(model: Model<T>);
     private buildSelect;
     private applyQueryOptions;
     private toPlain;
+    private toPlainArray;
     /**
      * Create
      */
@@ -1883,17 +2009,17 @@ declare class BaseMongoRepository<T> implements IRepository<T> {
     /**
      * Read
      */
-    findAll(filter?: Filter<T>, options?: IQueryOptions<T>): Promise<T[]>;
-    findById(id: string, options?: IQueryOptions<T>): Promise<T | null>;
-    findOne(filter?: Filter<T>, options?: IQueryOptions<T>): Promise<T | null>;
-    findManyByIds(ids: string[], options?: IQueryOptions<T>): Promise<T[]>;
+    findAll(filter?: Filter<T>, options?: QueryOptions<T>): Promise<T[]>;
+    findById(id: string, options?: QueryOptions<T>): Promise<T | null>;
+    findOne(filter?: Filter<T>, options?: QueryOptions<T>): Promise<T | null>;
+    findManyByIds(ids: string[], options?: QueryOptions<T>): Promise<T[]>;
     count(filter?: Filter<T>): Promise<number>;
     exists(filter?: Filter<T>): Promise<boolean>;
     /**
      * Update
      */
-    updateById(id: string, data: UpdateQuery<T>, options?: IUpdateQueryOptions): Promise<T | null>;
-    updateOne(filter: Filter<T>, data: Partial<T>, options?: IUpdateQueryOptions): Promise<T | null>;
+    updateById(id: string, data: UpdateQuery<T>, options?: UpdateQueryOptions): Promise<T | null>;
+    updateOne(filter: Filter<T>, data: Partial<T>, options?: UpdateQueryOptions): Promise<T | null>;
     updateMany(filter: Filter<T>, data: Partial<T>): Promise<number>;
     /**
      * Delete
@@ -2050,4 +2176,4 @@ declare function toMinutes(ms: number): number;
 declare function toHours(ms: number): number;
 declare function sleep(ms: number): Promise<void>;
 
-export { APIFactory, APIFeatures, APIResponse, AVLTree, AdjacencyList, AdjacencyMatrix, type AdjacentEdge, type AllowedOriginsOptions, AppError, type AzureBlobStorageConfig, AzureBlobStorageService, BPlusTree, BTree, BaseMongoRepository, BinaryHeap, BinarySearchTree, BinaryTree, BloomFilter, CircularArray, CircularLinkedList, CircularQueue, type CloudinaryConfig, CloudinaryService, ConsistentHash, CountMinSketch, type DatabaseConfig, Deque, type DirectedEdge, DirectedGraph, DisjointSetUnion, DoublyLinkedList, DynamicArray, type Edge, type EmailProvider, EmailService, FenwickTree, FibNode, FibonacciHeap, GlobalErrorHandler, Graph, HashMap, HashSet, HyperLogLog, type IQueryOptions, type IRepository, type IUpdateQueryOptions, type Interval, IntervalTree, JWTService, type JWTServiceOptions, KDTree, LFUCache, LRUCache, type LoggerOptions, MaxHeap, MaxStack, MinHeap, MinStack, MulterFileHandlerService, MultiSet, Node, OrderedSet, PairingHeap, PairingNode, type Point, type Point2D, PriorityQueue, type ProgressCallback, QuadTree, Queue, RadixTree, type Rect, RedBlackTree, SMTPProvider, SegmentTree, type SendEmailOptions, Set, SinglyLinkedList, SparseTable, SplayTree, Stack, StaticArray, SuffixArray, SuffixTree, TemplateEngine, TernarySearchTree, TreeNode, Trie, type UploadOptions, asyncHandler, authMiddleware, connectMongoDB, createAllowedOrigins, createCorsOptions, days, errorToString, hours, loadEnv, logger, milliseconds, minutes, pickFields, seconds, sleep, toHours, toMinutes, toSeconds, validate };
+export { AVLTree, AdjacencyList, AdjacencyMatrix, type AdjacentEdge, type AllowedOriginsOptions, ApiFeatures, type ApiMeta, ApiResponse, type ApiResponseOptions, AppError, AsyncHandler, type AsyncRequestHandler, type AuthenticatedUser, type AzureBlobStorageConfig, AzureBlobStorageService, BPlusTree, BTree, BinaryHeap, BinarySearchTree, BinaryTree, BloomFilter, CircularArray, CircularLinkedList, CircularQueue, type CloudinaryConfig, CloudinaryService, ConsistentHash, CountMinSketch, CrudControllerFactory, type CrudControllerOptions, DEFAULT_LIMIT, DEFAULT_PAGE, DEFAULT_SORT_DIRECTION, type DatabaseConnectionOptions, DatabaseManager, type DatabaseProvider, Deque, type DirectedEdge, DirectedGraph, DisjointSetUnion, DoublyLinkedList, DynamicArray, type Edge, type EmailProvider, EmailService, type ErrorMeta, ErrorMiddleware, FenwickTree, FibNode, FibonacciHeap, type Filter, Graph, HashMap, HashSet, HyperLogLog, type IValidator, type Interval, IntervalTree, JWTService, type JWTServiceOptions, JoiValidator, KDTree, LFUCache, LRUCache, type LoggerOptions, MaxHeap, MaxStack, MinHeap, MinStack, type MongoDatabaseConfig, MongoDatabaseProvider, MongoRepository, MulterFileHandlerService, MultiSet, Node, OrderedSet, type PaginationMeta, type PaginationQuery, PairingHeap, PairingNode, type ParsedQuery, type PickOptions, type Point, type Point2D, PriorityQueue, type ProgressCallback, QUERY_RESERVED_FIELDS, QuadTree, type QueryFilter, type QueryOperator, type QueryOptions, type QuerySort, Queue, RadixTree, type Rect, RedBlackTree, type Repository, SMTPProvider, SUPPORTED_OPERATORS, SegmentTree, type Select, type SendEmailOptions, Set, SinglyLinkedList, type Sort, SparseTable, SplayTree, Stack, type StandardApiResponse, StaticArray, SuffixArray, SuffixTree, TemplateEngine, TernarySearchTree, TreeNode, Trie, type UpdateQueryOptions, type UploadOptions, type ValidationResult, type ValidationSchema, ZodValidator, authMiddleware, createAllowedOrigins, createCorsOptions, days, errorToString, hours, isJoiSchema, isZodSchema, loadEnv, logger, milliseconds, minutes, pickFields, seconds, sleep, toHours, toMinutes, toSeconds, validate };