@duplojs/http 0.8.4 → 0.9.5

package/dist/core/router/index.mjs

@@ -2,14 +2,11 @@ import '../hub/index.mjs';
 import { pipe, A, isType, G, E, unwrap, justReturn, O, forward } from '@duplojs/utils';
 import { pathToRegExp } from './pathToRegExp.mjs';
 import { RouterBuildError } from './buildError.mjs';
-import '../functionsBuilders/route/index.mjs';
-import { decodeUrl } from './decodeUrl.mjs';
-export { regexQueryAnalyser, regexUrlAnalyser } from './decodeUrl.mjs';
 import { NotFoundBodyReaderImplementationError } from './notFoundBodyReaderImplementationError.mjs';
 import '../functionsBuilders/index.mjs';
-import { buildSystemRoute } from './buildSystemRoute.mjs';
+import { createRouterElementSystem } from './createRouterElementSystem.mjs';
 import './types/index.mjs';
-import { defaultRouteFunctionBuilder } from '../functionsBuilders/route/default.mjs';
+import { defaultRouteFunctionBuilder } from '../functionsBuilders/route/default/index.mjs';
 import { defaultCheckerStepFunctionBuilder } from '../functionsBuilders/steps/defaults/checkerStep.mjs';
 import { defaultCutStepFunctionBuilder } from '../functionsBuilders/steps/defaults/cutStep.mjs';
 import { defaultHandlerStepFunctionBuilder } from '../functionsBuilders/steps/defaults/handlerStep.mjs';
@@ -17,8 +14,10 @@ import { defaultExtractStepFunctionBuilder } from '../functionsBuilders/steps/de
 import { defaultProcessStepFunctionBuilder } from '../functionsBuilders/steps/defaults/processStep.mjs';
 import { launchHookBeforeBuildRoute } from '../hub/hooks.mjs';
 import { buildRouteFunction } from '../functionsBuilders/route/build.mjs';
+import { buildRouterFunction } from '../functionsBuilders/router/build.mjs';
+import { defaultRouterFunctionBuilder } from '../functionsBuilders/router/default/index.mjs';
 
-async function buildRouter(hub) {
+async function createRouter(hub) {
     const { environment } = hub.config;
     const { hooksRouteLifeCycle, routes, hooksHubLifeCycle, bodyReaderImplementations, } = hub;
     const routeFunctionBuilders = [
@@ -41,7 +40,7 @@ async function buildRouter(hub) {
         routeFunctionBuilders,
         defaultExtractContract: hub.defaultExtractContract,
     };
-    const groupedRoute = await G.asyncReduce(routes, G.reduceFrom({}), async ({ lastValue, element: route, nextWithObject, }) => {
+    const routerElementWrapper = await G.asyncReduce(routes, G.reduceFrom({}), async ({ lastValue, element: route, nextWithObject, }) => {
         const routeAfterHook = await launchHookBeforeBuildRoute(hooksBeforeBuildRoute, route);
         const buildedRoute = await buildRouteFunction(routeAfterHook, buildParams);
         if (E.isLeft(buildedRoute)) {
@@ -61,61 +60,23 @@ async function buildRouter(hub) {
             }))),
         });
     });
-    const defaultNotfoundRoute = await buildSystemRoute({
+    const notfoundRouterElement = await createRouterElementSystem({
         handlerStep: hub.notfoundHandler,
         buildParams,
     });
-    const defaultMalformedUrlRoute = await buildSystemRoute({
+    const malformedUrlRouterElement = await createRouterElementSystem({
         handlerStep: hub.malformedUrlHandler,
         buildParams,
     });
-    const Request = hub.classRequest;
     return {
-        exec: (initializationData) => {
-            const routerElements = groupedRoute[initializationData.method];
-            const decodedUrl = decodeUrl(initializationData.url);
-            if (!decodedUrl) {
-                return defaultMalformedUrlRoute.buildedRoute(new Request({
-                    ...initializationData,
-                    params: {},
-                    path: "",
-                    query: {},
-                    matchedPath: null,
-                    bodyReader: defaultMalformedUrlRoute.bodyReader,
-                }));
-            }
-            if (!routerElements) {
-                return defaultNotfoundRoute.buildedRoute(new Request({
-                    ...initializationData,
-                    ...decodedUrl,
-                    params: {},
-                    matchedPath: null,
-                    bodyReader: defaultNotfoundRoute.bodyReader,
-                }));
-            }
-            // eslint-disable-next-line @typescript-eslint/prefer-for-of
-            for (let index = 0; index < routerElements.length; index++) {
-                const routerElement = routerElements[index];
-                const result = routerElement.pattern.exec(decodedUrl.path);
-                if (!result) {
-                    continue;
-                }
-                return routerElement.buildedRoute(new Request({
-                    ...initializationData,
-                    ...decodedUrl,
-                    params: result.groups ?? {},
-                    matchedPath: routerElement.matchedPath,
-                    bodyReader: routerElement.bodyReader,
-                }));
-            }
-            return defaultNotfoundRoute.buildedRoute(new Request({
-                ...initializationData,
-                ...decodedUrl,
-                params: {},
-                matchedPath: null,
-                bodyReader: defaultNotfoundRoute.bodyReader,
-            }));
-        },
+        exec: await buildRouterFunction({
+            environment: hub.config.environment,
+            routerElementWrapper,
+            notfoundRouterElement: notfoundRouterElement,
+            malformedUrlRouterElement: malformedUrlRouterElement,
+            classRequest: hub.classRequest,
+            routerFunctionBuilder: hub.routerFunctionBuilder ?? defaultRouterFunctionBuilder,
+        }),
         hooksRouteLifeCycle,
         routeFunctionBuilders,
         routes,
@@ -124,4 +85,4 @@ async function buildRouter(hub) {
     };
 }
 
-export { NotFoundBodyReaderImplementationError, RouterBuildError, buildRouter, buildSystemRoute, decodeUrl, pathToRegExp };
+export { NotFoundBodyReaderImplementationError, RouterBuildError, createRouter, createRouterElementSystem, pathToRegExp };

package/dist/core/router/types/buildedRouter.d.ts

@@ -1,13 +1,3 @@
-import { type createStepFunctionBuilder, type createRouteFunctionBuilder } from "../../functionsBuilders";
-import { type HookHubLifeCycle } from "../../hub";
 import { type RequestInitializationData } from "../../request";
-import { type HookRouteLifeCycle, type Route } from "../../route";
-export type RouterInitializationData = Omit<RequestInitializationData, "matchedPath" | "bodyReader" | "params" | "path" | "query">;
-export interface BuildedRouter {
-    exec(initializationData: RouterInitializationData): Promise<void>;
-    readonly routes: ReadonlySet<Route>;
-    readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
-    readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
-    readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
-    readonly hooksHubLifeCycle: readonly HookHubLifeCycle[];
-}
+export type RouterParams = Omit<RequestInitializationData, "matchedPath" | "bodyReader" | "params" | "path" | "query">;
+export type BuildedRouter = (params: RouterParams) => Promise<void>;

package/dist/core/router/types/index.cjs

@@ -1,4 +1,8 @@
 'use strict';
 
 require('./buildedRouter.cjs');
+require('./router.cjs');
+require('./routerElement.cjs');
+require('./routerElementSystem.cjs');
+require('./routerElementWrapper.cjs');
 

package/dist/core/router/types/index.d.ts

@@ -1 +1,5 @@
 export * from "./buildedRouter";
+export * from "./router";
+export * from "./routerElement";
+export * from "./routerElementSystem";
+export * from "./routerElementWrapper";

package/dist/core/router/types/index.mjs

@@ -1 +1,5 @@
 import './buildedRouter.mjs';
+import './router.mjs';
+import './routerElement.mjs';
+import './routerElementSystem.mjs';
+import './routerElementWrapper.mjs';

package/dist/core/router/types/router.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/router/types/router.d.ts

@@ -0,0 +1,12 @@
+import { type createRouteFunctionBuilder, type createStepFunctionBuilder } from "../../functionsBuilders";
+import { type HookHubLifeCycle } from "../../hub";
+import { type HookRouteLifeCycle, type Route } from "../../route";
+import { type BuildedRouter } from "./buildedRouter";
+export interface Router {
+    exec: BuildedRouter;
+    readonly routes: ReadonlySet<Route>;
+    readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
+    readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
+    readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
+    readonly hooksHubLifeCycle: readonly HookHubLifeCycle[];
+}

package/dist/core/router/types/router.mjs

@@ -0,0 +1 @@
+

package/dist/core/router/types/routerElement.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/router/types/routerElement.d.ts

@@ -0,0 +1,8 @@
+import { type BodyReader } from "../../request";
+import { type BuildedRoute } from "../../route/types";
+export interface RouterElement {
+    readonly pattern: RegExp;
+    readonly matchedPath: string;
+    readonly bodyReader: BodyReader;
+    readonly buildedRoute: BuildedRoute;
+}

package/dist/core/router/types/routerElement.mjs

@@ -0,0 +1 @@
+

package/dist/core/router/types/routerElementSystem.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/router/types/routerElementSystem.d.ts

@@ -0,0 +1,6 @@
+import { type BodyReader } from "../../request";
+import { type BuildedRoute } from "../../route/types";
+export interface RouterElementSystem {
+    readonly bodyReader: BodyReader;
+    readonly buildedRoute: BuildedRoute;
+}

package/dist/core/router/types/routerElementSystem.mjs

@@ -0,0 +1 @@
+

package/dist/core/router/types/routerElementWrapper.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/router/types/routerElementWrapper.d.ts

@@ -0,0 +1,2 @@
+import { type RouterElement } from "./routerElement";
+export type RouterElementWrapper = Record<string, RouterElement[]>;

package/dist/core/router/types/routerElementWrapper.mjs

@@ -0,0 +1 @@
+

package/dist/core/steps/cut.d.ts

@@ -3,12 +3,11 @@ import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type StepFunctionParams } from "./types";
 import { type PredictedResponse, type ResponseContract } from "../response";
-import { type Request } from "../request";
 import { type Metadata } from "../metadata";
 export declare const cutStepOutputKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-output", unknown>>;
 export interface CutStepFunctionOutput<GenericData extends Record<string, unknown> = Record<string, unknown>> extends Kind<typeof cutStepOutputKind.definition>, WrappedValue<GenericData> {
 }
-export interface CutStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericRequest, GenericResponse> {
+export interface CutStepFunctionParams<GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericResponse> {
     output<GenericData extends Record<string, unknown> = never>(data?: GenericData): CutStepFunctionOutput<NeverCoalescing<GenericData, {}>>;
 }
 export interface CutStepDefinition {

package/dist/core/steps/handler.d.ts

@@ -2,7 +2,6 @@ import { type MaybePromise, type Kind, type MaybeArray } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type ServerSentEventsPredictedResponse, type PredictedResponse, type ResponseContract } from "../response";
-import { type Request } from "../request";
 import { type StepFunctionParams } from "./types";
 import { type Metadata } from "../metadata";
 interface HandlerStepFunctionParamsServerSentEventsResponse<GenericResponse extends ServerSentEventsPredictedResponse> {
@@ -10,7 +9,7 @@ interface HandlerStepFunctionParamsServerSentEventsResponse<GenericResponse exte
         information: GenericInformation;
     }>>(information: GenericInformation, startSendingEvents: GenericFilteredResponse["startSendingEvents"]): GenericFilteredResponse;
 }
-export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse | ServerSentEventsPredictedResponse = PredictedResponse | ServerSentEventsPredictedResponse> extends StepFunctionParams<GenericRequest, Extract<GenericResponse, PredictedResponse>>, HandlerStepFunctionParamsServerSentEventsResponse<Extract<GenericResponse, ServerSentEventsPredictedResponse>> {
+export interface HandlerStepFunctionParams<GenericResponse extends PredictedResponse | ServerSentEventsPredictedResponse = PredictedResponse | ServerSentEventsPredictedResponse> extends StepFunctionParams<Extract<GenericResponse, PredictedResponse>>, HandlerStepFunctionParamsServerSentEventsResponse<Extract<GenericResponse, ServerSentEventsPredictedResponse>> {
 }
 export interface HandlerStepDefinition {
     theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<PredictedResponse | ServerSentEventsPredictedResponse>;

package/dist/core/steps/types/stepFunctionParams.d.ts

@@ -1,8 +1,8 @@
 import { type Request } from "../../request";
 import { type PredictedResponse } from "../../response";
 import { type IsEqual, type Or } from "@duplojs/utils";
-export interface StepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> {
-    request: GenericRequest;
+export interface StepFunctionParams<GenericResponse extends PredictedResponse = PredictedResponse> {
+    request: Request;
     response<GenericInformation extends GenericResponse["information"], GenericFilteredResponse extends Extract<GenericResponse, {
         information: GenericInformation;
     }>>(information: GenericInformation, ...args: Or<[

package/dist/interfaces/node/bodyReaders/formData/index.cjs

@@ -55,6 +55,7 @@ function createFormDataBodyReaderImplementation(serverParams) {
         const result = await readRequestFormData.readRequestFormData(request.raw.request, new Map(), {
             maxBodySize: params.bodyMaxSize ?? serverMaxBodySize,
             fileMaxSize: params.fileMaxSize ?? Infinity,
+            textFieldMaxSize: params.textFieldMaxSize ?? Infinity,
             maxFileQuantity: params.maxFileQuantity,
             mimeType: params.mimeType,
             maxBufferSize: params.maxBufferSize,

package/dist/interfaces/node/bodyReaders/formData/index.mjs

@@ -53,6 +53,7 @@ function createFormDataBodyReaderImplementation(serverParams) {
         const result = await readRequestFormData(request.raw.request, new Map(), {
             maxBodySize: params.bodyMaxSize ?? serverMaxBodySize,
             fileMaxSize: params.fileMaxSize ?? Infinity,
+            textFieldMaxSize: params.textFieldMaxSize ?? Infinity,
             maxFileQuantity: params.maxFileQuantity,
             mimeType: params.mimeType,
             maxBufferSize: params.maxBufferSize,

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.cjs

@@ -32,6 +32,7 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
     let currentStream = undefined;
     let fileQuantity = 0;
     let currentFileSize = undefined;
+    let currentTextFieldSize = undefined;
     const checkSize = (receivedChunk) => {
         size += receivedChunk.length;
         return size > params.maxBodySize
@@ -61,6 +62,7 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         if (header.filename !== undefined) {
             currentFileSize = 0;
+            currentTextFieldSize = undefined;
             fileQuantity++;
             if (fileQuantity > params.maxFileQuantity) {
                 return new error.BodyParseFormDataError("File quantity exceeds limit.");
@@ -72,6 +74,7 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         else {
             currentFileSize = undefined;
+            currentTextFieldSize = 0;
         }
         const newStream = await onReceiveHeader(header);
         if (newStream instanceof Error) {
@@ -93,10 +96,16 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         if (typeof currentFileSize === "number") {
             currentFileSize += chunk.length;
-            if (params.fileMaxSize !== undefined && currentFileSize > params.fileMaxSize) {
+            if (currentFileSize > params.fileMaxSize) {
                 return new error.BodyParseFormDataError("File size exceeds limit.");
             }
         }
+        if (typeof currentTextFieldSize === "number") {
+            currentTextFieldSize += chunk.length;
+            if (currentTextFieldSize > params.textFieldMaxSize) {
+                return new error.BodyParseFormDataError("Text field size exceeds limit.");
+            }
+        }
         await currentStream.onReceiveChunk(chunk);
         return true;
     };

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.d.ts

@@ -14,7 +14,8 @@ export interface ReadRequestFormDataParams {
     maxFileQuantity: number;
     maxBufferSize: number;
     maxKeyLength: number;
-    fileMaxSize?: number;
+    fileMaxSize: number;
+    textFieldMaxSize: number;
     mimeType?: RegExp;
 }
 export declare function readRequestFormData<GenericValueAccumulator extends unknown, GenericOutputHeader extends E.Left = never>(request: http.IncomingMessage, firstValueAccumulator: GenericValueAccumulator, params: ReadRequestFormDataParams, onReceiveHeader: (header: HeaderPartInformation) => MaybePromise<ReadRequestFormDataStreamChunkEvent<GenericValueAccumulator> | Error>): Promise<E.Left<"server-error", unknown> | GenericOutputHeader | E.Error<Error> | GenericValueAccumulator>;

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.mjs

@@ -30,6 +30,7 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
     let currentStream = undefined;
     let fileQuantity = 0;
     let currentFileSize = undefined;
+    let currentTextFieldSize = undefined;
     const checkSize = (receivedChunk) => {
         size += receivedChunk.length;
         return size > params.maxBodySize
@@ -59,6 +60,7 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         if (header.filename !== undefined) {
             currentFileSize = 0;
+            currentTextFieldSize = undefined;
             fileQuantity++;
             if (fileQuantity > params.maxFileQuantity) {
                 return new BodyParseFormDataError("File quantity exceeds limit.");
@@ -70,6 +72,7 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         else {
             currentFileSize = undefined;
+            currentTextFieldSize = 0;
         }
         const newStream = await onReceiveHeader(header);
         if (newStream instanceof Error) {
@@ -91,10 +94,16 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         if (typeof currentFileSize === "number") {
             currentFileSize += chunk.length;
-            if (params.fileMaxSize !== undefined && currentFileSize > params.fileMaxSize) {
+            if (currentFileSize > params.fileMaxSize) {
                 return new BodyParseFormDataError("File size exceeds limit.");
             }
         }
+        if (typeof currentTextFieldSize === "number") {
+            currentTextFieldSize += chunk.length;
+            if (currentTextFieldSize > params.textFieldMaxSize) {
+                return new BodyParseFormDataError("Text field size exceeds limit.");
+            }
+        }
         await currentStream.onReceiveChunk(chunk);
         return true;
     };

package/dist/interfaces/node/createHttpServer.cjs

@@ -24,8 +24,8 @@ function createHttpServer(hub, params) {
         index.createTextBodyReaderImplementation(httpServerParams),
         index$1.createFormDataBodyReaderImplementation(httpServerParams),
     ]);
-    function whenUncaughtError(error, routerInitializationData) {
-        const serverResponse = routerInitializationData.raw.response;
+    function whenUncaughtError(error, routerParams) {
+        const serverResponse = routerParams.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {
             serverResponse.writeHead(500, {
                 [httpServerParams.informationHeaderKey]: "critical-server-error",

package/dist/interfaces/node/createHttpServer.mjs

@@ -22,8 +22,8 @@ function createHttpServer(hub, params) {
         createTextBodyReaderImplementation(httpServerParams),
         createFormDataBodyReaderImplementation(httpServerParams),
     ]);
-    function whenUncaughtError(error, routerInitializationData) {
-        const serverResponse = routerInitializationData.raw.response;
+    function whenUncaughtError(error, routerParams) {
+        const serverResponse = routerParams.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {
             serverResponse.writeHead(500, {
                 [httpServerParams.informationHeaderKey]: "critical-server-error",

package/dist/interfaces/node/hooks/index.d.ts

@@ -1,7 +1,7 @@
 import { type Hub } from "../../../core/hub";
 import { type HttpServerParams } from "../../../core/types";
 export declare function initNodeHook(hub: Hub, serverParams: HttpServerParams): {
-    readonly beforeSendResponse: ({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>) => import("../../../core/route").RouteHookExit;
-    readonly sendResponse: ({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>) => Promise<import("../../../core/route").RouteHookExit>;
-    readonly afterSendResponse: ({ request, next }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>) => Promise<import("../../../core/route").RouteHookNext>;
+    readonly beforeSendResponse: ({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter) => import("../../../core/route").RouteHookExit;
+    readonly sendResponse: ({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter) => Promise<import("../../../core/route").RouteHookExit>;
+    readonly afterSendResponse: ({ request, next }: import("../../../core/route").RouteHookParamsAfter) => Promise<import("../../../core/route").RouteHookNext>;
 };

package/dist/plugins/cacheController/hooks.cjs

@@ -12,7 +12,8 @@ function createCacheControllerHooks(params) {
     return hooks.createHookRouteLifeCycle({
         beforeSendResponse: ({ currentResponse, next }) => {
             if (cacheControl
-                && eligibleCodeRegex.test(currentResponse.code)) {
+                && eligibleCodeRegex.test(currentResponse.code)
+                && currentResponse.headers?.["cache-control"] === undefined) {
                 currentResponse.setHeader("cache-control", cacheControl);
             }
             return next();

package/dist/plugins/cacheController/hooks.d.ts

@@ -1,4 +1,4 @@
 import type { CacheControlDirectives } from "./types";
 export declare function createCacheControllerHooks(params?: CacheControlDirectives): {
-    readonly beforeSendResponse: ({ currentResponse, next }: import("../../core/route").RouteHookParamsAfter<import("../../core/request").Request>) => import("../../core/route").RouteHookNext;
+    readonly beforeSendResponse: ({ currentResponse, next }: import("../../core/route").RouteHookParamsAfter) => import("../../core/route").RouteHookNext;
 };

package/dist/plugins/cacheController/hooks.mjs

@@ -10,7 +10,8 @@ function createCacheControllerHooks(params) {
     return createHookRouteLifeCycle({
         beforeSendResponse: ({ currentResponse, next }) => {
             if (cacheControl
-                && eligibleCodeRegex.test(currentResponse.code)) {
+                && eligibleCodeRegex.test(currentResponse.code)
+                && currentResponse.headers?.["cache-control"] === undefined) {
                 currentResponse.setHeader("cache-control", cacheControl);
             }
             return next();

package/dist/plugins/cors/headerFunctions/allowHeaders.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const allowHeadersFunction = {
+    default(allowHeaders) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-headers", allowHeaders);
+        };
+    },
+};
+
+exports.allowHeadersFunction = allowHeadersFunction;

package/dist/plugins/cors/headerFunctions/allowHeaders.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+export declare const allowHeadersFunction: {
+    default(allowHeaders: string): (request: Request, response: Response) => void;
+};

package/dist/plugins/cors/headerFunctions/allowHeaders.mjs

@@ -0,0 +1,9 @@
+const allowHeadersFunction = {
+    default(allowHeaders) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-headers", allowHeaders);
+        };
+    },
+};
+
+export { allowHeadersFunction };

package/dist/plugins/cors/headerFunctions/allowMethods.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+const allowMethodsFunction = {
+    default(methods) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-methods", methods);
+        };
+    },
+    isBool(allowMethods) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-methods", allowMethods[request.path]);
+        };
+    },
+};
+
+exports.allowMethodsFunction = allowMethodsFunction;

package/dist/plugins/cors/headerFunctions/allowMethods.d.ts

@@ -0,0 +1,6 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+export declare const allowMethodsFunction: {
+    default(methods: string): (request: Request, response: Response) => void;
+    isBool(allowMethods: Record<string, string>): (request: Request, response: Response) => void;
+};

package/dist/plugins/cors/headerFunctions/allowMethods.mjs

@@ -0,0 +1,14 @@
+const allowMethodsFunction = {
+    default(methods) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-methods", methods);
+        };
+    },
+    isBool(allowMethods) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-methods", allowMethods[request.path]);
+        };
+    },
+};
+
+export { allowMethodsFunction };

package/dist/plugins/cors/headerFunctions/allowOrigin.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+const allowOriginFunction = {
+    default(allowOrigin) {
+        return (request, response) => {
+            if (allowOrigin.test(request.origin)) {
+                response.setHeader("access-control-allow-origin", request.origin);
+            }
+        };
+    },
+    isFunction(allowOrigin) {
+        return async (request, response) => {
+            let result = allowOrigin(request.origin);
+            if (result instanceof Promise) {
+                result = await result;
+            }
+            if (result === true) {
+                response.setHeader("access-control-allow-origin", request.origin);
+            }
+        };
+    },
+};
+
+exports.allowOriginFunction = allowOriginFunction;

package/dist/plugins/cors/headerFunctions/allowOrigin.d.ts

@@ -0,0 +1,7 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+import type { MaybePromise } from "@duplojs/utils";
+export declare const allowOriginFunction: {
+    default(allowOrigin: RegExp): (request: Request, response: Response) => void;
+    isFunction(allowOrigin: (origin: string) => MaybePromise<boolean>): (request: Request, response: Response) => Promise<void>;
+};

package/dist/plugins/cors/headerFunctions/allowOrigin.mjs

@@ -0,0 +1,22 @@
+const allowOriginFunction = {
+    default(allowOrigin) {
+        return (request, response) => {
+            if (allowOrigin.test(request.origin)) {
+                response.setHeader("access-control-allow-origin", request.origin);
+            }
+        };
+    },
+    isFunction(allowOrigin) {
+        return async (request, response) => {
+            let result = allowOrigin(request.origin);
+            if (result instanceof Promise) {
+                result = await result;
+            }
+            if (result === true) {
+                response.setHeader("access-control-allow-origin", request.origin);
+            }
+        };
+    },
+};
+
+export { allowOriginFunction };

package/dist/plugins/cors/headerFunctions/credentials.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const credentialsFunction = {
+    default() {
+        return (request, response) => {
+            response.setHeader("access-control-allow-credentials", "true");
+        };
+    },
+};
+
+exports.credentialsFunction = credentialsFunction;

package/dist/plugins/cors/headerFunctions/credentials.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+export declare const credentialsFunction: {
+    default(): (request: Request, response: Response) => void;
+};

package/dist/plugins/cors/headerFunctions/credentials.mjs

@@ -0,0 +1,9 @@
+const credentialsFunction = {
+    default() {
+        return (request, response) => {
+            response.setHeader("access-control-allow-credentials", "true");
+        };
+    },
+};
+
+export { credentialsFunction };

package/dist/plugins/cors/headerFunctions/exposeHeaders.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const exposeHeadersFunction = {
+    default(exposeHeaders) {
+        return (request, response) => {
+            response.setHeader("access-control-expose-headers", exposeHeaders);
+        };
+    },
+};
+
+exports.exposeHeadersFunction = exposeHeadersFunction;

package/dist/plugins/cors/headerFunctions/exposeHeaders.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+export declare const exposeHeadersFunction: {
+    default(exposeHeaders: string): (request: Request, response: Response) => void;
+};