monapi 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,315 @@
+import { Request, Response, NextFunction, RequestHandler, Router } from 'express';
+import { FilterQuery, SortOrder, Model, Schema, Connection } from 'mongoose';
+
+type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'like' | 'exists';
+interface FilterCondition {
+    operator: FilterOperator;
+    value: any;
+}
+interface ParsedFilters {
+    [field: string]: FilterCondition;
+}
+interface QueryOptions {
+    page?: number;
+    limit?: number;
+    sort?: string | string[];
+    fields?: string | string[];
+    [key: string]: any;
+}
+interface MongoQuery {
+    filter: FilterQuery<any>;
+    sort?: {
+        [key: string]: SortOrder;
+    };
+    skip?: number;
+    limit?: number;
+    projection?: {
+        [key: string]: 0 | 1;
+    };
+}
+interface PaginationMeta {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages?: number;
+}
+interface QueryConfig {
+    allowedFilters?: string[];
+    allowedSorts?: string[];
+    defaultSort?: string;
+    defaultLimit?: number;
+    maxLimit?: number;
+}
+declare enum FieldType {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Date = "date",
+    ObjectId = "objectid",
+    Array = "array",
+    Object = "object",
+    Mixed = "mixed"
+}
+
+type CRUDOperation = 'find' | 'create' | 'update' | 'patch' | 'delete';
+interface User {
+    id: string;
+    roles?: string[];
+    [key: string]: any;
+}
+interface HookContext {
+    collection: string;
+    operation: CRUDOperation;
+    user?: User;
+    query?: MongoQuery;
+    data?: any;
+    result?: any;
+    id?: string;
+    req: Request;
+    res: Response;
+    meta?: Record<string, any>;
+    preventDefault?: boolean;
+}
+type HookFunction = (ctx: HookContext) => Promise<void> | void;
+interface LifecycleHooks {
+    beforeFind?: HookFunction;
+    afterFind?: HookFunction;
+    beforeCreate?: HookFunction;
+    afterCreate?: HookFunction;
+    beforeUpdate?: HookFunction;
+    afterUpdate?: HookFunction;
+    beforeDelete?: HookFunction;
+    afterDelete?: HookFunction;
+}
+interface HookEntry {
+    collection: string;
+    operation: keyof LifecycleHooks;
+    handler: HookFunction;
+    priority?: number;
+}
+
+interface PermissionContext {
+    user: User;
+    collection: string;
+    operation: CRUDOperation;
+    data?: any;
+    id?: string;
+    req: Request;
+}
+type PermissionFunction = (ctx: PermissionContext) => boolean | Promise<boolean>;
+type Permission = string[] | PermissionFunction;
+interface PermissionConfig {
+    list?: Permission;
+    get?: Permission;
+    create?: Permission;
+    update?: Permission;
+    patch?: Permission;
+    delete?: Permission;
+}
+interface FieldPermission {
+    read?: string[];
+    write?: string[];
+}
+interface FieldPermissions {
+    [fieldName: string]: FieldPermission;
+}
+type AuthMiddleware = (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
+interface AuthConfig {
+    middleware?: AuthMiddleware;
+    jwtSecret?: string;
+    jwtOptions?: {
+        algorithm?: string;
+        expiresIn?: string;
+    };
+    sessionSecret?: string;
+}
+
+interface ValidationResult {
+    valid: boolean;
+    errors?: ValidationError$1[];
+    data?: any;
+}
+interface ValidationError$1 {
+    field: string;
+    message: string;
+    code?: string;
+}
+interface FieldMetadata {
+    name: string;
+    type: FieldType;
+    required?: boolean;
+    default?: any;
+    enum?: any[];
+}
+interface SchemaAdapter {
+    getFields(): string[];
+    getFieldType(field: string): FieldType;
+    getFieldMetadata(field: string): FieldMetadata | undefined;
+    getAllFieldsMetadata(): FieldMetadata[];
+    validate(data: unknown): Promise<ValidationResult> | ValidationResult;
+    getMongooseModel?(): Model<any> | undefined;
+    getMongooseSchema?(): Schema | undefined;
+}
+declare enum SchemaType {
+    Mongoose = "mongoose",
+    Typegoose = "typegoose",
+    Zod = "zod",
+    Joi = "joi",
+    Yup = "yup",
+    Unknown = "unknown"
+}
+interface SchemaOptions {
+    strict?: boolean;
+    timestamps?: boolean;
+    validateBeforeSave?: boolean;
+}
+
+type Handler = (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
+interface CRUDHandlers {
+    list: Handler;
+    get: Handler;
+    create: Handler;
+    update: Handler;
+    patch: Handler;
+    delete: Handler;
+}
+interface MiddlewareConfig {
+    all?: RequestHandler[];
+    list?: RequestHandler[];
+    get?: RequestHandler[];
+    create?: RequestHandler[];
+    update?: RequestHandler[];
+    patch?: RequestHandler[];
+    delete?: RequestHandler[];
+}
+interface CollectionConfig {
+    schema: Schema | Model<any> | any;
+    validator?: any;
+    model?: Model<any>;
+    handlers?: Partial<CRUDHandlers>;
+    hooks?: Partial<LifecycleHooks>;
+    middleware?: MiddlewareConfig;
+    permissions?: PermissionConfig;
+    fields?: FieldPermissions;
+    query?: QueryConfig;
+    adapter?: SchemaAdapter;
+}
+interface DefaultConfig {
+    pagination?: {
+        limit?: number;
+        maxLimit?: number;
+    };
+    security?: {
+        maxRegexLength?: number;
+        maxRegexComplexity?: number;
+        maxQueryCost?: number;
+    };
+    query?: QueryConfig;
+}
+interface MonapiConfig {
+    connection: Connection;
+    basePath?: string;
+    framework?: 'express' | 'fastify';
+    defaults?: DefaultConfig;
+    auth?: AuthConfig;
+    logger?: Logger;
+}
+interface Logger {
+    info(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    error(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+}
+interface ListResponse<T = any> {
+    data: T[];
+    meta: {
+        page: number;
+        limit: number;
+        total: number;
+    };
+}
+interface SingleResponse<T = any> {
+    data: T;
+}
+interface ErrorResponse {
+    error: {
+        code: string;
+        message: string;
+        details?: any;
+    };
+}
+
+declare class Monapi {
+    private config;
+    private logger;
+    private collections;
+    private authMiddleware?;
+    constructor(config: MonapiConfig);
+    resource(name: string, collectionConfig: CollectionConfig): this;
+    router(): Router;
+    getModel(name: string): Model<any> | undefined;
+    getAdapter(name: string): SchemaAdapter | undefined;
+    private resolveModel;
+}
+
+declare class MongooseAdapter implements SchemaAdapter {
+    private schema;
+    private model?;
+    constructor(schemaOrModel: Schema | Model<any>);
+    private isModel;
+    getFields(): string[];
+    getFieldType(field: string): FieldType;
+    getFieldMetadata(field: string): FieldMetadata | undefined;
+    getAllFieldsMetadata(): FieldMetadata[];
+    validate(data: unknown): Promise<ValidationResult>;
+    private basicValidation;
+    getMongooseModel(): Model<any> | undefined;
+    getMongooseSchema(): Schema;
+}
+
+declare function detectSchemaType(schema: any): SchemaType;
+declare function createSchemaAdapter(schema: Schema | Model<any> | any): SchemaAdapter;
+
+declare class MonapiError extends Error {
+    readonly statusCode: number;
+    readonly code: string;
+    readonly details?: any;
+    constructor(message: string, statusCode: number, code: string, details?: any);
+}
+declare class NotFoundError extends MonapiError {
+    constructor(resource: string, id?: string);
+}
+declare class ValidationError extends MonapiError {
+    constructor(message: string, details?: any);
+}
+declare class ForbiddenError extends MonapiError {
+    constructor(message?: string);
+}
+declare class UnauthorizedError extends MonapiError {
+    constructor(message?: string);
+}
+declare class BadRequestError extends MonapiError {
+    constructor(message: string, details?: any);
+}
+
+interface FilterParserOptions {
+    adapter?: SchemaAdapter;
+    queryConfig?: QueryConfig;
+    maxRegexLength?: number;
+    maxFilters?: number;
+}
+declare function parseFilters(query: Record<string, any>, options?: FilterParserOptions): FilterQuery<any>;
+
+interface QueryBuilderOptions {
+    adapter?: SchemaAdapter;
+    queryConfig?: QueryConfig;
+    defaultLimit?: number;
+    maxLimit?: number;
+    maxRegexLength?: number;
+}
+declare function buildQuery(queryParams: Record<string, any>, options?: QueryBuilderOptions): MongoQuery;
+declare function buildPaginationMeta(total: number, page: number, limit: number): PaginationMeta;
+
+declare function createErrorHandler(logger?: Logger): (err: Error, _req: Request, res: Response, _next: NextFunction) => void;
+
+export { type AuthConfig, type AuthMiddleware, BadRequestError, type CRUDHandlers, type CRUDOperation, type CollectionConfig, type DefaultConfig, type ErrorResponse, type FieldMetadata, type FieldPermission, type FieldPermissions, FieldType, type FilterCondition, type FilterOperator, ForbiddenError, type Handler, type HookContext, type HookEntry, type HookFunction, type LifecycleHooks, type ListResponse, type Logger, type MiddlewareConfig, Monapi, type MonapiConfig, MonapiError, type MongoQuery, MongooseAdapter, NotFoundError, type PaginationMeta, type ParsedFilters, type Permission, type PermissionConfig, type PermissionContext, type PermissionFunction, type QueryConfig, type QueryOptions, type SchemaAdapter, type SchemaOptions, SchemaType, type ValidationError$1 as SchemaValidationError, type SingleResponse, UnauthorizedError, type User, ValidationError, type ValidationResult, buildPaginationMeta, buildQuery, createErrorHandler, createSchemaAdapter, detectSchemaType, parseFilters };