@dnax/core 0.16.4 → 0.16.6

package/app/hono.ts

@@ -92,14 +92,10 @@ function HonoInstance(): typeof app {
       var token = jwt.getToken("Bearer", c.req.header()["authorization"]) || "";
       var { decode, valid, error } = jwt.verify(token);
       let sessionData = {};
-      if (valid && decode) {
-        await localSession
-          .get(decode?.sessionId)
-          .then((data) => {
-            //console.log("Data", data);
-            sessionData = data;
-          })
-          .catch();
+      if (valid && decode && decode?.session) {
+        sessionData = decode?.session;
+      } else {
+        // console.log("No valid token", error);
       }
 
       let _v = {
@@ -107,7 +103,10 @@ function HonoInstance(): typeof app {
         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"),
+          c.req.raw.headers?.get("x-real-ip") ||
+          c.req.raw.headers?.get("remoteaddr") ||
+          "::1",
+
         isAuth: valid ? true : false,
         reqAt: moment().format().toString(),
         setAt: sessionData?._v?.setAt || null,
@@ -115,6 +114,8 @@ function HonoInstance(): typeof app {
       c.set("_v", _v);
       c.set("tenant-id", c.req.header()["tenant-id"]);
 
+      //console.log("_v", _v);
+
       if (token && valid) {
         session.set({
           generateToken: false,
@@ -340,12 +341,42 @@ function HonoInstance(): typeof app {
               responseAuth !== null &&
               responseAuth
             ) {
+              rest.activity.save({
+                collection: collection,
+                data: {
+                  input: body,
+                },
+                action: "authCollection",
+                auth: true,
+                user: sessionStorage().get().state?.user,
+                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") ||
+                  c.req.raw.headers?.get("remoteaddr") ||
+                  "::1",
+              });
               return c.json({
                 auth: true,
                 data: responseAuth,
                 token: sessionStorage().get().token,
               });
             } else {
+              rest.activity.save({
+                collection: collection,
+                data: {
+                  input: body,
+                },
+                action: "authCollection",
+                auth: false,
+                user: sessionStorage().get().state?.user,
+                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") ||
+                  c.req.raw.headers?.get("remoteaddr") ||
+                  "::1",
+              });
               c.status(401);
               return c.json({ message: "Authentification failed" });
             }

package/driver/mongo/rest.ts

@@ -75,6 +75,23 @@ class useRest {
   Direct Api Mongo , use it with caution
    */
   db: Tenant["database"]["db"];
+  activity: {
+    save?: (activity: {
+      collection?: string;
+      data: {
+        input: any;
+      };
+      action: string;
+      ip?: string;
+      user?: object;
+    }) => Promise<any>;
+    list?: (filter?: {
+      $match: {};
+      $limit?: number;
+      $sort?: {};
+      $skip?: number;
+    }) => Promise<Array<any>>;
+  };
 
   constructor(options: options) {
     this.#c = options.c;
@@ -85,6 +102,18 @@ class useRest {
     this.#useHook = options?.useHook ?? true;
     this.db = this.#tenant.database.db;
 
+    this.activity = {
+      save: async (activityInput) => {
+        return await restActivity.save(this.#tenant, activityInput);
+      },
+      list: async (activityFilter) => {
+        return await restActivity
+          .list(this.#tenant, activityFilter || {})
+          .then((e) => e)
+          .catch((err) => []);
+      },
+    };
+
     /*  if (options?.useHook == undefined || options?.useHook == null) {
       this.#useHook = true;
     } else {
@@ -335,6 +364,18 @@ class useRest {
             }),
           });
         }
+        restActivity.save(this.#tenant, {
+          collection: collection,
+          data: {
+            input: data,
+          },
+          transaction: this.#session ? true : false,
+          action: "insertOne",
+          user:
+            sessionStorage().get().state?.user ||
+            sessionStorage().get().state?.by ||
+            null,
+        });
         return resolve(toJson(data));
       } catch (err) {
         return reject(err);
@@ -442,6 +483,18 @@ class useRest {
             }),
           });
         }
+        restActivity.save(this.#tenant, {
+          collection: collection,
+          data: {
+            input: toJson(data),
+          },
+          action: "insertMany",
+          transaction: this.#session ? true : false,
+          user:
+            sessionStorage().get().state?.user ||
+            sessionStorage().get().state?.by ||
+            null,
+        });
 
         return resolve(toJson(data));
       } catch (err) {
@@ -492,6 +545,7 @@ class useRest {
    * @param params - Find params
    * @param options
    */
+
   async find(
     collection: string,
     params: findParam,
@@ -835,6 +889,20 @@ class useRest {
           });
         }
 
+        restActivity.save(this.#tenant, {
+          collection: collection,
+          data: {
+            input: update,
+            id: id,
+            ids: [id],
+          },
+          transaction: this.#session ? true : false,
+          action: "updateOne",
+          user:
+            sessionStorage().get().state?.user ||
+            sessionStorage().get().state?.by ||
+            null,
+        });
         return resolve(result.doc);
       } catch (err) {
         return reject(err);
@@ -1098,7 +1166,19 @@ class useRest {
               }),
             });
           }
-
+          restActivity.save(this.#tenant, {
+            collection: collection,
+            data: {
+              input: update,
+              ids: ids,
+            },
+            action: "updateMany",
+            transaction: this.#session ? true : false,
+            user:
+              sessionStorage().get().state?.user ||
+              sessionStorage().get().state?.by ||
+              null,
+          });
           return resolve(result.docs);
         } else {
           throw new contextError("List of id required", 400);
@@ -1194,7 +1274,20 @@ class useRest {
             }),
           });
         }
-
+        restActivity.save(this.#tenant, {
+          collection: collection,
+          data: {
+            input: doc,
+            id: id,
+            ids: [id],
+          },
+          transaction: this.#session ? true : false,
+          action: "deleteOne",
+          user:
+            sessionStorage().get().state?.user ||
+            sessionStorage().get().state?.by ||
+            null,
+        });
         return resolve(doc);
       } catch (err) {
         return resolve(err);
@@ -1288,6 +1381,20 @@ class useRest {
           });
         }
 
+        restActivity.save(this.#tenant, {
+          collection: collection,
+          data: {
+            input: null,
+            ids: ids,
+          },
+          transaction: this.#session ? true : false,
+          action: "deleteMany",
+          user:
+            sessionStorage().get().state?.user ||
+            sessionStorage().get().state?.by ||
+            null,
+        });
+
         return resolve(deletedIds);
       } catch (err) {
         return reject(err);
@@ -1301,7 +1408,23 @@ class useRest {
       .estimatedDocumentCount();
   }
   async dropCollection(Collection: string) {
-    return await this.#tenant.database.db?.collection(Collection).drop();
+    return new Promise(async (resolve, reject) => {
+      try {
+        let r = await this.#tenant.database.db?.collection(Collection).drop();
+        restActivity.save(this.#tenant, {
+          collection: Collection,
+          data: {},
+          action: "dropCollection",
+          user:
+            sessionStorage().get().state?.user ||
+            sessionStorage().get().state?.by ||
+            null,
+        });
+        return resolve(r);
+      } catch (err) {
+        return reject(err);
+      }
+    });
   }
 
   async dropIndexes(Collection: string) {
@@ -1344,4 +1467,57 @@ class useRest {
   }
 }
 
+const restActivity = {
+  list: async (
+    tenant: Tenant,
+    filter?: {
+      $match?: {};
+      $limit?: number;
+      $sort?: {};
+      $skip?: number;
+    }
+  ) => {
+    return await tenant.database.db
+      ?.collection("___activity__")
+      .find({
+        ...filter?.$match,
+      })
+      .limit(filter?.$limit || 100)
+      .sort({ createdAt: -1, ...filter?.$sort })
+      .skip(filter?.$skip || 0)
+      .toArray()
+      .catch((err) => []);
+  },
+  save: async (
+    tenant: Tenant,
+    activity: {
+      collection?: string;
+      data: any;
+      action: string;
+      ip?: string;
+      user?: object;
+      transaction?: boolean;
+      auth?: boolean;
+    }
+  ) => {
+    return await tenant.database.db
+      ?.collection("___activity__")
+      .insertOne(
+        toBson({
+          ip: activity?.ip,
+          tenant: tenant.id,
+          data: activity?.data || {},
+          action: activity.action,
+          collection: activity?.collection,
+          auth: activity?.auth ?? false,
+          createdAt: moment().format(),
+          updatedAt: moment().format(),
+          user: activity?.user,
+          transaction: activity?.transaction ?? false,
+        })
+      )
+      .catch();
+  },
+};
+
 export { useRest };

package/lib/asyncLocalStorage.ts

@@ -39,26 +39,15 @@ const sessionStorage = () => ({
       id: "",
       state: {},
       _v: {},
-      generateToken: true,
     }
   ): any {
-    input.generateToken = input?.generateToken ?? true;
     let store = asyncLocalStorage.getStore() as InstanceType<typeof Map>;
     if (!input?.id) {
       input.id = v4();
     }
 
-    if (input?.generateToken) {
-      input.token =
-        input.token ||
-        jwt.sign(input.id, {
-          expiresIn: input?.expiresIn || "7d",
-        });
-    }
-
     let data = {
-      token: input?.token || null,
-      state: input?.state,
+      state: input?.state || {},
       role: input?.role || null,
       _v: {
         ...(input?._v || {}),
@@ -66,11 +55,28 @@ const sessionStorage = () => ({
       },
     };
 
-    if (input?.generateToken) {
-      localSession.set(input?.id, data);
-    }
+    input.token =
+      input.token ||
+      jwt.sign(
+        {
+          id: input.id,
+          state: input?.state,
+          role: input?.role || null,
+          _v: {
+            ...(input?._v || {}),
+            setAt: new Date().toString(),
+          },
+        },
+        {
+          expiresIn: input?.expiresIn || "7d",
+        }
+      );
+
+    store.set(key, {
+      ...data,
+      token: input.token,
+    });
 
-    store.set(key, data);
     return {
       state: input.state,
       _v: input._v,

package/package.json

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

package/tsconfig.json

@@ -10,6 +10,8 @@
     "moduleDetection": "force",
     "jsx": "react-jsx",
     "allowJs": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     // Bundler mode
     "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,

package/types/index.ts

@@ -162,14 +162,20 @@ export type accessCtx = (ctx: {
 
 export type sessionCtx = {
   set: (session: {
-    state: object | any;
+    state: {
+      [key: string]: any;
+      user?: object;
+    };
     token?: string;
     _v?: object;
     role?: string | null | undefined;
     expiresIn?: string;
   }) => void;
   get: () => {
-    state: object;
+    state: {
+      [key: string]: any;
+      user?: object;
+    };
     _v: object;
     role: string | null | undefined;
     token: string | null | undefined;

package/utils/index.ts

@@ -59,7 +59,7 @@ const jwt = {
   ) => {
     // console.log("payload", payload, options);
 
-    return jwto.sign({ sessionId: payload }, JWT_SECRET, {
+    return jwto.sign({ session: payload }, JWT_SECRET, {
       ...options,
     });
   },
@@ -98,9 +98,14 @@ function isDate(date: string): boolean {
   const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
   const dateRegex2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
   const dateRegex3 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/;
+  // le regex pour cette forme 2024-11-30T21:36:12+00:00
+  const dateRegex4 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2}$/;
   let isDate_ =
     !isNaN(Date.parse(date)) &&
-    (dateRegex.test(date) || dateRegex2.test(date) || dateRegex3.test(date));
+    (dateRegex.test(date) ||
+      dateRegex2.test(date) ||
+      dateRegex4.test(date) ||
+      dateRegex3.test(date));
   if (isDate_) return true;
   try {
     isDate_ = moment(date, "YYYY-MM-DD", true).isValid();