@dnax/core 0.2.7 → 0.2.9

package/app/hono.ts

@@ -43,13 +43,17 @@ function HonoInstance(): typeof app {
       c.set("isStudio", isStudio(secretKeyStudio));
       c.set("_v", {
         token: token || null,
-        ip: c.req.raw.headers.get("CF-Connecting-IP"),
-        isAuth: decode?._v?.isAuth ? true : false,
+        ip:
+          c.req.raw.headers?.get("CF-Connecting-IP") ||
+          c.req.raw.headers?.get("x-forwarded-for") ||
+          c.req.raw.headers?.get("x-real-ip"),
+        isAuth: valid ? true : false,
       });
       c.set("tenant-id", c.req.header()["tenant-id"]);
       if (token && valid) {
         session.set({
-          state: decode,
+          state: decode?.state || {},
+          access: decode?.access || {},
           _v: c.var?._v || {},
           token: token,
         });
@@ -278,7 +282,7 @@ function HonoInstance(): typeof app {
               return c.json({
                 auth: true,
                 data: responseAuth,
-                token: jwt.sign(sessionStorage().get().state),
+                token: sessionStorage().get().token,
               });
             } else {
               c.status(401);

package/driver/mongo/rest.ts

@@ -298,7 +298,7 @@ class useRest {
             }),
           });
         }
-        return resolve(data);
+        return resolve(toJson(data));
       } catch (err) {
         return reject(err);
       }
@@ -659,7 +659,7 @@ class useRest {
           update.$set = transformAllDate(update.$set);
           update.$set = await hashPasswordAuto(update.$set, col);
           //   data = transformAllDate(data);
-          // data = deepSetId(col, data);
+          //update.$set = deepSetId(col, update.$set);
           var { valid, output, error } = this.validator(
             collection,
             update.$set,

package/lib/asyncLocalStorage.ts

@@ -1,5 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { sessionCtx } from "../types";
+import { jwt } from "../utils";
 const asyncLocalStorage = new AsyncLocalStorage();
 const key = "___sessionStorage___";
 const stateKey = "____requestState____";
@@ -7,7 +8,23 @@ const sessionStorage = () => ({
   get(): { state: object; _v: object; token: string } {
     let store = asyncLocalStorage.getStore() as InstanceType<typeof Map>;
     return (
-      (store.get(key) as { state: object; _v: object; token: string }) || {
+      (store.get(key) as {
+        state: object;
+        _v: object;
+        token: string;
+        access: {
+          aggreate?: boolean;
+          find?: boolean;
+          findOne?: boolean;
+          insertOne?: boolean;
+          insertMany?: boolean;
+          updateOne?: boolean;
+          updateMany?: boolean;
+          deleteOne?: boolean;
+          deleteMany?: boolean;
+          upload?: boolean;
+        };
+      }) || {
         state: {},
         _v: {},
         token: "",
@@ -15,20 +32,41 @@ const sessionStorage = () => ({
     );
   },
   set(
-    input: { state: object; _v?: object; token?: string | undefined | null } = {
+    input: {
+      state: object;
+      _v?: object;
+      token?: string | undefined | null;
+      access?: {
+        aggreate?: boolean;
+        find?: boolean;
+        findOne?: boolean;
+        insertOne?: boolean;
+        insertMany?: boolean;
+        updateOne?: boolean;
+        updateMany?: boolean;
+        deleteOne?: boolean;
+        deleteMany?: boolean;
+        upload?: boolean;
+      };
+    } = {
       state: {},
       _v: {},
-      token: null,
+      // token: null,
     }
   ) {
     let store = asyncLocalStorage.getStore() as InstanceType<typeof Map>;
+    let generateToken = jwt.sign({
+      state: input.state,
+      access: input?.access || {},
+    });
     store.set(key, {
       ...this.get(),
       state: {
         ...this.get().state,
         ...input.state,
       },
-      token: input.token || this.get().token,
+      access: input?.access || {},
+      token: generateToken,
     });
   },
 });

package/lib/schema.ts

@@ -50,7 +50,12 @@ function buildSchema(col: Collection) {
     }
 
     if (f?.type == "relationship") {
-      propertySchema[f.name] = v.string().optional();
+      propertySchema[f.name] = v
+        .string()
+        .optional()
+        .messages({
+          "string.base": `${f.name} must be ObjectId or String`,
+        });
     }
 
     if (f?.type == "relationship" && f.relation?.hasMany) {

package/package.json

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

package/types/index.ts

@@ -158,7 +158,23 @@ export type accessCtx = (ctx: {
 }) => boolean | undefined | void | Promise<any>;
 
 export type sessionCtx = {
-  set: (session: { state: object | any; token?: string; _v?: object }) => void;
+  set: (session: {
+    state: object | any;
+    token?: string;
+    _v?: object;
+    access?: {
+      aggreate?: boolean;
+      find?: boolean;
+      findOne?: boolean;
+      insertOne?: boolean;
+      insertMany?: boolean;
+      updateOne?: boolean;
+      updateMany?: boolean;
+      deleteOne?: boolean;
+      deleteMany?: boolean;
+      upload?: boolean;
+    };
+  }) => void;
   get: () => { state: object; _v: object };
 };
 

package/utils/index.ts

@@ -31,7 +31,9 @@ const jwt = {
   getToken: (prefix = "Bearer", input: string): string | null => {
     if (input?.startsWith(prefix)) {
       let token = input?.slice(prefix?.length + 1);
-      if (!token || token?.replace(/\s/g, "") === "") return null;
+      let getToken = (token as string) || null;
+      if (!token || token?.replace(/\s/g, "") === "") getToken = null;
+      return getToken;
     } else {
       return null;
     }