@dnax/core 0.0.1

package/lib/media.ts

@@ -0,0 +1,74 @@
+import { cleanDoubleSlashes } from "ufo";
+import fs from "fs";
+import { v4 } from "uuid";
+type driverOptions = {
+  location: string;
+  visibility?: "public" | "private";
+};
+
+function formatFileName(texte: string) {
+  texte = v4() + "-" + texte;
+  // Enlever les diacritiques
+  texte = texte?.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+  texte = texte?.replace(/\s/g, "");
+  return texte;
+}
+
+function formatPath(path: string) {
+  return cleanDoubleSlashes(path);
+}
+
+class MediaDrive {
+  options: driverOptions;
+  #driver: driverOptions;
+  constructor(options: driverOptions) {
+    this.options = options;
+    this.#driver = {
+      location:
+        process.cwd() +
+          "/uploads/" +
+          options.location +
+          "/" +
+          options?.visibility || "public/",
+      visibility: options.visibility,
+    };
+    this.initialize();
+  }
+
+  async initialize() {
+    if (!fs.existsSync(formatPath(this.#driver.location))) {
+      fs.mkdirSync(formatPath(this.#driver.location), { recursive: true });
+    }
+  }
+
+  async write(filename: string, contents: any) {
+    let name = filename;
+    filename = formatFileName(filename);
+
+    let dest = this.#driver.location + "/" + filename;
+    await Bun.write(formatPath(dest), contents);
+    let file = await Bun.file(dest);
+    let diskPath =
+      cleanDoubleSlashes(
+        "/files/" + this.options.location + "/" + this.options?.visibility ??
+          "/public//"
+      ) +
+      "/" +
+      filename;
+
+    return {
+      original_name: name,
+      name: filename,
+      type: file.type,
+      size: file.size,
+      path: diskPath,
+      //url: url,
+    };
+  }
+
+  async get(filename: string) {
+    return await Bun.file(formatPath(this.#driver.location + "/" + filename));
+  }
+}
+
+export { MediaDrive };

package/lib/schema.ts

@@ -0,0 +1,112 @@
+import type { Collection } from "../types";
+import * as v from "valibot";
+function buildSchema(col: Collection) {
+  let propertySchema = {};
+
+  if (col?.media) {
+    propertySchema["_file"] = v.object({});
+  }
+
+  col?.fields?.map((f) => {
+    if (f?.type == "array") {
+      propertySchema[f.name] = v.array(v.any());
+    }
+
+    if (f?.type == "random" && f?.random?.toNumber) {
+      propertySchema[f.name] = v.number();
+    }
+    if (f?.type == "random" && !f?.random?.toNumber) {
+      propertySchema[f.name] = v.string();
+    }
+
+    if (f?.type.match(/(string|richText|textarea)/)) {
+      propertySchema[f.name] = v.string();
+    }
+
+    if (f.type == "number") {
+      propertySchema[f.name] = v.number();
+    }
+    if (f.type == "integer") {
+      propertySchema[f.name] = v.pipe(v.number(), v.integer());
+    }
+
+    if (f?.type == "boolean") {
+      propertySchema[f.name] = v.boolean();
+    }
+    if (f?.type == "json") {
+      propertySchema[f.name] = v.object({});
+    }
+    if (f?.type == "email") {
+      propertySchema[f.name] = v.pipe(v.string(), v.email());
+    }
+
+    if (f?.type == "relationship" && f.relationType == "ref-to-one") {
+      propertySchema[f.name] = v.string();
+    }
+
+    if (f?.type == "relationship" && f.relationType == "ref-to-many") {
+      propertySchema[f.name] = v.array(v.string());
+    }
+
+    if (f?.type?.match(/(date)/)) {
+      propertySchema[f.name] = v.date();
+    }
+
+    if (f?.type == "file") {
+      propertySchema[f.name] = v.object({});
+    }
+
+    if (f?.type == "url") {
+      propertySchema[f.name] = v.pipe(v.string(), v.url());
+    }
+
+    if (f?.type == "ipv4") {
+      propertySchema[f.name] = v.pipe(v.string(), v.ipv4());
+    }
+    if (f?.type == "ipv6") {
+      propertySchema[f.name] = v.pipe(v.string(), v.ipv6());
+    }
+
+    if (f?.type == "geojson") {
+      propertySchema[f.name] = v.object({
+        type: v.picklist(["Point", "LineString", "Polygon", "MultiPoint"]),
+        coordinates: v.array(v.number()),
+      });
+    }
+
+    if (f?.type == "random") {
+      propertySchema[f.name] = v.any();
+    }
+
+    if (f?.type == "password") {
+      propertySchema[f.name] = v.string();
+    }
+
+    if (f?.type == "enum") {
+      let items: Array<any> = [];
+      f?.enum?.items?.map((item) => {
+        if (typeof item == "string") {
+          items.push(item);
+        }
+        if (typeof item == "object") {
+          items.push(item?.value);
+        }
+      });
+      items = [...new Set(items)];
+
+      if (f?.enum?.multiple) {
+        propertySchema[f.name] = v.array(v.picklist(items || []));
+      } else {
+        propertySchema[f.name] = v.picklist(items || []);
+      }
+    }
+
+    if (f?.nullable) {
+      propertySchema[f.name] = v.nullish(propertySchema[f.name]);
+    }
+  });
+
+  return v.object(propertySchema, v.never());
+}
+
+export { buildSchema };

package/lib/service.ts

@@ -0,0 +1,43 @@
+import { omit } from "radash";
+import type { Collection, Endpoint, Field, Service } 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";
+
+async function loadServices() {
+  let services: Service[] = [];
+  if (Cfg.tenants) {
+    for await (let t of Cfg.tenants) {
+      let tenantPath = `${t.dir}/services/**/**.service.{ts,js}`;
+      const glob = new Glob(tenantPath);
+      for await (let file of glob.scan({
+        cwd: Cfg.cwd,
+      })) {
+        let fullPathFile = path.join(Cfg.cwd || "", file);
+
+        await import(fullPathFile)
+          .then((inject) => {
+            services.push({
+              ...inject?.default,
+              tenant_id: t.id,
+            });
+          })
+          .catch((err) => {
+            console.error(err);
+          });
+      }
+    }
+  }
+
+  Cfg.services = services;
+}
+
+function getService(name: string, tenant_id: string): Service | undefined {
+  return Cfg.services?.find(
+    (s) => s?.tenant_id == tenant_id && s?.name == name && s?.fx
+  );
+}
+
+export { loadServices, getService };

package/lib/socket.ts

@@ -0,0 +1,51 @@
+import { Cfg } from "../config";
+import { Server } from "socket.io";
+import consola from "consola";
+import { Glob } from "bun";
+import path from "path";
+import { useRest } from "../driver/mongo";
+async function loadSocket() {
+  var io = new Server(Number(Cfg.server?.socket?.port || 9000), {
+    cors: {
+      ...Cfg.server.cors,
+      credentials: true,
+    },
+  });
+  /*  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}`;
+      const glob = new Glob(tenantPath);
+      for await (let file of glob.scan({
+        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
+            ) {
+              let rest = new useRest({
+                tenant_id: t.id,
+              });
+              socketInstance.handler({
+                io,
+                rest,
+              });
+            }
+          })
+          .catch((err) => {
+            consola.error(file || "", err?.message);
+          });
+      }
+    }
+  }
+  Cfg.io = io;
+}
+
+export { loadSocket };

package/lib/studio.ts

@@ -0,0 +1,12 @@
+import { Cfg } from "../config";
+
+function isStudio(key: string) {
+  if (!key) return false;
+
+  let canPerform = false;
+  if (Cfg.studio?.secretKey == key && Cfg.studio?.enabled) canPerform = true;
+
+  return canPerform;
+}
+
+export { isStudio };

package/lib/tenant.ts

@@ -0,0 +1,9 @@
+import { Cfg } from "../config";
+import type { Tenant } from "../types";
+
+function getTenant(id: string): Tenant | any {
+  let tenant = Cfg.tenants.find((t) => t.id == id);
+  return tenant;
+}
+
+export { getTenant };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@dnax/core",
+  "version": "0.0.1",
+  "module": "index.ts",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@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",
+    "clean-deep": "^3.4.0",
+    "consola": "^3.2.3",
+    "cookie": "^0.6.0",
+    "croner": "^8.0.2",
+    "find-open-port": "^2.0.3",
+    "generate-unique-id": "^2.0.3",
+    "hono": "^4.4.3",
+    "hono-sessions": "^0.5.8",
+    "json-joy": "^16.8.0",
+    "jsonwebtoken": "^9.0.2",
+    "mingo": "^6.4.15",
+    "moment": "^2.30.1",
+    "mongodb": "^6.7.0",
+    "radash": "^12.1.0",
+    "signaldb": "^0.9.0",
+    "socket.io": "^4.7.5",
+    "ufo": "^1.5.3",
+    "uuid": "^10.0.0",
+    "valibot": "^0.31.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}