@dnax/core 0.14.1 → 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(

package/app/index.ts

@@ -9,6 +9,8 @@ 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>;
@@ -41,7 +43,7 @@ async function runApp(config?: configRunApp, clb?: Function) {
       // Load all ressouce
       await init();
       const HonoApp = HonoInstance();
-      await loadSocket(HonoApp);
+      //await loadSocket(HonoApp);
       //BeforeStart
       if (config?.beforeStart) {
         for (const fn of config?.beforeStart) {
@@ -49,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/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 "../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

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

@@ -1,17 +1,14 @@
-import { Cfg } from "../config";
+import { Cfg } from "../../config";
 import { Server } from "socket.io";
-import type { Hono } from "hono";
-import { createServer } from "http";
 import consola from "consola";
 import { Glob } from "bun";
 import path from "path";
-import { useRest } from "../driver/mongo";
-async function loadSocket(app: InstanceType<typeof Hono>) {
-  let httpServer = createServer(app.fetch);
-  var io = new Server(httpServer);
-  io.on("connection", (socket) => {
+import { useRest } from "../../driver/mongo";
+import { io } from "./instance";
+async function loadSocket() {
+  /*  io.on("connection", (socket) => {
     console.log("ok");
-  });
+  }); */
   if (Cfg.tenants) {
     for await (let t of Cfg.tenants) {
       let tenantPath = `${t.dir}/sockets/**/**.ws.{ts,js}`;
@@ -20,18 +17,20 @@ async function loadSocket(app: InstanceType<typeof Hono>) {
         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.1",
+  "version": "0.14.2",
   "module": "index.ts",
   "type": "module",
   "bin": {

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,
 };