@randajan/koa-io-session 2.1.0 → 3.0.0

package/dist/cjs/index.cjs

@@ -29,50 +29,73 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.js
 var index_exports = {};
 __export(index_exports, {
+  LiveStore: () => LiveStore,
   SessionBridge: () => SessionBridge,
-  SessionStore: () => SessionStore,
   bridgeSession: () => bridgeSession,
   default: () => index_default,
-  generateUid: () => generateUid
+  generateUid: () => generateUid,
+  ms: () => ms
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/class/SessionBridge.js
-var import_events2 = require("events");
+var import_events = require("events");
 var import_http = require("http");
 var import_props4 = require("@randajan/props");
 
 // src/tools.js
 var import_crypto = __toESM(require("crypto"), 1);
+
+// src/const.js
+var _errPrefix = "[koa-io-session]";
+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"
+]);
+var _privs = /* @__PURE__ */ new WeakMap();
+
+// src/tools.js
 var generateUid = (len = 16) => import_crypto.default.randomBytes(len).toString("base64url").slice(0, len);
 var is = (type, any) => typeof any === type;
+var _typeOf = (any) => any === null ? "null" : Array.isArray(any) ? "array" : typeof any;
+var _err = (msg) => `${_errPrefix} ${msg}`;
 var valid = (type, any, req = false, msg = "argument") => {
   if (any == null) {
     if (!req) {
       return;
     }
-    throw new Error(`${msg} require typeof '${type}'`);
+    throw new TypeError(_err(`Missing required '${msg}'. Expected type '${type}'.`));
   }
   if (is(type, any)) {
     return any;
   }
-  throw new Error(`${msg} is not typeof '${type}'`);
+  throw new TypeError(_err(`Invalid '${msg}'. Expected type '${type}', received '${_typeOf(any)}'.`));
 };
-var validRange = (min, max, any, req = false, msg = "argument") => {
+var validRange = (any, min, max, 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}`);
+  if (num < min || num > max) {
+    throw new RangeError(_err(`Invalid '${msg}'. Expected value in range <${min}, ${max}>, received '${num}'.`));
   }
   return num;
 };
 var validInterval = (any, req = false, msg = "argument") => {
-  return validRange(10, 2147483647, any, req, msg);
+  return validRange(any, 10, 2147483647, req, msg);
 };
 var validObject = (any, req = false, msg = "argument") => {
   const obj = valid("object", any, req, msg);
@@ -82,25 +105,27 @@ var validObject = (any, req = false, msg = "argument") => {
   if (!Array.isArray(obj)) {
     return obj;
   }
-  throw new Error(`${msg} must be object, not array`);
+  throw new TypeError(_err(`Invalid '${msg}'. Expected plain object, received 'array'.`));
 };
-var validStore = (store) => {
+var validStore = (store, req = false) => {
+  store = validObject(store, req, "store");
+  if (!store) {
+    return;
+  }
   const missing = [];
-  if (!is("function", store?.get)) {
+  if (!is("function", store.get)) {
     missing.push("get()");
   }
-  if (!is("function", store?.set)) {
+  if (!is("function", store.set)) {
     missing.push("set()");
   }
-  if (!is("function", store?.destroy)) {
+  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(", ")}`);
+    throw new TypeError(_err(`Invalid 'store'. Missing required API: ${missing.join(", ")}.`));
   }
+  valid("function", store.list, false, "store.list()");
   return store;
 };
 
@@ -127,10 +152,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 = (0, import_koa_session.default)({ ...opt, store, externalKey }, app);
+  const koaSession = (0, import_koa_session.default)({ ...opt, maxAge, store, externalKey }, app);
   return [koaSession, externalKey];
 };
 var createClientCookie = (opt) => {
@@ -150,161 +176,64 @@ var createClientCookie = (opt) => {
 // src/socketSession.js
 var import_props = require("@randajan/props");
 var sidLocks = /* @__PURE__ */ new Map();
-var createSessionCtx = (sessionId, session2, socket) => (0, import_props.solids)({ session: session2 }, { sessionId, socket });
-var createSessionHash = (session2) => {
-  try {
-    return JSON.stringify(session2 ?? null);
-  } catch {
-    return null;
+var applyOnMissing = (onMissing) => {
+  if (onMissing instanceof Error) {
+    throw onMissing;
+  }
+  if (is("function", onMissing)) {
+    return onMissing();
   }
+  return onMissing;
 };
-var isSessionHashChanged = (originalHash, session2) => {
-  const nextHash = createSessionHash(session2);
-  if (originalHash == null || nextHash == null) {
-    return true;
+var runSessionHandler = async (sid, socket, handler, gw, onMissing) => {
+  const session2 = await gw.get(sid);
+  if (!session2) {
+    return applyOnMissing(onMissing);
+  }
+  const sessionCtx = (0, import_props.solids)({ session: session2 }, { sessionId: sid, socket });
+  const result = await handler(sessionCtx, socket);
+  if (sid === socket.sessionId) {
+    await gw.set(sid, sessionCtx.session);
   }
-  return originalHash !== nextHash;
+  return result;
 };
-var withLock = async (task, socket, ...args) => {
-  const sid = socket.sessionId;
+var createLock = (sid) => {
+  let _release;
   const previous = sidLocks.get(sid);
-  let releaseCurrent;
   const current = new Promise((resolve) => {
-    releaseCurrent = resolve;
+    _release = resolve;
   });
   sidLocks.set(sid, current);
-  if (previous) {
-    await previous;
-  }
-  try {
-    return await task(socket, ...args);
-  } finally {
-    releaseCurrent();
+  const release = () => {
+    _release();
     if (sidLocks.get(sid) === current) {
       sidLocks.delete(sid);
     }
-  }
-};
-var runSessionHandler = async (socket, handler, store) => {
-  const sid = socket.sessionId;
-  const current = await store.get(sid);
-  if (!current) {
-    throw new Error("Session not found");
-  }
-  const session2 = current;
-  const sessionCtx = createSessionCtx(sid, session2, socket);
-  const originalHash = createSessionHash(sessionCtx.session);
-  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);
-  }
-  return result;
-};
-var applySessionHandler = async (socket, handler, store) => {
-  if (typeof handler !== "function") {
-    throw new TypeError("socket.withSession(handler) requires a function");
-  }
-  if (!socket.sessionId) {
-    throw new Error("Missing session id");
-  }
-  return withLock(runSessionHandler, socket, handler, store);
-};
-
-// src/class/SessionStore.js
-var import_props2 = require("@randajan/props");
-var import_events = require("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 };
+  };
+  return [previous, release];
 };
-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));
-    (0, import_props2.solid)(this, "maxAge", maxAge);
-    (0, import_props2.solid)(this, "event", new import_events.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 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);
     }
-    this.delete(sid);
-  }
-  set(sid, session2, maxAge) {
-    const d = super.get(sid);
-    if (session2 == null) {
-      return !d || this.destroy(sid);
+    const [previous, release] = createLock(sid);
+    if (previous) {
+      await previous;
     }
-    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);
-    }
-    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
@@ -317,9 +246,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 = {}) => {
@@ -337,11 +264,11 @@ var formatOptions = (opt = {}) => {
 };
 
 // src/class/Bridge.js
-var import_props3 = require("@randajan/props");
+var import_props2 = require("@randajan/props");
 var Bridge = class {
   constructor(opt = {}) {
     const { onSet, onDelete } = opt;
-    (0, import_props3.solids)(this, {
+    (0, import_props2.solids)(this, {
       onSet,
       onDelete,
       s2c: /* @__PURE__ */ new Map(),
@@ -359,7 +286,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) {
@@ -378,7 +305,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) {
@@ -391,30 +318,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
+var import_props3 = require("@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;
+    (0, import_props3.solid)(this, "emit", emit);
+    (0, import_props3.solid)(this, "maxAge", maxAge);
+    (0, import_props3.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 import_events2.EventEmitter {
+var SessionBridge = class extends import_events.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;
       }
@@ -428,21 +570,15 @@ var SessionBridge = class extends import_events2.EventEmitter {
       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);
       (0, import_props4.solid)(ctx, "clientId", cid);
       (0, import_props4.virtual)(ctx, "sessionId", (_) => brg.getByCid(cid));
       await next();
@@ -453,23 +589,87 @@ var SessionBridge = class extends import_events2.EventEmitter {
       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);
       (0, import_props4.solid)(socket, "clientId", cid);
       (0, import_props4.virtual)(socket, "sessionId", (_) => brg.getByCid(cid));
-      (0, import_props4.solid)(socket, "withSession", async (handler) => {
-        return applySessionHandler(socket, handler, store);
+      (0, import_props4.solid)(socket, "withSession", async function(handler, onMissing) {
+        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);
-    });
-    (0, import_props4.solid)(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);
   }
 };