quantum-flow 1.0.1

package/dist/core/Endpoint.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USE = exports.DELETE = exports.PATCH = exports.PUT = exports.POST = exports.GET = void 0;
+exports.Endpoint = Endpoint;
+const _constants_1 = require("@constants");
+function Endpoint(method, pathPattern, middlewares) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        if (!originalMethod) {
+            console.warn('❌ originalMethod is undefined!');
+            return descriptor;
+        }
+        if (method && pathPattern) {
+            Reflect.defineMetadata(_constants_1.ENDPOINT, [method, pathPattern], target, propertyKey);
+            Reflect.defineMetadata('middlewares', middlewares || [], target, propertyKey);
+        }
+        return descriptor;
+    };
+}
+const GET = (pathPattern, middelwares) => {
+    return Endpoint('GET', pathPattern, middelwares);
+};
+exports.GET = GET;
+const POST = (pathPattern, middelwares) => {
+    return Endpoint('POST', pathPattern, middelwares);
+};
+exports.POST = POST;
+const PUT = (pathPattern, middelwares) => {
+    return Endpoint('PUT', pathPattern, middelwares);
+};
+exports.PUT = PUT;
+const PATCH = (pathPattern, middelwares) => {
+    return Endpoint('PATCH', pathPattern, middelwares);
+};
+exports.PATCH = PATCH;
+const DELETE = (pathPattern, middelwares) => {
+    return Endpoint('DELETE', pathPattern, middelwares);
+};
+exports.DELETE = DELETE;
+const USE = (pathPattern, middelwares) => {
+    return Endpoint('USE', pathPattern, middelwares);
+};
+exports.USE = USE;

package/dist/core/index.d.ts

@@ -0,0 +1,4 @@
+export { EndpointResponse, IController, Interceptor, Middleware, Request, Router, WebSocketClient, WebSocketEvent, WebSocketMessage, } from '@types';
+export * from './Controller';
+export * from './Endpoint';
+export * from './utils';

package/dist/core/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Controller"), exports);
+__exportStar(require("./Endpoint"), exports);
+__exportStar(require("./utils"), exports);

package/dist/core/utils/extractors.d.ts

@@ -0,0 +1,15 @@
+import { ParamDecoratorType } from '@types';
+export interface ParamMetadata {
+    index: number;
+    type: ParamDecoratorType;
+    dto?: any;
+    name?: string;
+}
+export declare const Body: (dto?: any) => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare const Params: (name?: string) => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare const Query: (name?: string) => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare const Request: () => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare const Headers: (name?: string) => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare const Cookies: (name?: string) => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare const Multipart: (name?: string) => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare const Response: () => (target: any, propertyKey: string | symbol, parameterIndex: number) => void;

package/dist/core/utils/extractors.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = exports.Multipart = exports.Cookies = exports.Headers = exports.Request = exports.Query = exports.Params = exports.Body = void 0;
+const _constants_1 = require("@constants");
+function createParamDecorator(type, dto, name) {
+    return function (target, propertyKey, parameterIndex) {
+        const existingParams = Reflect.getMetadata(_constants_1.PARAM_METADATA_KEY, target, propertyKey) || [];
+        existingParams.push({ index: parameterIndex, type, dto, name });
+        existingParams.sort((a, b) => a.index - b.index);
+        Reflect.defineMetadata(_constants_1.PARAM_METADATA_KEY, existingParams, target, propertyKey);
+        const saved = Reflect.getMetadata(_constants_1.PARAM_METADATA_KEY, target, propertyKey);
+    };
+}
+const Body = (dto) => createParamDecorator('body', dto);
+exports.Body = Body;
+const Params = (name) => createParamDecorator('params', undefined, name);
+exports.Params = Params;
+const Query = (name) => createParamDecorator('query', undefined, name);
+exports.Query = Query;
+const Request = () => createParamDecorator('request');
+exports.Request = Request;
+const Headers = (name) => createParamDecorator('headers', undefined, name);
+exports.Headers = Headers;
+const Cookies = (name) => createParamDecorator('cookies', undefined, name);
+exports.Cookies = Cookies;
+const Multipart = (name) => createParamDecorator('multipart', undefined, name);
+exports.Multipart = Multipart;
+const Response = () => createParamDecorator('response');
+exports.Response = Response;

package/dist/core/utils/helpers.d.ts

@@ -0,0 +1,4 @@
+export declare function Status(status: number): (target: any, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<any>) => void;
+export declare const Ok200: () => (target: any, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<any>) => void;
+export declare const Ok201: () => (target: any, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<any>) => void;
+export declare const Ok204: () => (target: any, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<any>) => void;

package/dist/core/utils/helpers.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ok204 = exports.Ok201 = exports.Ok200 = void 0;
+exports.Status = Status;
+const _constants_1 = require("@constants");
+function Status(status) {
+    return function (target, propertyKey, descriptor) {
+        if (!propertyKey) {
+            Reflect.defineMetadata(_constants_1.OK_METADATA_KEY, status, target.prototype || target);
+            return;
+        }
+        if (descriptor) {
+            Reflect.defineMetadata(_constants_1.OK_METADATA_KEY, status, target, propertyKey);
+        }
+    };
+}
+const Ok200 = () => Status(200);
+exports.Ok200 = Ok200;
+const Ok201 = () => Status(201);
+exports.Ok201 = Ok201;
+const Ok204 = () => Status(204);
+exports.Ok204 = Ok204;

package/dist/core/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './extractors';
+export * from './helpers';
+export * from './websocket';

package/dist/core/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./extractors"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./websocket"), exports);

package/dist/core/utils/websocket.d.ts

@@ -0,0 +1,8 @@
+import { WebSocketHandlerType } from '@types';
+export declare function OnWS(type: WebSocketHandlerType, topic?: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function OnConnection(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function OnMessage(topic?: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function OnClose(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function OnError(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function Subscribe(topic: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function InjectWS(): (target: any, propertyKey: string, parameterIndex: number) => void;

package/dist/core/utils/websocket.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnWS = OnWS;
+exports.OnConnection = OnConnection;
+exports.OnMessage = OnMessage;
+exports.OnClose = OnClose;
+exports.OnError = OnError;
+exports.Subscribe = Subscribe;
+exports.InjectWS = InjectWS;
+const _constants_1 = require("@constants");
+function OnWS(type, topic) {
+    return function (target, propertyKey, descriptor) {
+        const handlers = Reflect.getMetadata(_constants_1.WS_METADATA_KEY, target.constructor) || [];
+        handlers.push({ type, topic, method: propertyKey });
+        Reflect.defineMetadata(_constants_1.WS_METADATA_KEY, handlers, target.constructor);
+        return descriptor;
+    };
+}
+function OnConnection() {
+    return OnWS('connection');
+}
+function OnMessage(topic) {
+    return OnWS('message', topic);
+}
+function OnClose() {
+    return OnWS('close');
+}
+function OnError() {
+    return OnWS('error');
+}
+function Subscribe(topic) {
+    return function (target, propertyKey, descriptor) {
+        const topics = Reflect.getMetadata(_constants_1.WS_TOPIC_KEY, target.constructor) || [];
+        topics.push({ topic, method: propertyKey });
+        Reflect.defineMetadata(_constants_1.WS_TOPIC_KEY, topics, target.constructor);
+        return descriptor;
+    };
+}
+function InjectWS() {
+    return function (target, propertyKey, parameterIndex) {
+        const existingParams = Reflect.getMetadata(_constants_1.WS_SERVICE_KEY, target, propertyKey) || [];
+        existingParams.push({ index: parameterIndex });
+        Reflect.defineMetadata(_constants_1.WS_SERVICE_KEY, existingParams, target, propertyKey);
+    };
+}

package/dist/types/common.d.ts

@@ -0,0 +1,47 @@
+import { IncomingHttpHeaders, ServerResponse } from 'http';
+type P_Q = Record<string, string | undefined> | null | unknown;
+export type Request<B = unknown, Q extends P_Q = unknown, P extends P_Q = unknown> = {
+    method: string;
+    url: URL;
+    headers: IncomingHttpHeaders;
+    query?: Q;
+    params?: P;
+    body: B;
+    isBase64Encoded?: boolean;
+};
+export type Router = (req: Request, res?: ServerResponse) => Promise<{
+    status: number;
+    data: any;
+    message?: string;
+}>;
+export type EndpointResponse<T = any> = {
+    status: number;
+    data?: T;
+    error?: any;
+};
+export type AxiosQuery = {
+    data?: {
+        [key: string]: any;
+    };
+    headers?: {
+        [key: string]: any;
+    };
+    params?: {
+        [key: string]: any;
+    };
+    url: string;
+    method: 'POST' | 'GET' | 'PATCH' | 'DELETE';
+};
+export interface IController {
+    handleRequest: Router;
+}
+export type Middleware = (req: Request, res?: ServerResponse) => Promise<Request> | Request;
+export type Interceptor = (data: any, req?: Request, res?: ServerResponse) => Promise<unknown> | unknown;
+export type ParamDecoratorType = 'body' | 'params' | 'query' | 'request' | 'headers' | 'cookies' | 'response' | 'multipart';
+export interface ParamMetadata {
+    index: number;
+    type: ParamDecoratorType;
+    dto?: any;
+    name?: string;
+}
+export {};

package/dist/types/common.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/controller.d.ts

@@ -0,0 +1,4 @@
+export type ControllerClass = {
+    new (...args: any[]): any;
+};
+export type ControllerInstance = InstanceType<ControllerClass>;

package/dist/types/controller.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/http.d.ts

@@ -0,0 +1,18 @@
+export interface ServerConfig {
+    port?: number;
+    host?: string;
+    globalMiddlewares?: any[];
+    globalInterceptors?: any[];
+    globalErrorHandler?: any;
+    controllers?: any[];
+    websocket?: {
+        enabled: boolean;
+        path?: string;
+        lazy?: boolean;
+    };
+}
+export type Conf = ServerConfig & {
+    globalMiddlewares?: any[];
+    globalInterceptors?: any[];
+    globalErrorHandler?: any;
+};

package/dist/types/http.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './common';
+export * from './controller';
+export * from './http';
+export * from './lambda';
+export * from './websocket';

package/dist/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common"), exports);
+__exportStar(require("./controller"), exports);
+__exportStar(require("./http"), exports);
+__exportStar(require("./lambda"), exports);
+__exportStar(require("./websocket"), exports);

package/dist/types/lambda.d.ts

@@ -0,0 +1,26 @@
+import { APIGatewayProxyEvent, Context } from 'aws-lambda';
+export interface LambdaRequest {
+    method: string;
+    path: string;
+    headers: Record<string, string | string[]>;
+    query: Record<string, string | string[]>;
+    body: any;
+    params: Record<string, string>;
+    cookies: Record<string, string>;
+    raw: APIGatewayProxyEvent;
+    context: Context;
+    isBase64Encoded: boolean;
+    requestId: string;
+    stage: string;
+    sourceIp: string;
+    userAgent: string;
+    url: URL;
+}
+export interface LambdaResponse {
+    statusCode: number;
+    headers?: Record<string, string>;
+    body: string;
+    isBase64Encoded?: boolean;
+    multiValueHeaders?: Record<string, string[]>;
+    cookies?: string[];
+}

package/dist/types/lambda.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/websocket.d.ts

@@ -0,0 +1,55 @@
+import WebSocket from 'ws';
+export type WebSocketHandlerType = 'connection' | 'message' | 'close' | 'error';
+export interface WebSocketMessage {
+    type: string;
+    topic?: string;
+    data: any;
+    clientId?: string;
+}
+export interface WebSocketEvent {
+    type: WebSocketHandlerType;
+    client: WebSocketClient;
+    message?: WebSocketMessage;
+    data?: any;
+}
+export interface WebSocketClient {
+    id: string;
+    socket: WebSocket;
+    topics: Set<string>;
+    data: Record<string, any>;
+    connectedAt: Date;
+}
+export interface WebSocketMessage {
+    type: string;
+    topic?: string;
+    data: any;
+    clientId?: string;
+}
+export interface WebSocketStats {
+    clients: number;
+    topics: Array<{
+        topic: string;
+        subscribers: number;
+    }>;
+}
+export interface IWebSocketService {
+    sendToClient(clientId: string, message: any): boolean;
+    publishToTopic(topic: string, data: any, exclude?: string[]): void;
+    broadcast(message: any, excludeClientId?: string): void;
+    getStats(): {
+        clients: number;
+        topics: Array<{
+            topic: string;
+            subscribers: number;
+        }>;
+    };
+    isAvailable(): boolean;
+}
+export interface IWebSocketServer {
+    sendToClient(clientId: string, message: any): boolean;
+    publishToTopic(topic: string, data: any, exclude: string[]): void;
+    broadcast(message: any, excludeClientId?: string): void;
+    getStats(): WebSocketStats;
+    subscribeToTopic(client: WebSocketClient, topic: string): void;
+    unsubscribeFromTopic(client: WebSocketClient, topic: string): void;
+}

package/dist/types/websocket.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/controller.d.ts

@@ -0,0 +1,9 @@
+import { ControllerInstance } from '@types';
+import { ServerResponse } from 'http';
+export declare const executeControllerMethod: (controller: ControllerInstance, propertyName: string, payload: any, response?: ServerResponse) => Promise<any>;
+export declare const getControllerMethods: (controller: ControllerInstance) => {
+    name: string;
+    httpMethod: string;
+    pattern: string;
+    middlewares?: Array<(req: any, res?: ServerResponse) => any>;
+}[];

package/dist/utils/controller.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getControllerMethods = exports.executeControllerMethod = void 0;
+const _utils_1 = require("@utils");
+const WebsocetService_1 = require("../app/http/websocket/WebsocetService");
+const validate_1 = require("./validate");
+const _constants_1 = require("@constants");
+const getBodyAndMultipart = (payload) => {
+    let body = payload.body;
+    let multipart;
+    if (_utils_1.MultipartProcessor.isMultipart({ headers: payload.headers })) {
+        try {
+            const { fields, files } = _utils_1.MultipartProcessor.parse({
+                body: payload.rawBody || payload.body,
+                headers: payload.headers,
+                isBase64Encoded: payload.isBase64Encoded,
+            });
+            multipart = files;
+            body = fields;
+        }
+        catch (error) {
+            console.error('❌ Multipart parsing error:', error);
+            throw { status: 400, message: 'Invalid multipart data' };
+        }
+    }
+    return { multipart, body };
+};
+const executeControllerMethod = async (controller, propertyName, payload, response) => {
+    const fn = controller[propertyName];
+    if (typeof fn !== 'function')
+        return null;
+    const endpointMeta = Reflect.getMetadata(_constants_1.ENDPOINT, controller, propertyName);
+    if (!endpointMeta)
+        return null;
+    const methodMiddlewares = Reflect.getMetadata(_constants_1.MIDDLEWARES, controller, propertyName) || [];
+    for (let i = 0; i < methodMiddlewares.length; i++) {
+        const middleware = methodMiddlewares[i];
+        const result = await middleware(payload);
+        if (result) {
+            payload = { ...payload, ...result };
+        }
+    }
+    const prototype = Object.getPrototypeOf(controller);
+    const paramMetadata = Reflect.getMetadata(_constants_1.PARAM_METADATA_KEY, prototype, propertyName) || [];
+    const { body, multipart } = getBodyAndMultipart(payload);
+    if (paramMetadata.length === 0) {
+        return fn.call(controller, payload);
+    }
+    const args = [];
+    const wsParams = Reflect.getMetadata(_constants_1.WS_SERVICE_KEY, controller, propertyName) || [];
+    const totalParams = Math.max(paramMetadata.length ? Math.max(...paramMetadata.map((p) => p.index)) + 1 : 0, wsParams.length ? Math.max(...wsParams.map((p) => p.index)) + 1 : 0);
+    for (let i = 0; i < totalParams; i++) {
+        const wsParam = wsParams.find((p) => p.index === i);
+        if (wsParam) {
+            args[i] = WebsocetService_1.WebSocketService.getInstance();
+            continue;
+        }
+        const param = paramMetadata.find((p) => p.index === i);
+        if (!param) {
+            args[i] = undefined;
+            continue;
+        }
+        let value = param.name ? payload[param.type]?.[param.name] : payload[param.type];
+        if (param.type === 'multipart') {
+            value = multipart;
+        }
+        if (param.type === 'request') {
+            value = payload;
+        }
+        if (param.type === 'response') {
+            value = response;
+        }
+        if (param.type === 'response') {
+            value = response;
+        }
+        if (param.type === 'body') {
+            value = body;
+        }
+        if (_constants_1.TO_VALIDATE.includes(param.type)) {
+            value = await (0, validate_1.validate)(param.dto, value);
+        }
+        args[i] = value;
+    }
+    return fn.apply(controller, args);
+};
+exports.executeControllerMethod = executeControllerMethod;
+const getControllerMethods = (controller) => {
+    const methods = [];
+    let proto = Object.getPrototypeOf(controller);
+    while (proto && proto !== Object.prototype) {
+        const propertyNames = Object.getOwnPropertyNames(proto);
+        for (const propertyName of propertyNames) {
+            if (propertyName === 'constructor')
+                continue;
+            const endpointMeta = Reflect.getMetadata(_constants_1.ENDPOINT, proto, propertyName);
+            if (endpointMeta) {
+                const [httpMethod, pattern] = endpointMeta;
+                const methodMiddlewares = Reflect.getMetadata(_constants_1.MIDDLEWARES, proto, propertyName);
+                methods.push({
+                    name: propertyName,
+                    httpMethod,
+                    pattern,
+                    middlewares: methodMiddlewares,
+                });
+            }
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return methods;
+};
+exports.getControllerMethods = getControllerMethods;

package/dist/utils/helper.d.ts

@@ -0,0 +1 @@
+export declare const matchRoute: (routePattern: string, actualPath: string) => Record<string, string> | null;

package/dist/utils/helper.js

@@ -0,0 +1,24 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchRoute = void 0;
+const matchRoute = (routePattern, actualPath) => {
+    const routeParts = routePattern.split('/').filter(Boolean);
+    const pathParts = actualPath.split('/').filter(Boolean);
+    if (routeParts.length !== pathParts.length)
+        return null;
+    const params = {};
+    for (let i = 0; i < routeParts.length; i++) {
+        const routePart = routeParts[i];
+        const pathPart = pathParts[i];
+        if (routePart.startsWith(':')) {
+            const paramName = routePart.slice(1);
+            params[paramName] = decodeURIComponent(pathPart);
+        }
+        else if (routePart !== pathPart) {
+            return null;
+        }
+    }
+    return params;
+};
+exports.matchRoute = matchRoute;

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './controller';
+export * from './helper';
+export * from './multipart';
+export * from './parsers';
+export * from './server';
+export * from './transform';
+export * from './validate';

package/dist/utils/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./controller"), exports);
+__exportStar(require("./helper"), exports);
+__exportStar(require("./multipart"), exports);
+__exportStar(require("./parsers"), exports);
+__exportStar(require("./server"), exports);
+__exportStar(require("./transform"), exports);
+__exportStar(require("./validate"), exports);

package/dist/utils/multipart.d.ts

@@ -0,0 +1,15 @@
+export interface MultipartFile {
+    fieldname: string;
+    filename: string;
+    contentType: string;
+    data: Buffer;
+    size: number;
+    encoding?: string;
+}
+export declare class MultipartProcessor {
+    static parse(request: any): {
+        fields: Record<string, any>;
+        files: Record<string, MultipartFile | MultipartFile[]>;
+    };
+    static isMultipart(request: any): boolean;
+}