@duplojs/http 0.8.5 → 0.10.0

package/dist/plugins/cookie/parser.cjs

@@ -0,0 +1,84 @@
+'use strict';
+
+/**
+ * @internal
+ */
+function findPairEndIndex(value, start, len) {
+    const index = value.indexOf(";", start);
+    return index === -1 ? len : index;
+}
+/**
+ * @internal
+ */
+function sliceAndTrimOws(value, min, max) {
+    if (min === max) {
+        return "";
+    }
+    let start = min;
+    let end = max;
+    do {
+        const code = value.charCodeAt(start);
+        if (code !== 32 /*   */ && code !== 9 /* \t */) {
+            break;
+        }
+    } while (++start < end);
+    while (end > start) {
+        const code = value.charCodeAt(end - 1);
+        if (code !== 32 /*   */ && code !== 9 /* \t */) {
+            break;
+        }
+        end--;
+    }
+    return value.slice(start, end);
+}
+/**
+ * @internal
+ */
+function decode(value) {
+    if (!value.includes("%")) {
+        return value;
+    }
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function defaultParser(value) {
+    const result = {};
+    const valueLength = value.length;
+    if (valueLength < 2) {
+        return result;
+    }
+    let index = 0;
+    do {
+        const equalCharIndex = value.indexOf("=", index);
+        if (equalCharIndex === -1) {
+            break;
+        }
+        const pairEndIndex = findPairEndIndex(value, index, valueLength);
+        if (equalCharIndex > pairEndIndex) {
+            index = value.lastIndexOf(";", equalCharIndex - 1) + 1;
+            continue;
+        }
+        const key = sliceAndTrimOws(value, index, equalCharIndex);
+        if (key === ""
+            || key === "__proto__"
+            || key === "constructor"
+            || key === "prototype") {
+            index = pairEndIndex + 1;
+            continue;
+        }
+        if (result[key] === undefined) {
+            result[key] = decode(sliceAndTrimOws(value, equalCharIndex + 1, pairEndIndex));
+        }
+        index = pairEndIndex + 1;
+    } while (index < valueLength);
+    return result;
+}
+
+exports.decode = decode;
+exports.defaultParser = defaultParser;
+exports.findPairEndIndex = findPairEndIndex;
+exports.sliceAndTrimOws = sliceAndTrimOws;

package/dist/plugins/cookie/parser.d.ts

@@ -0,0 +1,2 @@
+export declare function defaultParser(value: string): Partial<Record<string, string>>;
+export type Parser = typeof defaultParser;

package/dist/plugins/cookie/parser.mjs

@@ -0,0 +1,79 @@
+/**
+ * @internal
+ */
+function findPairEndIndex(value, start, len) {
+    const index = value.indexOf(";", start);
+    return index === -1 ? len : index;
+}
+/**
+ * @internal
+ */
+function sliceAndTrimOws(value, min, max) {
+    if (min === max) {
+        return "";
+    }
+    let start = min;
+    let end = max;
+    do {
+        const code = value.charCodeAt(start);
+        if (code !== 32 /*   */ && code !== 9 /* \t */) {
+            break;
+        }
+    } while (++start < end);
+    while (end > start) {
+        const code = value.charCodeAt(end - 1);
+        if (code !== 32 /*   */ && code !== 9 /* \t */) {
+            break;
+        }
+        end--;
+    }
+    return value.slice(start, end);
+}
+/**
+ * @internal
+ */
+function decode(value) {
+    if (!value.includes("%")) {
+        return value;
+    }
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function defaultParser(value) {
+    const result = {};
+    const valueLength = value.length;
+    if (valueLength < 2) {
+        return result;
+    }
+    let index = 0;
+    do {
+        const equalCharIndex = value.indexOf("=", index);
+        if (equalCharIndex === -1) {
+            break;
+        }
+        const pairEndIndex = findPairEndIndex(value, index, valueLength);
+        if (equalCharIndex > pairEndIndex) {
+            index = value.lastIndexOf(";", equalCharIndex - 1) + 1;
+            continue;
+        }
+        const key = sliceAndTrimOws(value, index, equalCharIndex);
+        if (key === ""
+            || key === "__proto__"
+            || key === "constructor"
+            || key === "prototype") {
+            index = pairEndIndex + 1;
+            continue;
+        }
+        if (result[key] === undefined) {
+            result[key] = decode(sliceAndTrimOws(value, equalCharIndex + 1, pairEndIndex));
+        }
+        index = pairEndIndex + 1;
+    } while (index < valueLength);
+    return result;
+}
+
+export { decode, defaultParser, findPairEndIndex, sliceAndTrimOws };

package/dist/plugins/cookie/plugin.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+require('./hooks/index.cjs');
+var metadata = require('./metadata.cjs');
+var cookieHooks = require('./hooks/cookieHooks.cjs');
+
+function cookiePlugin(params) {
+    return () => ({
+        name: "cookie-plugin",
+        hooksHubLifeCycle: [
+            {
+                beforeBuildRoute: (route) => {
+                    if (utils.A.some(route.definition.metadata, metadata.IgnoreRouteCookieMetadata.is)) {
+                        return route;
+                    }
+                    return {
+                        ...route,
+                        definition: {
+                            ...route.definition,
+                            hooks: [...route.definition.hooks, cookieHooks.cookieHooks(params)],
+                        },
+                    };
+                },
+            },
+        ],
+    });
+}
+
+exports.cookiePlugin = cookiePlugin;

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

@@ -0,0 +1,8 @@
+import type { HubPlugin } from "../../core/hub";
+import type { Parser } from "./parser";
+import type { Serializer } from "./serialize";
+export interface CookiePluginParams {
+    parser?: Parser;
+    serializer?: Serializer;
+}
+export declare function cookiePlugin(params?: CookiePluginParams): () => HubPlugin;

package/dist/plugins/cookie/plugin.mjs

@@ -0,0 +1,28 @@
+import { A } from '@duplojs/utils';
+import './hooks/index.mjs';
+import { IgnoreRouteCookieMetadata } from './metadata.mjs';
+import { cookieHooks } from './hooks/cookieHooks.mjs';
+
+function cookiePlugin(params) {
+    return () => ({
+        name: "cookie-plugin",
+        hooksHubLifeCycle: [
+            {
+                beforeBuildRoute: (route) => {
+                    if (A.some(route.definition.metadata, IgnoreRouteCookieMetadata.is)) {
+                        return route;
+                    }
+                    return {
+                        ...route,
+                        definition: {
+                            ...route.definition,
+                            hooks: [...route.definition.hooks, cookieHooks(params)],
+                        },
+                    };
+                },
+            },
+        ],
+    });
+}
+
+export { cookiePlugin };

package/dist/plugins/cookie/serialize.cjs

@@ -0,0 +1,84 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('./kind.cjs');
+
+const nameRegex = /^[!#$%&'*+\-.^_`|~A-Za-z0-9]+$/;
+const domainValueRegex = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+const pathValueRegex = /^[\u0020-\u003A\u003C-\u007E]*$/;
+class SerializeCookieError extends utils.kindHeritage("serialize-cookie-error", kind.createCookiePluginKind("serialize-cookie-error"), Error) {
+    constructor(message) {
+        super({}, [message]);
+    }
+}
+function defaultSerializer(name, value, params) {
+    if (!nameRegex.test(name)) {
+        throw new SerializeCookieError(`argument name is invalid: ${name}`);
+    }
+    let encodedValue = "";
+    try {
+        encodedValue = encodeURIComponent(value);
+    }
+    catch {
+        throw new SerializeCookieError(`argument value is invalid: ${value}`);
+    }
+    let setCookie = `${name}=${encodedValue}`;
+    if (params?.maxAge !== undefined) {
+        if (!Number.isInteger(params.maxAge)) {
+            throw new SerializeCookieError(`param maxAge is invalid: ${params.maxAge}`);
+        }
+        setCookie += `; Max-Age=${params.maxAge}`;
+    }
+    if (params?.domain) {
+        if (!domainValueRegex.test(params.domain)) {
+            throw new SerializeCookieError(`param domain is invalid: ${params.domain}`);
+        }
+        setCookie += `; Domain=${params.domain}`;
+    }
+    if (params?.path) {
+        if (!pathValueRegex.test(params.path)) {
+            throw new SerializeCookieError(`param path is invalid: ${params.path}`);
+        }
+        setCookie += `; Path=${params.path}`;
+    }
+    if (params?.expires && params?.expireIn) {
+        throw new SerializeCookieError("params expires and expireIn are mutually exclusive");
+    }
+    if (params?.expires) {
+        setCookie += `; Expires=${params.expires.toUTCString()}`;
+    }
+    if (params?.expireIn !== undefined) {
+        setCookie += `; Expires=${utils.D.addTime(utils.D.now(), params.expireIn).toUTCString()}`;
+    }
+    if (params?.httpOnly) {
+        setCookie += "; HttpOnly";
+    }
+    if (params?.secure) {
+        setCookie += "; Secure";
+    }
+    if (params?.partitioned) {
+        setCookie += "; Partitioned";
+    }
+    if (params?.priority === "high") {
+        setCookie += "; Priority=High";
+    }
+    else if (params?.priority === "low") {
+        setCookie += "; Priority=Low";
+    }
+    else if (params?.priority === "medium") {
+        setCookie += "; Priority=Medium";
+    }
+    if (params?.sameSite === "strict") {
+        setCookie += "; SameSite=Strict";
+    }
+    else if (params?.sameSite === "lax") {
+        setCookie += "; SameSite=Lax";
+    }
+    else if (params?.sameSite === "none") {
+        setCookie += "; SameSite=None";
+    }
+    return setCookie;
+}
+
+exports.SerializeCookieError = SerializeCookieError;
+exports.defaultSerializer = defaultSerializer;

package/dist/plugins/cookie/serialize.d.ts

@@ -0,0 +1,29 @@
+import { D } from "@duplojs/utils";
+declare const SerializeCookieError_base: new (params: {
+    "@DuplojsCookiePlugin/serialize-cookie-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsCookiePlugin/serialize-cookie-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"serialize-cookie-error", unknown>, unknown> & Error;
+export declare class SerializeCookieError extends SerializeCookieError_base {
+    constructor(message: string);
+}
+interface SerializerParamsBase {
+    maxAge?: number;
+    domain?: string;
+    path?: string;
+    httpOnly?: boolean;
+    secure?: boolean;
+    partitioned?: boolean;
+    priority?: "low" | "medium" | "high";
+    sameSite?: "lax" | "strict" | "none";
+}
+export interface SerializerParamsWithExpires extends SerializerParamsBase {
+    expires?: D.TheDate;
+    expireIn?: undefined;
+}
+export interface SerializerParamsWithExpireIn extends SerializerParamsBase {
+    expires?: undefined;
+    expireIn?: D.TheTime;
+}
+export type SerializerParams = SerializerParamsWithExpires | SerializerParamsWithExpireIn;
+export declare function defaultSerializer(name: string, value: string, params?: SerializerParams): string;
+export type Serializer = typeof defaultSerializer;
+export {};

package/dist/plugins/cookie/serialize.mjs

@@ -0,0 +1,81 @@
+import { kindHeritage, D } from '@duplojs/utils';
+import { createCookiePluginKind } from './kind.mjs';
+
+const nameRegex = /^[!#$%&'*+\-.^_`|~A-Za-z0-9]+$/;
+const domainValueRegex = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+const pathValueRegex = /^[\u0020-\u003A\u003C-\u007E]*$/;
+class SerializeCookieError extends kindHeritage("serialize-cookie-error", createCookiePluginKind("serialize-cookie-error"), Error) {
+    constructor(message) {
+        super({}, [message]);
+    }
+}
+function defaultSerializer(name, value, params) {
+    if (!nameRegex.test(name)) {
+        throw new SerializeCookieError(`argument name is invalid: ${name}`);
+    }
+    let encodedValue = "";
+    try {
+        encodedValue = encodeURIComponent(value);
+    }
+    catch {
+        throw new SerializeCookieError(`argument value is invalid: ${value}`);
+    }
+    let setCookie = `${name}=${encodedValue}`;
+    if (params?.maxAge !== undefined) {
+        if (!Number.isInteger(params.maxAge)) {
+            throw new SerializeCookieError(`param maxAge is invalid: ${params.maxAge}`);
+        }
+        setCookie += `; Max-Age=${params.maxAge}`;
+    }
+    if (params?.domain) {
+        if (!domainValueRegex.test(params.domain)) {
+            throw new SerializeCookieError(`param domain is invalid: ${params.domain}`);
+        }
+        setCookie += `; Domain=${params.domain}`;
+    }
+    if (params?.path) {
+        if (!pathValueRegex.test(params.path)) {
+            throw new SerializeCookieError(`param path is invalid: ${params.path}`);
+        }
+        setCookie += `; Path=${params.path}`;
+    }
+    if (params?.expires && params?.expireIn) {
+        throw new SerializeCookieError("params expires and expireIn are mutually exclusive");
+    }
+    if (params?.expires) {
+        setCookie += `; Expires=${params.expires.toUTCString()}`;
+    }
+    if (params?.expireIn !== undefined) {
+        setCookie += `; Expires=${D.addTime(D.now(), params.expireIn).toUTCString()}`;
+    }
+    if (params?.httpOnly) {
+        setCookie += "; HttpOnly";
+    }
+    if (params?.secure) {
+        setCookie += "; Secure";
+    }
+    if (params?.partitioned) {
+        setCookie += "; Partitioned";
+    }
+    if (params?.priority === "high") {
+        setCookie += "; Priority=High";
+    }
+    else if (params?.priority === "low") {
+        setCookie += "; Priority=Low";
+    }
+    else if (params?.priority === "medium") {
+        setCookie += "; Priority=Medium";
+    }
+    if (params?.sameSite === "strict") {
+        setCookie += "; SameSite=Strict";
+    }
+    else if (params?.sameSite === "lax") {
+        setCookie += "; SameSite=Lax";
+    }
+    else if (params?.sameSite === "none") {
+        setCookie += "; SameSite=None";
+    }
+    return setCookie;
+}
+
+export { SerializeCookieError, defaultSerializer };

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;
+};

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

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

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var allowHeaders = require('./allowHeaders.cjs');
+var allowMethods = require('./allowMethods.cjs');
+var allowOrigin = require('./allowOrigin.cjs');
+var credentials = require('./credentials.cjs');
+var exposeHeaders = require('./exposeHeaders.cjs');
+var maxAge = require('./maxAge.cjs');
+var vary = require('./vary.cjs');
+
+
+
+exports.allowHeadersFunction = allowHeaders.allowHeadersFunction;
+exports.allowMethodsFunction = allowMethods.allowMethodsFunction;
+exports.allowOriginFunction = allowOrigin.allowOriginFunction;
+exports.credentialsFunction = credentials.credentialsFunction;
+exports.exposeHeadersFunction = exposeHeaders.exposeHeadersFunction;
+exports.maxAgeFunction = maxAge.maxAgeFunction;
+exports.varyFunction = vary.varyFunction;

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

@@ -0,0 +1,7 @@
+export * from "./allowHeaders";
+export * from "./allowMethods";
+export * from "./allowOrigin";
+export * from "./credentials";
+export * from "./exposeHeaders";
+export * from "./maxAge";
+export * from "./vary";

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

@@ -0,0 +1,7 @@
+export { allowHeadersFunction } from './allowHeaders.mjs';
+export { allowMethodsFunction } from './allowMethods.mjs';
+export { allowOriginFunction } from './allowOrigin.mjs';
+export { credentialsFunction } from './credentials.mjs';
+export { exposeHeadersFunction } from './exposeHeaders.mjs';
+export { maxAgeFunction } from './maxAge.mjs';
+export { varyFunction } from './vary.mjs';

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

@@ -0,0 +1,11 @@
+'use strict';
+
+const maxAgeFunction = {
+    default(maxAge) {
+        return (request, response) => {
+            response.setHeader("access-control-max-age", maxAge);
+        };
+    },
+};
+
+exports.maxAgeFunction = maxAgeFunction;