@dnax/core 0.9.8 → 0.10.1

package/app/hono.ts

@@ -10,6 +10,7 @@ import { serveStatic, getConnInfo } from "hono/bun";
 import { consola } from "consola";
 import { cors } from "hono/cors";
 import { asyncLocalStorage, sessionStorage } from "../lib/asyncLocalStorage";
+import { localSession } from "../lib/session";
 import {
   cleanPath,
   contextError,
@@ -150,10 +151,16 @@ function HonoInstance(): typeof app {
       let session = sessionStorage();
       var token = jwt.getToken("Bearer", c.req.header()["authorization"]) || "";
       var { decode, valid, error } = jwt.verify(token);
-      if (valid && decode?.studio) {
-        // FIX STUDIO INFO
-        c.set("_STUDIO_SECRET_KEY_", secretKeyStudio);
-        c.set("isStudio", isStudio(secretKeyStudio));
+      let sessionData = {};
+
+      if (valid && decode) {
+        await localSession
+          .get(decode?.sessionId)
+          .then((data) => {
+            //console.log("Data", data);
+            sessionData = data;
+          })
+          .catch();
       }
 
       let _v = {
@@ -164,21 +171,23 @@ function HonoInstance(): typeof app {
           c.req.raw.headers?.get("x-real-ip"),
         isAuth: valid ? true : false,
         reqAt: moment().format().toString(),
-        setAt: decode?._v?.setAt || null,
+        setAt: sessionData?._v?.setAt || null,
       };
       c.set("_v", _v);
       c.set("tenant-id", c.req.header()["tenant-id"]);
 
       if (token && valid) {
         session.set({
-          // token: token,
-          state: decode?.state || {},
-          role: decode?.role || null,
+          generateToken: false,
+          token: token,
+          state: sessionData?.state || {},
+          role: sessionData?.role || null,
           _v: { ...(_v || {}) },
         });
       } else {
         // no valid token
         session.set({
+          generateToken: false,
           state: {},
           role: undefined,
           _v: { ...(_v || {}) },

package/lib/asyncLocalStorage.ts

@@ -1,5 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { sessionCtx } from "../types";
+import { localSession } from "./session";
+import { v4 } from "uuid";
 import { jwt } from "../utils";
 const asyncLocalStorage = new AsyncLocalStorage();
 const key = "___sessionStorage___";
@@ -8,8 +10,8 @@ const sessionStorage = () => ({
   get(): {
     state: object;
     _v: object;
-
     role: string | null | undefined;
+    token?: string;
   } {
     let store = asyncLocalStorage.getStore() as InstanceType<typeof Map>;
     return (
@@ -26,35 +28,55 @@ const sessionStorage = () => ({
   },
   set(
     input: {
+      id: string;
       state: object;
       _v?: object;
       role?: string;
-      token?: string | null | undefined;
+      token?: string;
+      expiresIn?: string;
+      generateToken?: boolean;
     } = {
+      id: "",
       state: {},
       _v: {},
-      token: null,
+      generateToken: true,
     }
-  ) {
+  ): any {
+    input.generateToken = input?.generateToken ?? true;
     let store = asyncLocalStorage.getStore() as InstanceType<typeof Map>;
-    let generateToken = jwt.sign({
-      state: input.state,
-      role: input?.role || {},
-    });
+    if (!input?.id) {
+      input.id = v4();
+    }
 
-    store.set(key, {
-      ...this.get(),
-      state: {
-        ...this.get().state,
-        ...input.state,
-      },
+    if (input?.generateToken) {
+      input.token =
+        input.token ||
+        jwt.sign(input.id, {
+          expiresIn: input?.expiresIn || "7d",
+        });
+    }
+
+    let data = {
+      token: input?.token || null,
+      state: input.state,
+      role: input?.role || null,
       _v: {
         ...(input?._v || {}),
         setAt: new Date().toString(),
       },
-      role: input?.role || null,
-      token: generateToken,
-    });
+    };
+
+    if (input?.generateToken) {
+      localSession.set(input?.id, data);
+    }
+    store.set(key, data);
+    return {
+      state: input.state,
+      _v: input._v,
+      role: input.role,
+      token: input.token,
+      id: input.id,
+    };
   },
 });
 

package/lib/bento/index.ts

@@ -1,5 +1,29 @@
 import { BentoCache, bentostore } from "bentocache";
 import { memoryDriver } from "bentocache/drivers/memory";
+import { fileDriver } from "bentocache/drivers/file";
+import { v4 } from "uuid";
+import fs from "fs-extra";
+import path from "path";
+const cacheDirectory = path.join(process.cwd(), "/.cache/system/");
+
+if (!fs?.existsSync(cacheDirectory + "bentocache")) {
+  fs.mkdirSync(cacheDirectory + "bentocache", {
+    recursive: true,
+  });
+}
+const systemCache = new BentoCache({
+  default: "systemCache",
+  stores: {
+    systemCache: bentostore().useL2Layer(
+      fileDriver({
+        directory: cacheDirectory,
+        pruneInterval: "1h",
+        //maxSize: 100 * 1024 * 1024,
+      })
+    ),
+  },
+});
+
 const bentoCache = new BentoCache({
   default: "dnaxCache",
   stores: {
@@ -27,4 +51,6 @@ function bentoKey(data: object | string) {
   return key;
 }
 
-export { bentoCache, bentoKey };
+const sessionCache = systemCache.namespace("tokens");
+
+export { bentoCache, bentoKey, systemCache, sessionCache };

package/lib/session/index.ts

@@ -0,0 +1,28 @@
+import { v4 } from "uuid";
+import { sessionCache } from "../bento";
+
+const localSession = {
+  get: async (id: string) => {
+    return await sessionCache.get(id);
+  },
+  set: (
+    id: string,
+    data: object,
+    options = {
+      ttl: "7d",
+    }
+  ) => {
+    sessionCache.set({
+      key: id,
+      value: data,
+      //  ttl: "1m",
+      ttl: options?.ttl || "7d",
+    });
+
+    return {
+      data: data,
+    };
+  },
+};
+
+export { localSession };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.9.8",
+  "version": "0.10.1",
   "module": "index.ts",
   "type": "module",
   "bin": {

package/utils/index.ts

@@ -47,7 +47,9 @@ const jwt = {
       expiresIn: "7d",
     }
   ) => {
-    return jwto.sign(payload, JWT_SECRET, {
+    console.log("payload", payload, options);
+
+    return jwto.sign({ sessionId: payload }, JWT_SECRET, {
       ...options,
     });
   },