@duplojs/http 0.8.5 → 0.10.0

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/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/cookie/hooks/cookieHooks.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var parser = require('../parser.cjs');
+var serialize = require('../serialize.cjs');
+var parseRequestCookie = require('./parseRequestCookie.cjs');
+var serializeResponseCookie = require('./serializeResponseCookie.cjs');
+
+function cookieHooks({ parser: parser$1 = parser.defaultParser, serializer = serialize.defaultSerializer, } = {}) {
+    return {
+        ...parseRequestCookie.parseRequestCookieHook({ parser: parser$1 }),
+        ...serializeResponseCookie.serializeResponseCookieHook({ serializer }),
+    };
+}
+
+exports.cookieHooks = cookieHooks;

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

@@ -0,0 +1,11 @@
+import { type Parser } from "../parser";
+import { type Serializer } from "../serialize";
+interface CookieHooksParams {
+    parser?: Parser;
+    serializer?: Serializer;
+}
+export declare function cookieHooks({ parser, serializer, }?: CookieHooksParams): {
+    beforeSendResponse: ({ currentResponse, next }: import("../../../core/route").RouteHookParamsAfter) => import("../../../core/route").RouteHookNext;
+    beforeRouteExecution: ({ request, next }: import("../../../core/route").RouteHookParams) => import("../../../core/route").RouteHookNext;
+};
+export {};

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

@@ -0,0 +1,13 @@
+import { defaultParser } from '../parser.mjs';
+import { defaultSerializer } from '../serialize.mjs';
+import { parseRequestCookieHook } from './parseRequestCookie.mjs';
+import { serializeResponseCookieHook } from './serializeResponseCookie.mjs';
+
+function cookieHooks({ parser = defaultParser, serializer = defaultSerializer, } = {}) {
+    return {
+        ...parseRequestCookieHook({ parser }),
+        ...serializeResponseCookieHook({ serializer }),
+    };
+}
+
+export { cookieHooks };

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

@@ -0,0 +1,11 @@
+'use strict';
+
+var parseRequestCookie = require('./parseRequestCookie.cjs');
+var serializeResponseCookie = require('./serializeResponseCookie.cjs');
+var cookieHooks = require('./cookieHooks.cjs');
+
+
+
+exports.parseRequestCookieHook = parseRequestCookie.parseRequestCookieHook;
+exports.serializeResponseCookieHook = serializeResponseCookie.serializeResponseCookieHook;
+exports.cookieHooks = cookieHooks.cookieHooks;

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

@@ -0,0 +1,3 @@
+export * from "./parseRequestCookie";
+export * from "./serializeResponseCookie";
+export * from "./cookieHooks";

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

@@ -0,0 +1,3 @@
+export { parseRequestCookieHook } from './parseRequestCookie.mjs';
+export { serializeResponseCookieHook } from './serializeResponseCookie.mjs';
+export { cookieHooks } from './cookieHooks.mjs';

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

@@ -0,0 +1,20 @@
+'use strict';
+
+require('../../../core/route/index.cjs');
+var hooks = require('../../../core/route/hooks.cjs');
+
+function parseRequestCookieHook(params) {
+    return hooks.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();
+        },
+    });
+}
+
+exports.parseRequestCookieHook = parseRequestCookieHook;

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

@@ -0,0 +1,8 @@
+import { type Parser } from "../parser";
+interface ParseRequestCookieHookParams {
+    parser: Parser;
+}
+export declare function parseRequestCookieHook(params: ParseRequestCookieHookParams): {
+    readonly beforeRouteExecution: ({ request, next }: import("../../../core/route").RouteHookParams) => import("../../../core/route").RouteHookNext;
+};
+export {};

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 parseRequestCookie = require('./hooks/parseRequestCookie.cjs');
+var serializeResponseCookie = require('./hooks/serializeResponseCookie.cjs');
+var cookieHooks = require('./hooks/cookieHooks.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.parseRequestCookieHook = parseRequestCookie.parseRequestCookieHook;
+exports.serializeResponseCookieHook = serializeResponseCookie.serializeResponseCookieHook;
+exports.cookieHooks = cookieHooks.cookieHooks;

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 { parseRequestCookieHook } from './hooks/parseRequestCookie.mjs';
+export { serializeResponseCookieHook } from './hooks/serializeResponseCookie.mjs';
+export { cookieHooks } from './hooks/cookieHooks.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;
+};