@dnax/core 0.14.0 → 0.14.2

package/app/hono.ts

@@ -10,6 +10,7 @@ import { getCookie, setCookie } from "hono/cookie";
 import colors from "@colors/colors/safe";
 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";
@@ -40,6 +41,7 @@ import { v4 } from "uuid";
 const cache = bentoCache.namespace("DNAX_API");
 const app = new Hono();
 const API_PATH = "/api";
+
 function HonoInstance(): typeof app {
   // Public assets
   app.get(
@@ -364,7 +366,7 @@ function HonoInstance(): typeof app {
       // Exec service
       if (action == "execService") {
         if (!service) return fn.error("Service not found", 404);
-        let fx = service.exec || service.fx;
+        let fx = service?.exec || service?.fx;
         if (fx) {
           response = await fx({
             io: Cfg.io,

package/app/index.ts

@@ -4,9 +4,13 @@ import { init } from "../lib";
 import { hookDatabase } from "../lib/database";
 import killPort from "kill-port";
 import boxen from "boxen";
+import { loadSocket } from "../lib/socket";
+import pidusage from "pidusage";
 import "@colors/colors";
 import pkg from "../package.json";
 import findPort from "find-open-port";
+import { Server } from "socket.io";
+import { webSocketServer } from "../lib/socket/instance";
 import { HonoInstance } from "./hono";
 type configRunApp = {
   register?: Array<Function>;
@@ -39,6 +43,7 @@ async function runApp(config?: configRunApp, clb?: Function) {
       // Load all ressouce
       await init();
       const HonoApp = HonoInstance();
+      //await loadSocket(HonoApp);
       //BeforeStart
       if (config?.beforeStart) {
         for (const fn of config?.beforeStart) {
@@ -46,10 +51,18 @@ async function runApp(config?: configRunApp, clb?: Function) {
         }
       }
 
-      Bun.serve({
+      var server = Bun.serve({
         port: PORT,
-        fetch: HonoApp.fetch,
+        fetch: (req, server) => {
+          if (server.upgrade(req)) {
+            // handle authentication
+            return;
+          }
+
+          return HonoApp.fetch(req, server);
+        },
         maxRequestBodySize: 1024 * 1024 * 900,
+        websocket: webSocketServer(server),
       });
 
       console.log();

package/define/index.ts

@@ -22,7 +22,7 @@ function Config(config: Config) {
 
 function Collection(col: Collection) {
   col.timestamps = col?.timestamps ?? true;
-
+  if (!col?.fields) col.fields = [];
   return col;
 }
 

package/driver/mongo/rest.ts

@@ -71,6 +71,11 @@ class useRest {
   #tenant_id: string;
   #session: ClientSession | null | undefined;
   #useCustomApi: boolean = true;
+  /**
+  Direct Api Mongo , use it with caution
+   */
+  db: Tenant["database"]["db"];
+
   constructor(options: options) {
     this.#c = options.c;
     this.#useCustomApi = options.useCustomApi ?? true;
@@ -78,6 +83,8 @@ class useRest {
     this.#session = null;
     this.#tenant = getTenant(this.#tenant_id);
     this.#useHook = options?.useHook ?? true;
+    this.db = this.#tenant.database.db;
+
     /*  if (options?.useHook == undefined || options?.useHook == null) {
       this.#useHook = true;
     } else {

package/lib/index.ts

@@ -4,10 +4,11 @@ import { loadEndpoints } from "./endpoint";
 import { loadServices } from "./service";
 import { initCron } from "./cron";
 import { loadPermissions } from "./permissions";
-import { loadSocket } from "./socket";
+import { loadSocket } from "../lib/socket";
 import { loadAutoRoutes } from "./routes";
 // load all ressource
 async function init(cf = { app: null }) {
+  await loadSocket();
   // load all tenants database
   await connectTenantsDatabase();
   // load all collections
@@ -22,9 +23,6 @@ async function init(cf = { app: null }) {
   // load Service
   loadServices();
 
-  // load Socket
-  await loadSocket();
-
   // load all loadEndpoints
   await loadEndpoints();
 

package/lib/service.ts

@@ -36,7 +36,7 @@ async function loadServices() {
 
 function getService(name: string, tenant_id: string): Service | undefined {
   return Cfg.services?.find(
-    (s) => s?.tenant_id == tenant_id && s?.name == name && s?.fx
+    (s) => s?.tenant_id == tenant_id && s?.name == name && (s?.fx || s?.exec)
   );
 }
 

package/lib/{socket.ts → socket/index.ts}

@@ -1,16 +1,11 @@
-import { Cfg } from "../config";
+import { Cfg } from "../../config";
 import { Server } from "socket.io";
 import consola from "consola";
 import { Glob } from "bun";
 import path from "path";
-import { useRest } from "../driver/mongo";
+import { useRest } from "../../driver/mongo";
+import { io } from "./instance";
 async function loadSocket() {
-  var io = new Server(Number(Cfg.server?.socket?.port || 9000), {
-    cors: {
-      ...Cfg.server.cors,
-      credentials: true,
-    },
-  });
   /*  io.on("connection", (socket) => {
     console.log("ok");
   }); */
@@ -22,18 +17,20 @@ async function loadSocket() {
         cwd: Cfg.cwd,
       })) {
         let fullPathFile = path.join(Cfg.cwd || "", file);
+
         await import(fullPathFile)
           .then((inject) => {
             let socketInstance = inject?.default || null;
+
             if (
               socketInstance &&
               socketInstance?.enabled &&
-              socketInstance?.handler
+              socketInstance?.exec
             ) {
               let rest = new useRest({
                 tenant_id: t.id,
               });
-              socketInstance.handler({
+              socketInstance.exec({
                 io,
                 rest,
               });

package/lib/socket/instance.ts

@@ -0,0 +1,113 @@
+import type { ServerWebSocket, WebSocketHandler, Server } from "bun";
+import { EventEmitter } from "events";
+import { v4 } from "uuid";
+const wsClients = new Map<string, ServerWebSocket>();
+const wsEvents: optionsIo[] = [];
+
+class Io {
+  constructor() {}
+  on(event: string, cb: Function) {
+    wsEvents.push({
+      type: "on",
+      event: event,
+      cb: cb,
+    });
+  }
+  emit(event: string, data: any) {
+    wsEvents.push({
+      type: "emit",
+      event: event,
+      data: data,
+    });
+  }
+}
+
+const io = new Io();
+type optionsIo = {
+  type: "on" | "emit";
+  event: string | "connection" | "close";
+  data?: any;
+  cb?: Function;
+  token?: string;
+  uuid?: string;
+};
+
+export type socketIoType = {
+  id: string;
+  on: <T extends "connection" | "close" | string>(
+    event: T,
+    cb: (socket: {
+      id: string;
+      emit: (event: string, data: any) => void;
+    }) => void
+  ) => void;
+  emit: (event: string, data: any) => void;
+  broadcast: (event: string, data: any) => void;
+};
+
+function webSocketServer(server: Server): WebSocketHandler {
+  return {
+    open: (ws) => {
+      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"
+      );
+
+      // exec cb for conenction
+      evs?.map((ev) => {
+        if (ev && ev.cb) {
+          ev.cb({
+            id: id,
+            emit: (event: string, data: any) =>
+              ws.send(JSON.stringify({ type: "emit", event, data })),
+          });
+        }
+      });
+    },
+    close(ws, code, reason) {
+      console.log("close", code, reason);
+      console.log(ws.id);
+    },
+    message: (ws, message: any) => {
+      try {
+        let options: optionsIo = JSON.parse(message);
+
+        // find all listeners : On
+        let evs = wsEvents.filter(
+          (e) => e.event == options?.event && e?.type == "on"
+        );
+
+        // run all listeners function if matchs
+        evs?.map((ev) => {
+          if (ev && ev.cb) {
+            ev.cb({
+              data: options.data,
+              ws: {
+                broadcast: (event: string, data: any) => {
+                  // send to all clients
+                  wsClients.forEach((client) => {
+                    client.send(JSON.stringify({ type: "emit", event, data }));
+                  });
+                },
+                emit: (event: string, data: any) =>
+                  ws.send(JSON.stringify({ type: "emit", event, data })),
+              },
+            });
+          }
+        });
+
+        //wsEvents.on(options.event)
+      } catch (err) {
+        //console.log("Not a valid JSON string", err?.message);
+      }
+    },
+  };
+}
+
+export { webSocketServer, wsClients, io };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "module": "index.ts",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
     "@types/fs-extra": "^11.0.4",
     "@types/mime-types": "^2.1.4",
     "@types/nodemailer": "^6.4.15",
+    "@types/pidusage": "^2.0.5",
     "@types/uuid": "^10.0.0"
   },
   "peerDependencies": {
@@ -37,7 +38,7 @@
     "find-open-port": "^2.0.3",
     "fs-extra": "^11.2.0",
     "generate-unique-id": "^2.0.3",
-    "groq-sdk": "^0.7.0",
+    "groq-sdk": "^0.8.0",
     "hono": "^4.6.3",
     "joi": "^17.13.3",
     "json-joy": "^16.8.0",
@@ -45,14 +46,15 @@
     "mime-types": "^2.1.35",
     "mingo": "^6.4.15",
     "moment": "^2.30.1",
-    "mongodb": "^6.8.0",
+    "mongodb": "^6.10.0",
     "nodemailer": "^6.9.14",
     "ollama": "^0.5.9",
-    "openai": "^4.71.1",
+    "openai": "^4.72.0",
+    "pidusage": "^3.0.2",
     "radash": "^12.1.0",
     "sharp": "^0.33.5",
     "signaldb": "^0.18.0",
-    "socket.io": "^4.7.5",
+    "socket.io": "^4.8.1",
     "ufo": "^1.5.3",
     "urlencode": "^2.0.0",
     "uuid": "^10.0.0"

package/types/index.ts

@@ -6,9 +6,9 @@ import type { Db, MongoClient } from "mongodb";
 import { useRest } from "../driver/mongo/rest";
 import { sessionStorage } from "../lib/asyncLocalStorage";
 import type { Context, Hono } from "hono";
-import type { Server as ServerIO, Socket as SocketType } from "socket.io";
+//import type { Server as ServerIO, Socket as SocketType } from "socket.io";
 
-type Io = InstanceType<typeof ServerIO>;
+import type { socketIoType } from "../lib/socket/instance";
 
 import { fn } from "../utils";
 import type {
@@ -20,7 +20,7 @@ import type { RouterRoute } from "hono/types";
 import type { MongoClientOptions } from "mongodb";
 export type Socket = {
   enabled: boolean;
-  handler: (ctx: { rest: useRest; io: Io; session: sessionCtx }) => void;
+  exec: (ctx: { rest: useRest; io: socketIoType }) => void;
 };
 
 export type Tenant = {

package/utils/index.ts

@@ -12,11 +12,16 @@ import collect from "collect.js";
 import * as uuid from "uuid";
 import * as urlencode from "urlencode";
 import dotJson from "dot-object";
+import deepClone from "deep-clone";
 
 const JWT_SECRET = process?.env?.JWT_SECRET || "secret-libv";
 import * as _ from "radash";
 import { email } from "../lib/mail";
 
+function copy(data: object): object | any {
+  return deepClone(data);
+}
+
 const jwt = {
   verify: (token: string): { decode: any; valid: boolean; error: any } => {
     let decode = null;
@@ -343,4 +348,5 @@ export {
   Otp, // Otp utils
   urlencode,
   stringToBoolean,
+  copy,
 };