@duplojs/http 0.9.5 → 0.11.0

package/dist/plugins/cookie/hooks/parseRequestCookie.mjs

@@ -0,0 +1,18 @@
+import '../../../core/route/index.mjs';
+import { createHookRouteLifeCycle } from '../../../core/route/hooks.mjs';
+
+function parseRequestCookieHook(params) {
+    return createHookRouteLifeCycle({
+        beforeRouteExecution: ({ request, next }) => {
+            if (request.headers.cookie) {
+                const cookieValue = Array.isArray(request.headers.cookie)
+                    ? request.headers.cookie.join("; ")
+                    : request.headers.cookie;
+                request.cookies = params.parser(cookieValue);
+            }
+            return next();
+        },
+    });
+}
+
+export { parseRequestCookieHook };

package/dist/plugins/cookie/hooks/serializeResponseCookie.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+require('../../../core/route/index.cjs');
+var hooks = require('../../../core/route/hooks.cjs');
+
+function serializeResponseCookieHook(params) {
+    return hooks.createHookRouteLifeCycle({
+        beforeSendResponse: ({ currentResponse, next }) => {
+            if (currentResponse.cookie !== undefined && Object.keys(currentResponse.cookie).length !== 0) {
+                currentResponse.setHeader("set-cookie", Object.entries(currentResponse.cookie).map(([name, content]) => params.serializer(name, content.value, content.params)));
+            }
+            return next();
+        },
+    });
+}
+
+exports.serializeResponseCookieHook = serializeResponseCookieHook;

package/dist/plugins/cookie/hooks/serializeResponseCookie.d.ts

@@ -0,0 +1,7 @@
+import { type Serializer } from "../serialize";
+export interface SerializeResponseCookieHookParams {
+    serializer: Serializer;
+}
+export declare function serializeResponseCookieHook(params: SerializeResponseCookieHookParams): {
+    readonly beforeSendResponse: ({ currentResponse, next }: import("../../../core/route").RouteHookParamsAfter) => import("../../../core/route").RouteHookNext;
+};

package/dist/plugins/cookie/hooks/serializeResponseCookie.mjs

@@ -0,0 +1,15 @@
+import '../../../core/route/index.mjs';
+import { createHookRouteLifeCycle } from '../../../core/route/hooks.mjs';
+
+function serializeResponseCookieHook(params) {
+    return createHookRouteLifeCycle({
+        beforeSendResponse: ({ currentResponse, next }) => {
+            if (currentResponse.cookie !== undefined && Object.keys(currentResponse.cookie).length !== 0) {
+                currentResponse.setHeader("set-cookie", Object.entries(currentResponse.cookie).map(([name, content]) => params.serializer(name, content.value, content.params)));
+            }
+            return next();
+        },
+    });
+}
+
+export { serializeResponseCookieHook };

package/dist/plugins/cookie/index.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var parser = require('./parser.cjs');
+var serialize = require('./serialize.cjs');
+require('./override.cjs');
+var metadata = require('./metadata.cjs');
+require('./hooks/index.cjs');
+var plugin = require('./plugin.cjs');
+var cookieHooks = require('./hooks/cookieHooks.cjs');
+var parseRequestCookie = require('./hooks/parseRequestCookie.cjs');
+var serializeResponseCookie = require('./hooks/serializeResponseCookie.cjs');
+
+
+
+exports.decode = parser.decode;
+exports.defaultParser = parser.defaultParser;
+exports.findPairEndIndex = parser.findPairEndIndex;
+exports.sliceAndTrimOws = parser.sliceAndTrimOws;
+exports.SerializeCookieError = serialize.SerializeCookieError;
+exports.defaultSerializer = serialize.defaultSerializer;
+exports.IgnoreRouteCookieMetadata = metadata.IgnoreRouteCookieMetadata;
+exports.cookiePlugin = plugin.cookiePlugin;
+exports.cookieHooks = cookieHooks.cookieHooks;
+exports.parseRequestCookieHook = parseRequestCookie.parseRequestCookieHook;
+exports.serializeResponseCookieHook = serializeResponseCookie.serializeResponseCookieHook;

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

@@ -0,0 +1,6 @@
+export * from "./parser";
+export * from "./serialize";
+export * from "./override";
+export * from "./metadata";
+export * from "./hooks";
+export * from "./plugin";

package/dist/plugins/cookie/index.mjs

@@ -0,0 +1,9 @@
+export { decode, defaultParser, findPairEndIndex, sliceAndTrimOws } from './parser.mjs';
+export { SerializeCookieError, defaultSerializer } from './serialize.mjs';
+import './override.mjs';
+export { IgnoreRouteCookieMetadata } from './metadata.mjs';
+import './hooks/index.mjs';
+export { cookiePlugin } from './plugin.mjs';
+export { cookieHooks } from './hooks/cookieHooks.mjs';
+export { parseRequestCookieHook } from './hooks/parseRequestCookie.mjs';
+export { serializeResponseCookieHook } from './hooks/serializeResponseCookie.mjs';

package/dist/plugins/cookie/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+const createCookiePluginKind = utils.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsCookiePlugin");
+
+exports.createCookiePluginKind = createCookiePluginKind;

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

@@ -0,0 +1,6 @@
+declare module "@duplojs/utils" {
+    interface ReservedKindNamespace {
+        DuplojsCookiePlugin: true;
+    }
+}
+export declare const createCookiePluginKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("@duplojs/utils/string").ForbiddenString<GenericName, "@" | "/">) => import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<`@DuplojsCookiePlugin/${GenericName}`, GenericKindValue>>;

package/dist/plugins/cookie/kind.mjs

@@ -0,0 +1,7 @@
+import { createKindNamespace } from '@duplojs/utils';
+
+const createCookiePluginKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsCookiePlugin");
+
+export { createCookiePluginKind };

package/dist/plugins/cookie/metadata.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+require('../../core/metadata/index.cjs');
+var base = require('../../core/metadata/base.cjs');
+
+const IgnoreRouteCookieMetadata = base.createMetadata("ignore-by-cookie");
+
+exports.IgnoreRouteCookieMetadata = IgnoreRouteCookieMetadata;

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

@@ -0,0 +1 @@
+export declare const IgnoreRouteCookieMetadata: import("../../core/metadata").MetadataHandler<"ignore-by-cookie", unknown>;

package/dist/plugins/cookie/metadata.mjs

@@ -0,0 +1,6 @@
+import '../../core/metadata/index.mjs';
+import { createMetadata } from '../../core/metadata/base.mjs';
+
+const IgnoreRouteCookieMetadata = createMetadata("ignore-by-cookie");
+
+export { IgnoreRouteCookieMetadata };

package/dist/plugins/cookie/override.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var index = require('../../core/request/index.cjs');
+require('../../core/response/index.cjs');
+var base = require('../../core/response/base.cjs');
+
+index.Request.prototype.cookies = undefined;
+base.Response.prototype.cookie = undefined;
+base.Response.prototype.setCookie = function (name, value, params) {
+    if (!this.cookie) {
+        this.cookie = {};
+    }
+    this.cookie[name] = {
+        value,
+        params,
+    };
+    return this;
+};
+base.Response.prototype.dropCookie = function (name) {
+    if (!this.cookie) {
+        this.cookie = {};
+    }
+    this.cookie[name] = {
+        value: "",
+        params: {
+            maxAge: 0,
+        },
+    };
+    return this;
+};

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

@@ -0,0 +1,16 @@
+import type { SerializerParams } from "./serialize";
+declare module "../../core/request" {
+    interface Request {
+        cookies?: Partial<Record<string, string>>;
+    }
+}
+declare module "../../core/response" {
+    interface Response<GenericCode, GenericInformation, GenericBody> {
+        cookie?: Record<string, {
+            value: string;
+            params?: SerializerParams;
+        }>;
+        setCookie(name: string, value: string, params?: SerializerParams): this;
+        dropCookie(name: string): this;
+    }
+}

package/dist/plugins/cookie/override.mjs

@@ -0,0 +1,28 @@
+import { Request } from '../../core/request/index.mjs';
+import '../../core/response/index.mjs';
+import { Response } from '../../core/response/base.mjs';
+
+Request.prototype.cookies = undefined;
+Response.prototype.cookie = undefined;
+Response.prototype.setCookie = function (name, value, params) {
+    if (!this.cookie) {
+        this.cookie = {};
+    }
+    this.cookie[name] = {
+        value,
+        params,
+    };
+    return this;
+};
+Response.prototype.dropCookie = function (name) {
+    if (!this.cookie) {
+        this.cookie = {};
+    }
+    this.cookie[name] = {
+        value: "",
+        params: {
+            maxAge: 0,
+        },
+    };
+    return this;
+};

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