@dnax/core 0.66.3 → 0.67.1

package/app/hono.ts

@@ -15,7 +15,6 @@ import { consola } from "consola";
 
 import { cors } from "hono/cors";
 import { asyncLocalStorage, sessionStorage } from "../lib/asyncLocalStorage";
-import { localSession } from "../lib/session";
 import { crypt } from "../lib/crypto";
 import {
   cleanPath,
@@ -32,7 +31,6 @@ import { useRest } from "../driver/mongo/rest";
 import moment from "moment";
 import { Cfg } from "../config";
 import { getService } from "../lib/service";
-import { bentoCache, bentoKey } from "../lib/bento";
 import { MediaDrive } from "../lib/media";
 import { isStudio } from "../lib/studio";
 
@@ -45,14 +43,13 @@ import { csrf } from "hono/csrf";
 import { v4 } from "uuid";
 import type { SearchParams } from "meilisearch";
 import { utils } from "..";
-const cache = bentoCache.namespace("DNAX_API");
 const app = new Hono();
 const API_PATH = "/api";
 
 function HonoInstance(): typeof app {
   app.use(
     cors({
-      origin: Cfg.server?.cors?.origin || ["*"],
+      origin: (Cfg.server?.cors?.origin as string[]) || ["*"],
       credentials: Cfg.server?.cors?.credentials ?? false,
       allowMethods: Cfg.server?.cors?.allowMethods || [
         "GET",
@@ -73,6 +70,9 @@ function HonoInstance(): typeof app {
         "X-Requested-With",
         "Access-Control-Request-Method",
         "Access-Control-Request-Headers",
+        "X-Forwarded-For",
+        "Cookie",
+        "X-Forwarded-Host",
       ],
     })
   );
@@ -126,8 +126,17 @@ function HonoInstance(): typeof app {
         reqAt: moment().format().toString(),
         setAt: sessionData?._v?.setAt || null,
       };
+      let tenantId =
+        c.req.header()["tenant-id"] ||
+        c.req.query("tenant-id") ||
+        c.req.query("tenantId") ||
+        c.req.query("tenant_id") ||
+        null;
+
+      tenantId = tenantId ? String(tenantId) : null;
+
       c.set("_v", _v);
-      c.set("tenant-id", c.req.header()["tenant-id"]);
+      c.set("tenant-id", tenantId);
 
       //console.log("_v", _v);
 
@@ -566,38 +575,12 @@ function HonoInstance(): typeof app {
             });
           }
         }
+
         // find
         if (action == "find") {
-          if (col?.cache?.enabled && useCache) {
-            let keyCache = crypt.AES.generateKey({
-              body: body,
-              query: c?.req?.query,
-            });
-
-            // if customCache
-            if (col?.cache?.fetch) {
-              let fetchFromCache = await col?.cache?.fetch({
-                key: keyCache,
-                action: action,
-                params: body?.params,
-                rest: rest,
-                session: sessionStorage(),
-                state: col?.cache?.state || {},
-                c: c,
-              });
-              if (!fetchFromCache?.isStale) {
-                response = fetchFromCache.data;
-              } else {
-                response = await rest.find(collection, body?.params || {}, {
-                  withMeta: body?.withMeta || false,
-                });
-              }
-            }
-          } else {
-            response = await rest.find(collection, body?.params || {}, {
-              withMeta: body?.withMeta || false,
-            });
-          }
+          response = await rest.find(collection, body?.params || {}, {
+            withMeta: body?.withMeta || false,
+          });
         }
 
         if (action == "listActivity") {

package/app/index.ts

@@ -2,17 +2,16 @@ import consola from "consola";
 import { Cfg, loadCfg } from "../config";
 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 { findPort } from "../utils/port";
 import { webSocketServer } from "../lib/socket/instance";
 import { HonoInstance } from "./hono";
 import { utils } from "..";
 import type { Server } from "bun";
+import { getPidUsage } from "../utils/os";
 type configRunApp = {
   register?: Array<Function>;
   beforeStart?: Array<Function>;
@@ -22,125 +21,106 @@ type configRunApp = {
   dbSync?: Array<Function>;
 };
 async function runApp(config?: configRunApp, clb?: Function): Promise<Server> {
-  hookDatabase.cb = config?.dbSync || [];
-  await loadCfg(); // Load Config
+  try {
+    hookDatabase.cb = config?.dbSync || [];
+    await loadCfg(); // Load Config
 
-  const PORT = Cfg.server?.port || process.env?.PORT || 4000;
-  const CLUSTER_MODE = Cfg?.clusterMode ?? false;
-  /*  const PORT_SOCKET = Cfg.server?.socket?.port || 9000;
+    const PORT = Cfg.server?.port || process.env?.PORT || 4000;
+    const CLUSTER_MODE = Cfg?.clusterMode ?? false;
 
-  // available port Socket
-  await findPort.isAvailable(PORT_SOCKET).then(async (available: boolean) => {
-    if (!available) {
-      console.error(`⚠️ Socket Port ${PORT_SOCKET} is not available`);
-      console.log("");
-      process.exit(1);
-    }
-  }); */
-
-  // available port Server
-  return await findPort
-    .isAvailable(PORT)
-    .then(async (available: boolean) => {
-      // Start App server
-      if (!available && !Cfg?.clusterMode) {
-        console.error(`⚠️ Port ${PORT} is not available`);
-        console.log("");
-        process.exit();
-      }
-
-      if (available) {
-        // Load all ressouce
-        await init();
-        const HonoApp = HonoInstance();
-        //await loadSocket(HonoApp);
-        //BeforeStart
-        if (config?.beforeStart) {
-          for (const fn of config?.beforeStart) {
-            await fn();
-          }
+    // available port Server
+    return await findPort
+      .isAvailable(Number(PORT))
+      .then(async (available: boolean) => {
+        // Start App server
+        if (!available && !Cfg?.clusterMode) {
+          console.error(`⚠️ Port ${PORT} is not available`);
+          console.log("");
+          process.exit();
         }
 
-        var server: any = Bun.serve({
-          port: PORT,
-          reusePort: CLUSTER_MODE,
-          fetch: (req, server) => {
-            if (server.upgrade(req)) {
-              // handle authentication
-              return;
+        if (available) {
+          // Load all ressouce
+          await init();
+          const HonoApp = HonoInstance();
+          //await loadSocket(HonoApp);
+          //BeforeStart
+          if (config?.beforeStart) {
+            for (const fn of config?.beforeStart) {
+              await fn();
             }
+          }
 
-            return HonoApp.fetch(req, server);
-          },
-          maxRequestBodySize: 1024 * 1024 * 900,
-          websocket: webSocketServer(server),
-        });
+          var server: any = Bun.serve({
+            port: PORT,
+            reusePort: CLUSTER_MODE,
+            fetch: (req, server) => {
+              if (server.upgrade(req)) {
+                // handle authentication
+                return;
+              }
 
-        let serverName =
-          process.env.SERVER_NAME || Cfg?.server?.name || "SERVER";
+              return HonoApp.fetch(req, server);
+            },
+            maxRequestBodySize: 1024 * 1024 * 900,
+            websocket: webSocketServer(server),
+          });
 
-        /*      console.log(
-          boxen(`SERVER : ${PORT}`, {
-            borderStyle: "round",
-            title: `@dnax/server ${pkg.version}`,
-            padding: 1,
-            dimBorder: true,
-            titleAlignment: "center",
-            //float: "center",
-            //margin: 1,
-            borderColor: "gray",
-          })
-        ); */
-        let info = "";
-        let envName = process.env?.NODE_ENV || "dev";
-        info += `${serverName}`.gray.underline.bold;
-        info += `\n`;
-        info += `\n`;
-        info += `Env: ${envName}`.green.bold + "\n";
-        info += `url: http://localhost:${PORT}\n`.gray.bold;
-        //info += `Jwt Secret: ${Cfg.server.jwt?.secret}\n`.gray;
-        info += `\n`;
-        info += "TENANTS :".gray.underline.bold;
-        info += `\n`;
-        Cfg.tenants?.map((t: any) => {
-          info += `\n${t?.name?.blue || "_"} : ${t?.id?.green}`.bold;
-        });
-        info += `\n\n`;
-        info += `🔄 ${new Date().toLocaleString()}`.gray;
+          let serverName =
+            process.env.SERVER_NAME || Cfg?.server?.name || "SERVER";
 
-        if (clb) clb();
+          let info = "";
+          let envName = process.env?.NODE_ENV || "dev";
+          info += `${serverName}`.gray.underline.bold;
+          info += `\n`;
+          info += `\n`;
+          info += `Env: ${envName}`.green.bold + "\n";
+          info += `url: http://localhost:${PORT}\n`.gray.bold;
+          //info += `Jwt Secret: ${Cfg.server.jwt?.secret}\n`.gray;
+          info += `\n`;
+          info += "TENANTS :".gray.underline.bold;
+          info += `\n`;
+          Cfg.tenants?.map((t: any) => {
+            info += `\n${t?.name?.blue || "_"} : ${t?.id?.green}`.bold;
+          });
+          info += `\n\n`;
+          info += `🔄 ${new Date().toLocaleString()}`.gray;
 
-        console.log();
-        console.log(
-          boxen(info, {
-            borderStyle: "double",
-            title: `@dnax/server ${pkg.version}`,
-            padding: 1.5,
-            dimBorder: true,
+          if (clb) clb();
+          console.log(
+            boxen(info, {
+              borderStyle: "double",
+              title: `@dnax/server ${pkg.version}`,
+              padding: 1.5,
+              dimBorder: true,
 
-            titleAlignment: "center",
-            //float: "center",
-            //margin: 1,
-            borderColor: "gray",
-          })
-        );
+              titleAlignment: "center",
+              //float: "center",
+              //margin: 1,
+              borderColor: "gray",
+            })
+          );
 
-        //AfterStart
-        if (config?.afterStart) {
-          for (const fn of config?.afterStart) {
-            await fn({
-              config: utils.copy(Cfg),
-            });
+          //AfterStart
+          if (config?.afterStart) {
+            for (const fn of config?.afterStart) {
+              await fn({
+                config: utils.copy(Cfg),
+              });
+            }
           }
         }
-      }
 
-      return server;
-    })
-    .catch((err: any) => {
-      console.error("Warning", err?.message);
-      process.exit(1);
-    });
+        return server;
+      })
+      .catch((err: any) => {
+        console.error(err);
+        process.exit(1);
+      });
+  } catch (err: any) {
+    consola.error(err?.message);
+    process.exit(1);
+  }
 }
 
 //process.on("exit", async () => {});

package/config/index.ts

@@ -1,11 +1,10 @@
 import { cors } from "hono/cors";
-import { Config } from "./../types/index";
 import type { Config } from "../types";
 import fs from "fs-extra";
-import { systemCache } from "../lib/bento";
 import { Glob } from "bun";
 import path from "path";
 import { v4 } from "uuid";
+import { consola } from "consola";
 
 const ROOT_PATH = process.cwd();
 const Cfg: Config = {
@@ -52,22 +51,7 @@ async function setCfg(config: Config) {
   }
 
   if (!Cfg?.server?.jwt?.secret) {
-    let jwtSecret = await systemCache.get({
-      key: ".jwt.json",
-    });
-    if (!jwtSecret) {
-      jwtSecret = v4().replaceAll("-", "");
-      await systemCache.set({
-        key: ".jwt.json",
-        value: jwtSecret,
-        ttl: "2y",
-      });
-    }
-    Cfg.server.jwt.secret = jwtSecret;
-  }
-
-  if (!Cfg?.server.jwt?.secret) {
-    console.error("JWT_SECRET is not defined");
+    consola.error("JWT_SECRET is not defined".red);
     process.exit(1);
   }
 

package/driver/mongo/@types.ts

@@ -24,6 +24,21 @@ export type findParam = {
   };
 };
 
+export type restEventType = [
+  "*",
+  "insertOne",
+  "insertMany",
+  "updateOne",
+  "updateMany",
+  "deleteOne",
+  "deleteMany",
+  "find",
+  "findOne",
+  "findAndUpdate",
+  "findOneAndUpdate",
+  "aggregate",
+  "count"
+];
 export type findOneParam = {
   $match: object;
   $include?: Array<object>;

package/driver/mongo/connect.ts

@@ -13,8 +13,8 @@ async function connectToMongo(t: Tenant) {
     await client
       .connect()
       .then((e) => {
-        console.log("\n");
-        consola.success(`DB connected : [${t.id}] ✅`.green);
+        //console.log("\n");
+        // consola.success(`DB connected : [${t.id}] ✅`.green);
         t.database.isConnected = true;
         t.database.client = client;
         t.database.db = client.db();

package/driver/mongo/database.ts

@@ -0,0 +1,85 @@
+type options = {
+  uri: string;
+  binPath?: string;
+};
+import { consola } from "consola";
+import { $ } from "bun";
+import moment from "moment";
+
+class DatabaseTools {
+  options: options;
+  constructor(options: options) {
+    this.options = options;
+  }
+  /**
+   * @param output - path to the output file
+   */
+  async backup(
+    filename: string,
+    path: string,
+    options?: {
+      debug?: boolean;
+    }
+  ) {
+    try {
+      consola.log("🔄 Backuping database to", path);
+      const { uri, binPath } = this.options;
+      const cmdBin = binPath ? `${binPath}/mongodump` : "mongodump";
+      let outputPath = path + "/" + filename + ".gz";
+      if (options?.debug) {
+        const output =
+          await $`${cmdBin} --uri ${uri}  --archive=${outputPath} --gzip`;
+        console.log(output);
+      } else {
+        const output =
+          await $`${cmdBin} --uri ${uri}  --archive=${outputPath} --gzip`.quiet();
+      }
+      console.log();
+
+      consola.log(`✅ Backup [${filename}] completed to [${path}]`.bold);
+    } catch (err: any) {
+      consola.error(err?.message);
+    }
+  }
+
+  async export(
+    collectionName: string,
+    databaseName: string,
+    path: string,
+    options?: {
+      debug?: boolean;
+      format?: "json" | "gz";
+    }
+  ) {
+    try {
+      consola.log(
+        `🔄 Exporting collection [${collectionName}] to [${path}]`.bold
+      );
+      let format = options?.format || "json";
+      const { uri, binPath } = this.options;
+      const cmdBin = binPath ? `${binPath}/mongoexport` : "mongoexport";
+      let outputPath = path + "/" + collectionName + ".json";
+      if (options?.debug) {
+        const output =
+          await $`${cmdBin} --uri ${uri}  --db=${databaseName} --collection=${collectionName} --out=${outputPath} --jsonArray --pretty`;
+        console.log(output);
+      } else {
+        const output =
+          await $`${cmdBin} --uri ${uri}  --db=${databaseName} --collection=${collectionName} --out=${outputPath} --jsonArray --pretty`.quiet();
+      }
+      console.log();
+
+      consola.log(
+        `✅[${collectionName}]'s collection exported to [${path}]`.bold
+      );
+    } catch (err: any) {
+      consola.error(err?.message);
+    }
+  }
+}
+
+function useDatabaseTools(options: options): DatabaseTools {
+  return new DatabaseTools(options);
+}
+
+export { useDatabaseTools };

package/driver/mongo/rest.ts

@@ -23,6 +23,7 @@ import type {
   findOneParam,
   findParam,
   queryParam,
+  restEventType,
   updateParams,
 } from "./@types";
 import {
@@ -462,17 +463,6 @@ class useRest {
           });
         }
 
-        try {
-          col?.cache?.watch({
-            action: "insertOne",
-            c: this.#c,
-            session: sessionStorage(),
-            rest: this,
-            state: col?.cache?.state || {},
-            result: toJson(data),
-          });
-        } catch (err) {}
-
         // meilisearch engine
         if (
           this.#tenant?.searchEngine?.meilisearch?.enabled &&
@@ -621,16 +611,6 @@ class useRest {
           });
         }
 
-        try {
-          col?.cache?.watch({
-            action: "insertMany",
-            c: this.#c,
-            session: sessionStorage(),
-            rest: this,
-            state: col?.cache?.state || {},
-            result: toJson(data),
-          });
-        } catch (err) {}
         if (
           this.#tenant?.searchEngine?.meilisearch?.enabled &&
           col?.searchEngine?.meilisearch?.dispatchAction == "auto"
@@ -663,6 +643,8 @@ class useRest {
       }
     });
   }
+
+  //on(event: restEventType, clb: Function) {}
   /**
    *
    * @param queries
@@ -711,19 +693,14 @@ class useRest {
     collection: string,
     params?: findParam,
     options?: optionCb
-  ): Promise<
-    object[] | { data: object[]; meta: { total: number; count: number } }
-  > {
+  ): Promise<{ _id: string; [key: string]: any }[]> {
     return new Promise(async (resolve, reject) => {
       try {
         if (!params) params = {};
         if (options?.cleanDeep) {
           params = cleanDeep(params);
         }
-        let meta: { total: number; count: number } = {
-          total: 0,
-          count: 0,
-        };
+
         let useHook = options?.useHook ?? this.#useHook;
         let useCustomApi = options?.useCustomApi ?? this.#useCustomApi;
         let sharedData = {};
@@ -789,22 +766,6 @@ class useRest {
 
         result.docs = toJson(result.docs);
 
-        if (options?.withMeta) {
-          meta.count = await this.#tenant.database.db
-            ?.collection(collection)
-            .countDocuments({
-              ...(params?.$match || {}),
-            })
-            .then((e) => e || 0)
-            .catch((err) => 0);
-          meta.total = await this.#tenant.database.db
-            ?.collection(collection)
-            .estimatedDocumentCount();
-        } else {
-          meta.total = result.docs.length;
-          meta.count = result.docs.length;
-        }
-
         if (col?.hooks?.afterFind && useHook) {
           await col.hooks.afterFind({
             sharedData: sharedData,
@@ -830,13 +791,6 @@ class useRest {
           resultDocs = resultDocs[options?.elementAt] ?? null;
         }
 
-        if (options?.withMeta) {
-          return resolve({
-            data: resultDocs,
-            meta: meta,
-          });
-        }
-
         return resolve(resultDocs);
       } catch (err) {
         return reject(err);
@@ -847,10 +801,7 @@ class useRest {
   async count(
     collection: string,
     params: findParam,
-    options?: Omit<
-      optionCb,
-      "useCustomApi" | "withMeta" | "elementAt" | "useHook"
-    >
+    options?: Omit<optionCb, "useCustomApi" | "withMeta" | "elementAt">
   ): Promise<number> {
     return new Promise(async (resolve, reject) => {
       try {
@@ -1264,16 +1215,6 @@ class useRest {
           });
         }
 
-        try {
-          col?.cache?.watch({
-            action: "insertMany",
-            c: this.#c,
-            session: sessionStorage(),
-            rest: this,
-            state: col?.cache?.state || {},
-            result: toJson(result?.doc || {}),
-          });
-        } catch (err) {}
         if (
           this.#tenant?.searchEngine?.meilisearch?.enabled &&
           col?.searchEngine?.meilisearch?.dispatchAction == "auto"
@@ -1544,44 +1485,6 @@ class useRest {
     });
   }
 
-  async search(
-    collection: string,
-    term: string,
-    searchOptions: SearchParams
-  ): Promise<{
-    hits: Array<object>;
-    limit: number;
-    offset: number;
-    total: number;
-    processingTimeMs: number;
-    facetDistribution?: object;
-    facetsStats?: object;
-    estimatedTotalHits?: number;
-    totalHits?: number;
-    hitsPerPage?: number;
-    page?: number;
-  }> {
-    return new Promise(async (resolve, reject) => {
-      try {
-        let index = getCollection(collection, this.#tenant_id)?.searchEngine
-          ?.meilisearch?.index!;
-
-        if (!index)
-          return reject({
-            code: 400,
-            message: "Search engine Index required",
-          });
-
-        let result = this.meilisearch.client.index(index).search(term, {
-          ...searchOptions,
-        });
-        resolve(result);
-      } catch (err) {
-        return reject(err);
-      }
-    });
-  }
-
   async updateMany(
     collection: string,
     ids: Array<string>,
@@ -1746,16 +1649,6 @@ class useRest {
             });
           }
 
-          try {
-            col?.cache?.watch({
-              action: "updateMany",
-              c: this.#c,
-              session: sessionStorage(),
-              rest: this,
-              state: col?.cache?.state || {},
-              result: toJson(result?.docs || []),
-            });
-          } catch (err) {}
           if (
             this.#tenant?.searchEngine?.meilisearch?.enabled &&
             col?.searchEngine?.meilisearch?.dispatchAction == "auto"
@@ -1885,16 +1778,6 @@ class useRest {
           });
         }
 
-        try {
-          col?.cache?.watch({
-            action: "deleteOne",
-            c: this.#c,
-            session: sessionStorage(),
-            rest: this,
-            state: col?.cache?.state || {},
-            result: toJson(doc || {}),
-          });
-        } catch (err) {}
         if (
           this.#tenant?.searchEngine?.meilisearch?.enabled &&
           col?.searchEngine?.meilisearch?.dispatchAction == "auto"
@@ -2027,16 +1910,6 @@ class useRest {
           });
         }
 
-        try {
-          col?.cache?.watch({
-            action: "deleteMany",
-            c: this.#c,
-            session: sessionStorage(),
-            rest: this,
-            state: col?.cache?.state || {},
-            result: deletedIds || [],
-          });
-        } catch (err) {}
         if (
           this.#tenant?.searchEngine?.meilisearch?.enabled &&
           col?.searchEngine?.meilisearch?.dispatchAction == "auto"

package/index.ts

@@ -6,13 +6,12 @@ import * as v from "joi";
 import { $ } from "bun";
 import define from "./define";
 import * as utils from "./utils";
-import { dataCache } from "./lib/bento";
 import { FilesystemSftpAdapter, MinioAdapter } from "./lib/media";
 import { crypt } from "./lib/crypto";
 import { contextStorage } from "./lib/asyncLocalStorage";
 import { Cron as Task } from "croner";
-import { useWorkflow } from "./lib/workflow";
 import { serveStatic } from "hono/bun";
+import { useDatabaseTools } from "./driver/mongo/database";
 // Adapter
 
 const Adapter = {
@@ -32,11 +31,10 @@ export {
   utils,
   useRest,
   v,
-  dataCache,
   Task,
   crypt,
   $,
   contextStorage,
   Adapter,
-  //useWorkflow,
+  useDatabaseTools,
 };

package/lib/asyncLocalStorage.ts

@@ -1,6 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { sessionCtx } from "../types";
-import { localSession } from "./session";
 import { v4 } from "uuid";
 import { jwt, uuid } from "../utils";
 import { Cfg } from "../config";

package/lib/bento/index.ts

@@ -19,61 +19,4 @@ if (!fs?.existsSync(path.resolve(cacheDirectoryData + "bentocache"))) {
   });
 }
 
-const systemCache = new BentoCache({
-  default: "systemCache",
-
-  stores: {
-    systemCache: bentostore().useL2Layer(
-      fileDriver({
-        directory: cacheDirectory,
-        pruneInterval: "1h",
-        //maxSize: 100 * 1024 * 1024,
-      })
-    ),
-  },
-});
-
-const dataCache = new BentoCache({
-  default: "dataCache",
-  stores: {
-    dataCache: bentostore().useL2Layer(
-      fileDriver({
-        directory: cacheDirectoryData,
-        pruneInterval: false,
-
-        //maxSize: 100 * 1024 * 1024,
-      })
-    ),
-  },
-});
-
-const bentoCache = new BentoCache({
-  default: "dnaxCache",
-  stores: {
-    dnaxCache: bentostore().useL1Layer(
-      memoryDriver({
-        maxSize: 100 * 1024 * 1024,
-      })
-    ),
-  },
-});
-
-function bentoKey(data: object | string) {
-  let key = "";
-  if (data) {
-    if (typeof data == "object") {
-      key = JSON.stringify(data);
-      key = key.replace(/\s/g, "").trim();
-    }
-
-    if (typeof data == "string") {
-      key = data.replace(/\s/g, "").trim();
-    }
-  }
-
-  return key;
-}
-
-const sessionCache = systemCache.namespace("tokens");
-
-export { bentoCache, bentoKey, systemCache, sessionCache, dataCache };
+export {};

package/lib/collection.ts

@@ -43,7 +43,7 @@ async function loadAllCollections() {
 
 function getCollection(
   name: string,
-  tenant_id: string | number
+  tenant_id: string
 ): Collection | undefined | null {
   if (Cfg?.collections?.length) {
     return Cfg.collections.find((col: Collection) => {

package/lib/index.ts

@@ -1,5 +1,4 @@
 import { loadAllCollections, syncCollectionDatabase } from "./collection";
-import { syncMeilisearchClientOnTenant } from "./meilisearch";
 import { connectTenantsDatabase } from "../driver";
 import { loadEndpoints } from "./endpoint";
 import { loadServices } from "./service";
@@ -10,41 +9,67 @@ import { loadAutoRoutes } from "./routes";
 import { initScript } from "../lib/scripts";
 import { syncAdapterFileSystem } from "./media";
 import { runGenTypes } from "../types/gen";
+import consola from "consola";
+import ora from "ora";
 
 // load all ressource
 async function init(cf = { app: null }) {
+  console.log("\n");
+  const spinner = ora("Initializing...").start();
+  spinner.color = "green";
+
+  //console.log("🔄 Initializing...".blue);
   await loadSocket();
+  //consola.success("Loaded socket");
   // load all tenants database
   await connectTenantsDatabase();
+  // consola.success("Loaded tenants database");
   // load all collections
   await loadAllCollections();
+  //consola.success("Loaded collections");
 
   // load all permissions
   await loadPermissions();
+  //consola.success("Loaded permissions");
 
   // sync all collections database ( Indexes)
   syncCollectionDatabase();
+  //consola.success("Synced collections database");
 
-  // sync
-  syncMeilisearchClientOnTenant();
+  runGenTypes();
 
   // load Service
   loadServices();
+  //consola.success("Loaded services");
 
   // sync all adapter file system
   syncAdapterFileSystem();
+  //consola.success(" adapter file system");
 
   // load all loadEndpoints
   await loadEndpoints();
+  // consola.success("Loaded endpoints");
 
   // load auto routes
   await loadAutoRoutes();
+  //consola.success("Loaded auto routes");
 
   await initCron();
-
-  runGenTypes();
+  //consola.success("Loaded cron/Tasks");
 
   initScript();
+  //consola.success("Loaded scripts");
+  //spinner.clear();
+  spinner.stop();
+  spinner.clear();
+  console.log(
+    "\n---------------------------------------\n".gray +
+      "\n✨  Your server is up and running\n".green.bold +
+      "---------------------------------------\n".gray +
+      `🌍  Environment : ${process.env.NODE_ENV || "development"}\n`.gray +
+      `🕒  Started at  : ${new Date().toLocaleString()}\n`.gray +
+      "---------------------------------------\n".gray
+  );
 }
 
 export { init };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.66.3",
+  "version": "0.67.1",
   "module": "index.ts",
   "type": "module",
   "bin": {},
@@ -9,9 +9,9 @@
     "@types/dot-object": "^2.1.6",
     "@types/fs-extra": "^11.0.4",
     "@types/jsonwebtoken": "9.0.9",
-    "@types/mime-types": "^2.1.4",
+    "@types/mime-types": "^3.0.1",
     "@types/minio": "^7.1.1",
-    "@types/nodemailer": "^6.4.15",
+    "@types/nodemailer": "^6.4.17",
     "@types/pidusage": "^2.0.5",
     "@types/ssh2-sftp-client": "^9.0.4",
     "@types/uuid": "^10.0.0"
@@ -22,7 +22,8 @@
   "dependencies": {
     "@colors/colors": "^1.6.0",
     "@lukeed/ms": "^2.0.2",
-    "bentocache": "^1.2.1",
+    "@types/blessed": "^0.1.25",
+    "bentocache": "^1.5.0",
     "boxen": "^7.1.1",
     "chokidar": "3.6.0",
     "clean-deep": "^3.4.0",
@@ -32,22 +33,19 @@
     "croner": "8.1.1",
     "deepcopy": "^2.1.0",
     "dot-object": "2.1.5",
-    "find-open-port": "^2.0.3",
     "fs-extra": "^11.2.0",
     "generate-unique-id": "^2.0.3",
-    "hono": "4.6.14",
+    "hono": "4.8.9",
     "joi": "17.13.3",
     "json-joy": "16.8.0",
     "jsonwebtoken": "^9.0.2",
-    "meilisearch": "^0.50.0",
     "mime-types": "^2.1.35",
-    "mingo": "^6.5.0",
     "minio": "^8.0.5",
     "moment": "^2.30.1",
-    "mongodb": "6.17.0",
-    "nodemailer": "^6.9.14",
+    "mongodb": "6.18.0",
+    "nodemailer": "^7.0.5",
+    "ora": "^8.2.0",
     "pidusage": "^4.0.0",
-    "pizzip": "^3.1.8",
     "radash": "^12.1.0",
     "rfc6902": "^5.1.2",
     "sharp": "^0.33.5",

package/types/index.ts

@@ -320,70 +320,7 @@ export type Collection = {
     findOne?: (ctx: ctxApi) => object;
     count?: (ctx: ctxApi) => number;
   };
-  searchEngine?: {
-    meilisearch: {
-      /**
-       * unique name of the index on meilisearch
-       */
-      index: string;
-      primaryKey?: string;
-      /**
-       * default value :auto
-       */
-      dispatchAction: "auto" | "manual";
-      filterableAttributes?: Array<string>;
-    };
-  };
-  /**
-   * Cache available for action 'find' | 'findOne'
-   */
-  cache?: {
-    enabled?: boolean;
-    state?: {
-      [key: string]: any;
-    };
-    init?: (ctx: {
-      rest: InstanceType<typeof useRest>;
-      state: {
-        [key: string]: any;
-      };
-    }) => void;
-    watch: (ctx: {
-      action:
-        | "insertOne"
-        | "insertMany"
-        | "updateOne"
-        | "updateMany"
-        | "deleteOne"
-        | "deleteMany"
-        | "findOneAndUpdate";
-      rest: InstanceType<typeof useRest>;
-      c?: Context;
-      session?: sessionCtx;
-      result: any;
-      state: {
-        [key: string]: any;
-      };
-    }) => void;
-    fetch?: (ctx: {
-      state: {
-        [key: string]: any;
-      };
-      body: {
-        params: findParam;
-        pipeline: Array<object>;
-        withMeta: boolean;
-      };
-      key: string;
-      action: "find" | "aggregate";
-      rest: InstanceType<typeof useRest>;
-      c: Context;
-      session: sessionCtx;
-    }) => {
-      isStale: boolean;
-      data: any;
-    };
-  };
+
   schema?: object;
   auth?: {
     enabled?: boolean;

package/utils/os.ts

@@ -1 +1,22 @@
-function Os() {}
+import pidusage from "pidusage";
+
+/**
+ * Retourne les stats CPU/RAM pour un ou plusieurs PIDs.
+ * @param {number[]} pids - Liste des PIDs à surveiller.
+ * @returns {Promise<{ pid: number, cpu: number, ram: number, elapsed: number }[]>}
+ */
+export async function getPidUsage(pids = [process.pid]) {
+  try {
+    const stats = await pidusage(pids);
+
+    return Object.entries(stats).map(([pid, usage]) => ({
+      pid: Number(pid),
+      cpu: usage.cpu, // en %
+      ram: usage.memory / 1024 / 1024, // en MB
+      elapsed: usage.elapsed / 1000, // uptime en secondes
+    }));
+  } catch (err) {
+    console.error("Erreur getPidUsage:", err.message);
+    return [];
+  }
+}

package/utils/port.ts

@@ -0,0 +1,41 @@
+import net from "net";
+import type { AddressInfo } from "net";
+function findPort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.on("error", reject);
+    server.listen(0, () => {
+      const { port, address } = server.address() as AddressInfo;
+      server.on("close", resolve.bind(null, port));
+      server.close();
+    });
+  });
+}
+
+function isAvailable(port: number): Promise<boolean> {
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(port);
+    socket.setTimeout(500, () => {
+      socket.destroy();
+      const error = new Error("ETIMEDOUT") as any;
+      error.code = "ETIMEDOUT";
+      reject(error);
+    });
+    socket.on("error", (error: any) => {
+      if (error.code === "ECONNREFUSED") {
+        return resolve(true);
+      }
+      return reject(error);
+    });
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+
+findPort.findPort = findPort;
+findPort.default = findPort;
+findPort.isAvailable = isAvailable;
+
+export { findPort };

package/bin/_.ts

@@ -1,121 +0,0 @@
-#! /usr/bin/env bun
-
-import ch from "chokidar";
-import { spinner } from "@clack/prompts";
-import "@colors/colors";
-var exec;
-var s = spinner();
-function runPkg(
-  opts = {
-    stopSpinner: false,
-  }
-) {
-  if (opts?.stopSpinner) {
-    s.stop();
-  }
-
-  exec = Bun.spawn([`bun`, `index.ts`], {
-    stdio: ["inherit", "inherit", "inherit"],
-    serialization: "json",
-    stdin: "inherit",
-    ipc(message, subprocess) {
-      console.log(message);
-    },
-  });
-}
-
-// Écoutez le signal SIGINT (Ctrl + C)
-process.on("SIGINT", () => {
-  if (exec?.kill) exec.kill();
-  process.exit(1); // Terminez le processus principal
-});
-
-ch.watch(".", {
-  cwd: process.cwd(),
-  ignored: [
-    /.*\.(jpg|jpeg|png|gif|bmp|svg|webp|dump|zip|rar|.git|.lockb|package.json)$/i,
-    /node_modules|node_modules\/.*/,
-    /node_modules/,
-    /(^|[\/\\])\../,
-    "node_modules/**/*",
-    ".env.*",
-    ".env",
-    ".nitro",
-    ".git",
-    ".output",
-    ".vscode",
-    ".idea",
-    ".DS_Store",
-    ".env.local",
-    ".env.development",
-    ".env.test",
-    ".env.production",
-    "node_modules",
-    "package.json",
-    "package-lock.json",
-    "yarn.lock",
-    "yarn-error.log",
-    "bun.lockb",
-    "bun.lock",
-    "*.docs",
-    ".docx",
-    ".pdf",
-    ".xlsx",
-    ".pptx",
-    ".zip",
-    "package-lock.json",
-    "yarn.lock",
-    "tsconfig.json",
-    "tsconfig.tsbuildinfo",
-    "*.tsbuildinfo",
-    "*.log",
-    "*.tgz",
-    "/.git",
-    "/.github",
-    "/.vscode",
-    "/.idea",
-    "/coverage",
-    "/dist",
-    "/build",
-    "/node_modules",
-    "/package-lock.json",
-    "/yarn.lock",
-    ".cache",
-    "dist",
-    "*/dist",
-    "*.zip",
-    "*.log",
-    ".DS_Store",
-    "*.tar",
-    "*.tar.gz",
-    "build",
-    "*.lockb",
-    "coverage",
-    "packages/*/dist",
-    "packages/*/build",
-    "packages/*/coverage",
-    "packages/*/node_modules",
-  ],
-})
-  .on("change", (path) => {
-    console.log("Changed file:".gray, path.green);
-    let dev = process.argv.includes("--dev");
-    if (dev && (path?.endsWith(".ts") || path?.endsWith(".js"))) {
-      s.start("Restarting due to changes ...");
-      if (exec?.kill) {
-        exec.kill();
-      }
-      setTimeout(() => {
-        runPkg({ stopSpinner: true });
-      }, 1500);
-    }
-  })
-  .on("ready", () => {
-    let dev = process.argv.includes("--dev");
-    let start = process.argv.includes("--start");
-    if (dev || start) {
-      runPkg();
-    } else {
-      process.exit();
-    }
-  });

package/lib/meilisearch/index.ts

@@ -1,25 +0,0 @@
-import { MeiliSearch } from "meilisearch";
-import { Cfg } from "../../config";
-function getClient(config: {
-  host: string;
-  apiKey?: string;
-}): InstanceType<typeof MeiliSearch> {
-  const client = new MeiliSearch({
-    host: config?.host,
-    apiKey: config?.apiKey,
-  });
-  return client;
-}
-
-async function syncMeilisearchClientOnTenant() {
-  for await (let t of Cfg.tenants) {
-    if (t?.searchEngine?.meilisearch?.enabled) {
-      t.searchEngine.meilisearch.client = getClient({
-        host: t.searchEngine.meilisearch.host,
-        apiKey: t.searchEngine.meilisearch.apiKey,
-      });
-    }
-  }
-}
-
-export { MeiliSearch, getClient, syncMeilisearchClientOnTenant };