@dnax/core 0.16.3 → 0.16.5

package/app/hono.ts

@@ -107,7 +107,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 +118,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 +345,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/socket/instance.ts

@@ -75,9 +75,9 @@ function webSocketServer(server: Server): WebSocketHandler {
       let id = v4();
       ws.id = id;
       wsClients.set(id, ws);
+
       // set Id to client and emit it
       ws.send(JSON.stringify({ type: "setId", id: id }));
-
       // run all listenners event for connection
       let evs = wsEvents.filter(
         (e) => e.type == "on" && e?.event == "connection"
@@ -113,13 +113,15 @@ function webSocketServer(server: Server): WebSocketHandler {
           );
         }
       });
+
+      wsClients?.delete(ws.id);
       // console.log("close", code, reason);
       // console.log(ws.id);
     },
     message: (ws, message: any) => {
       try {
         let options: optionsIo = JSON.parse(message);
-        //console.log(options);
+
         // find all listeners : On
         let evs = wsEvents.filter(
           (e) => e.event == options?.event && e?.type == "on"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.16.3",
+  "version": "0.16.5",
   "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

@@ -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();