@scayle/h3-session 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @scayle/h3-session
 
+## 0.5.0
+
+### Minor Changes
+
+- Cookie metadata is no longer saved in the session store. Previously, `h3-session` stored a copy of the cookie settings in the session store alongside the session data. This has been changed and now only the session data itself is stored. The cookie settings can still be read and manipulated from the `Session` object.
+
+### Patch Changes
+
+- Removed dependency `zod@^3.23.8`
+- Replace regex used for cookie parsing
+
+## 0.4.2
+
+### Patch Changes
+
+- Build the package with `unbuild`
+
 ## 0.4.1
 
 ### Patch Changes

package/dist/index.d.mts

@@ -0,0 +1,143 @@
+import { setCookie, H3Event } from 'h3';
+import { Storage } from 'unstorage';
+
+interface SessionMethods {
+    save: () => Promise<void>;
+    reload: () => Promise<void>;
+    destroy: () => Promise<void>;
+    regenerate: () => Promise<void>;
+}
+declare class Session implements SessionMethods {
+    #private;
+    data: SessionDataT;
+    cookie: SessionCookie;
+    constructor(id: string, data: SessionDataT, store: SessionStore, generate: () => Promise<{
+        id: string;
+        data: SessionDataT;
+    }>, cookie: SessionCookie);
+    get id(): string;
+    save(): Promise<void>;
+    reload(): Promise<void>;
+    destroy(): Promise<void>;
+    regenerate(): Promise<void>;
+}
+
+type TTL = number | ((data: RawSession) => number);
+interface UnstorageSessionStoreOptions {
+    prefix: string;
+    ttl: TTL;
+}
+declare class UnstorageSessionStore implements SessionStore {
+    storage: Storage<RawSession>;
+    prefix: string;
+    ttl: TTL;
+    constructor(storage: Storage, options?: Partial<UnstorageSessionStoreOptions>);
+    /**
+     * Destroy the session with the specified session ID
+     * @param sid the un-prefixed session ID
+     */
+    destroy(sid: string): Promise<void>;
+    /**
+     * Get the session with the specified session ID
+     * @param sid the un-prefixed session ID
+     */
+    get(sid: string): Promise<SessionDataT | undefined>;
+    /**
+     * Save the session with the specified session ID
+     * If the session has expired (has a TTL <= 0) it is deleted.
+     * @param sid the un-prefixed session ID
+     * @param data the session data
+     */
+    set(sid: string, data: RawSession): Promise<void>;
+    /**
+     * Update a session's TTL
+     * @param sid the un-prefixed session ID
+     * @param data the session data
+     */
+    touch(sid: string, data: RawSession): Promise<void>;
+    /**
+     * Remove all saved sessions
+     */
+    clear(): Promise<void>;
+    /**
+     * Fetch all saved sessions.
+     */
+    all(): Promise<SessionDataT[]>;
+    /**
+     * Returns the number of saved sessions
+     */
+    length(): Promise<number>;
+    private getAllKeys;
+    private getKey;
+    /**
+     * Get the TTL for the session, either from the TTL function if it exists
+     * or falling back to the default TTL value.
+     * @param session
+     * @private
+     */
+    private getTTL;
+}
+
+type SessionCookieOptions = Parameters<typeof setCookie>[3];
+type SessionCookie = SessionCookieOptions & {
+    setSessionId: (sid: string) => Promise<void>;
+};
+interface SessionDataT {
+}
+type RawSession = SessionDataT;
+interface SessionStore {
+    all?: () => Promise<RawSession[]>;
+    destroy: (sid: string) => Promise<void>;
+    clear?: () => Promise<void>;
+    length?: () => Promise<number>;
+    get: (sid: string) => Promise<RawSession | undefined>;
+    set: (sid: string, data: RawSession) => Promise<void>;
+    touch: (sid: string, data: SessionDataT) => Promise<void>;
+}
+interface H3SessionOptions {
+    store: SessionStore;
+    cookie?: {
+        domain?: string;
+        expires?: Date;
+        httpOnly?: boolean;
+        maxAge?: number;
+        path?: string;
+        sameSite?: true | false | 'lax' | 'none' | 'strict';
+        secure?: boolean;
+    };
+    name?: string;
+    genid?: (event: H3Event) => string;
+    generate?: () => SessionDataT;
+    saveUninitialized?: boolean;
+    secret: string | string[];
+}
+declare module 'h3' {
+    interface H3EventContext {
+        session: Session;
+        sessionId: string;
+        sessionStore: SessionStore;
+    }
+}
+/**
+ * Verify that a cookie was signed with one of the secrets
+ * If it's valid, return the embedded message
+ *
+ * @param value a cookie value in the format `s:[value].[signature]`
+ * @param secrets an array of secret strings to verify with
+ */
+declare function unsignCookie(value: string, secrets: string[]): Promise<string | false>;
+/**
+ * Creates a signed cookie value in the format `s:[value].[signature]`
+ * @param value
+ * @param secret
+ */
+declare function signCookie(value: string, secret: string): Promise<string>;
+declare function validateConfig(config: H3SessionOptions): void;
+/**
+ * Attach a session to an H3Event
+ * @param event
+ * @param config
+ */
+declare function useSession(event: H3Event, config: H3SessionOptions): Promise<void>;
+
+export { type H3SessionOptions, type RawSession, Session, type SessionCookie, type SessionCookieOptions, type SessionDataT, type SessionMethods, type SessionStore, UnstorageSessionStore, signCookie, unsignCookie, useSession, validateConfig };

package/dist/index.d.ts

@@ -0,0 +1,143 @@
+import { setCookie, H3Event } from 'h3';
+import { Storage } from 'unstorage';
+
+interface SessionMethods {
+    save: () => Promise<void>;
+    reload: () => Promise<void>;
+    destroy: () => Promise<void>;
+    regenerate: () => Promise<void>;
+}
+declare class Session implements SessionMethods {
+    #private;
+    data: SessionDataT;
+    cookie: SessionCookie;
+    constructor(id: string, data: SessionDataT, store: SessionStore, generate: () => Promise<{
+        id: string;
+        data: SessionDataT;
+    }>, cookie: SessionCookie);
+    get id(): string;
+    save(): Promise<void>;
+    reload(): Promise<void>;
+    destroy(): Promise<void>;
+    regenerate(): Promise<void>;
+}
+
+type TTL = number | ((data: RawSession) => number);
+interface UnstorageSessionStoreOptions {
+    prefix: string;
+    ttl: TTL;
+}
+declare class UnstorageSessionStore implements SessionStore {
+    storage: Storage<RawSession>;
+    prefix: string;
+    ttl: TTL;
+    constructor(storage: Storage, options?: Partial<UnstorageSessionStoreOptions>);
+    /**
+     * Destroy the session with the specified session ID
+     * @param sid the un-prefixed session ID
+     */
+    destroy(sid: string): Promise<void>;
+    /**
+     * Get the session with the specified session ID
+     * @param sid the un-prefixed session ID
+     */
+    get(sid: string): Promise<SessionDataT | undefined>;
+    /**
+     * Save the session with the specified session ID
+     * If the session has expired (has a TTL <= 0) it is deleted.
+     * @param sid the un-prefixed session ID
+     * @param data the session data
+     */
+    set(sid: string, data: RawSession): Promise<void>;
+    /**
+     * Update a session's TTL
+     * @param sid the un-prefixed session ID
+     * @param data the session data
+     */
+    touch(sid: string, data: RawSession): Promise<void>;
+    /**
+     * Remove all saved sessions
+     */
+    clear(): Promise<void>;
+    /**
+     * Fetch all saved sessions.
+     */
+    all(): Promise<SessionDataT[]>;
+    /**
+     * Returns the number of saved sessions
+     */
+    length(): Promise<number>;
+    private getAllKeys;
+    private getKey;
+    /**
+     * Get the TTL for the session, either from the TTL function if it exists
+     * or falling back to the default TTL value.
+     * @param session
+     * @private
+     */
+    private getTTL;
+}
+
+type SessionCookieOptions = Parameters<typeof setCookie>[3];
+type SessionCookie = SessionCookieOptions & {
+    setSessionId: (sid: string) => Promise<void>;
+};
+interface SessionDataT {
+}
+type RawSession = SessionDataT;
+interface SessionStore {
+    all?: () => Promise<RawSession[]>;
+    destroy: (sid: string) => Promise<void>;
+    clear?: () => Promise<void>;
+    length?: () => Promise<number>;
+    get: (sid: string) => Promise<RawSession | undefined>;
+    set: (sid: string, data: RawSession) => Promise<void>;
+    touch: (sid: string, data: SessionDataT) => Promise<void>;
+}
+interface H3SessionOptions {
+    store: SessionStore;
+    cookie?: {
+        domain?: string;
+        expires?: Date;
+        httpOnly?: boolean;
+        maxAge?: number;
+        path?: string;
+        sameSite?: true | false | 'lax' | 'none' | 'strict';
+        secure?: boolean;
+    };
+    name?: string;
+    genid?: (event: H3Event) => string;
+    generate?: () => SessionDataT;
+    saveUninitialized?: boolean;
+    secret: string | string[];
+}
+declare module 'h3' {
+    interface H3EventContext {
+        session: Session;
+        sessionId: string;
+        sessionStore: SessionStore;
+    }
+}
+/**
+ * Verify that a cookie was signed with one of the secrets
+ * If it's valid, return the embedded message
+ *
+ * @param value a cookie value in the format `s:[value].[signature]`
+ * @param secrets an array of secret strings to verify with
+ */
+declare function unsignCookie(value: string, secrets: string[]): Promise<string | false>;
+/**
+ * Creates a signed cookie value in the format `s:[value].[signature]`
+ * @param value
+ * @param secret
+ */
+declare function signCookie(value: string, secret: string): Promise<string>;
+declare function validateConfig(config: H3SessionOptions): void;
+/**
+ * Attach a session to an H3Event
+ * @param event
+ * @param config
+ */
+declare function useSession(event: H3Event, config: H3SessionOptions): Promise<void>;
+
+export { type H3SessionOptions, type RawSession, Session, type SessionCookie, type SessionCookieOptions, type SessionDataT, type SessionMethods, type SessionStore, UnstorageSessionStore, signCookie, unsignCookie, useSession, validateConfig };

package/dist/index.mjs

@@ -0,0 +1,279 @@
+import { Buffer } from 'node:buffer';
+import { getCookie, setCookie } from 'h3';
+import { defu } from 'defu';
+import { subtle, randomUUID } from 'uncrypto';
+
+class Session {
+  #id;
+  #store;
+  data;
+  #generate;
+  cookie;
+  constructor(id, data, store, generate, cookie) {
+    this.data = data;
+    this.#id = id;
+    this.#store = store;
+    this.#generate = generate;
+    this.cookie = cookie;
+  }
+  get id() {
+    return this.#id;
+  }
+  async save() {
+    await this.#store.set(this.#id, this.data);
+  }
+  async reload() {
+    this.data = await this.#store.get(this.#id) ?? (await this.#generate()).data;
+  }
+  async destroy() {
+    this.cookie.maxAge = 0;
+    await this.#store.destroy(this.#id);
+  }
+  async regenerate() {
+    await this.#store.destroy(this.#id);
+    const { data, id } = await this.#generate();
+    this.data = data;
+    this.#id = id;
+    await Promise.all([this.cookie.setSessionId(id), this.save()]);
+  }
+}
+
+class UnstorageSessionStore {
+  storage;
+  prefix;
+  ttl;
+  constructor(storage, options) {
+    this.storage = storage;
+    this.prefix = options?.prefix ?? "sess";
+    this.ttl = options?.ttl ?? 60 * 60 * 24;
+  }
+  /**
+   * Destroy the session with the specified session ID
+   * @param sid the un-prefixed session ID
+   */
+  async destroy(sid) {
+    await this.storage.removeItem(this.getKey(sid));
+  }
+  /**
+   * Get the session with the specified session ID
+   * @param sid the un-prefixed session ID
+   */
+  async get(sid) {
+    const item = await this.storage.getItem(this.getKey(sid));
+    return item ?? void 0;
+  }
+  /**
+   * Save the session with the specified session ID
+   * If the session has expired (has a TTL <= 0) it is deleted.
+   * @param sid the un-prefixed session ID
+   * @param data the session data
+   */
+  async set(sid, data) {
+    const ttl = this.getTTL(data);
+    if (ttl > 0) {
+      await this.storage.setItem(this.getKey(sid), data, { ttl });
+    } else {
+      await this.destroy(sid);
+    }
+  }
+  /**
+   * Update a session's TTL
+   * @param sid the un-prefixed session ID
+   * @param data the session data
+   */
+  async touch(sid, data) {
+    await this.set(sid, data);
+  }
+  /**
+   * Remove all saved sessions
+   */
+  async clear() {
+    return await this.storage.clear(this.prefix);
+  }
+  /**
+   * Fetch all saved sessions.
+   */
+  async all() {
+    const keys = await this.getAllKeys();
+    const values = await this.storage.getItems(keys);
+    return values.map(({ value }) => {
+      return value;
+    });
+  }
+  /**
+   * Returns the number of saved sessions
+   */
+  async length() {
+    const keys = await this.getAllKeys();
+    return keys.length;
+  }
+  async getAllKeys() {
+    return await this.storage.getKeys(this.prefix);
+  }
+  getKey(key) {
+    return [this.prefix, key].join(":");
+  }
+  /**
+   * Get the TTL for the session, either from the TTL function if it exists
+   * or falling back to the default TTL value.
+   * @param session
+   * @private
+   */
+  getTTL(session) {
+    if (typeof this.ttl === "function") {
+      return this.ttl(session);
+    }
+    return this.ttl;
+  }
+}
+
+const signatureLength = 43;
+function parseCookieValue(value) {
+  if (value.length < signatureLength + 3) {
+    return void 0;
+  }
+  const separatorIndex = value.length - signatureLength - 1;
+  if (value.charAt(0) !== "s" || value.charAt(1) !== ":" || value.charAt(separatorIndex) !== ".") {
+    return void 0;
+  }
+  return [
+    value.substring(2, separatorIndex),
+    value.substring(separatorIndex + 1)
+  ];
+}
+async function unsignCookie(value, secrets) {
+  const matches = parseCookieValue(value);
+  if (!matches) {
+    return false;
+  }
+  const [message, signature] = matches;
+  const encoder = new TextEncoder();
+  const messageUint8Array = encoder.encode(message);
+  const signatureUint8Array = Uint8Array.from(Buffer.from(signature, "base64"));
+  for (let i = 0; i < secrets.length; i++) {
+    const keyUint8Array = encoder.encode(secrets[i]);
+    const cryptoKey = await subtle.importKey(
+      "raw",
+      keyUint8Array,
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["verify"]
+    );
+    const result = await subtle.verify(
+      "HMAC",
+      cryptoKey,
+      signatureUint8Array,
+      messageUint8Array
+    );
+    if (result) {
+      return message;
+    }
+  }
+  return false;
+}
+async function signCookie(value, secret) {
+  if (!value) {
+    throw new Error("[h3-session] No value was provided!");
+  }
+  if (!secret) {
+    throw new Error("[h3-session] No secret was provided!");
+  }
+  const encoder = new TextEncoder();
+  const messageUint8Array = encoder.encode(value);
+  const keyUint8Array = encoder.encode(secret);
+  const cryptoKey = await subtle.importKey(
+    "raw",
+    keyUint8Array,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await subtle.sign("HMAC", cryptoKey, messageUint8Array);
+  const b64Signature = Buffer.from(signature).toString("base64").replace(/=+$/, "");
+  return `s:${value}.${b64Signature}`;
+}
+function validateConfig(config) {
+  if (!config.store) {
+    throw new Error("[h3-session] Session store is required!");
+  }
+  if (!config.secret) {
+    throw new Error("[h3-session] Session secret is required!");
+  }
+}
+async function useSession(event, config) {
+  if (event.context.session) {
+    return;
+  }
+  validateConfig(config);
+  const sessionConfig = defu(config, {
+    name: "connect.sid",
+    genid: (_event) => {
+      return randomUUID();
+    },
+    generate: () => ({}),
+    cookie: { path: "/", httpOnly: true, secure: true, maxAge: null },
+    saveUninitialized: false
+  });
+  const { store } = sessionConfig;
+  const generate = async () => {
+    return await Promise.resolve({
+      id: sessionConfig.genid(event),
+      data: sessionConfig.generate()
+    });
+  };
+  const normalizedSecrets = Array.isArray(sessionConfig.secret) ? sessionConfig.secret : [sessionConfig.secret];
+  const createSessionCookie = async (sid) => {
+    let signedCookie;
+    const cookie = {
+      ...sessionConfig.cookie,
+      // Default to a max age of one day
+      maxAge: sessionConfig.cookie.maxAge || 60 * 60 * 24,
+      setSessionId: async (sid2) => {
+        signedCookie = await signCookie(
+          sid2,
+          normalizedSecrets[normalizedSecrets.length - 1]
+        );
+        setCookie(event, sessionConfig.name, signedCookie, cookie);
+      }
+    };
+    await cookie.setSessionId(sid);
+    return new Proxy(cookie, {
+      set(target, property, value) {
+        target[property] = value;
+        setCookie(event, sessionConfig.name, signedCookie, cookie);
+        return true;
+      }
+    });
+  };
+  const rawCookie = getCookie(event, sessionConfig.name);
+  const sessionId = rawCookie ? await unsignCookie(rawCookie, normalizedSecrets) : null;
+  let sessionData;
+  if (sessionId) {
+    sessionData = await store.get(sessionId);
+  }
+  async function createNewSession() {
+    const { id, data } = await generate();
+    const cookie = await createSessionCookie(id);
+    event.context.session = new Session(id, data, store, generate, cookie);
+    if (sessionConfig.saveUninitialized) {
+      await event.context.session.save();
+    }
+    event.context.sessionId = id;
+  }
+  async function createExistingSession(id, data) {
+    const cookie = await createSessionCookie(id);
+    if (store.touch) {
+      await store.touch(id, data);
+    }
+    event.context.session = new Session(id, data, store, generate, cookie);
+    event.context.sessionId = id;
+  }
+  if (!sessionId || !sessionData) {
+    await createNewSession();
+  } else {
+    await createExistingSession(sessionId, sessionData);
+  }
+  event.context.sessionStore = store;
+}
+
+export { Session, UnstorageSessionStore, signCookie, unsignCookie, useSession, validateConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/h3-session",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Persistent sessions for h3",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -9,19 +9,24 @@
     "registry": "https://registry.npmjs.org/"
   },
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.mjs"
   },
-  "main": "./dist/index.js",
+  "main": "./dist/index.mjs",
   "files": [
     "CHANGELOG.md",
-    "./dist/*.js"
+    "dist/**"
   ],
   "scripts": {
-    "build": "yarn tsc -p tsconfig.json",
+    "build": "unbuild",
+    "verify-packaging": "attw --pack . --profile esm-only",
     "format": "dprint check",
     "format:fix": "dprint fmt",
     "lint": "eslint . --format gitlab",
-    "lint:fix": "eslint . --fix"
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:ci": "vitest --run --coverage --reporter=default --reporter=junit --outputFile=./junit.xml",
+    "test:watch": "vitest watch",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "peerDependencies": {
     "h3": "^1.10.0"
@@ -29,18 +34,20 @@
   "dependencies": {
     "defu": "^6.1.4",
     "uncrypto": "^0.1.3",
-    "unstorage": "^1.10.2",
-    "zod": "^3.23.8"
+    "unstorage": "^1.10.2"
   },
   "devDependencies": {
-    "@scayle/eslint-config-storefront": "4.3.1",
-    "dprint": "0.47.2",
-    "eslint": "9.12.0",
+    "@arethetypeswrong/cli": "0.17.1",
+    "@scayle/eslint-config-storefront": "4.4.0",
+    "dprint": "0.47.6",
+    "eslint": "9.17.0",
     "eslint-formatter-gitlab": "5.1.0",
     "h3": "1.13.0",
-    "typescript": "5.6.3"
+    "typescript": "5.6.3",
+    "unbuild": "3.0.1",
+    "vitest": "2.1.8"
   },
   "volta": {
-    "node": "20.18.0"
+    "node": "22.12.0"
   }
 }

package/dist/index.js

@@ -1,159 +0,0 @@
-// A session implementation for h3 based on express-session
-import { Buffer } from 'node:buffer';
-import { getCookie, setCookie } from 'h3';
-import { defu } from 'defu';
-import { randomUUID, subtle } from 'uncrypto';
-import { Session } from './session';
-/**
- * Verify that a cookie was signed with one of the secrets
- * If it's valid, return the embedded message
- *
- * @param value a cookie value in the format `s:[value].[signature]`
- * @param secrets an array of secret strings to verify with
- */
-export async function unsignCookie(value, secrets) {
-    // Validate cookie format
-    const matches = /s:([^.]*)\.(.*)/.exec(value);
-    if (!matches) {
-        return false;
-    }
-    const [, message, signature] = matches;
-    const encoder = new TextEncoder();
-    const messageUint8Array = encoder.encode(message);
-    const signatureUint8Array = Uint8Array.from(Buffer.from(signature, 'base64'));
-    for (let i = 0; i < secrets.length; i++) {
-        const keyUint8Array = encoder.encode(secrets[i]);
-        const cryptoKey = await subtle.importKey('raw', keyUint8Array, { name: 'HMAC', hash: 'SHA-256' }, false, ['verify']);
-        const result = await subtle.verify('HMAC', cryptoKey, signatureUint8Array, messageUint8Array);
-        if (result) {
-            return message;
-        }
-    }
-    return false;
-}
-/**
- * Creates a signed cookie value in the format `s:[value].[signature]`
- * @param value
- * @param secret
- */
-async function signCookie(value, secret) {
-    // Convert the value and secret to Uint8Array
-    const encoder = new TextEncoder();
-    const messageUint8Array = encoder.encode(value);
-    const keyUint8Array = encoder.encode(secret);
-    // Import the secret as a CryptoKey
-    const cryptoKey = await subtle.importKey('raw', keyUint8Array, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
-    const signature = await subtle.sign('HMAC', cryptoKey, messageUint8Array);
-    // Encode in base64
-    const b64Signature = Buffer.from(signature)
-        .toString('base64')
-        .replace(/=+$/, '');
-    return `s:${value}.${b64Signature}`;
-}
-function validateConfig(config) {
-    if (!config.store) {
-        throw new Error('[h3-session] Session store is required!');
-    }
-    if (!config.secret) {
-        throw new Error('[h3-session] Session secret is required!');
-    }
-}
-/**
- * Attach a session to an H3Event
- * @param event
- * @param config
- */
-export async function useSession(event, config) {
-    // Skip if session is already attached
-    if (event.context.session) {
-        return;
-    }
-    validateConfig(config);
-    // Populate default config values
-    const sessionConfig = defu(config, {
-        name: 'connect.sid',
-        genid: (_event) => {
-            return randomUUID();
-        },
-        generate: () => ({}),
-        cookie: { path: '/', httpOnly: true, secure: true, maxAge: null },
-        saveUninitialized: false,
-    });
-    const { store } = sessionConfig;
-    const generate = async () => {
-        return await Promise.resolve({
-            id: sessionConfig.genid(event),
-            data: sessionConfig.generate(),
-        });
-    };
-    // Secret can be a string or array, normalize to an array
-    const normalizedSecrets = Array.isArray(sessionConfig.secret)
-        ? sessionConfig.secret
-        : [sessionConfig.secret];
-    const createSessionCookie = async (sid) => {
-        let signedCookie;
-        const cookie = {
-            ...sessionConfig.cookie,
-            // Default to a max age of one day
-            maxAge: sessionConfig.cookie.maxAge || 60 * 60 * 24,
-            setSessionId: async (sid) => {
-                signedCookie = await signCookie(sid, normalizedSecrets[normalizedSecrets.length - 1]);
-                setCookie(event, sessionConfig.name, signedCookie, cookie);
-            },
-        };
-        await cookie.setSessionId(sid);
-        // Update the Set-Cookie header whenever a property on the cookie object changes
-        // We can't hook into the onBeforeResponse, so this is the best alternative
-        return new Proxy(cookie, {
-            set(target, property, value) {
-                // @ts-expect-error Implicitly has type any
-                target[property] = value;
-                setCookie(event, sessionConfig.name, signedCookie, cookie);
-                return true;
-            },
-        });
-    };
-    // Check the request for a session cookie
-    const rawCookie = getCookie(event, sessionConfig.name);
-    // Extract the ID from the cookie
-    const sessionId = rawCookie
-        ? await unsignCookie(rawCookie, normalizedSecrets)
-        : null;
-    // Load the session data from the store
-    let sessionData;
-    if (sessionId) {
-        sessionData = await store.get(sessionId);
-    }
-    async function createNewSession() {
-        const { id, data } = await generate();
-        const cookie = await createSessionCookie(id);
-        event.context.session = new Session(id, data, store, generate, cookie);
-        if (sessionConfig.saveUninitialized) {
-            await event.context.session.save();
-        }
-        // Set sessionId on event context
-        event.context.sessionId = id;
-    }
-    async function createExistingSession(id, data) {
-        const cookie = await createSessionCookie(id);
-        if (store.touch) {
-            // touch existing sessions to refresh their TTLs
-            await store.touch(id, data);
-        }
-        event.context.session = new Session(id, data, store, generate, cookie);
-        // Set sessionId on event context
-        event.context.sessionId = id;
-    }
-    // Create the session data and a new ID if it does not exist
-    if (!sessionId || !sessionData) {
-        await createNewSession();
-    }
-    else {
-        await createExistingSession(sessionId, sessionData);
-    }
-    // expose session store
-    event.context.sessionStore = store;
-}
-export * from './session';
-export * from './unstorage-store';
-//# sourceMappingURL=index.js.map

package/dist/session.js

@@ -1,37 +0,0 @@
-export class Session {
-    #id;
-    #store;
-    data;
-    #generate;
-    cookie;
-    constructor(id, data, store, generate, cookie) {
-        this.data = data;
-        this.#id = id;
-        this.#store = store;
-        this.#generate = generate;
-        this.cookie = cookie;
-    }
-    get id() {
-        return this.#id;
-    }
-    async save() {
-        await this.#store.set(this.#id, { ...this.data, cookie: this.cookie });
-    }
-    async reload() {
-        this.data = (await this.#store.get(this.#id)) ??
-            (await this.#generate()).data;
-    }
-    async destroy() {
-        // Delete the cookie by setting maxAge to 0
-        this.cookie.maxAge = 0;
-        await this.#store.destroy(this.#id);
-    }
-    async regenerate() {
-        await this.#store.destroy(this.#id);
-        const { data, id } = await this.#generate();
-        this.data = data;
-        this.#id = id;
-        await Promise.all([this.cookie.setSessionId(id), this.save()]);
-    }
-}
-//# sourceMappingURL=session.js.map

package/dist/unstorage-store.js

@@ -1,111 +0,0 @@
-import { z } from 'zod';
-const CookieSchema = z.object({
-    domain: z.string().optional(),
-    expires: z.coerce.date().optional(),
-    httpOnly: z.boolean().optional(),
-    maxAge: z.number().optional(),
-    path: z.string().optional(),
-    sameSite: z.enum(['lax', 'none', 'strict']).or(z.boolean()).optional(),
-    secure: z.boolean().optional(),
-});
-export class UnstorageSessionStore {
-    storage;
-    prefix;
-    ttl;
-    constructor(storage, options) {
-        this.storage = storage;
-        this.prefix = options?.prefix ?? 'sess';
-        this.ttl = options?.ttl ?? 60 * 60 * 24;
-    }
-    /**
-     * Destroy the session with the specified session ID
-     * @param sid the un-prefixed session ID
-     */
-    async destroy(sid) {
-        await this.storage.removeItem(this.getKey(sid));
-    }
-    /**
-     * Get the session with the specified session ID
-     * @param sid the un-prefixed session ID
-     */
-    async get(sid) {
-        const item = await this.storage.getItem(this.getKey(sid));
-        // If the cookie saved in the storage is not valid, delete it
-        if (item && item.cookie) {
-            try {
-                item.cookie = CookieSchema.parse(item.cookie);
-            }
-            catch {
-                delete item.cookie;
-            }
-        }
-        return item ?? undefined;
-    }
-    /**
-     * Save the session with the specified session ID
-     * If the session has expired (has a TTL <= 0) it is deleted.
-     * @param sid the un-prefixed session ID
-     * @param data the session data
-     */
-    async set(sid, data) {
-        const ttl = this.getTTL(data);
-        if (ttl > 0) {
-            await this.storage.setItem(this.getKey(sid), data, { ttl });
-        }
-        else {
-            await this.destroy(sid);
-        }
-    }
-    /**
-     * Update a session's TTL
-     * @param sid the un-prefixed session ID
-     * @param data the session data
-     */
-    async touch(sid, data) {
-        // For now, it seems the best way to bump the TTL through the unstorage
-        // interface is by re-saving the data
-        await this.set(sid, data);
-    }
-    /**
-     * Remove all saved sessions
-     */
-    async clear() {
-        return await this.storage.clear(this.prefix);
-    }
-    /**
-     * Fetch all saved sessions.
-     */
-    async all() {
-        const keys = await this.getAllKeys();
-        const values = await this.storage.getItems(keys);
-        return values.map(({ value }) => {
-            return value;
-        });
-    }
-    /**
-     * Returns the number of saved sessions
-     */
-    async length() {
-        const keys = await this.getAllKeys();
-        return keys.length;
-    }
-    async getAllKeys() {
-        return await this.storage.getKeys(this.prefix);
-    }
-    getKey(key) {
-        return [this.prefix, key].join(':');
-    }
-    /**
-     * Get the TTL for the session, either from the TTL function if it exists
-     * or falling back to the default TTL value.
-     * @param session
-     * @private
-     */
-    getTTL(session) {
-        if (typeof this.ttl === 'function') {
-            return this.ttl(session);
-        }
-        return this.ttl;
-    }
-}
-//# sourceMappingURL=unstorage-store.js.map