@randajan/koa-io-session 2.2.0 → 3.0.0

package/dist/esm/index.mjs

@@ -1,70 +1,22 @@
+import {
+  _customOptKeys,
+  _errPrefix,
+  _privs,
+  generateUid,
+  is,
+  ms,
+  valid,
+  validInterval,
+  validObject,
+  validRange,
+  validStore
+} from "./chunk-27XQ42ES.js";
+
 // src/class/SessionBridge.js
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter } from "events";
 import { ServerResponse } from "http";
 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 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 validRange = (min, max, any, req = false, msg = "argument") => {
-  const num = valid("number", any, req, msg);
-  if (num == null) {
-    return;
-  }
-  if (num < min) {
-    throw new Error(`${msg} must be greater than ${min}`);
-  }
-  if (num > max) {
-    throw new Error(`${msg} must be less than ${max}`);
-  }
-  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;
-  }
-  if (!Array.isArray(obj)) {
-    return obj;
-  }
-  throw new Error(`${msg} must be object, not array`);
-};
-var validStore = (store) => {
-  const missing = [];
-  if (!is("function", store?.get)) {
-    missing.push("get()");
-  }
-  if (!is("function", store?.set)) {
-    missing.push("set()");
-  }
-  if (!is("function", store?.destroy)) {
-    missing.push("destroy()");
-  }
-  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";
 
@@ -88,10 +40,11 @@ var wrapExternalKey = (opt, onSet) => {
 };
 
 // src/httpSession.js
-var createKoaSession = (opt, app, onSet) => {
-  const store = wrapStore(opt.store);
+var createKoaSession = (app, gw, opt, onSet) => {
+  const maxAge = gw.maxAge;
+  const store = wrapStore(gw);
   const externalKey = wrapExternalKey(opt, onSet);
-  const koaSession = session({ ...opt, store, externalKey }, app);
+  const koaSession = session({ ...opt, maxAge, store, externalKey }, app);
   return [koaSession, externalKey];
 };
 var createClientCookie = (opt) => {
@@ -111,41 +64,6 @@ var createClientCookie = (opt) => {
 // src/socketSession.js
 import { solids } from "@randajan/props";
 var sidLocks = /* @__PURE__ */ new Map();
-var createSessionCtx = (sessionId, session2, socket) => solids({ session: session2 }, { sessionId, socket });
-var createSessionHash = (session2) => {
-  try {
-    return JSON.stringify(session2 ?? null);
-  } catch {
-    return null;
-  }
-};
-var isSessionHashChanged = (originalHash, session2) => {
-  const nextHash = createSessionHash(session2);
-  if (originalHash == null || nextHash == null) {
-    return true;
-  }
-  return originalHash !== nextHash;
-};
-var withLock = async (task, socket, ...args) => {
-  const sid = socket.sessionId;
-  const previous = sidLocks.get(sid);
-  let releaseCurrent;
-  const current = new Promise((resolve) => {
-    releaseCurrent = resolve;
-  });
-  sidLocks.set(sid, current);
-  if (previous) {
-    await previous;
-  }
-  try {
-    return await task(socket, ...args);
-  } finally {
-    releaseCurrent();
-    if (sidLocks.get(sid) === current) {
-      sidLocks.delete(sid);
-    }
-  }
-};
 var applyOnMissing = (onMissing) => {
   if (onMissing instanceof Error) {
     throw onMissing;
@@ -155,126 +73,55 @@ var applyOnMissing = (onMissing) => {
   }
   return onMissing;
 };
-var runSessionHandler = async (socket, handler, store, onMissing) => {
-  const sid = socket.sessionId;
-  const current = await store.get(sid);
-  if (!current) {
+var runSessionHandler = async (sid, socket, handler, gw, onMissing) => {
+  const session2 = await gw.get(sid);
+  if (!session2) {
     return applyOnMissing(onMissing);
   }
-  const session2 = current;
-  const sessionCtx = createSessionCtx(sid, session2, socket);
-  const originalHash = createSessionHash(sessionCtx.session);
+  const sessionCtx = solids({ session: session2 }, { sessionId: sid, socket });
   const result = await handler(sessionCtx, socket);
-  if (sessionCtx.session == null) {
-    await store.destroy(sid);
-    return result;
-  }
-  sessionCtx.session = validObject(sessionCtx.session, false, "session");
-  if (isSessionHashChanged(originalHash, sessionCtx.session)) {
-    await store.set(sid, sessionCtx.session);
+  if (sid === socket.sessionId) {
+    await gw.set(sid, sessionCtx.session);
   }
   return result;
 };
-var applySessionHandler = async (socket, handler, store, onMissing) => {
-  if (typeof handler !== "function") {
-    throw new TypeError("socket.withSession(handler) requires a function");
-  }
-  if (!socket.sessionId) {
-    return applyOnMissing(onMissing);
-  }
-  return withLock(runSessionHandler, socket, handler, store, onMissing);
-};
-
-// 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);
-  }
-  on(eventName, callback) {
-    return this.event.on(eventName, callback);
-  }
-  get(sid) {
-    const d = super.get(sid);
-    if (!d) {
-      return;
-    }
-    if (Date.now() < d.expiresAt) {
-      return d.session;
+var createLock = (sid) => {
+  let _release;
+  const previous = sidLocks.get(sid);
+  const current = new Promise((resolve) => {
+    _release = resolve;
+  });
+  sidLocks.set(sid, current);
+  const release = () => {
+    _release();
+    if (sidLocks.get(sid) === current) {
+      sidLocks.delete(sid);
     }
-    this.delete(sid);
-  }
-  set(sid, session2, maxAge) {
-    const d = super.get(sid);
-    if (session2 == null) {
-      return !d || this.destroy(sid);
+  };
+  return [previous, release];
+};
+var applySessionHandler = async (socket, handler, gw, onMissing) => {
+  valid("function", handler, true, "handler");
+  for (let i = 0; i < 5; i++) {
+    const sid = socket.sessionId;
+    if (!sid) {
+      return applyOnMissing(onMissing);
     }
-    super.set(sid, formatState(session2, maxAge, d?.ttl, this.maxAge));
-    this.event.emit("set", this, sid, !d);
-    return true;
-  }
-  delete(sid) {
-    return this.destroy(sid);
-  }
-  destroy(sid) {
-    if (this.has(sid)) {
-      super.delete(sid);
-      this.event.emit("destroy", this, sid);
+    const [previous, release] = createLock(sid);
+    if (previous) {
+      await previous;
     }
-    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 (previous && sid !== socket.sessionId) {
+      release();
+      continue;
     }
-    if (cleared) {
-      this.event.emit("cleanup", this, cleared);
+    try {
+      return await runSessionHandler(sid, socket, handler, gw, onMissing);
+    } finally {
+      release();
     }
-    return cleared;
   }
+  throw new Error(`${_errPrefix} socket.sessionId changed during withSession execution.`);
 };
 
 // src/formatOptions.js
@@ -287,9 +134,7 @@ var pickKoaOpt = (rawOpt) => {
     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 = {}) => {
@@ -329,7 +174,7 @@ var Bridge = class {
     }
     this.c2s.set(cid, sid);
     this.s2c.set(sid, cid);
-    this.onSet({ clientId: cid, sessionId: sid });
+    this.onSet(cid, sid);
     return true;
   }
   getByCid(cid) {
@@ -348,7 +193,7 @@ var Bridge = class {
     }
     this.s2c.delete(sid);
     this.c2s.delete(cid);
-    this.onDelete({ clientId: cid, sessionId: sid });
+    this.onDelete(cid, sid);
     return true;
   }
   deleteByCid(cid, skipIf) {
@@ -361,30 +206,245 @@ var Bridge = class {
     }
     this.c2s.delete(cid);
     this.s2c.delete(sid);
-    this.onDelete({ clientId: cid, sessionId: sid });
+    this.onDelete(cid, sid);
+    return true;
+  }
+};
+
+// src/class/TempMap.js
+var TempMap = class extends Map {
+  constructor(ttl) {
+    super();
+    const _p = {
+      ttl: validInterval(ttl, true, "ttl"),
+      ts: /* @__PURE__ */ new Map()
+    };
+    _privs.set(this, _p);
+  }
+  set(key, value, overwrite = true) {
+    const { ts, ttl } = _privs.get(this);
+    if (!overwrite && this.has(key)) {
+      return false;
+    }
+    this.delete(key);
+    super.set(key, value);
+    const t = setTimeout((_) => {
+      this.delete(key);
+    }, ttl);
+    ts.set(key, t);
+    return true;
+  }
+  get(key, andDelete = false) {
+    const v = super.get(key);
+    if (andDelete) {
+      this.delete(key);
+    }
+    return v;
+  }
+  delete(key) {
+    if (!super.delete(key)) {
+      return false;
+    }
+    const { ts } = _privs.get(this);
+    const t = ts.get(key);
+    clearTimeout(t);
+    ts.delete(key);
+    return true;
+  }
+};
+
+// src/class/StoreGateway.js
+import { solid } from "@randajan/props";
+
+// src/stores/LiveStore.js
+var LiveStore = class extends Map {
+  get(sid) {
+    return super.get(sid);
+  }
+  set(sid, state) {
+    super.set(sid, state);
+    return true;
+  }
+  destroy(sid) {
+    return super.delete(sid);
+  }
+  list() {
+    return this.keys();
+  }
+};
+
+// src/class/StoreGateway.js
+var formatState = (session2, maxAge, maxAgeDefault) => {
+  const ttl = maxAge ?? maxAgeDefault;
+  const expiresAt = Date.now() + ttl;
+  return { session: session2, expiresAt, ttl };
+};
+var requireList = (store) => {
+  if (!store.list) {
+    throw new TypeError(`${_errPrefix} store.list() is required`);
+  }
+};
+var StoreGateway = class _StoreGateway {
+  static is(any) {
+    return any instanceof _StoreGateway;
+  }
+  constructor(opt = {}, emit = {}) {
+    const maxAge = validRange(opt.maxAge, ms.m(), ms.y(), false, "maxAge") ?? ms.M();
+    const autoCleanup = valid("boolean", opt.autoCleanup, false, "autoCleanup") ?? false;
+    solid(this, "emit", emit);
+    solid(this, "maxAge", maxAge);
+    solid(this, "store", validStore(opt.store, false) ?? new LiveStore());
+    if (autoCleanup) {
+      this.startAutoCleanup(validInterval(opt.autoCleanupMs, false, "autoCleanupMs"));
+    }
+  }
+  async list() {
+    const { store } = this;
+    requireList(store);
+    return store.list();
+  }
+  async get(sid) {
+    const { store } = this;
+    const c = await store.get(sid);
+    if (!c) {
+      return;
+    }
+    if (Date.now() >= c.expiresAt) {
+      await this.destroy(sid);
+      return;
+    }
+    try {
+      return JSON.parse(c.session);
+    } catch {
+      await this.destroy(sid);
+      throw new Error(`${_errPrefix} Invalid session JSON for sid='${sid}'.`);
+    }
+    ;
+  }
+  async set(sid, session2, maxAge) {
+    const { store } = this;
+    const ses = validObject(session2, false, "session");
+    if (ses == null) {
+      return this.destroy(sid);
+    }
+    const to = JSON.stringify(ses);
+    const from = await store.get(sid, false);
+    if (to === from?.session) {
+      return true;
+    }
+    const isOk = await store.set(sid, formatState(to, maxAge, this.maxAge));
+    if (isOk === false) {
+      return false;
+    }
+    this.emit.notifySet(sid, !from);
+    return true;
+  }
+  async destroy(sid) {
+    const { store } = this;
+    const isOk = await store.destroy(sid);
+    if (isOk === false) {
+      return false;
+    }
+    this.emit.notifyDestroy(sid);
+    return true;
+  }
+  async cleanup() {
+    const { store } = this;
+    requireList(store);
+    const list = await store.list();
+    const now = Date.now();
+    let cleared = 0;
+    await Promise.all([...list].map(async (sid) => {
+      const d = await store.get(sid);
+      if (!d) {
+        return;
+      }
+      if (now < d.expiresAt) {
+        return;
+      }
+      if (await this.destroy(sid)) {
+        cleared++;
+      }
+    }));
+    if (is("function", store.optimize)) {
+      await store.optimize(cleared);
+    }
+    this.emit.notifyCleanup(cleared);
+    return cleared;
+  }
+  startAutoCleanup(interval) {
+    const { store, maxAge, _intId } = this;
+    requireList(store);
+    const int = validRange(interval, ms.m(), ms.d(), false, "interval") ?? Math.max(ms.m(), Math.min(ms.d(), maxAge / 4));
+    clearInterval(_intId);
+    this._intId = setInterval((_) => this.cleanup().catch(() => {
+    }), int);
+    return true;
+  }
+  stopAutoCleanup() {
+    const { _intId } = this;
+    if (!_intId) {
+      return false;
+    }
+    clearInterval(_intId);
+    delete this._intId;
     return true;
   }
 };
 
 // src/class/SessionBridge.js
-var SessionBridge = class extends EventEmitter2 {
+var SessionBridge = class extends EventEmitter {
   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 { koaOpt, clientOpt, clientAlwaysRoll } = formatOptions(opt);
+    const _p = {};
+    const tmp = new TempMap(5e3);
+    const brg = _p.brg = new Bridge({
+      onSet: (clientId, sessionId) => {
+        const isNew = !!tmp.get(sessionId, true);
+        this.emit("sessionSet", { clientId, sessionId, isNew, isInit: true });
+      },
+      onDelete: (clientId, sessionId) => this.emit("sessionDestroy", { clientId, sessionId })
     });
-    const cc = createClientCookie(o.clientOpt);
-    const [koaSession, sc] = createKoaSession(o.koaOpt, app, (ctx, sid) => {
+    _p.notifySet = (sid, isNew) => {
+      if (!sid) {
+        return;
+      }
+      const cid = brg.getBySid(sid);
+      if (!cid) {
+        tmp.set(sid, isNew, false);
+        return;
+      }
+      this.emit("sessionSet", { clientId: cid, sessionId: sid, isNew: !!isNew, isInit: false });
+    };
+    _p.notifyDestroy = (sid) => {
+      if (sid) {
+        brg.deleteBySid(sid);
+      }
+    };
+    _p.notifyCleanup = (cleared) => {
+      this.emit("cleanup", cleared);
+    };
+    const gw = _p.gw = new StoreGateway(opt, _p);
+    const cc = createClientCookie(clientOpt);
+    const [koaSession, sc] = createKoaSession(app, gw, koaOpt, (ctx, sid) => {
       const cid = cc.get(ctx);
       brg.set(cid, sid);
     });
-    const regenerateSid = async (ctx, cid, reqSid) => {
+    const reviveCid = (ctx) => {
+      let cid = cc.get(ctx);
+      if (!cid) {
+        cc.set(ctx, cid = generateUid(24));
+      } else if (clientAlwaysRoll) {
+        cc.set(ctx, cid);
+      }
+      return cid;
+    };
+    const reviveSid = async (ctx, cid) => {
+      const reqSid = sc.get(ctx);
       if (cid == null || reqSid == null) {
         return;
       }
@@ -398,21 +458,15 @@ var SessionBridge = class extends EventEmitter2 {
       if (brg.getBySid(reqSid)) {
         return;
       }
-      if (!await store.get(reqSid)) {
+      if (!await gw.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);
+      const cid = reviveCid(ctx);
+      await reviveSid(ctx, cid);
       solid2(ctx, "clientId", cid);
       virtual(ctx, "sessionId", (_) => brg.getByCid(cid));
       await next();
@@ -423,24 +477,87 @@ var SessionBridge = class extends EventEmitter2 {
       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);
+      const cid = reviveCid(ctx);
+      await reviveSid(ctx, cid);
       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);
+        const onm = arguments.length > 1 ? onMissing : new Error(`${_errPrefix} Session is missing for this socket.`);
+        return applySessionHandler(socket, handler, gw, onm);
       }, false);
       await next();
     });
-    store.on("destroy", (_store, sid) => {
-      if (!sid) {
-        return;
-      }
-      brg.deleteBySid(sid);
-    });
-    solid2(this, "store", store);
+    _privs.set(this, _p);
+  }
+  async getById(sessionId) {
+    const { gw, brg } = _privs.get(this);
+    const cid = brg.getBySid(sessionId);
+    if (cid) {
+      return gw.get(sessionId);
+    }
+  }
+  async destroyById(sessionId) {
+    const { gw, brg } = _privs.get(this);
+    const cid = brg.getBySid(sessionId);
+    if (cid) {
+      return gw.destroy(sessionId);
+    }
+    return false;
+  }
+  async setById(sessionId, session2, maxAge) {
+    const { gw, brg } = _privs.get(this);
+    const cid = brg.getBySid(sessionId);
+    if (cid) {
+      return gw.set(sessionId, session2, maxAge);
+    }
+    throw new Error(`${_errPrefix} Creating session via setById() is prohibited. sessionId='${sessionId}'.`);
+  }
+  async getByClientId(clientId) {
+    const { gw, brg } = _privs.get(this);
+    const sid = brg.getByCid(clientId);
+    if (sid) {
+      return gw.get(sid);
+    }
+  }
+  async destroyByClientId(clientId) {
+    const { gw, brg } = _privs.get(this);
+    const sid = brg.getByCid(clientId);
+    if (sid) {
+      return gw.destroy(sid);
+    }
+    return false;
+  }
+  async setByClientId(clientId, session2, maxAge) {
+    const { gw, brg } = _privs.get(this);
+    const sid = brg.getByCid(clientId);
+    if (sid) {
+      return gw.set(sid, session2, maxAge);
+    }
+    throw new Error(`${_errPrefix} Creating session via setByClientId() is prohibited. clientId='${clientId}'.`);
+  }
+  getSessionId(clientId) {
+    return _privs.get(this).brg.getByCid(clientId);
+  }
+  getClientId(sessionId) {
+    return _privs.get(this).brg.getBySid(sessionId);
+  }
+  async cleanup() {
+    return _privs.get(this).gw.cleanup();
+  }
+  startAutoCleanup(interval) {
+    return _privs.get(this).gw.startAutoCleanup(interval);
+  }
+  stopAutoCleanup() {
+    return _privs.get(this).gw.stopAutoCleanup();
+  }
+  notifyStoreSet(sessionId, isNew) {
+    return _privs.get(this).notifySet(sessionId, isNew);
+  }
+  notifyStoreDestroy(sessionId) {
+    return _privs.get(this).notifyDestroy(sessionId);
+  }
+  notifyStoreCleanup(clearedCount) {
+    return _privs.get(this).notifyCleanup(clearedCount);
   }
 };
 
@@ -448,10 +565,11 @@ var SessionBridge = class extends EventEmitter2 {
 var bridgeSession = (app, io, opt = {}) => new SessionBridge(app, io, opt);
 var index_default = bridgeSession;
 export {
+  LiveStore,
   SessionBridge,
-  SessionStore,
   bridgeSession,
   index_default as default,
-  generateUid
+  generateUid,
+  ms
 };
 //# sourceMappingURL=index.js.map