@dooboostore/simple-boot-http-server 1.0.16 → 1.0.18

package/dist/esm/session/SessionManager.d.ts

@@ -0,0 +1,57 @@
+import { HttpServerOption } from '../option/HttpServerOption';
+import { RequestResponse } from '../models/RequestResponse';
+export declare class SessionManager {
+    private option;
+    private sessions;
+    sessionOption: {
+        key: string;
+        expiredTime: number;
+        provider?: {
+            uuids: () => Promise<string[]>;
+            delete: (uuid: string) => Promise<void>;
+            get: (uuid: string) => Promise<{
+                access: number;
+                data?: any;
+            }>;
+            set: (uuid: string, data: {
+                access: number;
+                data?: any;
+            }) => Promise<void>;
+        };
+    };
+    constructor(option: HttpServerOption);
+    getSessionUUIDs(): Promise<string[]>;
+    deleteSession(uuid: string): Promise<void>;
+    getSessionDataSet(uuid: string): Promise<{
+        access: number;
+        data?: any;
+    }>;
+    setSessionDataSet(uuid: string, dataSet: {
+        access: number;
+        data?: any;
+    }): Promise<void>;
+    isExpired(access: number, now?: number): boolean;
+    makeUUID(): string;
+    session(): Promise<{
+        uuid: string;
+        dataSet: {
+            access: number;
+            data?: any;
+        };
+    }>;
+    session(uuid: string): Promise<{
+        uuid: string;
+        dataSet: {
+            access: number;
+            data?: any;
+        };
+    }>;
+    session(rr: RequestResponse): Promise<{
+        uuid: string;
+        dataSet: {
+            access: number;
+            data?: any;
+        };
+    }>;
+}
+//# sourceMappingURL=SessionManager.d.ts.map

package/dist/esm/session/SessionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionManager.d.ts","sourceRoot":"","sources":["../../../src/session/SessionManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAC,eAAe,EAAC,MAAM,2BAA2B,CAAC;AAE1D,qBAAa,cAAc;IAIX,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,QAAQ,CAAqD;IAC9D,aAAa,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE;YAAC,KAAK,EAAE,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;YAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;YAAC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAC;gBAAC,IAAI,CAAC,EAAE,GAAG,CAAA;aAAE,CAAC,CAAC;YAAC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAC;gBAAC,IAAI,CAAC,EAAE,GAAG,CAAA;aAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;SAAC,CAAA;KAAE,CAAC;gBAEzQ,MAAM,EAAE,gBAAgB;IAatC,eAAe;IAQf,aAAa,CAAC,IAAI,EAAE,MAAM;IAQ1B,iBAAiB,CAAC,IAAI,EAAE,MAAM;gBAhCS,MAAM;eAAS,GAAG;;IAwCzD,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,GAAG,CAAA;KAAE;IAQ7E,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB;IAIlD,QAAQ;IAIF,OAAO,IAAI,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,GAAG,CAAA;SAAE,CAAA;KAAE,CAAC;IAC7E,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,GAAG,CAAA;SAAE,CAAA;KAAE,CAAC;IACzF,OAAO,CAAC,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,GAAG,CAAA;SAAE,CAAA;KAAE,CAAC;CAyBzG"}

package/dist/esm/session/SessionManager.js

@@ -0,0 +1,553 @@
+// src/session/SessionManager.ts
+import { RandomUtils } from "@dooboostore/core/random/RandomUtils";
+
+// src/models/RequestResponse.ts
+import { Intent } from "@dooboostore/simple-boot/intent/Intent";
+import { URL, URLSearchParams } from "url";
+import { Buffer } from "buffer";
+
+// src/models/datas/body/ReqFormUrlBody.ts
+var ReqFormUrlBody = class {
+};
+
+// src/models/datas/body/ReqJsonBody.ts
+var ReqJsonBody = class {
+};
+
+// src/models/datas/ReqHeader.ts
+var ReqHeader = class {
+};
+
+// src/models/RequestResponse.ts
+import { gzip } from "node-gzip";
+import { FileUtils } from "@dooboostore/core-node/file/FileUtils";
+import { ConvertUtils as CoreConvertUtils } from "@dooboostore/core/convert/ConvertUtils";
+import { ConvertUtils } from "@dooboostore/core-node/convert/ConvertUtils";
+var RequestResponse = class _RequestResponse {
+  // protected sessionManager?: SessionManager;
+  // constructor(req: IncomingMessage, res: ServerResponse);
+  // constructor(req: RequestResponse);
+  // constructor(req: IncomingMessage, res: ServerResponse, sessionManager?: SessionManager);
+  // constructor(req: IncomingMessage | RequestResponse, res?: ServerResponse, sessionManager?: SessionManager) {
+  //   // this.req = req;
+  //   // this.res = res;
+  //   if (req instanceof RequestResponse) {
+  //     this.req = req.req;
+  //     this.res = req.res;
+  //     this.sessionManager = req.sessionManager;
+  //   } else {
+  //     this.req = req;
+  //     this.res = res!;
+  //     this.sessionManager = sessionManager;
+  //   }
+  // }
+  constructor(req, res, config) {
+    if (req instanceof _RequestResponse) {
+      this.req = req.req;
+      this.res = req.res;
+      this.config = config;
+    } else {
+      this.req = req;
+      this.res = res;
+      this.config = config;
+    }
+  }
+  get reqSocket() {
+    return this.req.socket;
+  }
+  get reqCookieMap() {
+    let cookies = this.reqHeader("Cookie" /* Cookie */) ?? "";
+    if (Array.isArray(cookies)) {
+      cookies = cookies.join(";");
+    }
+    const map = /* @__PURE__ */ new Map();
+    cookies.split(";").map((it) => it.trim().split("=")).forEach((it) => {
+      map.set(it[0], it[1]);
+    });
+    return map;
+  }
+  reqCookieGet(key) {
+    return this.reqCookieMap.get(key);
+  }
+  get reqRemoteAddress() {
+    const ipHeader = this.req.headers["x-forwarded-for"];
+    let ip = this.req.socket.remoteAddress;
+    if (Array.isArray(ipHeader)) {
+      ip = ipHeader.join(",").split(",").shift();
+    } else if (typeof ipHeader === "string") {
+      ip = ipHeader.split(",").shift();
+    }
+    return ip;
+  }
+  get reqUrlObject() {
+    return new URL(this.reqUrl, `${this.reqSocket ? "https://" : "http"}${this.reqHost ?? "localhost"}`);
+  }
+  get reqUrlPathName() {
+    return this.reqUrlObj().pathname ?? "";
+  }
+  get reqUrl() {
+    return this.req.url ?? "";
+  }
+  reqUrlObj(config) {
+    return new URL(`${config?.scheme ?? "http"}://${config?.host ? config?.host : this.reqHeaderFirst("Host" /* Host */) ?? "localhost"}${this.req.url ?? ""}`);
+  }
+  get reqUrlSearchParamTuples() {
+    return Array.from(this.reqUrlObj().searchParams);
+  }
+  get reqUrlSearchParams() {
+    return this.reqUrlObj().searchParams;
+  }
+  get reqUrlSearchParamsObj() {
+    const entries = this.reqUrlObj().searchParams;
+    return CoreConvertUtils.toObject(entries);
+  }
+  get reqPathSearchParamUrl() {
+    const reqUrlObj = this.reqUrlObj();
+    return reqUrlObj.pathname + (reqUrlObj.searchParams.toString() ? "?" + reqUrlObj.searchParams.toString() : "");
+  }
+  get reqReadable() {
+    return this.req.readable;
+  }
+  get reqIntent() {
+    return new Intent(this.reqPathSearchParamUrl);
+  }
+  reqHasContentTypeHeader(mime) {
+    return (this.reqHeaderFirst("Content-Type" /* ContentType */) ?? "").toLowerCase().indexOf(mime.toLocaleLowerCase()) > -1;
+  }
+  reqHasAcceptHeader(mime) {
+    return (this.reqHeaderFirst("Accept" /* Accept */) ?? "").toLowerCase().indexOf(mime.toLocaleLowerCase()) > -1;
+  }
+  reqBodyData() {
+    return new Promise((resolve, reject) => {
+      if (this.reqReadable) {
+        const data = [];
+        this.req.on("data", (chunk) => data.push(chunk));
+        this.req.on("error", (err) => reject(err));
+        this.req.on("end", () => {
+          this.reqBodyChunk = Buffer.concat(data);
+          resolve(this.reqBodyChunk);
+        });
+      } else {
+        resolve(this.reqBodyChunk ?? Buffer.alloc(0));
+      }
+    });
+  }
+  resBodyData() {
+    return this.resWriteChunk;
+  }
+  async reqBodyMultipartFormDataObject() {
+    const m = await this.reqBodyMultipartFormData();
+    const formData = {};
+    for (const it of m) {
+      if (it.isFile) {
+        formData[it.name] = await FileUtils.writeFile(it.value, { originalName: it.filename });
+      } else {
+        const target = formData[it.name];
+        if (Array.isArray(target)) {
+          target.push(it.value);
+        } else if (typeof target === "string") {
+          formData[it.name] = [target, it.value];
+        } else {
+          formData[it.name] = it.value;
+        }
+      }
+    }
+    ;
+    return formData;
+  }
+  reqBodyMultipartFormData() {
+    return new Promise((resolve, reject) => {
+      const contentTypeHeader = this.req.headers["content-type"];
+      if (!contentTypeHeader || !contentTypeHeader.startsWith("multipart/form-data")) {
+        return reject(new Error("Invalid Content-Type. Expected multipart/form-data."));
+      }
+      const boundaryMatch = contentTypeHeader.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+      if (!boundaryMatch) {
+        return reject(new Error("Boundary not found in Content-Type header."));
+      }
+      const boundary = boundaryMatch[1] || boundaryMatch[2];
+      if (!boundary) {
+        return reject(new Error("Failed to extract boundary."));
+      }
+      const boundaryBuffer = Buffer.from(`--${boundary}`);
+      const crlfBuffer = Buffer.from("\r\n");
+      const doubleCrlfBuffer = Buffer.from("\r\n\r\n");
+      const chunks = [];
+      let totalLength = 0;
+      this.req.on("data", (chunk) => {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+      });
+      this.req.on("error", (err) => {
+        reject(err);
+      });
+      this.req.on("end", () => {
+        if (totalLength === 0) {
+          return resolve([]);
+        }
+        const fullBuffer = Buffer.concat(chunks, totalLength);
+        const parsedParts = [];
+        let currentPosition = 0;
+        let boundaryStartIndex = fullBuffer.indexOf(boundaryBuffer, currentPosition);
+        if (boundaryStartIndex === -1) {
+          return reject(new Error("Initial boundary not found."));
+        }
+        currentPosition = boundaryStartIndex + boundaryBuffer.length;
+        if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+          currentPosition += crlfBuffer.length;
+        }
+        while (currentPosition < fullBuffer.length) {
+          const nextBoundaryIndex = fullBuffer.indexOf(boundaryBuffer, currentPosition);
+          if (nextBoundaryIndex === -1) {
+            break;
+          }
+          let partEndIndex = nextBoundaryIndex;
+          if (partEndIndex > crlfBuffer.length && fullBuffer.slice(partEndIndex - crlfBuffer.length, partEndIndex).equals(crlfBuffer)) {
+            partEndIndex -= crlfBuffer.length;
+          }
+          const partBuffer = fullBuffer.slice(currentPosition, partEndIndex);
+          const headerBodySeparatorIndex = partBuffer.indexOf(doubleCrlfBuffer);
+          if (headerBodySeparatorIndex === -1) {
+            console.warn("Skipping malformed part: no header/body separator found.");
+            currentPosition = nextBoundaryIndex + boundaryBuffer.length;
+            if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+              currentPosition += crlfBuffer.length;
+            }
+            if (fullBuffer.slice(currentPosition, currentPosition + 2).toString() === "--") break;
+            continue;
+          }
+          const headerBuffer = partBuffer.slice(0, headerBodySeparatorIndex);
+          const bodyBuffer = partBuffer.slice(headerBodySeparatorIndex + doubleCrlfBuffer.length);
+          const headersStr = headerBuffer.toString("utf-8");
+          const headers = {};
+          headersStr.split("\r\n").forEach((line) => {
+            const colonIndex = line.indexOf(":");
+            if (colonIndex > 0) {
+              const key = line.substring(0, colonIndex).trim().toLowerCase();
+              const value = line.substring(colonIndex + 1).trim();
+              headers[key] = value;
+            }
+          });
+          const contentDisposition = headers["content-disposition"];
+          if (!contentDisposition) {
+            console.warn("Skipping part: no Content-Disposition header.");
+            currentPosition = nextBoundaryIndex + boundaryBuffer.length;
+            if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+              currentPosition += crlfBuffer.length;
+            }
+            if (fullBuffer.slice(currentPosition, currentPosition + 2).toString() === "--") break;
+            continue;
+          }
+          const nameMatch = contentDisposition.match(/name="([^"]+)"/i);
+          const filenameMatch = contentDisposition.match(/filename="([^"]+)"/i);
+          const name = nameMatch ? nameMatch[1] : null;
+          const filename = filenameMatch ? filenameMatch[1] : null;
+          const contentType = headers["content-type"] || null;
+          if (name) {
+            const isFile = !!filename;
+            const multipartData = {
+              name,
+              isFile,
+              // filename이 있으면 파일로 간주
+              filename,
+              contentType,
+              value: isFile ? bodyBuffer : bodyBuffer.toString("utf-8")
+            };
+            parsedParts.push(multipartData);
+          } else {
+            console.warn("Skipping part: 'name' not found in Content-Disposition.");
+          }
+          currentPosition = nextBoundaryIndex + boundaryBuffer.length;
+          if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+            currentPosition += crlfBuffer.length;
+          }
+          if (fullBuffer.slice(currentPosition, currentPosition + 2).toString() === "--") {
+            break;
+          }
+        }
+        resolve(parsedParts);
+      });
+    });
+  }
+  async reqBodyStringData() {
+    const data = (await this.reqBodyData()).toString();
+    return data;
+  }
+  async reqBodyJsonData() {
+    return JSON.parse(await this.reqBodyStringData());
+  }
+  async reqBodyFormUrlData() {
+    const data = await this.reqBodyStringData();
+    const formData = {};
+    Array.from(new URLSearchParams(data).entries()).forEach(([k, v]) => {
+      const target = formData[k];
+      if (Array.isArray(target)) {
+        target.push(v);
+      } else if (typeof target === "string") {
+        formData[k] = [target, v];
+      } else {
+        formData[k] = v;
+      }
+    });
+    return formData;
+  }
+  async reqBodyReqFormUrlBody() {
+    const data = await this.reqBodyFormUrlData();
+    return Object.assign(new ReqFormUrlBody(), data);
+  }
+  async reqBodyReqJsonBody() {
+    const data = await this.reqBodyStringData();
+    return Object.assign(new ReqJsonBody(), data ? JSON.parse(data) : {});
+  }
+  // reqBodyReqMultipartFormBody(): Promise<ReqMultipartFormBody> {
+  //   return this.reqBodyMultipartFormData().then(it => new ReqMultipartFormBody(it))
+  // }
+  resBodyJsonData() {
+    const data = ConvertUtils.toString(this.resBodyData());
+    return data ? JSON.parse(data) : null;
+  }
+  resBodyStringData() {
+    return ConvertUtils.toString(this.resBodyData());
+  }
+  reqMethod() {
+    return this.req.method?.toUpperCase();
+  }
+  reqHeader(key) {
+    return this.req.headers[key.toLowerCase()];
+  }
+  get reqHost() {
+    return this.reqHeaderFirst("Host" /* Host */);
+  }
+  get reqHeaderObj() {
+    const h = new ReqHeader();
+    Object.entries(this.req.headers).forEach(([k, v]) => {
+      h[k] = v;
+    });
+    return h;
+  }
+  reqHeaderFirst(key, defaultValue) {
+    const header = this.req.headers[key.toLowerCase()];
+    if (header && Array.isArray(header)) {
+      return header[0] ?? defaultValue;
+    } else {
+      return header ?? defaultValue;
+    }
+  }
+  reqAuthorizationHeader() {
+    return this.reqHeaderFirst("Authorization" /* Authorization */);
+  }
+  reqRefreshTokenHeader() {
+    return this.reqHeaderFirst("Authorization" /* Authorization */);
+  }
+  // eslint-disable-next-line no-dupe-class-members
+  resStatusCode(code) {
+    if (code) {
+      this.res.statusCode = code;
+      return new RequestResponseChain(this.req, this.res, this.config, this.res.statusCode);
+    } else {
+      return this.res.statusCode;
+    }
+  }
+  resHeader(key) {
+    return this.res.getHeader(key.toLowerCase());
+  }
+  resHeaderFirst(key, defaultValue) {
+    const header = this.res.getHeader(key.toLowerCase());
+    if (header && Array.isArray(header)) {
+      return header[0] ?? defaultValue;
+    } else {
+      return header ?? defaultValue;
+    }
+  }
+  async reqSession() {
+    if (this.config.sessionManager) {
+      return (await this.config.sessionManager.session(this)).dataSet.data;
+    } else {
+      return Promise.reject(new Error("Not SessionManager"));
+    }
+  }
+  reqSessionSet(key, value) {
+    this.reqSession[key] = value;
+  }
+  reqSessionGet(key) {
+    const session = this.reqSession;
+    if (session) {
+      return session[key];
+    }
+  }
+  resSetStatusCode(statusCode) {
+    this.res.statusCode = statusCode;
+    return this.createRequestResponseChain(this.res.statusCode);
+  }
+  // resEnd() {
+  //     this.res.end();
+  // }
+  // eslint-disable-next-line no-undef
+  resWrite(chunk, encoding = "utf8") {
+    this.resWriteChunk = chunk;
+    return this.createRequestResponseChain(this.resWriteChunk);
+  }
+  // eslint-disable-next-line no-undef
+  resWriteJson(chunk, encoding = "utf8") {
+    return this.resWrite(JSON.stringify(chunk), encoding);
+  }
+  resSetHeader(key, value) {
+    return this.createRequestResponseChain(this.res.setHeader(key.toLowerCase(), value));
+  }
+  resAddHeader(key, value) {
+    const existingValue = this.res.getHeader(key.toLowerCase());
+    const newValue = Array.isArray(existingValue) ? existingValue.concat(value) : existingValue ? [existingValue.toString(), ...[].concat(value)] : value;
+    return this.createRequestResponseChain(this.res.setHeader(key.toLowerCase(), newValue));
+  }
+  resSetHeaders(headers) {
+    Object.entries(headers).forEach(([key, value]) => this.resSetHeader(key, value));
+    return this.createRequestResponseChain();
+  }
+  resAddHeaders(headers) {
+    Object.entries(headers).forEach(([key, value]) => this.resAddHeader(key, value));
+    return this.createRequestResponseChain();
+  }
+  // 마지막 종료될때 타는거.
+  async resEndChunk() {
+    const encoding = this.reqHeaderFirst("Accept-Encoding" /* AcceptEncoding */);
+    let data = this.resWriteChunk;
+    if (encoding?.includes("gzip")) {
+      data = await gzip(data);
+      this.resSetHeader("Content-Encoding" /* ContentEncoding */, "gzip");
+    }
+    this.res.end(data);
+  }
+  async resEnd(chunk) {
+    this.resWriteChunk = chunk ?? this.resWriteChunk;
+    if (this.req.readable) {
+      await this.reqBodyData();
+      await this.resEndChunk();
+    } else {
+      await this.resEndChunk();
+    }
+  }
+  // writeContinue(callback?: () => void) {
+  //     this.res.writeContinue(callback);
+  //     return new RequestResponseChain(this.req, this.res);
+  // }
+  // reqWrite(chunk?: any) {
+  //     this.resWriteChunk = chunk;
+  //     // this.res.write(chunk);
+  //     return this.createRequestResponseChain();
+  // }
+  resWriteHead(statusCode, headers) {
+    return this.createRequestResponseChain(this.res.writeHead(statusCode, headers));
+  }
+  resWriteHeadEnd(statusCode, headers) {
+    this.createRequestResponseChain(this.res.writeHead(statusCode, headers));
+    this.res.end();
+  }
+  resIsDone() {
+    return this.res.finished || this.res.writableEnded || this.res.headersSent;
+  }
+  createRequestResponseChain(data) {
+    const requestResponseChain = new RequestResponseChain(this.req, this.res, this.config, data);
+    requestResponseChain.resWriteChunk = this.resWriteChunk;
+    requestResponseChain.reqBodyChunk = this.reqBodyChunk;
+    return requestResponseChain;
+  }
+  // res.on("readable", () => {
+  //     console.log('readable???')
+  // });
+  // res.on('complete', function (details) {
+  //     var size = details.req.bytes;
+  //     console.log('complete-->', size)
+  // });
+  // res.on('finish', function() {
+  //     console.log('finish??');
+  // });
+  // res.on('end', () => {
+  //     console.log('end--?')
+  // });
+};
+var RequestResponseChain = class extends RequestResponse {
+  constructor(req, res, config, result) {
+    super(req, res, config);
+    this.result = result;
+  }
+};
+
+// src/session/SessionManager.ts
+var SessionManager = class {
+  constructor(option) {
+    this.option = option;
+    this.sessions = /* @__PURE__ */ new Map();
+    this.sessionOption = option.sessionOption;
+    setInterval(async () => {
+      const uuids = await this.getSessionUUIDs();
+      for (const uuid of uuids) {
+        const dataSet = await this.getSessionDataSet(uuid);
+        if (dataSet && this.isExpired(dataSet.access)) {
+          await this.deleteSession(uuid);
+        }
+      }
+    }, this.sessionOption.expiredTime);
+  }
+  async getSessionUUIDs() {
+    if (this.sessionOption.provider?.uuids) {
+      return this.sessionOption.provider.uuids();
+    } else {
+      return Array.from(this.sessions.keys());
+    }
+  }
+  async deleteSession(uuid) {
+    if (this.sessionOption.provider?.delete) {
+      this.sessionOption.provider.delete(uuid);
+    } else {
+      this.sessions.delete(uuid);
+    }
+  }
+  async getSessionDataSet(uuid) {
+    if (this.sessionOption.provider?.get) {
+      return this.sessionOption.provider.get(uuid);
+    } else {
+      return this.sessions.get(uuid);
+    }
+  }
+  async setSessionDataSet(uuid, dataSet) {
+    if (this.sessionOption.provider?.set) {
+      this.sessionOption.provider.set(uuid, dataSet);
+    } else {
+      this.sessions.set(uuid, dataSet);
+    }
+  }
+  isExpired(access, now = Date.now()) {
+    return now - access >= this.option.sessionOption.expiredTime;
+  }
+  makeUUID() {
+    return RandomUtils.uuid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+  }
+  async session(rrOrUUID) {
+    let uuid;
+    if (rrOrUUID instanceof RequestResponse) {
+      uuid = rrOrUUID.reqCookieGet(this.sessionOption.key) ?? this.makeUUID();
+    } else if (typeof rrOrUUID === "string") {
+      uuid = rrOrUUID;
+    } else {
+      uuid = this.makeUUID();
+    }
+    let dataSet = await this.getSessionDataSet(uuid);
+    const now = Date.now();
+    if (dataSet) {
+      if (this.isExpired(dataSet.access, now)) {
+        delete dataSet.data;
+      }
+      dataSet.access = now;
+    } else {
+      dataSet = {
+        access: now
+      };
+    }
+    await this.setSessionDataSet(uuid, dataSet);
+    return { uuid, dataSet };
+  }
+};
+export {
+  SessionManager
+};
+//# sourceMappingURL=SessionManager.js.map