@duplojs/http 0.8.5 → 0.9.5

package/dist/plugins/cors/plugin.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var metadata = require('./metadata.cjs');
+var index = require('../../core/route/index.cjs');
+require('./headerFunctions/index.cjs');
+var vary = require('./headerFunctions/vary.cjs');
+var allowOrigin = require('./headerFunctions/allowOrigin.cjs');
+var exposeHeaders = require('./headerFunctions/exposeHeaders.cjs');
+var credentials = require('./headerFunctions/credentials.cjs');
+var hooks = require('../../core/route/hooks.cjs');
+var allowMethods = require('./headerFunctions/allowMethods.cjs');
+var allowHeaders = require('./headerFunctions/allowHeaders.cjs');
+var maxAge = require('./headerFunctions/maxAge.cjs');
+
+/* eslint-disable @typescript-eslint/prefer-for-of */
+function corsPlugin(params) {
+    const headerFunctionOtherRoutes = [];
+    if (params.allowOrigin) {
+        headerFunctionOtherRoutes.push(vary.varyFunction.default());
+        headerFunctionOtherRoutes.push(typeof params.allowOrigin === "function"
+            ? allowOrigin.allowOriginFunction.isFunction(params.allowOrigin)
+            : allowOrigin.allowOriginFunction.default(utils.toRegExp(params.allowOrigin === true
+                ? "*"
+                : params.allowOrigin)));
+    }
+    if (params.exposeHeaders) {
+        headerFunctionOtherRoutes.push(utils.pipe(params.exposeHeaders, utils.A.coalescing, utils.A.join(","), exposeHeaders.exposeHeadersFunction.default));
+    }
+    if (params.credentials) {
+        headerFunctionOtherRoutes.push(credentials.credentialsFunction.default());
+    }
+    const hookOtherRoute = hooks.createHookRouteLifeCycle({
+        beforeSendResponse: (params) => {
+            for (let index = 0; index < headerFunctionOtherRoutes.length; index++) {
+                headerFunctionOtherRoutes[index](params.request, params.currentResponse);
+            }
+            return params.next();
+        },
+    });
+    return () => ({
+        name: "cors",
+        hooksHubLifeCycle: [
+            {
+                beforeServerBuildRoutes: (hub) => {
+                    const headerFunctionRouteOptions = [];
+                    if (params.allowMethods === true) {
+                        const allowMethodsFunctionIsBool = utils.pipe(hub.routes, utils.G.filter((route) => !utils.A.some(route.definition.metadata, metadata.IgnoreRouteCorsMetadata.is)), utils.G.map((route) => utils.A.map(route.definition.paths, (path) => ({
+                            path,
+                            method: route.definition.method,
+                        }))), utils.G.flat, utils.G.reduce(utils.G.reduceFrom({}), ({ element, lastValue, next }) => {
+                            lastValue[element.path] = lastValue[element.path]
+                                ? `${lastValue[element.path]},${element.method}`
+                                : element.method;
+                            return next(lastValue);
+                        }), allowMethods.allowMethodsFunction.isBool);
+                        headerFunctionRouteOptions.push(allowMethodsFunctionIsBool);
+                    }
+                    else if (params.allowMethods) {
+                        headerFunctionRouteOptions.push(utils.pipe(params.allowMethods, utils.A.coalescing, utils.A.join(","), allowMethods.allowMethodsFunction.default));
+                    }
+                    if (params.allowHeaders) {
+                        headerFunctionRouteOptions.push(allowHeaders.allowHeadersFunction.default(params.allowHeaders === true
+                            ? "*"
+                            : utils.pipe(params.allowHeaders, utils.A.coalescing, utils.A.join(","))));
+                    }
+                    if (params.maxAge) {
+                        headerFunctionRouteOptions.push(maxAge.maxAgeFunction.default(params.maxAge.toString()));
+                    }
+                    const hookRouteOptions = hooks.createHookRouteLifeCycle({
+                        beforeRouteExecution: (params) => {
+                            const response = params.response("204", "cors");
+                            for (let index = 0; index < headerFunctionRouteOptions.length; index++) {
+                                headerFunctionRouteOptions[index](params.request, response);
+                            }
+                            return response;
+                        },
+                    });
+                    const routeOptions = index.createRoute({
+                        paths: ["/*"],
+                        method: "OPTIONS",
+                        hooks: [hookRouteOptions],
+                        metadata: [metadata.IgnoreRouteCorsMetadata()],
+                        steps: [],
+                        preflightSteps: [],
+                        bodyController: null,
+                    });
+                    hub.register(routeOptions);
+                    return hub;
+                },
+                beforeBuildRoute: (route) => {
+                    if (route.definition.method === "OPTIONS" || utils.A.some(route.definition.metadata, metadata.IgnoreRouteCorsMetadata.is)) {
+                        return route;
+                    }
+                    return {
+                        ...route,
+                        definition: {
+                            ...route.definition,
+                            hooks: [...route.definition.hooks, hookOtherRoute],
+                        },
+                    };
+                },
+            },
+        ],
+    });
+}
+
+exports.corsPlugin = corsPlugin;

package/dist/plugins/cors/plugin.d.ts

@@ -0,0 +1,12 @@
+import { type AnyTuple, type MaybePromise, type O } from "@duplojs/utils";
+import { type RequestMethods } from "../../core/request";
+import { type HubPlugin } from "../../core/hub";
+export interface CorsPluginParams {
+    readonly allowOrigin?: string | RegExp | AnyTuple<string> | ((origin: string) => MaybePromise<boolean>) | true;
+    readonly allowHeaders?: string | AnyTuple<string> | true;
+    readonly exposeHeaders?: string | AnyTuple<string>;
+    readonly maxAge?: number;
+    readonly credentials?: boolean;
+    readonly allowMethods?: RequestMethods | AnyTuple<RequestMethods> | true;
+}
+export declare function corsPlugin<GenericParams extends CorsPluginParams>(params: GenericParams & O.RequireAtLeastOne<GenericParams>): () => HubPlugin;

package/dist/plugins/cors/plugin.mjs

@@ -0,0 +1,106 @@
+import { toRegExp, pipe, A, G } from '@duplojs/utils';
+import { IgnoreRouteCorsMetadata } from './metadata.mjs';
+import { createRoute } from '../../core/route/index.mjs';
+import './headerFunctions/index.mjs';
+import { varyFunction } from './headerFunctions/vary.mjs';
+import { allowOriginFunction } from './headerFunctions/allowOrigin.mjs';
+import { exposeHeadersFunction } from './headerFunctions/exposeHeaders.mjs';
+import { credentialsFunction } from './headerFunctions/credentials.mjs';
+import { createHookRouteLifeCycle } from '../../core/route/hooks.mjs';
+import { allowMethodsFunction } from './headerFunctions/allowMethods.mjs';
+import { allowHeadersFunction } from './headerFunctions/allowHeaders.mjs';
+import { maxAgeFunction } from './headerFunctions/maxAge.mjs';
+
+/* eslint-disable @typescript-eslint/prefer-for-of */
+function corsPlugin(params) {
+    const headerFunctionOtherRoutes = [];
+    if (params.allowOrigin) {
+        headerFunctionOtherRoutes.push(varyFunction.default());
+        headerFunctionOtherRoutes.push(typeof params.allowOrigin === "function"
+            ? allowOriginFunction.isFunction(params.allowOrigin)
+            : allowOriginFunction.default(toRegExp(params.allowOrigin === true
+                ? "*"
+                : params.allowOrigin)));
+    }
+    if (params.exposeHeaders) {
+        headerFunctionOtherRoutes.push(pipe(params.exposeHeaders, A.coalescing, A.join(","), exposeHeadersFunction.default));
+    }
+    if (params.credentials) {
+        headerFunctionOtherRoutes.push(credentialsFunction.default());
+    }
+    const hookOtherRoute = createHookRouteLifeCycle({
+        beforeSendResponse: (params) => {
+            for (let index = 0; index < headerFunctionOtherRoutes.length; index++) {
+                headerFunctionOtherRoutes[index](params.request, params.currentResponse);
+            }
+            return params.next();
+        },
+    });
+    return () => ({
+        name: "cors",
+        hooksHubLifeCycle: [
+            {
+                beforeServerBuildRoutes: (hub) => {
+                    const headerFunctionRouteOptions = [];
+                    if (params.allowMethods === true) {
+                        const allowMethodsFunctionIsBool = pipe(hub.routes, G.filter((route) => !A.some(route.definition.metadata, IgnoreRouteCorsMetadata.is)), G.map((route) => A.map(route.definition.paths, (path) => ({
+                            path,
+                            method: route.definition.method,
+                        }))), G.flat, G.reduce(G.reduceFrom({}), ({ element, lastValue, next }) => {
+                            lastValue[element.path] = lastValue[element.path]
+                                ? `${lastValue[element.path]},${element.method}`
+                                : element.method;
+                            return next(lastValue);
+                        }), allowMethodsFunction.isBool);
+                        headerFunctionRouteOptions.push(allowMethodsFunctionIsBool);
+                    }
+                    else if (params.allowMethods) {
+                        headerFunctionRouteOptions.push(pipe(params.allowMethods, A.coalescing, A.join(","), allowMethodsFunction.default));
+                    }
+                    if (params.allowHeaders) {
+                        headerFunctionRouteOptions.push(allowHeadersFunction.default(params.allowHeaders === true
+                            ? "*"
+                            : pipe(params.allowHeaders, A.coalescing, A.join(","))));
+                    }
+                    if (params.maxAge) {
+                        headerFunctionRouteOptions.push(maxAgeFunction.default(params.maxAge.toString()));
+                    }
+                    const hookRouteOptions = createHookRouteLifeCycle({
+                        beforeRouteExecution: (params) => {
+                            const response = params.response("204", "cors");
+                            for (let index = 0; index < headerFunctionRouteOptions.length; index++) {
+                                headerFunctionRouteOptions[index](params.request, response);
+                            }
+                            return response;
+                        },
+                    });
+                    const routeOptions = createRoute({
+                        paths: ["/*"],
+                        method: "OPTIONS",
+                        hooks: [hookRouteOptions],
+                        metadata: [IgnoreRouteCorsMetadata()],
+                        steps: [],
+                        preflightSteps: [],
+                        bodyController: null,
+                    });
+                    hub.register(routeOptions);
+                    return hub;
+                },
+                beforeBuildRoute: (route) => {
+                    if (route.definition.method === "OPTIONS" || A.some(route.definition.metadata, IgnoreRouteCorsMetadata.is)) {
+                        return route;
+                    }
+                    return {
+                        ...route,
+                        definition: {
+                            ...route.definition,
+                            hooks: [...route.definition.hooks, hookOtherRoute],
+                        },
+                    };
+                },
+            },
+        ],
+    });
+}
+
+export { corsPlugin };

package/dist/plugins/openApiGenerator/makeOpenApiRoute.d.ts

@@ -17,7 +17,7 @@ export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: stri
             readonly coerce: boolean;
             readonly checkers: readonly [];
         }>>>;
-        theFunction(floor: {}, param: import("../../core/steps").HandlerStepFunctionParams<import("../../core/request").Request, import("../../core/response").PredictedResponse<"200", "swaggerUi", string>>): import("@duplojs/utils").MaybePromise<import("../../core/response").PredictedResponse<"200", "swaggerUi", string>>;
+        theFunction(floor: {}, param: import("../../core/steps").HandlerStepFunctionParams<import("../../core/response").PredictedResponse<"200", "swaggerUi", string>>): import("@duplojs/utils").MaybePromise<import("../../core/response").PredictedResponse<"200", "swaggerUi", string>>;
         readonly metadata: readonly [];
     }>];
 }>;

package/dist/plugins/static/makeRouteFile.d.ts

@@ -26,7 +26,7 @@ export declare function makeRouteFile(params: MakeRouteFileParams): import("../.
     readonly method: "GET";
     readonly metadata: readonly [import("../../core/metadata").Metadata<"ignore-by-route-store", unknown>];
     readonly hooks: readonly [{
-        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;
     }];
     readonly paths: readonly [`/${string}`] | AnyTuple<`/${string}`>;
     readonly preflightSteps: readonly [];
@@ -41,7 +41,7 @@ export declare function makeRouteFile(params: MakeRouteFileParams): import("../.
             readonly checkExist: boolean;
             readonly checkers: readonly [];
         }>>>, NoInfer<ResponseContract.Contract<"304", "resource.notModified", import("@duplojs/utils/dataParser").DataParserEmpty<import("@duplojs/utils/dataParser").DataParserDefinitionEmpty>>>];
-        theFunction(floor: {}, param: import("../../core/steps").HandlerStepFunctionParams<import("../../core/request").Request, import("../../core/response").PredictedResponse<"200", "resource.found", SF.FileInterface> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>): import("@duplojs/utils").MaybePromise<import("../../core/response").PredictedResponse<"200", "resource.found", SF.FileInterface> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>;
+        theFunction(floor: {}, param: import("../../core/steps").HandlerStepFunctionParams<import("../../core/response").PredictedResponse<"200", "resource.found", SF.FileInterface> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>): import("@duplojs/utils").MaybePromise<import("../../core/response").PredictedResponse<"200", "resource.found", SF.FileInterface> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>;
         readonly metadata: readonly [];
     }>];
 }>;

package/dist/plugins/static/makeRouteFolder.cjs

@@ -15,7 +15,7 @@ function makeRouteFolder(params) {
     const localPrefix = utils.A.coalescing(params.prefix);
     const routePath = utils.A.mapTuple(localPrefix, (prefix) => `${prefix}/*`);
     const prefixRegex = utils.pipe(localPrefix, utils.A.map(utils.escapeRegExp), utils.A.join("|"), (value) => new RegExp(`^(?:${value})(?:/|$)`));
-    const getResourcePath = utils.innerPipe(utils.S.replace(prefixRegex, ""), utils.S.prepend(sourcePath));
+    const getResourcePath = utils.innerPipe(utils.S.replace(prefixRegex, ""), utils.S.prepend(sourcePath), utils.S.replace(/\/+$/, ""));
     return builder.useRouteBuilder("GET", routePath, {
         metadata: [ignoreByRouteStore.IgnoreByRouteStoreMetadata()],
         hooks: [hooks.createCacheControllerHooks(params.cacheControlConfig)],

package/dist/plugins/static/makeRouteFolder.d.ts

@@ -13,7 +13,7 @@ export declare function makeRouteFolder(params: MakeRouteFolderParams): import("
     readonly method: "GET";
     readonly metadata: readonly [import("../../core/metadata").Metadata<"ignore-by-route-store", unknown>];
     readonly hooks: readonly [{
-        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;
     }];
     readonly paths: [`/${string}/*`] | [`/${string}/*`, ...`/${string}/*`[]];
     readonly preflightSteps: readonly [];
@@ -32,7 +32,7 @@ export declare function makeRouteFolder(params: MakeRouteFolderParams): import("
             readonly coerce: boolean;
             readonly checkers: readonly [];
         }>>>, NoInfer<ResponseContract.Contract<"304", "resource.notModified", import("@duplojs/utils/dataParser").DataParserEmpty<import("@duplojs/utils/dataParser").DataParserDefinitionEmpty>>>];
-        theFunction(floor: {}, param: import("../../core/steps").HandlerStepFunctionParams<import("../../core/request").Request, import("../../core/response").PredictedResponse<"200", "resource.found", SF.FileInterface> | import("../../core/response").PredictedResponse<"404", "resource.notfound", undefined> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>): import("@duplojs/utils").MaybePromise<import("../../core/response").PredictedResponse<"200", "resource.found", SF.FileInterface> | import("../../core/response").PredictedResponse<"404", "resource.notfound", undefined> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>;
+        theFunction(floor: {}, param: import("../../core/steps").HandlerStepFunctionParams<import("../../core/response").PredictedResponse<"200", "resource.found", SF.FileInterface> | import("../../core/response").PredictedResponse<"404", "resource.notfound", undefined> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>): import("@duplojs/utils").MaybePromise<import("../../core/response").PredictedResponse<"200", "resource.found", SF.FileInterface> | import("../../core/response").PredictedResponse<"404", "resource.notfound", undefined> | import("../../core/response").PredictedResponse<"304", "resource.notModified", undefined>>;
         readonly metadata: readonly [];
     }>];
 }>;

package/dist/plugins/static/makeRouteFolder.mjs

@@ -13,7 +13,7 @@ function makeRouteFolder(params) {
     const localPrefix = A.coalescing(params.prefix);
     const routePath = A.mapTuple(localPrefix, (prefix) => `${prefix}/*`);
     const prefixRegex = pipe(localPrefix, A.map(escapeRegExp), A.join("|"), (value) => new RegExp(`^(?:${value})(?:/|$)`));
-    const getResourcePath = innerPipe(S.replace(prefixRegex, ""), S.prepend(sourcePath));
+    const getResourcePath = innerPipe(S.replace(prefixRegex, ""), S.prepend(sourcePath), S.replace(/\/+$/, ""));
     return useRouteBuilder("GET", routePath, {
         metadata: [IgnoreByRouteStoreMetadata()],
         hooks: [createCacheControllerHooks(params.cacheControlConfig)],

package/dist/plugins/static/plugin.d.ts

@@ -11,7 +11,7 @@ export interface StaticPluginFileParams extends BaseStaticPluginParams {
 }
 export interface StaticPluginFolderParams extends BaseStaticPluginParams {
     readonly prefix: RoutePath | AnyTuple<RoutePath>;
-    readonly directoryIndexFilePrefix?: string;
+    readonly directoryFallBackFile?: string;
 }
 declare const StaticPluginError_base: new (params: {
     "@DuplojsStaticPlugin/static-plugin"?: unknown;

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@duplojs/http",
-  "version": "0.8.5",
-  "author": "mathcovax",
+  "version": "0.9.5",
+  "author": {
+    "name": "mathcovax",
+    "url": "https://github.com/mathcovax"
+  },
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -68,6 +71,11 @@
       "import": "./dist/plugins/static/index.mjs",
       "require": "./dist/plugins/static/index.cjs",
       "types": "./dist/plugins/static/index.d.ts"
+    },
+    "./cors": {
+      "import": "./dist/plugins/cors/index.mjs",
+      "require": "./dist/plugins/cors/index.cjs",
+      "types": "./dist/plugins/cors/index.d.ts"
     }
   },
   "files": [
@@ -77,7 +85,7 @@
   "peerDependencies": {
     "@duplojs/data-parser-tools": ">=0.2.9 <1.0.0",
     "@duplojs/server-utils": ">=0.2.2 <1.0.0",
-    "@duplojs/utils": ">=1.5.13 <2.0.0"
+    "@duplojs/utils": ">=1.5.15 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",
@@ -108,8 +116,25 @@
     "integration",
     "docs"
   ],
-  "keywords": [],
   "engines": {
     "node": ">=22.15.1"
-  }
+  },
+  "keywords": [
+    "duplojs",
+    "http",
+    "client",
+    "sse",
+    "static",
+    "codeGenerator",
+    "openApiGenerator",
+    "cors",
+    "cross-platform"
+  ],
+  "homepage": "https://http.duplojs.dev/",
+  "contributors": [
+    {
+      "name": "ZeRiix",
+      "url": "https://github.com/ZeRiix"
+    }
+  ]
 }

package/dist/core/functionsBuilders/route/default.d.ts

@@ -1 +0,0 @@
-export declare const defaultRouteFunctionBuilder: (route: import("../../route").Route, params: import("./create").RouteFunctionBuilderParams) => import("@duplojs/utils").MaybePromise<import("./create").BuildRouteNotSupportEither | import("./create").BuildRouteSuccessEither | import("..").BuildStepNotSupportEither>;

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

@@ -1,11 +0,0 @@
-import { type BuildRouteFunctionParams } from "../functionsBuilders";
-import { type HandlerStep } from "../steps";
-interface BuildSystemRouteParams {
-    handlerStep: HandlerStep;
-    buildParams: BuildRouteFunctionParams;
-}
-export declare function buildSystemRoute(params: BuildSystemRouteParams): Promise<{
-    bodyReader: import("../request").BodyReader<"empty">;
-    buildedRoute: import("../functionsBuilders").BuildedRouteFunction;
-}>;
-export {};