@dnax/core 0.15.2 → 0.15.4

package/app/hono.ts

@@ -52,78 +52,6 @@ function HonoInstance(): typeof app {
     })
   );
 
-  if (Cfg?.server?.logger) {
-    if (typeof Cfg?.server?.logger == "function" && Cfg?.server?.logger) {
-      app.use(async (c, next) => {
-        const start = Date.now();
-        const { action, collection, cleanDeep, useCache } = c.req.query() as Q;
-        Cfg.server.logger(c, {
-          mode: "incomming",
-          start: start,
-          action: action,
-          collection: collection,
-          cleanDeep: cleanDeep,
-          useCache: stringToBoolean(useCache, false),
-          method: c.req.method,
-          url: c.req.url,
-          path: c.req.path,
-        });
-        await next();
-        const duration = Date.now() - start;
-        Cfg.server.logger(c, {
-          mode: "outgoing",
-          duration,
-          start,
-          action,
-          collection,
-          cleanDeep,
-          useCache: stringToBoolean(useCache, false),
-          method: c.req.method,
-          url: c.req.url,
-          status: c.res.status,
-          path: c.req.path,
-        });
-      });
-    }
-    if (typeof Cfg?.server?.logger == "boolean" && Cfg?.server?.logger) {
-      app.use(async (c, next) => {
-        let 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");
-        const origin =
-          c.req?.header("Origin") || c.req.raw?.headers?.get("Origin") || "";
-        const info = getConnInfo(c);
-        if (c.req.method == "OPTIONS") return await next();
-        const start = Date.now();
-        const { action, collection, cleanDeep, useCache, name } =
-          c.req.query() as Q;
-        // Log the incoming request
-        console.log(
-          `<-- ${ip || info.remote.address} ${origin} | ${c.req.method.gray} ${
-            c.req.path?.gray
-          } -C ${colors.blue(`${collection || ""}`)} -A ${
-            action?.gray || ""
-          } -Sn ${name?.gray || ""} -t ${
-            moment(start).format("YYYY-DD-MM:HH:mm:ss").gray
-          } \n`
-        );
-
-        await next();
-        // Calculate the duration of the request processing
-        const duration = Date.now() - start;
-        console.log(
-          `--> ${ip || info.remote.address} ${origin} | ${c.req.method.gray} ${
-            c.req.path?.gray
-          } -C ${colors.blue(`${collection || ""}`)} -A ${
-            action?.gray || ""
-          } -Sn ${name?.gray || ""} -s ${c.res.status} -d ${colors.green(
-            `(${duration}ms)`
-          )} -t ${moment().format("YYYY-DD-MM:HH:mm:ss").gray} \n`
-        );
-      });
-    }
-  }
   app.use(
     ipRestriction(getConnInfo, {
       allowList: Cfg?.server?.whiteListIps || [],
@@ -160,12 +88,10 @@ function HonoInstance(): typeof app {
   app.use(async (c, next) => {
     return asyncLocalStorage.run(new Map(), async () => {
       let cookie = getCookie(c);
-      let secretKeyStudio = cookie["_STUDIO_SECRET_KEY_"] || null;
       let session = sessionStorage();
       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)

package/lib/cron/index.ts

@@ -22,18 +22,21 @@ async function initCron() {
               let cronTask = new Cron(cronOpt.pattern, {
                 ...cleanDeep(cronOpt.options),
               });
-              cronOpt.handler({
-                io: Cfg.io,
-                rest: new useRest({
+              let cronTaskExec = cronOpt?.exec || cronOpt?.handler;
+              if (cronTaskExec && typeof cronTaskExec == "function") {
+                cronTaskExec({
+                  io: Cfg.io,
+                  rest: new useRest({
+                    tenant_id: t.id,
+                  }),
+                  task: cronTask,
+                });
+                cronTasks.push({
                   tenant_id: t.id,
-                }),
-                task: cronTask,
-              });
-              cronTasks.push({
-                tenant_id: t.id,
-                name: cronOpt.name,
-                cron: cronOpt,
-              });
+                  name: cronOpt.name,
+                  cron: cronOpt,
+                });
+              }
             }
           })
           .catch((err) => {

package/lib/permissions.ts

@@ -15,7 +15,7 @@ async function loadPermissions() {
   let permissions: permissionSchema[] = [];
   if (Cfg.tenants) {
     for await (let t of Cfg.tenants) {
-      let tenantPath = `${t.dir}/permissions/**/**.rabc.{ts,js}`;
+      let tenantPath = `${t.dir}/permissions/**/**.rbac.{ts,js}`;
       const glob = new Glob(tenantPath);
 
       for await (let file of glob.scan({

package/lib/socket/instance.ts

@@ -5,12 +5,21 @@ import { v4 } from "uuid";
 const wsClients = new Map<string, ServerWebSocket>();
 const wsEvents: optionsIo[] = [];
 
+/**
+ * reason for disconnection
+ */
+type reasonType = any;
+export type callbackType = (
+  socket: socketIoType,
+  data: any | reasonType
+) => void;
+
 class Io {
   id: string | null;
   constructor() {
     this.id = null;
   }
-  on(event: string, cb: Function) {
+  on(event: string, cb: callbackType) {
     wsEvents.push({
       type: "on",
       event: event,
@@ -20,7 +29,6 @@ class Io {
   to(id: string) {
     const newInstance = new Io();
     newInstance.id = id;
-
     return newInstance;
   }
   emit(event: string, data: any) {
@@ -55,12 +63,9 @@ export type socketIoType = {
   id: string;
   on: <T extends "connection" | "close" | string>(
     event: T,
-    cb: (socket: {
-      id: string;
-      emit: (event: string, data: any) => void;
-    }) => void
+    cb: callbackType
   ) => void;
-  emit: (event: string, id: string, data: any) => void;
+  emit: (event: string, data: any) => void;
   broadcast: (event: string, data: any) => void;
 };
 
@@ -90,13 +95,31 @@ function webSocketServer(server: Server): WebSocketHandler {
       });
     },
     close(ws, code, reason) {
-      console.log("close", code, reason);
-      console.log(ws.id);
+      // get all closed events
+      let evs = wsEvents.filter((e) => e.event == "close" && e?.type == "on");
+
+      evs.map((ev) => {
+        if (ev && ev.cb) {
+          ev.cb(
+            {
+              id: ws.id,
+              broadcast: (event: string, data: any) => {
+                wsClients.forEach((client) => {
+                  client.send(JSON.stringify({ type: "emit", event, data }));
+                });
+              },
+            },
+            reason
+          );
+        }
+      });
+      // 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"
@@ -104,10 +127,11 @@ function webSocketServer(server: Server): WebSocketHandler {
 
         // run all listeners function if matchs
         evs?.map((ev) => {
-          if (ev && ev.cb) {
-            ev.cb({
-              data: options.data,
-              ws: {
+          ws.token = options?.token || null;
+          if (ev && ev?.cb) {
+            ev.cb(
+              {
+                id: ws.id,
                 broadcast: (event: string, data: any) => {
                   // send to all clients
                   wsClients.forEach((client) => {
@@ -117,12 +141,14 @@ function webSocketServer(server: Server): WebSocketHandler {
                 emit: (event: string, data: any) =>
                   ws.send(JSON.stringify({ type: "emit", event, data })),
               },
-            });
+              options.data
+            );
           }
         });
 
         //wsEvents.on(options.event)
-      } catch (err) {
+      } catch (err: any) {
+        console.log(err?.message);
         //console.log("Not a valid JSON string", err?.message);
       }
     },

package/package.json

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

package/types/index.ts

@@ -123,7 +123,7 @@ export type Field = {
 
 export type cronCtx = {
   rest: InstanceType<typeof useRest>;
-  io: Io;
+  io: socketIoType;
   task: InstanceType<typeof Cron>;
 };
 
@@ -137,7 +137,8 @@ export type cronConfig = {
     stopAt?: Date;
     paused?: Boolean;
   };
-  handler: (ctx: cronCtx) => void;
+  handler?: (ctx: cronCtx) => void;
+  exec?: (ctx: cronCtx) => void;
 };
 
 export type middlewareCtx = (ctx: {
@@ -364,12 +365,19 @@ export type Config = {
   server: {
     logger?: Boolean | loggerFunction;
     whiteListIps?: Array<string>;
-    blackListIps?: Array<string>;
+    blackListIps?: string[];
     cors?: {
-      origin: string[];
+      origin:
+        | string[]
+        | ((ctx: { origin: string; c: Context }) => string[])
+        | string;
+      /**
+       * default true
+       @default true
+       */
       credentials?: boolean;
-      allowMethods?: Array<string>;
-      allowHeaders?: Array<string>;
+      allowMethods?: string[];
+      allowHeaders?: string[];
     };
     socket?: {
       /**