feat(cookie): update @routup/cookie for routup v5

packages/assets/package.json

@@ -52,10 +52,10 @@
     },
     "homepage": "https://github.com/routup/plugins#readme",
     "peerDependencies": {
-        "routup": "^5.0.0-beta.2"
+        "routup": "^5.0.0-beta.3"
     },
     "devDependencies": {
-        "routup": "^5.0.0-beta.2"
+        "routup": "^5.0.0-beta.3"
     },
     "publishConfig": {
         "access": "public"

packages/cookie/README.md

@@ -19,6 +19,8 @@ response.
   - [setRequestCookies](#setrequestcookies)
   - [useRequestCookies](#userequestcookies)
   - [useRequestCookie](#userequestcookie)
+  - [setResponseCookie](#setresponsecookie)
+  - [unsetResponseCookie](#unsetresponsecookie)
 - [License](#license)
 
 ## Installation
@@ -37,33 +39,33 @@ It is important to invoke the request middleware,
 to parse the cookies of the request header.
 
 ```typescript
-import { createServer } from 'node:http';
 import {
-    createNodeDispatcher,
-    coreHandler,
-    Router
+    Router,
+    defineCoreHandler,
+    serve,
 } from 'routup';
 import {
     cookie,
     useRequestCookie,
-    useRequestCookies
+    useRequestCookies,
 } from '@routup/cookie';
 
 const router = new Router();
 
 router.use(cookie());
 
-router.get('/', coreHandler((req, res) => {
-    const cookies = useRequestCookies(req);
+router.get('/', defineCoreHandler((event) => {
+    const cookies = useRequestCookies(event);
     console.log(cookies);
     // { key: value, ... }
 
-    const cookie = useRequestCookie(req, 'key');
+    const value = useRequestCookie(event, 'key');
     // value
+
+    return value;
 }));
 
-const server = createServer(createNodeDispatcher(router));
-server.listen(3000);
+serve(router, { port: 3000 });
 ```
 
 ## Options
@@ -93,13 +95,13 @@ This function sets the parsed request cookies for the current request.
 
 ```typescript
 declare function setRequestCookies(
-    req: Request,
+    event: IRoutupEvent,
     key: string,
     value: unknown
 ) : void;
 
 declare function setRequestCookies(
-    req: Request,
+    event: IRoutupEvent,
     record: Record<string, any>
 ) : void;
 ```
@@ -110,21 +112,46 @@ This function returns the parsed request cookies.
 
 ```typescript
 declare function useRequestCookies(
-    req: IncomingMessage,
+    event: IRoutupEvent,
 ) : Record<string, string>;
 ```
 
 ### `useRequestCookie`
 
-This function returns a **single** parsed request cookies.
+This function returns a **single** parsed request cookie.
 
 ```typescript
 declare function useRequestCookie(
-    req: IncomingMessage,
+    event: IRoutupEvent,
     name: string
 ) : string | undefined;
 ```
 
+### `setResponseCookie`
+
+This function sets a cookie on the response.
+
+```typescript
+declare function setResponseCookie(
+    event: IRoutupEvent,
+    name: string,
+    value: string,
+    options?: SerializeOptions
+) : void;
+```
+
+### `unsetResponseCookie`
+
+This function removes a cookie by setting its `maxAge` to `0`.
+
+```typescript
+declare function unsetResponseCookie(
+    event: IRoutupEvent,
+    name: string,
+    options?: SerializeOptions
+) : void;
+```
+
 ## License
 
 Made with 💚

packages/cookie/package.json

@@ -51,15 +51,13 @@
     },
     "homepage": "https://github.com/routup/plugins#readme",
     "peerDependencies": {
-        "routup": "^4.0.1"
+        "routup": "^5.0.0-beta.3"
     },
     "dependencies": {
         "cookie-es": "^3.1.1"
     },
     "devDependencies": {
-        "@types/supertest": "^7.2.0",
-        "routup": "^4.0.1",
-        "supertest": "^7.1.4"
+        "routup": "^5.0.0-beta.3"
     },
     "gitHead": "94d729e309c1eec0401afb4d8083f65ce3aa8e0b",
     "publishConfig": {

packages/cookie/src/handler.ts

@@ -1,5 +1,5 @@
 import {
-    coreHandler,
+    defineCoreHandler,
 } from 'routup';
 
 import {
@@ -11,14 +11,13 @@ import type { ParseOptions } from './types';
 import { parseRequestCookies } from './utils';
 
 export function createHandler(options?: ParseOptions) {
-    return coreHandler((req, res, next) => {
-        if (hasRequestCookies(req)) {
-            next();
-            return;
+    return defineCoreHandler((event) => {
+        if (hasRequestCookies(event)) {
+            return event.next();
         }
 
-        setRequestCookies(req, parseRequestCookies(req, options));
+        setRequestCookies(event, parseRequestCookies(event, options));
 
-        next();
+        return event.next();
     });
 }

packages/cookie/src/request.ts

@@ -1,34 +1,34 @@
-import type { Request } from 'routup';
+import type { IRoutupEvent } from 'routup';
 import { isObject } from './utils';
 
 const CookieSymbol = Symbol.for('ReqCookie');
 
 export function useRequestCookies(
-    req: Request,
+    event: IRoutupEvent,
 ) : Record<string, string> {
-    if (CookieSymbol in req) {
-        return (req as any)[CookieSymbol];
+    if (CookieSymbol in event.store) {
+        return event.store[CookieSymbol] as Record<string, string>;
     }
 
     return {};
 }
 
-export function hasRequestCookies(req: Request) {
-    return CookieSymbol in req &&
-        isObject((req as any)[CookieSymbol]);
+export function hasRequestCookies(event: IRoutupEvent) {
+    return CookieSymbol in event.store &&
+        isObject(event.store[CookieSymbol]);
 }
 
-export function useRequestCookie(req: Request, name: string) : string | undefined {
-    return useRequestCookies(req)[name];
+export function useRequestCookie(event: IRoutupEvent, name: string) : string | undefined {
+    return useRequestCookies(event)[name];
 }
 
-export function setRequestCookies(req: Request, key: string, value: unknown) : void;
-export function setRequestCookies(req: Request, record: Record<string, any>) : void;
-export function setRequestCookies(req: Request, key: Record<string, any> | string, value?: unknown) : void {
+export function setRequestCookies(event: IRoutupEvent, key: string, value: unknown) : void;
+export function setRequestCookies(event: IRoutupEvent, record: Record<string, any>) : void;
+export function setRequestCookies(event: IRoutupEvent, key: Record<string, any> | string, value?: unknown) : void {
     if (isObject(key)) {
-        (req as any)[CookieSymbol] = key;
+        event.store[CookieSymbol] = key;
         return;
     }
 
-    (req as any)[CookieSymbol] = { [key]: value };
+    event.store[CookieSymbol] = { [key]: value };
 }

packages/cookie/src/response.ts

@@ -1,18 +1,18 @@
-import type { Response } from 'routup';
-import { HeaderName, appendResponseHeader } from 'routup';
+import type { IRoutupEvent } from 'routup';
+import { appendResponseHeader } from 'routup';
 import { serialize } from 'cookie-es';
 import type { SerializeOptions } from './types';
 
-export function setResponseCookie(res: Response, name: string, value: string, options?: SerializeOptions) {
-    appendResponseHeader(res, HeaderName.SET_COOKIE, serialize(name, value, {
+export function setResponseCookie(event: IRoutupEvent, name: string, value: string, options?: SerializeOptions) {
+    appendResponseHeader(event, 'set-cookie', serialize(name, value, {
         path: '/',
         ...(options || {}),
     }));
 }
 
 /* istanbul ignore next */
-export function unsetResponseCookie(res: Response, name: string, options?: SerializeOptions) {
-    setResponseCookie(res, name, '', {
+export function unsetResponseCookie(event: IRoutupEvent, name: string, options?: SerializeOptions) {
+    setResponseCookie(event, name, '', {
         ...(options || {}),
         maxAge: 0,
     });

packages/cookie/src/utils.ts

@@ -1,10 +1,9 @@
-import type { Request } from 'routup';
-import { HeaderName } from 'routup';
+import type { IRoutupEvent } from 'routup';
 import { parse } from 'cookie-es';
 import type { ParseOptions } from './types';
 
-export function parseRequestCookies(req: Request, options?: ParseOptions) {
-    return parse(req.headers[HeaderName.COOKIE] || '', options || {});
+export function parseRequestCookies(event: IRoutupEvent, options?: ParseOptions) {
+    return parse(event.headers.get('cookie') || '', options || {});
 }
 
 export function isObject(item: unknown) : item is Record<string, any> {