@dnax/core 0.11.0 → 0.12.0

package/app/hono.ts

@@ -1,5 +1,6 @@
 import type { Q, Tenant, sessionCtx } from "../types/";
 import fs from "fs-extra";
+import { cleanDoubleSlashes } from "ufo";
 import sharp from "sharp";
 import path from "path";
 import mime from "mime-types";
@@ -39,6 +40,15 @@ const cache = bentoCache.namespace("DNAX_API");
 const app = new Hono();
 const API_PATH = "/api";
 function HonoInstance(): typeof app {
+  // Public assets
+  app.get(
+    "/assets/*",
+    serveStatic({
+      root: "uploads",
+      //rewriteRequestPath: (path) => path?.replace(/^\/assets/, ""),
+    })
+  );
+
   if (Cfg?.server?.logger) {
     if (typeof Cfg?.server?.logger == "function" && Cfg?.server?.logger) {
       app.use(async (c, next) => {
@@ -650,16 +660,13 @@ function HonoInstance(): typeof app {
     }
   });
 
+  if (Cfg.routes?.length) {
+    Cfg.routes.map((r) => {
+      app.route(cleanDoubleSlashes("/" + r.base), r.router);
+    });
+  }
+
   return app;
 }
 
-// Public assets
-app.get(
-  "/assets/*",
-  serveStatic({
-    root: "uploads",
-    //rewriteRequestPath: (path) => path?.replace(/^\/assets/, ""),
-  })
-);
-
 export { HonoInstance };

package/define/index.ts

@@ -10,6 +10,7 @@ import type {
   ctxApi,
   middlewareCtx,
   permissionSchema,
+  routeCtx,
 } from "../types";
 import { Cfg } from "../config/";
 import { deepMerge, freeze } from "../utils";
@@ -29,6 +30,11 @@ function Endpoint(config: Endpoint) {
   return config;
 }
 
+function Route(config: routeCtx) {
+  config.ok = true;
+  return config;
+}
+
 function Service(config: Service) {
   return config;
 }
@@ -93,6 +99,7 @@ const define = {
   Permission,
   Api,
   Access,
+  Route,
 };
 
 export default define;

package/lib/index.ts

@@ -5,6 +5,7 @@ import { loadServices } from "./service";
 import { initCron } from "./cron";
 import { loadPermissions } from "./permissions";
 import { loadSocket } from "./socket";
+import { loadAutoRoutes } from "./routes";
 // load all ressource
 async function init(cf = { app: null }) {
   // load all tenants database
@@ -27,6 +28,9 @@ async function init(cf = { app: null }) {
   // load all loadEndpoints
   await loadEndpoints();
 
+  // load auto routes
+  await loadAutoRoutes();
+
   await initCron();
 }
 

package/lib/routes.ts

@@ -0,0 +1,53 @@
+import { omit } from "radash";
+import type { Collection, Endpoint, Field } from "../types/index";
+import { Glob } from "bun";
+import { Cfg } from "../config";
+import { cleanPath, resolvePath } from "../utils";
+import path from "path";
+import { useRest } from "../driver/mongo/rest";
+import { Hono } from "hono";
+async function loadAutoRoutes() {
+  let endpoints = [] as any;
+  if (Cfg?.tenants) {
+    for await (let t of Cfg.tenants) {
+      let tenantPath = `${t.dir}/routes/**/*.{ts,js}`;
+      const glob = new Glob(tenantPath);
+      for await (let file of glob.scan({
+        cwd: Cfg.cwd,
+      })) {
+        let fullPathFile = path.join(Cfg.cwd || "", file);
+        const regex = /^src\/routes\/(.*)/;
+        const matchPath = file.match(regex);
+        let baseURL: string | null = null;
+
+        if (matchPath) {
+          baseURL = matchPath[1];
+          baseURL = path.dirname(baseURL);
+        }
+
+        await import(fullPathFile)
+          .then((inject) => {
+            let instance = {
+              router: new Hono(),
+            };
+            inject?.default?.handler({
+              io: Cfg.io,
+              router: instance.router,
+            });
+            if (baseURL) {
+              endpoints.push({
+                router: instance.router,
+                base: baseURL,
+              });
+            }
+          })
+          .catch((err) => {
+            console.error(err);
+          });
+      }
+    }
+  }
+  Cfg.routes = endpoints;
+}
+
+export { loadAutoRoutes };

package/package.json

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

package/types/index.ts

@@ -5,7 +5,7 @@ import * as v from "valibot";
 import type { Db, MongoClient } from "mongodb";
 import { useRest } from "../driver/mongo/rest";
 import { sessionStorage } from "../lib/asyncLocalStorage";
-import type { Context } from "hono";
+import type { Context, Hono } from "hono";
 import type { Server as ServerIO, Socket as SocketType } from "socket.io";
 
 type Io = InstanceType<typeof ServerIO>;
@@ -383,6 +383,7 @@ export type Config = {
    * Tenants database for API
    */
   tenants: Tenant[];
+  routes?: { base: string; router: InstanceType<typeof Hono> }[];
   permissions?: permissionSchema[];
   /**
    * Dont touch it automatically generated
@@ -426,6 +427,20 @@ export type Q = {
     | "batch";
 };
 
+export type routeOption = {
+  /**
+   * Base URL
+   */
+  base: string; // base URL
+  handler: (ctx: {
+    io: Io;
+    router: {
+      post: (path: string, clb: (c: Context) => void) => {};
+      get: (path: string, clb: (c: Context) => void) => {};
+    };
+  }) => any;
+};
+
 export type endpointCtx = {
   enabled: boolean;
   handler: (ctx: {
@@ -437,6 +452,17 @@ export type endpointCtx = {
   }) => any;
 };
 
+export type routeCtx = {
+  enabled: boolean;
+  handler: (ctx: {
+    io: Io;
+    router: {
+      post: (path: string, clb: (c: Context) => void) => {};
+      get: (path: string, clb: (c: Context) => void) => {};
+    };
+  }) => any;
+};
+
 export type Endpoint = endpointCtx;
 
 export type Service = {