@scayle/h3-session 0.4.1 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @scayle/h3-session
 
+## 0.4.2
+
+### Patch Changes
+
+- Build the package with `unbuild`
+
 ## 0.4.1
 
 ### Patch Changes

package/dist/index.d.mts

@@ -0,0 +1,138 @@
+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<RawSession | 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<RawSession[]>;
+    /**
+     * 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 & {
+    cookie?: SessionCookieOptions;
+};
+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>;
+/**
+ * Attach a session to an H3Event
+ * @param event
+ * @param config
+ */
+declare function useSession(event: H3Event, config: H3SessionOptions): Promise<void>;
+
+export { type RawSession, Session, type SessionCookie, type SessionCookieOptions, type SessionDataT, type SessionMethods, type SessionStore, UnstorageSessionStore, unsignCookie, useSession };

package/dist/index.d.ts

@@ -0,0 +1,138 @@
+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<RawSession | 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<RawSession[]>;
+    /**
+     * 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 & {
+    cookie?: SessionCookieOptions;
+};
+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>;
+/**
+ * Attach a session to an H3Event
+ * @param event
+ * @param config
+ */
+declare function useSession(event: H3Event, config: H3SessionOptions): Promise<void>;
+
+export { type RawSession, Session, type SessionCookie, type SessionCookieOptions, type SessionDataT, type SessionMethods, type SessionStore, UnstorageSessionStore, unsignCookie, useSession };

package/dist/index.mjs

@@ -0,0 +1,276 @@
+import { Buffer } from 'node:buffer';
+import { getCookie, setCookie } from 'h3';
+import { defu } from 'defu';
+import { subtle, randomUUID } from 'uncrypto';
+import { z } from 'zod';
+
+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() {
+    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()]);
+  }
+}
+
+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()
+});
+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 (item && item.cookie) {
+      try {
+        item.cookie = CookieSchema.parse(item.cookie);
+      } catch {
+        delete item.cookie;
+      }
+    }
+    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;
+  }
+}
+
+async function unsignCookie(value, secrets) {
+  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;
+}
+async function signCookie(value, secret) {
+  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, unsignCookie, useSession };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/h3-session",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Persistent sessions for h3",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -9,15 +9,16 @@
     "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",
@@ -33,14 +34,16 @@
     "zod": "^3.23.8"
   },
   "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"
   },
   "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