@randajan/koa-io-session 1.0.0 → 2.2.0

package/dist/esm/index.mjs

@@ -1,111 +1,116 @@
-// src/attachSession.js
+// src/class/SessionBridge.js
+import { EventEmitter as EventEmitter2 } from "events";
 import { ServerResponse } from "http";
-import session from "koa-session";
-import { solid as solid2 } from "@randajan/props";
+import { solid as solid2, virtual } from "@randajan/props";
 
 // src/tools.js
 import crypto from "crypto";
 var generateUid = (len = 16) => crypto.randomBytes(len).toString("base64url").slice(0, len);
-var isObject = (value) => !!value && typeof value === "object";
-
-// src/SessionStore.js
-import { solid } from "@randajan/props";
-import { EventEmitter } from "events";
-var wrapStore = (store) => {
-  return {
-    get: store.get.bind(store),
-    set: store.set.bind(store),
-    destroy: store.destroy.bind(store),
-    touch: store.touch.bind(store)
-  };
-};
-var formatState = (session2, maxAge, prevTTL, defaultTTL) => {
-  const ttl = maxAge ?? prevTTL ?? defaultTTL;
-  const expiresAt = Date.now() + ttl;
-  return { session: session2, expiresAt, ttl };
+var is = (type, any) => typeof any === type;
+var valid = (type, any, req = false, msg = "argument") => {
+  if (any == null) {
+    if (!req) {
+      return;
+    }
+    throw new Error(`${msg} require typeof '${type}'`);
+  }
+  if (is(type, any)) {
+    return any;
+  }
+  throw new Error(`${msg} is not typeof '${type}'`);
 };
-var SessionStore = class extends Map {
-  constructor(defaultTTL = 864e5, eventEmitterOpt = {}) {
-    super();
-    solid(this, "defaultTTL", defaultTTL);
-    solid(this, "event", new EventEmitter(eventEmitterOpt));
+var validRange = (min, max, any, req = false, msg = "argument") => {
+  const num = valid("number", any, req, msg);
+  if (num == null) {
+    return;
   }
-  on(eventName, callback) {
-    return this.event.on(eventName, callback);
+  if (num < min) {
+    throw new Error(`${msg} must be greater than ${min}`);
   }
-  get(sid) {
-    const d = super.get(sid);
-    if (!d) {
-      return;
-    }
-    if (Date.now() < d.expiresAt) {
-      return d.session;
-    }
-    this.delete(sid);
+  if (num > max) {
+    throw new Error(`${msg} must be less than ${max}`);
   }
-  touch(sid, maxAge) {
-    const { defaultTTL } = this;
-    const d = super.get(sid);
-    if (!d) {
-      return false;
-    }
-    super.set(sid, formatState(d.session, maxAge, d.ttl, defaultTTL));
-    this.event.emit("touch", this, sid);
-    return true;
+  return num;
+};
+var validInterval = (any, req = false, msg = "argument") => {
+  return validRange(10, 2147483647, any, req, msg);
+};
+var validObject = (any, req = false, msg = "argument") => {
+  const obj = valid("object", any, req, msg);
+  if (obj == null) {
+    return;
   }
-  set(sid, session2, maxAge) {
-    const { defaultTTL } = this;
-    const d = super.get(sid);
-    if (session2 == null) {
-      return !d || this.destroy(sid);
-    }
-    super.set(sid, formatState(session2, maxAge, d?.ttl, defaultTTL));
-    this.event.emit("set", this, sid, !d);
-    return true;
+  if (!Array.isArray(obj)) {
+    return obj;
   }
-  delete(sid) {
-    return this.destroy(sid);
+  throw new Error(`${msg} must be object, not array`);
+};
+var validStore = (store) => {
+  const missing = [];
+  if (!is("function", store?.get)) {
+    missing.push("get()");
   }
-  destroy(sid) {
-    if (this.has(sid)) {
-      super.delete(sid);
-      this.event.emit("destroy", this, sid);
-    }
-    return true;
+  if (!is("function", store?.set)) {
+    missing.push("set()");
   }
-  cleanup() {
-    const now = Date.now();
-    let cleared = 0;
-    for (const [sid, d] of this.entries()) {
-      if (now < d.expiresAt) {
-        continue;
-      }
-      if (this.destroy(sid)) {
-        cleared++;
-      }
-    }
-    if (cleared) {
-      this.event.emit("cleanup", this, cleared);
-    }
-    return cleared;
+  if (!is("function", store?.destroy)) {
+    missing.push("destroy()");
   }
-  autoCleanup(interval) {
-    const { defaultTTL } = this;
-    if (!interval) {
-      interval = defaultTTL / 10;
-    }
-    const tid = setInterval(() => {
-      this.cleanup();
-    }, interval);
-    return (_) => clearInterval(tid);
+  if (!is("function", store?.on)) {
+    missing.push("on()");
   }
+  if (missing.length) {
+    throw new TypeError(`store is missing required API: ${missing.join(", ")}`);
+  }
+  return store;
+};
+
+// src/httpSession.js
+import session from "koa-session";
+
+// src/wrappers.js
+var wrapStore = (store) => {
+  return {
+    get: store.get.bind(store),
+    set: store.set.bind(store),
+    destroy: store.destroy.bind(store)
+  };
+};
+var wrapExternalKey = (opt, onSet) => {
+  const { externalKey: base, key, signed } = opt;
+  const get = base?.get ? (ctx) => base.get(ctx) : (ctx) => ctx.cookies.get(key, { signed });
+  const setRaw = base?.set ? (ctx, sid) => base.set(ctx, sid) : (ctx, sid) => ctx.cookies.set(key, sid, opt);
+  const set = typeof onSet != "function" ? setRaw : (ctx, sid) => {
+    setRaw(ctx, sid);
+    onSet(ctx, sid);
+  };
+  return { get, set };
+};
+
+// src/httpSession.js
+var createKoaSession = (opt, app, onSet) => {
+  const store = wrapStore(opt.store);
+  const externalKey = wrapExternalKey(opt, onSet);
+  const koaSession = session({ ...opt, store, externalKey }, app);
+  return [koaSession, externalKey];
+};
+var createClientCookie = (opt) => {
+  const { key, maxAge, signed, path, secure, sameSite, httpOnly } = opt;
+  return wrapExternalKey({
+    key,
+    signed,
+    maxAge,
+    path: path ?? "/",
+    secure,
+    sameSite,
+    httpOnly: httpOnly ?? true,
+    overwrite: true
+  });
 };
 
 // src/socketSession.js
 import { solids } from "@randajan/props";
-import { createQueue } from "@randajan/queue";
 var sidLocks = /* @__PURE__ */ new Map();
-var touchQueues = /* @__PURE__ */ new Map();
 var createSessionCtx = (sessionId, session2, socket) => solids({ session: session2 }, { sessionId, socket });
 var createSessionHash = (session2) => {
   try {
@@ -141,155 +146,311 @@ var withLock = async (task, socket, ...args) => {
     }
   }
 };
-var getTouchQueue = (sid, store) => {
-  const existing = touchQueues.get(sid);
-  if (existing) {
-    return existing;
-  }
-  const queue = createQueue(async (touchMaxAge) => {
-    try {
-      await store.touch(sid, touchMaxAge);
-    } catch {
-    }
-    if (!queue.isPending) {
-      touchQueues.delete(sid);
-    }
-  }, { pass: "last", softMs: 1e3, hardMs: 5e3 });
-  touchQueues.set(sid, queue);
-  return queue;
-};
-var scheduleTouch = (sid, store, maxAge) => {
-  if (typeof store?.touch !== "function") {
-    return;
+var applyOnMissing = (onMissing) => {
+  if (onMissing instanceof Error) {
+    throw onMissing;
   }
-  const queue = getTouchQueue(sid, store);
-  queue(maxAge);
-};
-var clearTouchQueue = (sid) => {
-  const queue = touchQueues.get(sid);
-  if (!queue) {
-    return false;
-  }
-  queue.flush();
-  touchQueues.delete(sid);
-  return true;
+  if (is("function", onMissing)) {
+    return onMissing();
+  }
+  return onMissing;
 };
-var runSessionHandler = async (socket, handler, opt = {}) => {
+var runSessionHandler = async (socket, handler, store, onMissing) => {
   const sid = socket.sessionId;
-  const { store, maxAge } = opt;
   const current = await store.get(sid);
-  if (!isObject(current)) {
-    throw new Error("Session not found");
+  if (!current) {
+    return applyOnMissing(onMissing);
   }
   const session2 = current;
   const sessionCtx = createSessionCtx(sid, session2, socket);
   const originalHash = createSessionHash(sessionCtx.session);
   const result = await handler(sessionCtx, socket);
   if (sessionCtx.session == null) {
-    clearTouchQueue(sid);
     await store.destroy(sid);
     return result;
   }
-  if (!isObject(sessionCtx.session)) {
-    throw new TypeError("sessionCtx.session must be an object or null");
-  }
+  sessionCtx.session = validObject(sessionCtx.session, false, "session");
   if (isSessionHashChanged(originalHash, sessionCtx.session)) {
-    clearTouchQueue(sid);
-    await store.set(sid, sessionCtx.session, maxAge);
-  } else {
-    scheduleTouch(sid, store, maxAge);
+    await store.set(sid, sessionCtx.session);
   }
   return result;
 };
-var applySessionHandler = async (socket, handler, opt = {}) => {
+var applySessionHandler = async (socket, handler, store, onMissing) => {
   if (typeof handler !== "function") {
     throw new TypeError("socket.withSession(handler) requires a function");
   }
   if (!socket.sessionId) {
-    throw new Error("Missing session id");
+    return applyOnMissing(onMissing);
   }
-  return withLock(runSessionHandler, socket, handler, opt);
+  return withLock(runSessionHandler, socket, handler, store, onMissing);
 };
 
-// src/attachSession.js
-var validateStore = (store) => {
-  const missing = [];
-  if (typeof store?.get !== "function") {
-    missing.push("get()");
+// src/class/SessionStore.js
+import { solid } from "@randajan/props";
+import { EventEmitter } from "events";
+
+// src/const.js
+var ms = {
+  s: (v = 1) => v * 1e3,
+  m: (v = 1) => ms.s(v * 60),
+  h: (v = 1) => ms.m(v * 60),
+  d: (v = 1) => ms.h(v * 24),
+  w: (v = 1) => ms.d(v * 7),
+  M: (v = 1) => ms.d(v * 30),
+  y: (v = 1) => ms.d(v * 365)
+};
+var _customOptKeys = /* @__PURE__ */ new Set([
+  "store",
+  "autoCleanup",
+  "autoCleanupMs",
+  "clientKey",
+  "clientMaxAge",
+  "clientAlwaysRoll"
+]);
+
+// src/class/SessionStore.js
+var formatState = (session2, maxAge, prevTTL, maxAgeDefault) => {
+  const ttl = maxAge ?? prevTTL ?? maxAgeDefault;
+  const expiresAt = Date.now() + ttl;
+  return { session: session2, expiresAt, ttl };
+};
+var SessionStore = class extends Map {
+  constructor(opt = {}) {
+    super();
+    const maxAge = validRange(ms.s(), ms.y(), opt.maxAge, false, "maxAge") ?? ms.M();
+    const autoCleanup = valid("boolean", opt.autoCleanup, false, "autoCleanup") ?? true;
+    const autoCleanupMs = validInterval(opt.autoCleanupMs, false, "autoCleanupMs") ?? Math.max(ms.s(), Math.min(ms.h(), maxAge / 10));
+    solid(this, "maxAge", maxAge);
+    solid(this, "event", new EventEmitter());
+    if (!autoCleanup) {
+      return;
+    }
+    setInterval((_) => this.cleanup(), autoCleanupMs);
   }
-  if (typeof store?.set !== "function") {
-    missing.push("set()");
+  on(eventName, callback) {
+    return this.event.on(eventName, callback);
   }
-  if (typeof store?.destroy !== "function") {
-    missing.push("destroy()");
+  get(sid) {
+    const d = super.get(sid);
+    if (!d) {
+      return;
+    }
+    if (Date.now() < d.expiresAt) {
+      return d.session;
+    }
+    this.delete(sid);
   }
-  if (typeof store?.touch !== "function") {
-    missing.push("touch()");
+  set(sid, session2, maxAge) {
+    const d = super.get(sid);
+    if (session2 == null) {
+      return !d || this.destroy(sid);
+    }
+    super.set(sid, formatState(session2, maxAge, d?.ttl, this.maxAge));
+    this.event.emit("set", this, sid, !d);
+    return true;
   }
-  if (typeof store?.on !== "function") {
-    missing.push("on()");
+  delete(sid) {
+    return this.destroy(sid);
   }
-  if (missing.length) {
-    throw new TypeError(`attachSession options.store is missing required API: ${missing.join(", ")}`);
+  destroy(sid) {
+    if (this.has(sid)) {
+      super.delete(sid);
+      this.event.emit("destroy", this, sid);
+    }
+    return true;
+  }
+  cleanup() {
+    const now = Date.now();
+    let cleared = 0;
+    for (const [sid, d] of this.entries()) {
+      if (now < d.expiresAt) {
+        continue;
+      }
+      if (this.destroy(sid)) {
+        cleared++;
+      }
+    }
+    if (cleared) {
+      this.event.emit("cleanup", this, cleared);
+    }
+    return cleared;
   }
 };
-var attachSession = (app, io, opt = {}) => {
-  opt.signed = "signed" in opt ? !!opt.signed : true;
-  if (!app.keys) {
-    app.keys = Array(6).fill().map(() => generateUid(12));
-  }
-  if (!opt.key) {
-    opt.key = generateUid(12);
-  }
-  if (!opt.maxAge) {
-    opt.maxAge = 864e5;
-  }
-  const { key, signed, externalKey } = opt;
-  const store = opt.store || new SessionStore(opt.maxAge);
-  validateStore(store);
-  opt.store = wrapStore(store);
-  const getSID = externalKey ? (ctx) => externalKey.get(ctx) : (ctx) => ctx.cookies.get(key, { signed });
-  const koaSession = session(opt, app);
-  app.use(koaSession);
-  app.use(async (ctx, next) => {
-    solid2(ctx, "sessionId", getSID(ctx));
-    await next();
-  });
-  io.use(async (socket, next) => {
-    const req = socket.request;
-    const res = req.res ?? socket.response ?? new ServerResponse(req);
-    const ctx = app.createContext(req, res);
-    await koaSession(ctx, async () => {
+
+// src/formatOptions.js
+var pickKoaOpt = (rawOpt) => {
+  const koaOpt = {};
+  for (const key in rawOpt) {
+    if (_customOptKeys.has(key)) {
+      continue;
+    }
+    koaOpt[key] = rawOpt[key];
+  }
+  koaOpt.key = valid("string", koaOpt.key, false, "key") ?? generateUid(12);
+  koaOpt.maxAge = validRange(ms.s(), ms.y(), koaOpt.maxAge, false, "maxAge") ?? ms.M();
+  koaOpt.signed = valid("boolean", koaOpt.signed, false, "signed") ?? true;
+  koaOpt.store = validStore(rawOpt.store || new SessionStore(rawOpt));
+  return koaOpt;
+};
+var formatOptions = (opt = {}) => {
+  opt = validObject(opt, true, "options");
+  const koaOpt = pickKoaOpt(opt);
+  const clientKey = valid("string", opt.clientKey) ?? `${koaOpt.key}.cid`;
+  const clientMaxAge = validInterval(opt.clientMaxAge, false, "clientMaxAge") ?? ms.y();
+  const clientAlwaysRoll = valid("boolean", opt.clientAlwaysRoll, false, "clientAlwaysRoll") ?? true;
+  const clientOpt = { ...koaOpt, key: clientKey, maxAge: clientMaxAge };
+  return {
+    koaOpt,
+    clientOpt,
+    clientAlwaysRoll
+  };
+};
+
+// src/class/Bridge.js
+import { solids as solids2 } from "@randajan/props";
+var Bridge = class {
+  constructor(opt = {}) {
+    const { onSet, onDelete } = opt;
+    solids2(this, {
+      onSet,
+      onDelete,
+      s2c: /* @__PURE__ */ new Map(),
+      c2s: /* @__PURE__ */ new Map()
     });
-    solid2(socket, "sessionId", getSID(ctx));
-    solid2(socket, "withSession", async (handler) => {
-      return applySessionHandler(socket, handler, opt);
-    }, false);
-    await next();
-  });
-  io.on("connection", (socket) => {
-    const sid = socket.sessionId;
-    if (sid) {
-      socket.join(`sessionId:${sid}`);
+  }
+  set(cid, sid) {
+    if (!cid || !sid) {
+      return false;
     }
-  });
-  store.on("destroy", (_store, sid) => {
+    const byCid = this.deleteByCid(cid, sid);
+    const bySid = this.deleteBySid(sid, cid);
+    if (!byCid && !bySid) {
+      return false;
+    }
+    this.c2s.set(cid, sid);
+    this.s2c.set(sid, cid);
+    this.onSet({ clientId: cid, sessionId: sid });
+    return true;
+  }
+  getByCid(cid) {
+    return this.c2s.get(cid);
+  }
+  getBySid(sid) {
+    return this.s2c.get(sid);
+  }
+  deleteBySid(sid, skipIf) {
+    const cid = this.getBySid(sid);
+    if (!cid) {
+      return true;
+    }
+    if (skipIf && cid == skipIf) {
+      return false;
+    }
+    this.s2c.delete(sid);
+    this.c2s.delete(cid);
+    this.onDelete({ clientId: cid, sessionId: sid });
+    return true;
+  }
+  deleteByCid(cid, skipIf) {
+    const sid = this.getByCid(cid);
     if (!sid) {
-      return;
+      return true;
     }
-    clearTouchQueue(sid);
-    const room = io.in(`sessionId:${sid}`);
-    room.emit("session:destroy");
-    setTimeout((_) => room.disconnectSockets(true), 200);
-  });
-  return store;
+    if (skipIf && sid == skipIf) {
+      return false;
+    }
+    this.c2s.delete(cid);
+    this.s2c.delete(sid);
+    this.onDelete({ clientId: cid, sessionId: sid });
+    return true;
+  }
+};
+
+// src/class/SessionBridge.js
+var SessionBridge = class extends EventEmitter2 {
+  constructor(app, io, opt = {}) {
+    super();
+    if (!app.keys) {
+      app.keys = Array(6).fill().map(() => generateUid(12));
+    }
+    const o = formatOptions(opt);
+    const { store } = o.koaOpt;
+    const brg = new Bridge({
+      onSet: (pair) => this.emit("sessionStart", pair),
+      onDelete: (pair) => this.emit("sessionEnd", pair)
+    });
+    const cc = createClientCookie(o.clientOpt);
+    const [koaSession, sc] = createKoaSession(o.koaOpt, app, (ctx, sid) => {
+      const cid = cc.get(ctx);
+      brg.set(cid, sid);
+    });
+    const regenerateSid = async (ctx, cid, reqSid) => {
+      if (cid == null || reqSid == null) {
+        return;
+      }
+      const brgSid = brg.getByCid(cid);
+      if (brgSid == reqSid) {
+        return;
+      } else if (brgSid) {
+        sc.set(ctx, brgSid);
+        return;
+      }
+      if (brg.getBySid(reqSid)) {
+        return;
+      }
+      if (!await store.get(reqSid)) {
+        return;
+      }
+      brg.set(cid, reqSid);
+    };
+    app.use(koaSession);
+    app.use(async (ctx, next) => {
+      let cid = cc.get(ctx);
+      const sid = sc.get(ctx);
+      if (!cid) {
+        cc.set(ctx, cid = generateUid(24));
+      } else if (o.clientAlwaysRoll) {
+        cc.set(ctx, cid);
+      }
+      await regenerateSid(ctx, cid, sid);
+      solid2(ctx, "clientId", cid);
+      virtual(ctx, "sessionId", (_) => brg.getByCid(cid));
+      await next();
+    });
+    io.use(async (socket, next) => {
+      const req = socket.request;
+      const res = req.res ?? socket.response ?? new ServerResponse(req);
+      const ctx = app.createContext(req, res);
+      await koaSession(ctx, async () => {
+      });
+      const cid = cc.get(ctx);
+      const sid = sc.get(ctx);
+      await regenerateSid(ctx, cid, sid);
+      solid2(socket, "clientId", cid);
+      virtual(socket, "sessionId", (_) => brg.getByCid(cid));
+      solid2(socket, "withSession", async function(handler, onMissing) {
+        const onm = arguments.length > 1 ? onMissing : new Error("Session missing");
+        return applySessionHandler(socket, handler, store, onm);
+      }, false);
+      await next();
+    });
+    store.on("destroy", (_store, sid) => {
+      if (!sid) {
+        return;
+      }
+      brg.deleteBySid(sid);
+    });
+    solid2(this, "store", store);
+  }
 };
 
 // src/index.js
-var index_default = attachSession;
+var bridgeSession = (app, io, opt = {}) => new SessionBridge(app, io, opt);
+var index_default = bridgeSession;
 export {
+  SessionBridge,
   SessionStore,
-  attachSession,
+  bridgeSession,
   index_default as default,
   generateUid
 };