@whatwg-node/server-plugin-cookies 0.0.0

package/CookieChangeEvent.d.ts

@@ -0,0 +1,7 @@
+import { Event } from '@whatwg-node/events';
+import { CookieChangeEventInit, CookieList } from './types';
+export declare class CookieChangeEvent extends Event {
+    changed: CookieList;
+    deleted: CookieList;
+    constructor(type: string, eventInitDict?: CookieChangeEventInit);
+}

package/CookieStore.d.ts

@@ -0,0 +1,12 @@
+import { CookieChangeEvent } from './CookieChangeEvent';
+import { Cookie, CookieListItem, CookieStoreDeleteOptions, CookieStoreGetOptions } from './types';
+export declare class CookieStore extends EventTarget {
+    cookieString: string;
+    onchange?: (event: CookieChangeEvent) => void;
+    get [Symbol.toStringTag](): 'CookieStore';
+    constructor(cookieString: string);
+    get(init?: CookieStoreGetOptions['name'] | CookieStoreGetOptions): Promise<Cookie | undefined>;
+    set(init: CookieListItem | string, possibleValue?: string): Promise<void>;
+    getAll(init?: CookieStoreGetOptions['name'] | CookieStoreGetOptions): Promise<Cookie[]>;
+    delete(init: CookieStoreDeleteOptions['name'] | CookieStoreDeleteOptions): Promise<void>;
+}

package/index.d.ts

@@ -0,0 +1 @@
+export * from './useCookies';

package/index.js

@@ -0,0 +1,218 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const events = require('@whatwg-node/events');
+
+class CookieChangeEvent extends events.Event {
+    constructor(type, eventInitDict = { changed: [], deleted: [] }) {
+        super(type, eventInitDict);
+        this.changed = eventInitDict.changed || [];
+        this.deleted = eventInitDict.deleted || [];
+    }
+}
+
+const decode = decodeURIComponent;
+const pairSplitRegExp = /; */;
+// Try decoding a string using a decoding function.
+function tryDecode(str, decode) {
+    try {
+        return typeof decode === 'boolean' ? decodeURIComponent(str) : decode(str);
+    }
+    catch (e) {
+        return str;
+    }
+}
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ */
+function parse(str, options = {}) {
+    if (typeof str !== 'string') {
+        throw new TypeError('argument str must be a string');
+    }
+    const obj = [];
+    const opt = options || {};
+    const pairs = str.split(pairSplitRegExp);
+    const dec = opt.decode || decode;
+    for (let i = 0; i < pairs.length; i++) {
+        const pair = pairs[i];
+        let eqIdx = pair.indexOf('=');
+        // skip things that don't look like key=value
+        if (eqIdx < 0) {
+            continue;
+        }
+        const key = pair.substr(0, eqIdx).trim();
+        let val = pair.substr(++eqIdx, pair.length).trim();
+        // quoted values
+        if (val[0] === '"') {
+            val = val.slice(1, -1);
+        }
+        // only assign once
+        if (obj[key] == null) {
+            obj.push({
+                name: key,
+                value: tryDecode(val, dec),
+            });
+        }
+    }
+    return obj;
+}
+
+class CookieStore extends EventTarget {
+    get [Symbol.toStringTag]() {
+        return 'CookieStore';
+    }
+    constructor(cookieString) {
+        super();
+        this.cookieString = cookieString;
+    }
+    async get(init) {
+        if (init == null) {
+            throw new TypeError('CookieStoreGetOptions must not be empty');
+        }
+        else if (init instanceof Object && !Object.keys(init).length) {
+            throw new TypeError('CookieStoreGetOptions must not be empty');
+        }
+        return (await this.getAll(init))[0];
+    }
+    async set(init, possibleValue) {
+        var _a, _b, _c;
+        const item = {
+            name: '',
+            value: '',
+            path: '/',
+            secure: false,
+            sameSite: 'strict',
+            expires: null,
+            domain: null,
+        };
+        if (typeof init === 'string') {
+            item.name = init;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            item.value = possibleValue;
+        }
+        else {
+            Object.assign(item, init);
+            if (item.path && !item.path.startsWith('/')) {
+                throw new TypeError('Cookie path must start with "/"');
+            }
+            if ((_a = item.domain) === null || _a === void 0 ? void 0 : _a.startsWith('.')) {
+                throw new TypeError('Cookie domain cannot start with "."');
+            }
+            if (((_b = item.name) === null || _b === void 0 ? void 0 : _b.startsWith('__Host')) && item.domain) {
+                throw new TypeError('Cookie domain must not be specified for host cookies');
+            }
+            if (((_c = item.name) === null || _c === void 0 ? void 0 : _c.startsWith('__Host')) && item.path !== '/') {
+                throw new TypeError('Cookie path must not be specified for host cookies');
+            }
+            if (item.path && item.path.endsWith('/')) {
+                item.path = item.path.slice(0, -1);
+            }
+            if (item.path === '') {
+                item.path = '/';
+            }
+        }
+        if (item.name === '' && item.value && item.value.includes('=')) {
+            throw new TypeError("Cookie value cannot contain '=' if the name is empty");
+        }
+        if (item.name && item.name.startsWith('__Host')) {
+            item.secure = true;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        let cookieString = `${item.name}=${encodeURIComponent(item.value)}`;
+        if (item.domain) {
+            cookieString += '; Domain=' + item.domain;
+        }
+        if (item.path) {
+            cookieString += '; Path=' + item.path;
+        }
+        if (typeof item.expires === 'number') {
+            cookieString += '; Expires=' + new Date(item.expires).toUTCString();
+        }
+        else if (item.expires instanceof Date) {
+            cookieString += '; Expires=' + item.expires.toUTCString();
+        }
+        if ((item.name && item.name.startsWith('__Secure')) || item.secure) {
+            item.sameSite = 'lax';
+            cookieString += '; Secure';
+        }
+        switch (item.sameSite) {
+            case 'lax':
+                cookieString += '; SameSite=Lax';
+                break;
+            case 'strict':
+                cookieString += '; SameSite=Strict';
+                break;
+            case 'none':
+                cookieString += '; SameSite=None';
+                break;
+        }
+        const previousCookie = await this.get(item);
+        this.cookieString = cookieString;
+        if (this.onchange) {
+            const changed = [];
+            const deleted = [];
+            if (previousCookie && !(await this.get(item))) {
+                deleted.push({ ...item, value: undefined });
+            }
+            else {
+                changed.push(item);
+            }
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            const event = new CookieChangeEvent('change', { changed, deleted });
+            this.onchange(event);
+        }
+    }
+    async getAll(init) {
+        const cookies = parse(this.cookieString);
+        if (init == null || Object.keys(init).length === 0) {
+            return cookies;
+        }
+        let name;
+        if (typeof init === 'string') {
+            name = init;
+        }
+        else {
+            name = init.name;
+        }
+        return cookies.filter(cookie => cookie.name === name);
+    }
+    async delete(init) {
+        const item = {
+            name: '',
+            value: '',
+            path: '/',
+            secure: false,
+            sameSite: 'strict',
+            expires: null,
+            domain: null,
+        };
+        if (typeof init === 'string') {
+            item.name = init;
+        }
+        else {
+            Object.assign(item, init);
+        }
+        item.expires = 0;
+        await this.set(item);
+    }
+}
+
+function useCookies() {
+    return {
+        onRequest({ request }) {
+            request.cookieStore = new CookieStore(request.headers.get('cookie') || '');
+        },
+        onResponse({ request, response }) {
+            if (request.cookieStore) {
+                response.headers.set('set-cookie', request.cookieStore.cookieString);
+            }
+        },
+    };
+}
+
+exports.useCookies = useCookies;

package/index.mjs

@@ -0,0 +1,214 @@
+import { Event } from '@whatwg-node/events';
+
+class CookieChangeEvent extends Event {
+    constructor(type, eventInitDict = { changed: [], deleted: [] }) {
+        super(type, eventInitDict);
+        this.changed = eventInitDict.changed || [];
+        this.deleted = eventInitDict.deleted || [];
+    }
+}
+
+const decode = decodeURIComponent;
+const pairSplitRegExp = /; */;
+// Try decoding a string using a decoding function.
+function tryDecode(str, decode) {
+    try {
+        return typeof decode === 'boolean' ? decodeURIComponent(str) : decode(str);
+    }
+    catch (e) {
+        return str;
+    }
+}
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ */
+function parse(str, options = {}) {
+    if (typeof str !== 'string') {
+        throw new TypeError('argument str must be a string');
+    }
+    const obj = [];
+    const opt = options || {};
+    const pairs = str.split(pairSplitRegExp);
+    const dec = opt.decode || decode;
+    for (let i = 0; i < pairs.length; i++) {
+        const pair = pairs[i];
+        let eqIdx = pair.indexOf('=');
+        // skip things that don't look like key=value
+        if (eqIdx < 0) {
+            continue;
+        }
+        const key = pair.substr(0, eqIdx).trim();
+        let val = pair.substr(++eqIdx, pair.length).trim();
+        // quoted values
+        if (val[0] === '"') {
+            val = val.slice(1, -1);
+        }
+        // only assign once
+        if (obj[key] == null) {
+            obj.push({
+                name: key,
+                value: tryDecode(val, dec),
+            });
+        }
+    }
+    return obj;
+}
+
+class CookieStore extends EventTarget {
+    get [Symbol.toStringTag]() {
+        return 'CookieStore';
+    }
+    constructor(cookieString) {
+        super();
+        this.cookieString = cookieString;
+    }
+    async get(init) {
+        if (init == null) {
+            throw new TypeError('CookieStoreGetOptions must not be empty');
+        }
+        else if (init instanceof Object && !Object.keys(init).length) {
+            throw new TypeError('CookieStoreGetOptions must not be empty');
+        }
+        return (await this.getAll(init))[0];
+    }
+    async set(init, possibleValue) {
+        var _a, _b, _c;
+        const item = {
+            name: '',
+            value: '',
+            path: '/',
+            secure: false,
+            sameSite: 'strict',
+            expires: null,
+            domain: null,
+        };
+        if (typeof init === 'string') {
+            item.name = init;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            item.value = possibleValue;
+        }
+        else {
+            Object.assign(item, init);
+            if (item.path && !item.path.startsWith('/')) {
+                throw new TypeError('Cookie path must start with "/"');
+            }
+            if ((_a = item.domain) === null || _a === void 0 ? void 0 : _a.startsWith('.')) {
+                throw new TypeError('Cookie domain cannot start with "."');
+            }
+            if (((_b = item.name) === null || _b === void 0 ? void 0 : _b.startsWith('__Host')) && item.domain) {
+                throw new TypeError('Cookie domain must not be specified for host cookies');
+            }
+            if (((_c = item.name) === null || _c === void 0 ? void 0 : _c.startsWith('__Host')) && item.path !== '/') {
+                throw new TypeError('Cookie path must not be specified for host cookies');
+            }
+            if (item.path && item.path.endsWith('/')) {
+                item.path = item.path.slice(0, -1);
+            }
+            if (item.path === '') {
+                item.path = '/';
+            }
+        }
+        if (item.name === '' && item.value && item.value.includes('=')) {
+            throw new TypeError("Cookie value cannot contain '=' if the name is empty");
+        }
+        if (item.name && item.name.startsWith('__Host')) {
+            item.secure = true;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        let cookieString = `${item.name}=${encodeURIComponent(item.value)}`;
+        if (item.domain) {
+            cookieString += '; Domain=' + item.domain;
+        }
+        if (item.path) {
+            cookieString += '; Path=' + item.path;
+        }
+        if (typeof item.expires === 'number') {
+            cookieString += '; Expires=' + new Date(item.expires).toUTCString();
+        }
+        else if (item.expires instanceof Date) {
+            cookieString += '; Expires=' + item.expires.toUTCString();
+        }
+        if ((item.name && item.name.startsWith('__Secure')) || item.secure) {
+            item.sameSite = 'lax';
+            cookieString += '; Secure';
+        }
+        switch (item.sameSite) {
+            case 'lax':
+                cookieString += '; SameSite=Lax';
+                break;
+            case 'strict':
+                cookieString += '; SameSite=Strict';
+                break;
+            case 'none':
+                cookieString += '; SameSite=None';
+                break;
+        }
+        const previousCookie = await this.get(item);
+        this.cookieString = cookieString;
+        if (this.onchange) {
+            const changed = [];
+            const deleted = [];
+            if (previousCookie && !(await this.get(item))) {
+                deleted.push({ ...item, value: undefined });
+            }
+            else {
+                changed.push(item);
+            }
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            const event = new CookieChangeEvent('change', { changed, deleted });
+            this.onchange(event);
+        }
+    }
+    async getAll(init) {
+        const cookies = parse(this.cookieString);
+        if (init == null || Object.keys(init).length === 0) {
+            return cookies;
+        }
+        let name;
+        if (typeof init === 'string') {
+            name = init;
+        }
+        else {
+            name = init.name;
+        }
+        return cookies.filter(cookie => cookie.name === name);
+    }
+    async delete(init) {
+        const item = {
+            name: '',
+            value: '',
+            path: '/',
+            secure: false,
+            sameSite: 'strict',
+            expires: null,
+            domain: null,
+        };
+        if (typeof init === 'string') {
+            item.name = init;
+        }
+        else {
+            Object.assign(item, init);
+        }
+        item.expires = 0;
+        await this.set(item);
+    }
+}
+
+function useCookies() {
+    return {
+        onRequest({ request }) {
+            request.cookieStore = new CookieStore(request.headers.get('cookie') || '');
+        },
+        onResponse({ request, response }) {
+            if (request.cookieStore) {
+                response.headers.set('set-cookie', request.cookieStore.cookieString);
+            }
+        },
+    };
+}
+
+export { useCookies };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@whatwg-node/server-plugin-cookies",
+  "version": "0.0.0",
+  "description": "Cookies Plugin",
+  "sideEffects": false,
+  "peerDependencies": {
+    "@whatwg-node/server": "^0.7.1"
+  },
+  "dependencies": {
+    "@whatwg-node/events": "^0.0.2",
+    "tslib": "^2.3.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ardatan/whatwg-node",
+    "directory": "packages/server-plugin-cookies"
+  },
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "typescript": {
+    "definition": "index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./*": {
+      "require": "./*.js",
+      "import": "./*.mjs"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/parse.d.ts

@@ -0,0 +1,11 @@
+import { Cookie } from './types';
+export interface ParseOptions {
+    decode?: boolean;
+}
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ */
+export declare function parse(str: string, options?: ParseOptions): Cookie[];

package/types.d.ts

@@ -0,0 +1,33 @@
+export interface Cookie {
+    domain?: string;
+    expires?: number;
+    name: string;
+    path?: string;
+    secure?: boolean;
+    sameSite?: CookieSameSite;
+    value: string;
+}
+export interface CookieStoreDeleteOptions {
+    name: string;
+    domain?: string;
+    path?: string;
+}
+export interface CookieStoreGetOptions {
+    name?: string;
+    url?: string;
+}
+export type CookieSameSite = 'strict' | 'lax' | 'none';
+export interface CookieListItem {
+    name?: string;
+    value?: string;
+    domain: string | null;
+    path?: string;
+    expires: Date | number | null;
+    secure?: boolean;
+    sameSite?: CookieSameSite;
+}
+export type CookieList = CookieListItem[];
+export interface CookieChangeEventInit extends EventInit {
+    changed: CookieList;
+    deleted: CookieList;
+}

package/useCookies.d.ts

@@ -0,0 +1,8 @@
+import { ServerAdapterPlugin } from '@whatwg-node/server';
+import { CookieStore } from './CookieStore';
+declare global {
+    interface Request {
+        cookieStore?: CookieStore;
+    }
+}
+export declare function useCookies<TServerContext>(): ServerAdapterPlugin<TServerContext>;