@dnax/core 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# core
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.1.0. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/ai/gemini.ts

@@ -0,0 +1,97 @@
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { Cfg } from "../config";
+import { getCollection } from "../lib/collection";
+
+class Gemini {
+  #genAI: InstanceType<typeof GoogleGenerativeAI>;
+  #api_key: any;
+  #tenant_id: any;
+  #systemInstruction: string | undefined = "";
+  #model: string = "gemini-1.5-flash";
+
+  constructor(
+    opts: {
+      tenant_id?: string;
+      key?: string;
+      systemInstruction?: string;
+      model?: string;
+    } = {
+      model: "gemini-1.5-flash",
+    }
+  ) {
+    this.#genAI = new GoogleGenerativeAI(
+      opts.key || Cfg.ai?.key || process.env.AI_KEY || ""
+    );
+    this.#systemInstruction = opts.systemInstruction;
+    this.#tenant_id = opts?.tenant_id || null;
+    this.#api_key = process.env.key || Cfg.ai?.key || "";
+    this.#model = opts.model || "gemini-1.5-flash";
+  }
+
+  async generateContent(
+    content: string,
+    options: {
+      systemInstruction: string;
+      generationConfig?: {
+        responseMimeType: string;
+      };
+    } = {
+      systemInstruction: "",
+    }
+  ) {
+    let model = this.#genAI.getGenerativeModel({
+      model: this.#model,
+      systemInstruction: options.systemInstruction || this.#systemInstruction,
+      generationConfig: options.generationConfig || {},
+    });
+    let result = await model.generateContent(content);
+    let response = await result.response.text();
+    return response;
+  }
+
+  /* async generateFilter(opts: { collection: string; prompt: string }) {
+    let col = getCollection(opts.collection, this.#tenant_id);
+    let model = this.#genAI.getGenerativeModel({
+      model: "gemini-1.5-flash",
+      systemInstruction: `
+      
+      En te basant les informations json suivantes  : 
+      Nom de la base de donnée : ${col?.slug}
+      et de la structure des champs suivants :
+      ${col?.fields} 
+
+      Merci de fourni un filtre $match(aggregate) de mongodb qui correspond à la demande du 
+      l'utilisateur et de retourner ce $match sous forme de JSON parse
+
+      - Si la demande ne correspond pas à une generation de filter $match 
+      merci de retourner "{}" comme réponse en json parse .
+
+     Exemple de format json de retour : {"$match":{"nom":"John"}}
+    
+      `,
+    });
+    let result = await model.generateContent(opts.prompt);
+    let response = await result.response.text();
+
+    return extractJson(response);
+  } */
+}
+function extractJson(chaine: string) {
+  try {
+    // Utiliser une expression régulière pour extraire le contenu JSON
+    const match = chaine.match(/\{.*\}/);
+    if (match) {
+      // Extraire le contenu JSON
+      const jsonStr = match[0];
+      // Convertir la chaîne JSON en objet JavaScript
+      const jsonData = JSON.parse(jsonStr);
+      return jsonData;
+    } else {
+      return null;
+    }
+  } catch (err: any) {
+    console.log(err?.message);
+    return {};
+  }
+}
+export { Gemini };

package/ai/index.ts

@@ -0,0 +1,2 @@
+import { Gemini } from "./gemini";
+export { Gemini };

package/ai/mistral.ts

@@ -0,0 +1,63 @@
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { Cfg } from "../config";
+import { getCollection } from "../lib/collection";
+
+class Mistral {
+  #genAI: InstanceType<typeof GoogleGenerativeAI>;
+  #api_key: any;
+  #tenant_id: any;
+
+  constructor(opts: { tenant_id?: string; key?: string } = {}) {
+    this.#genAI = new GoogleGenerativeAI(
+      opts.key || Cfg.ai?.key || process.env.API_KEY || ""
+    );
+    this.#tenant_id = opts?.tenant_id || null;
+    this.#api_key = process.env.key || Cfg.ai?.key || "";
+  }
+
+  async generateFilter(opts: { collection: string; prompt: string }) {
+    let col = getCollection(opts.collection, this.#tenant_id);
+    let model = this.#genAI.getGenerativeModel({
+      model: "gemini-1.5-flash",
+      systemInstruction: `
+      
+      En te basant les informations json suivantes  : 
+      Nom de la base de donnée : ${col?.slug}
+      et de la structure des champs suivants :
+      ${col?.fields} 
+
+      Merci de fourni un filtre $match(aggregate) de mongodb qui correspond à la demande du 
+      l'utilisateur et de retourner ce $match sous forme de JSON parse
+
+      - Si la demande ne correspond pas à une generation de filter $match 
+      merci de retourner "{}" comme réponse en json parse .
+
+     Exemple de format json de retour : {"$match":{"nom":"John"}}
+    
+      `,
+    });
+    let result = await model.generateContent(opts.prompt);
+    let response = await result.response.text();
+
+    return extractJson(response);
+  }
+}
+function extractJson(chaine: string) {
+  try {
+    // Utiliser une expression régulière pour extraire le contenu JSON
+    const match = chaine.match(/\{.*\}/);
+    if (match) {
+      // Extraire le contenu JSON
+      const jsonStr = match[0];
+      // Convertir la chaîne JSON en objet JavaScript
+      const jsonData = JSON.parse(jsonStr);
+      return jsonData;
+    } else {
+      return null;
+    }
+  } catch (err: any) {
+    console.log(err?.message);
+    return {};
+  }
+}
+export { Mistral };

package/app/ctrl.ts

@@ -0,0 +1,26 @@
+import type { Q } from "../types/";
+const actions = [
+  "findOneAndUpdate",
+  "findOne",
+  "find",
+  "insertOne",
+  "insertMany",
+  "updateOne",
+  "updateMany",
+  "deleteOne",
+  "deleteMany",
+  "aggregate",
+  "authCollection",
+  "auth",
+  "execService",
+  "upload",
+];
+
+function getAction(action: string) {
+  if (actions.includes(action)) {
+    return true;
+  }
+  return false;
+}
+
+export { getAction };

package/app/hono.ts

@@ -0,0 +1,398 @@
+import type { Q, Tenant, sessionCtx } from "../types/";
+
+import { Hono } from "hono";
+import { getCookie, setCookie } from "hono/cookie";
+
+import { serveStatic, getConnInfo } from "hono/bun";
+import { consola } from "consola";
+import { cors } from "hono/cors";
+import { asyncLocalStorage, sessionStorage } from "../lib/asyncLocalStorage";
+import { cleanPath, contextError, jwt, fn, omit } from "../utils";
+import { getAction } from "./ctrl";
+import { getCollection } from "../lib/collection";
+import { useRest } from "../driver/mongo/rest";
+import moment from "moment";
+import { Cfg } from "../config";
+import { getService } from "../lib/service";
+import { MediaDrive } from "../lib/media";
+import { isStudio } from "../lib/studio";
+import { pick } from "radash";
+import { secureHeaders } from "hono/secure-headers";
+const app = new Hono();
+
+const API_PATH = "/api";
+function HonoInstance(): typeof app {
+  app.use(secureHeaders());
+
+  app.use(
+    cors({
+      origin: Cfg.server?.cors?.origin || [],
+      credentials: true,
+    })
+  );
+  //eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjoibm9tIiwiaWF0IjoxNzE3Nzc0MDQzLCJleHAiOjE3MTc3NzQxMDN9.Ud4-0y8pa4SMIcSn8PU1A-sjC-hT4ZVe_u3AdChyIJU
+  // Middleware
+  app.use(async (c, next) => {
+    return asyncLocalStorage.run(new Map(), async () => {
+      let cookie = getCookie(c);
+      let secretKeyStudio = cookie["_STUDIO_SECRET_KEY_"] || null;
+      let session = sessionStorage();
+      var token = jwt.getToken("Bearer", c.req.header()["authorization"]) || "";
+      var { decode, valid, error } = jwt.verify(token);
+      c.set("_STUDIO_SECRET_KEY_", secretKeyStudio);
+      c.set("isStudio", isStudio(secretKeyStudio));
+      c.set("_v", {
+        token: token || null,
+        ip: c.req.raw.headers.get("CF-Connecting-IP"),
+        isAuth: decode?._v?.isAuth ? true : false,
+      });
+      c.set("tenant-id", c.req.header()["tenant-id"]);
+      if (token && valid) {
+        session.set({
+          state: decode,
+          _v: c.var?._v || {},
+          token: token,
+        });
+      }
+
+      // If token  wrong or break
+      if (token && !valid) {
+        c.status(401);
+        return c.json({ error });
+      }
+
+      return await next();
+    });
+  });
+
+  // Public assets
+  app.get(
+    "/assets/*",
+    serveStatic({
+      root: "uploads",
+      //rewriteRequestPath: (path) => path?.replace(/^\/assets/, ""),
+    })
+  );
+
+  app.post("/api/studio", (c, next) => {
+    let cookie = getCookie(c);
+    let secretKeyStudio = cookie["_STUDIO_SECRET_KEY_"];
+    let canPerform = isStudio(secretKeyStudio);
+    let cf = {
+      collections: Cfg.collections?.map((c) =>
+        pick(c, ["fields", "slug", "tenant_id", "type"])
+      ),
+      tenants: Cfg.tenants.map((t) => t?.id),
+    };
+
+    if (canPerform) {
+      return c.json({
+        auth: true,
+        data: cf,
+      });
+    } else {
+      c.status(403);
+      return c.json({ message: "Unauthorized" });
+    }
+  });
+
+  Cfg.collections?.map((c) => {
+    if (c?.type == "media" && c.media?.enabled) {
+      let mediaPath = cleanPath(
+        "/files/" + (c?.media?.overwriteFolderName || c?.slug) + "/public/*"
+      );
+
+      //console.log("Media Path :", mediaPath);
+      app.get(
+        mediaPath,
+        serveStatic({
+          root: cleanPath("uploads"),
+          rewriteRequestPath: (path) => path?.replace(/^\/files/, ""),
+          onNotFound: (path, c) => {
+            console.log(`${path} is not found, you access ${c.req.path}`);
+          },
+        })
+      );
+    }
+  });
+
+  // access controle for api
+  app.use(cleanPath(API_PATH), async (c, next) => {
+    let session = sessionStorage();
+    const { action, collection, cleanDeep, useCache } = c.req.query() as Q;
+
+    let tenant_id = c.var["tenant-id"];
+    let col = getCollection(collection, tenant_id);
+    let colAccess = col?.access?.hasOwnProperty(action) || null;
+    let nextLifecyle: any = false;
+
+    if (col && col?.access?.beforeAction) {
+      await col?.access?.beforeAction({
+        token: c.var["token"] || null,
+        action: action,
+        c: c,
+        isAuth: c.var?._v?.isAuth || false,
+        rest: new useRest({ tenant_id: tenant_id }),
+        session: session as any,
+      });
+    }
+
+    if (
+      action == "auth" ||
+      action == "authCollection" ||
+      action == "execService" ||
+      action == "upload"
+    ) {
+      return await next();
+    }
+
+    let performFromStudio = c.var["isStudio"] || false;
+
+    if (col && col?.access?.allAction) {
+      nextLifecyle = await col?.access?.allAction({
+        token: c.var["token"] || null,
+        action: action,
+        c: c,
+        isAuth: false,
+        rest: new useRest({ tenant_id: tenant_id }),
+        session: sessionStorage(),
+      });
+    } else {
+      if ((col && action && colAccess) ?? false) {
+        nextLifecyle = await col?.access[action]({
+          session: sessionStorage(),
+          action: action,
+          c: c,
+          isAuth: c.var?._v?.isAuth || false,
+          rest: new useRest({ tenant_id: tenant_id }),
+        });
+      }
+    }
+
+    if (nextLifecyle || performFromStudio) {
+      return await next();
+    } else {
+      c.status(403);
+      return c.json({
+        message: "Unauthorized",
+      });
+    }
+  });
+
+  // API REST
+  app.post(cleanPath(API_PATH), async (c) => {
+    try {
+      var response;
+      var parseBody;
+      const { action, collection, cleanDeep, useCache, name } =
+        c.req.query() as Q;
+      const service = getService(name, c.var["tenant-id"]);
+      const col = getCollection(collection, c.var["tenant-id"]);
+
+      if (
+        c.req.raw?.headers
+          ?.get("content-type")
+          ?.match(/(multipart\/form-data)/) ||
+        c.req?.raw?.headers.get("content-type") ==
+          "application/x-www-form-urlencoded"
+      ) {
+        parseBody = (await c?.req.parseBody()) || {};
+      }
+
+      const body = await c?.req
+        ?.json()
+        .then((e) => e)
+        .catch((err) => null);
+
+      const rest = new useRest({
+        tenant_id: c.var["tenant-id"],
+      });
+
+      // Controlle action
+      if (!getAction(action)) {
+        throw new contextError(`Action ${action} not found`, 400);
+      }
+
+      // Exec service
+      if (action == "execService") {
+        if (!service) return fn.error("Service not found", 404);
+        response = await service.fx({
+          data: body?.data || {},
+          rest: rest,
+          error: fn.error,
+          session: sessionStorage(),
+          isAuth: c.var?._v?.isAuth || false,
+        });
+      }
+
+      // Controler on collection
+      if (
+        !getCollection(collection, c.var["tenant-id"]) &&
+        getAction(action) &&
+        collection
+      ) {
+        throw new contextError(`Collection ${collection} not found`, 404);
+      }
+
+      // if action and collection
+      //getCollection(collection, c.var["tenant-id"]
+      if (
+        getAction(action) &&
+        getCollection(collection, c.var["tenant-id"]) &&
+        collection
+      ) {
+        if (action == "authCollection") {
+          let reponse;
+          if (!col?.auth?.enabled) fn.error("Auth not enabled", 401);
+          if (!col?.auth?.handler) fn.error("Auth handler not set", 401);
+          if (col?.auth?.handler) {
+            let responseAuth = await col?.auth?.handler({
+              data: body,
+              c: c,
+              rest: rest,
+              error: fn.error,
+              session: sessionStorage(),
+            });
+
+            if (
+              responseAuth !== undefined &&
+              responseAuth !== null &&
+              responseAuth
+            ) {
+              return c.json({
+                auth: true,
+                data: responseAuth,
+                token: jwt.sign(sessionStorage().get().state),
+              });
+            } else {
+              c.status(401);
+              return c.json({ message: "Authentification failed" });
+            }
+          }
+        }
+
+        // upload
+        if (action == "upload") {
+          if (!parseBody?.file) return fn.error("File not found", 404);
+          if (col?.slug && col?.media?.enabled) {
+            let data = JSON.parse(parseBody?.data) || {};
+            rest.startTransaction();
+            const drive = new MediaDrive({
+              location: col?.media?.overwriteFolderName ?? col?.slug,
+              visibility: col?.media?.visibility ?? "public",
+            });
+
+            if (Array.isArray(parseBody?.file)) {
+              let insertedFiles = [];
+              for await (let file of parseBody?.file) {
+                let insertedFile = await drive.write(file.name, file);
+                insertedFiles.push(insertedFile);
+              }
+              response = await rest.insertMany(col?.slug, insertedFiles);
+            } else if (typeof parseBody?.file == "object") {
+              let insertedFile = await drive.write(
+                parseBody.file?.name,
+                parseBody.file
+              );
+
+              response = await rest.insertOne(col?.slug, {
+                ...data,
+                _file: insertedFile,
+              });
+            }
+            await rest?.commitTransaction();
+            // console.log("File is ", insertedFile);
+          } else {
+            return fn.error("Media config not set or not enabled", 404);
+          }
+        }
+
+        // aggregate
+        if (action == "aggregate") {
+          response = await rest.aggregate(collection, body.pipeline || []);
+        }
+
+        // udpateOne
+
+        if (action == "find") {
+          response = await rest.find(collection, body?.params || {});
+        }
+        if (action == "findOne") {
+          response = await rest.findOne(
+            collection,
+            body?.id || body._id,
+            body?.params || {}
+          );
+        }
+        if (action == "insertOne") {
+          response = await rest.insertOne(collection, body?.data || {});
+        }
+
+        if (action == "insertMany") {
+          response = await rest.insertMany(collection, body?.data || {});
+        }
+
+        if (action == "updateOne") {
+          response = await rest.updateOne(
+            collection,
+            body?.id || body?._id,
+            body?.update || {},
+            body?.options
+          );
+        }
+        if (action == "findOneAndUpdate") {
+          response = await rest.findOneAndUpdate(
+            collection,
+            body?.filter || {},
+            body?.update || {},
+            body?.options
+          );
+        }
+        if (action == "updateMany") {
+          response = await rest.updateMany(
+            collection,
+            body?.ids,
+            body?.update,
+            body?.options
+          );
+        }
+
+        if (action == "deleteOne") {
+          response = await rest.deleteOne(collection, body?.id || body._id);
+        }
+
+        if (action == "deleteMany") {
+          response = await rest.deleteMany(collection, body?.ids);
+        }
+      }
+
+      if (col?.privateFields?.length) {
+        response = omit(response, col?.privateFields || []);
+      }
+
+      return c.json(response);
+    } catch (err: any) {
+      if (Cfg?.debug) console.log(err?.message);
+      if (err?.code && (err?.code < 200 || err?.code > 599)) {
+        err.code = 409;
+      }
+      c.status(err.code || 500);
+      return c.json({
+        message: err?.message || err,
+      });
+    }
+  });
+
+  // Endpoint
+  Cfg?.endpoints?.map((e) => {
+    if (e?.enabled) {
+      e.handler({
+        router: app,
+      });
+    }
+  });
+
+  return app;
+}
+
+export { HonoInstance };

package/app/index.ts

@@ -0,0 +1,72 @@
+import consola from "consola";
+import { Cfg, loadCfg } from "../config";
+import { init } from "../lib";
+import boxen from "boxen";
+import "@colors/colors";
+import pkg from "../package.json";
+import findPort from "find-open-port";
+import { HonoInstance } from "./hono";
+async function runApp(config?: any, clb?: Function) {
+  console.log("\n");
+
+  await loadCfg();
+  //
+
+  // Load all ressouce
+  await init();
+
+  // Load Hono App and route api
+  const HonoApp = HonoInstance();
+  const PORT = Cfg.server?.port || process.env?.PORT || 4000;
+
+  await findPort.isAvailable(PORT).then((available: boolean) => {
+    // Start App server
+
+    if (available) {
+      Bun.serve({
+        port: PORT,
+        fetch: HonoApp.fetch,
+        maxRequestBodySize: 1024 * 1024 * 900,
+      });
+
+      console.log();
+      let info = "";
+      info += "SERVER DETAILS :".gray.italic.underline;
+      info += `\n`;
+      info += `\n`;
+      info +=
+        `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;
+      info += `\n`;
+      Cfg.tenants?.map((t: any) => {
+        info += `\n${t?.name?.blue || "_"} : ${t?.id?.green}`.italic;
+      });
+      info += `\n`;
+
+      if (clb) clb();
+
+      console.log(
+        boxen(info, {
+          borderStyle: "round",
+          title: `@libv/server ${pkg.version}`.italic,
+          padding: 1,
+          dimBorder: true,
+          titleAlignment: "center",
+          //float: "center",
+          //margin: 1,
+          borderColor: "gray",
+        })
+      );
+    } else {
+      console.error(`⚠️ Port ${PORT} is not available`);
+      console.log("");
+      process.exit();
+    }
+  });
+}
+
+export { runApp };