@dnax/core 0.1.20 → 0.2.0

package/app/index.ts

@@ -1,39 +1,43 @@
 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 "@colors/colors";
 import pkg from "../package.json";
 import findPort from "find-open-port";
 import { HonoInstance } from "./hono";
 type configRunApp = {
-  register?: Array<Function>,
-  beforeStart?: Array<Function>,
-  afterStart?: Array<Function>,
-  onError?: Array<Function>,
-  destroy?: Array<Function>,
-}
+  register?: Array<Function>;
+  beforeStart?: Array<Function>;
+  afterStart?: Array<Function>;
+  onError?: Array<Function>;
+  destroy?: Array<Function>;
+  dbSync?: Array<Function>;
+};
 async function runApp(config?: configRunApp, clb?: Function) {
-  console.log("\n");
-
-  await loadCfg();
-  //
-
-  // Load all ressouce
-  await init();
-
-  // Register all plugins
-
-  // Load Hono App and route api
+  hookDatabase.cb = config?.dbSync || [];
+  await loadCfg(); // Load Config
   const HonoApp = HonoInstance();
   const PORT = Cfg.server?.port || process.env?.PORT || 4000;
+  const PORT_SOCKET = Cfg.server?.socket?.port || 9000;
+
+  // 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();
+    }
+  });
 
+  // available port Server
   await findPort.isAvailable(PORT).then(async (available: boolean) => {
     // Start App server
-
     if (available) {
-
-
+      // Load all ressouce
+      await init();
       //BeforeStart
       if (config?.beforeStart) {
         for (const fn of config?.beforeStart) {
@@ -45,7 +49,6 @@ async function runApp(config?: configRunApp, clb?: Function) {
         port: PORT,
         fetch: HonoApp.fetch,
         maxRequestBodySize: 1024 * 1024 * 900,
-
       });
 
       console.log();
@@ -54,8 +57,9 @@ async function runApp(config?: configRunApp, clb?: Function) {
       info += `\n`;
       info += `\n`;
       info +=
-        `Env:  ${process.env.NODE_ENV === "production" ? "production" : "development"
-          }`.italic.blue.green + "\n";
+        `Env:  ${
+          process.env.NODE_ENV === "production" ? "production" : "development"
+        }`.italic.blue.green + "\n";
       info += `Server: http://localhost:${PORT}\n`.italic.blue;
       info += `\n`;
       info += "TENANTS DETAILS :".gray.italic.underline;
@@ -86,7 +90,6 @@ async function runApp(config?: configRunApp, clb?: Function) {
           await fn();
         }
       }
-
     } else {
       console.error(`⚠️ Port ${PORT} is not available`);
       console.log("");
@@ -95,4 +98,6 @@ async function runApp(config?: configRunApp, clb?: Function) {
   });
 }
 
+process.on("exit", async () => {});
+
 export { runApp };

package/bin/index.ts

@@ -0,0 +1,74 @@
+#! /usr/bin/env bun
+
+import ch from "chokidar";
+import { spinner } from "@clack/prompts";
+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(); // Terminez le processus principal
+});
+
+ch.watch(".", {
+  ignored: [
+    /^(?!.*\.(ts|js|env)$).*/,
+    /.*\.(jpg|jpeg|png|gif|bmp|svg|webp)$/i,
+    /node_modules|node_modules\/.*/,
+    /node_modules/,
+    /(^|[\/\\])\../,
+    "*/node_modules",
+    "*/dist",
+    "*.zip",
+    "*.tar",
+    "*.tar.gz",
+    "build",
+    "coverage",
+    "packages/*/dist",
+    "packages/*/build",
+    "packages/*/coverage",
+    "packages/*/node_modules",
+  ],
+})
+  .on("change", (path) => {
+    let dev = process.argv.includes("--dev");
+
+    if (dev) {
+      s.start("Restarting due to changes ...");
+      if (exec?.kill) {
+        exec.kill();
+      }
+      setTimeout(() => {
+        runPkg({ stopSpinner: true });
+      }, 600);
+    }
+  })
+  .on("ready", () => {
+    let dev = process.argv.includes("--dev");
+    let start = process.argv.includes("--start");
+
+    if (dev || start) {
+      runPkg();
+    } else {
+      process.exit();
+    }
+  });

package/driver/mongo/connect.ts

@@ -10,7 +10,7 @@ async function connectToMongo(t: Tenant) {
     await client
       .connect()
       .then((e) => {
-        consola.log(`[${t.id}] : Connected to db ✅`.green);
+        //consola.log(`[${t.id}] : Connected to db ✅`.green);
         t.database.isConnected = true;
         t.database.client = client;
         t.database.db = client.db();

package/lib/collection.ts

@@ -7,6 +7,7 @@ import { Cfg } from "../config";
 import { useRest } from "../driver/mongo/rest";
 import { buildSchema } from "./schema";
 import { cleanPath, resolvePath } from "../utils";
+import { hookDatabase } from "../lib/database";
 
 import path from "path";
 import consola from "consola";
@@ -180,7 +181,13 @@ async function syncCollectionDatabase() {
     //
     console.error(err?.message || err);
   }
-  consola.success("Database synchronized ");
+
+  // Data sync
+  if (hookDatabase?.cb?.length) {
+    for (const fn of hookDatabase.cb) {
+      fn();
+    }
+  }
 }
 
 export {

package/lib/database.ts

@@ -0,0 +1,5 @@
+const hookDatabase = {
+  cb: [] as Array<Function>,
+};
+
+export { hookDatabase };

package/lib/index.ts

@@ -17,7 +17,7 @@ async function init(cf = { app: null }) {
   loadServices();
 
   // load Socket
-  loadSocket();
+  await loadSocket();
 
   // load all loadEndpoints
   await loadEndpoints();

package/lib/mail.ts

@@ -0,0 +1,120 @@
+import { createTransport } from "nodemailer";
+import { Cfg } from "../config/index";
+import type { emailConfigType } from "../types";
+function sendLocalEmail(
+  mailOptions: {
+    from?: string;
+    text?: string;
+    html?: string;
+    subject?: string;
+    to?: string | Array<string> | null | undefined;
+    replyTo?: string;
+    cc?: string | Array<string> | null | undefined;
+    bcc?: string | Array<string> | null | undefined;
+  } = {}
+) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const smtp = Cfg.email?.smtpOptions;
+      const transport = createTransport({
+        host: smtp?.host,
+        port: Number(smtp?.port),
+        secure: smtp?.secure,
+        requireTLS: smtp?.requireTLS || true,
+        from: `${Cfg.email?.fromName || ""} <${Cfg?.email?.fromAddress || ""}>`,
+      });
+
+      var response = await transport.sendMail({
+        from:
+          mailOptions.from ||
+          `${Cfg.email?.fromName || ""} <${Cfg?.email?.fromAddress || ""}>`,
+        to: mailOptions?.to || undefined,
+        subject: mailOptions?.subject || "",
+        text: mailOptions?.text || "",
+        html: mailOptions?.html || "",
+        replyTo: mailOptions?.replyTo || undefined,
+        cc: mailOptions?.cc || undefined,
+        bcc: mailOptions?.bcc || undefined,
+      });
+      resolve(response);
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+function sendEmail(
+  emailConfig: emailConfigType,
+  mailOptions: {
+    from?: string;
+    text?: string;
+    html?: string;
+    subject?: string;
+    to?: string | Array<string> | null | undefined;
+    replyTo?: string;
+    cc?: string | Array<string> | null | undefined;
+    bcc?: string | Array<string> | null | undefined;
+  } = {}
+) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const smtp = Cfg.email?.smtpOptions;
+      const transport = createTransport(emailConfig.smtpOptions);
+
+      var response = await transport.sendMail({
+        from:
+          mailOptions.from ||
+          `${emailConfig?.fromName || ""} <${emailConfig?.fromAddress || ""}>`,
+        to: mailOptions?.to || undefined,
+        subject: mailOptions?.subject || "",
+        text: mailOptions?.text || "",
+        html: mailOptions?.html || "",
+        replyTo: mailOptions?.replyTo || undefined,
+        cc: mailOptions?.cc || undefined,
+        bcc: mailOptions?.bcc || undefined,
+      });
+      resolve(response);
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+function updateLocalEmailConfig(options: emailConfigType) {
+  Cfg.email = options;
+}
+
+function verifyLocalSmtpConnection(smtpConfig: emailConfigType["smtpOptions"]) {
+  return new Promise((resolve, reject) => {
+    let transport = createTransport(smtpConfig);
+    transport.verify((error, success) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(success);
+      }
+    });
+  });
+}
+
+function verifySmtpConnection(smtpConfig: emailConfigType["smtpOptions"]) {
+  return new Promise((resolve, reject) => {
+    let transport = createTransport(smtpConfig);
+    transport.verify((error, success) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(success);
+      }
+    });
+  });
+}
+
+const email = {
+  sendEmail,
+  sendLocalEmail,
+  updateLocalEmailConfig,
+  verifySmtpConnection,
+  verifyLocalSmtpConnection,
+};
+
+export { email };

package/lib/opt.ts

@@ -0,0 +1,55 @@
+import { parse } from "@lukeed/ms";
+import generateUniqueId from "generate-unique-id";
+type otpOptions = {
+  length?: number;
+  useLetters?: boolean;
+  useNumbers?: boolean;
+  includeSymbols?: Array<any>;
+  excludeSymbols?: Array<any>;
+  expireIn?: string;
+};
+
+class Otp {
+  #otps: Map<string, number> = new Map();
+  #options: otpOptions;
+  constructor(options: otpOptions) {
+    this.#options = options;
+  }
+
+  generate(options: { id?: string; data?: any } = {}): string | number {
+    setTimeout(() => {}, parse(String(this.#options.expireIn) || "1m"));
+    let otpCode = generateUniqueId({
+      length: this.#options.length || 6,
+      includeSymbols: this.#options.includeSymbols || [],
+      useLetters: this.#options.useLetters || true,
+      useNumbers: this.#options.useNumbers || true,
+      excludeSymbols: this.#options.excludeSymbols || [],
+    });
+    this.#otps.set(options?.id, {
+      otp: otpCode,
+      data: options?.data,
+    });
+
+    setTimeout(() => {
+      this.#otps.delete(options?.id);
+    }, parse(String(this.#options?.expireIn) || "1m"));
+    return otpCode;
+  }
+
+  delete(id: string): boolean {
+    return this.#otps.delete(id) ? true : false;
+  }
+  verify(id: string, otp: string): { valid: boolean; data: any } {
+    // verify otp
+    let otpData = this.#otps.get(id);
+    if (!otpData) return { valid: false, data: null };
+    if (otpData.otp === otp) {
+      this.#otps.delete(id);
+      return { valid: true, data: otpData?.data };
+    } else {
+      return { valid: false, data: null };
+    }
+  }
+}
+
+export { Otp };

package/package.json

@@ -1,21 +1,28 @@
 {
   "name": "@dnax/core",
-  "version": "0.1.20",
+  "version": "0.2.0",
   "module": "index.ts",
   "type": "module",
+  "bin": {
+    "dnax": "./bin/index.ts"
+  },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "@types/nodemailer": "^6.4.15"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
   "dependencies": {
+    "@clack/prompts": "^0.7.0",
     "@colors/colors": "^1.6.0",
     "@google/generative-ai": "0.14.0",
     "@lukeed/ms": "^2.0.2",
     "@types/jsonwebtoken": "^9.0.6",
     "boxen": "^7.1.1",
+    "chokidar": "^3.6.0",
     "clean-deep": "^3.4.0",
+    "collect.js": "^4.36.1",
     "consola": "^3.2.3",
     "cookie": "^0.6.0",
     "croner": "^8.0.2",
@@ -29,6 +36,7 @@
     "mingo": "^6.4.15",
     "moment": "^2.30.1",
     "mongodb": "^6.7.0",
+    "nodemailer": "^6.9.14",
     "radash": "^12.1.0",
     "signaldb": "^0.9.0",
     "socket.io": "^4.7.5",

package/types/index.ts

@@ -252,6 +252,21 @@ export type Collection = {
 };
 
 export type Config = {
+  email?: {
+    provider: "smtp";
+    fromName: string;
+    fromAddress: string;
+    smtpOptions?: {
+      host: string;
+      port: number;
+      secure?: boolean;
+      requireTLS?: boolean;
+      auth: {
+        user: string;
+        pass: string;
+      };
+    };
+  };
   studio?: {
     /**
      * Enable or disable the studio
@@ -386,3 +401,30 @@ export type Service = {
     io: Io;
   }) => any;
 };
+
+export type emailConfigType = {
+  provider: "smtp";
+  fromName: string;
+  fromAddress: string;
+  smtpOptions?: {
+    host: string;
+    port: number;
+    secure?: boolean;
+    requireTLS?: boolean;
+    auth: {
+      user: string;
+      pass: string;
+    };
+  };
+};
+
+export type smtpConfigType = {
+  host: string;
+  port: number;
+  secure?: boolean;
+  requireTLS?: boolean;
+  auth: {
+    user: string;
+    pass: string;
+  };
+};

package/utils/index.ts

@@ -7,8 +7,12 @@ import { parse, format } from "@lukeed/ms";
 import jwto from "jsonwebtoken";
 import generateUniqueId from "generate-unique-id";
 import dayjs from "dayjs";
+import { Otp } from "../lib/opt";
+import collect from "collect.js";
+
 const JWT_SECRET = process?.env?.JWT_SECRET || "secret-libv";
 import * as _ from "radash";
+import { email } from "../lib/mail";
 
 const jwt = {
   verify: (token: string): { decode: any; valid: boolean; error: any } => {
@@ -241,23 +245,31 @@ const fn = {
 };
 
 const $ = Bun.$;
+const password = {
+  hash: hashPassword,
+  verify: verifyHashPassword,
+};
 
 export {
+  password, // Hash and verify Password utils
+  email, // smtp utils
   moment,
-  $,
-  fn,
-  deepMerge,
-  toDate,
-  toJson,
+  $, // $ Bun utils
+  fn, // fn global error dispatch
+  deepMerge, // DeepMerge
+  toDate, // transform to date
+  toJson, //  to Json
   hashPassword,
   verifyHashPassword,
   cleanPath,
-  freeze,
+  freeze, // Lock object properties
   resolvePath,
-  isDate,
+  isDate, // Check if date
   contextError,
-  jwt,
-  _,
-  generateUniqueId,
-  omit,
+  jwt, // Jwt utils
+  _, // Moment utils
+  generateUniqueId, // Generate unique id
+  omit, // Omit utils
+  collect, // Collect utils
+  Otp, // Otp utils
 };