@dnax/core 0.0.1

package/driver/mongo/utils.ts

@@ -0,0 +1,361 @@
+import type { findParam } from "./@types";
+import type { Actions, Collection } from "../../types";
+import { ObjectId } from "mongodb";
+import { mapKeys, omit } from "radash";
+import { getCollection, getFieldCollection } from "../../lib/collection";
+import { isDate } from "../../utils";
+import generateUniqueId from "generate-unique-id";
+import { Cfg } from "../../config";
+function buildPipeline(params: findParam, col?: Collection | undefined | null) {
+  let pipeline = [];
+
+  // $match
+  if (params?.$match) {
+    pipeline.push({
+      $match: params.$match,
+    });
+  }
+
+  // $skip
+  if (params?.$skip) {
+    pipeline.push({
+      $skip: Number(params?.$skip) || 0,
+    });
+  }
+
+  // set Limit
+  if (params?.$limit !== 0 && params?.$limit !== -1) {
+    pipeline.push({
+      $limit:
+        params?.$limit ||
+        Number(process.env?.QUERY_LIMIT) ||
+        Number(Cfg?.server?.query_limit) ||
+        100,
+    });
+  }
+
+  // include
+
+  if (params?.$include?.length) {
+    params.$include.map((inc) => {
+      // AutoInclue by string
+
+      if (typeof inc === "string" && col) {
+        let field = getFieldCollection(inc, col);
+        if (field) {
+          pipeline.push({
+            $lookup: {
+              from: field.relationTo,
+              localField: inc,
+              foreignField: "_id",
+              as: inc,
+            },
+          });
+          if (field.relationType == "ref-to-one") {
+            pipeline.push({
+              $unwind: {
+                path: `$${inc}`,
+                preserveNullAndEmptyArrays: true,
+              },
+            });
+          }
+        }
+      }
+
+      if (typeof inc === "object") {
+        let field = getFieldCollection(inc?.localField, col);
+        pipeline.push({
+          $lookup: {
+            from: inc?.from || field?.relationTo,
+            localField: inc?.localField || field?.name,
+            foreignField: inc?.foreignField || "_id",
+            as: inc?.as || inc?.localField || field?.name,
+            pipeline: inc?.pipeline || [],
+          },
+        });
+
+        if (field?.relationType == "ref-to-one") {
+          pipeline.push({
+            $unwind: {
+              path: `$${inc?.as || inc?.localField || field?.name}`,
+              preserveNullAndEmptyArrays: true,
+            },
+          });
+        }
+
+        if (inc?.unwind) {
+          pipeline.push({
+            $unwind: {
+              path: `$${inc?.as || inc?.localField || field?.name}`,
+              preserveNullAndEmptyArrays: true,
+            },
+          });
+        }
+      }
+    });
+  }
+
+  // $matchInclude
+  if (params?.$matchInclude) {
+    pipeline.push({
+      $match: params.$matchInclude,
+    });
+  }
+
+  // project
+  if (params.$project) {
+    pipeline.push({
+      $project: params.$project,
+    });
+  }
+
+  // sorted
+  if (!params?.$sort?.createdAt) {
+    pipeline.push({
+      $sort: {
+        ...(params?.$sort || {}),
+        createdAt: -1,
+      },
+    });
+  }
+
+  // sample aleatoire
+  if (params?.$sample) {
+    pipeline.push({
+      $sample: params.$sample,
+    });
+  }
+  return pipeline || [];
+}
+
+function transformAllDate(data: object) {
+  try {
+    if (typeof data == "object" && data !== null && data !== undefined) {
+      mapKeys(data, (key, value) => {
+        if (typeof value == "string" && value && isDate(value)) {
+          data[key] = new Date(value);
+        } else {
+          return transformAllDate(data[key]);
+        }
+      });
+    }
+
+    //console.log(data);
+    return data;
+  } catch (error) {
+    console.log(error);
+
+    throw error;
+  }
+}
+
+function toBson<T>(
+  data: object | T,
+  options?: {
+    action?:
+      | "insertOne"
+      | "insertMany"
+      | "updateOne"
+      | "updateMany"
+      | "deleteOne"
+      | "deleteMany"
+      | "find"
+      | "findOne"
+      | "aggregate";
+  }
+): T {
+  if (data) {
+    // InsertOne
+    if (options?.action == "insertOne") {
+      data.createdAt = new Date();
+      data.updatedAt = new Date();
+    }
+
+    // insertMany
+    if (options?.action == "insertMany" && Array.isArray(data)) {
+      data?.map((d) => {
+        d.createdAt = new Date();
+        d.updatedAt = new Date();
+      });
+    }
+
+    // updateOne
+    if (options?.action == "updateOne") {
+      data.updateAt = new Date();
+    }
+
+    // updateMany
+    if (options?.action == "updateMany") {
+      data?.map((d) => {
+        d.updatedAt = new Date();
+      });
+    }
+
+    // start Transformation to Bson
+    if (typeof data == "string" && ObjectId.isValid(data)) {
+      data = new ObjectId(data);
+    }
+
+    if (typeof data == "string" && isDate(data)) {
+      if (isDate(data)) data = new Date(data);
+    }
+
+    // for object
+    if (typeof data == "object" && !Array.isArray(data)) {
+      mapKeys(data, (key, value) => {
+        data[key] = toBson(value);
+      });
+    }
+
+    // for array
+    if (typeof data == "object" && Array.isArray(data)) {
+      mapKeys(data, (key, value) => {
+        data[key] = toBson(value);
+      });
+    }
+  }
+  return data;
+}
+
+function deepSetId(col: Collection, data: any) {
+  if (col) {
+    col?.fields?.map((f) => {
+      if (f?.type == "array" && !data[f?.name]) {
+        data[f.name] = [];
+      }
+
+      if (f?.type == "relationship" && f?.relationType == "ref-to-many") {
+        data[f.name] = [];
+      }
+
+      if (f?.type == "relationship" && data[f.name]) {
+        if (typeof data[f.name] == "object" && !Array.isArray(data[f.name])) {
+          data[f.name] = data[f.name]?._id || data[f.name]?.id || data[f.name];
+        }
+
+        if (Array.isArray(data[f.name])) {
+          data[f.name].map((d, index) => {
+            d = d?._id || d?.id || d;
+            data[f.name][index] = d;
+          });
+        }
+      }
+    });
+  }
+  return data;
+}
+
+async function hashPasswordAuto(data: any, col: Collection) {
+  if (col) {
+    for await (let f of col?.fields || []) {
+      if (f.type == "password" && data[f?.name]) {
+        data[f.name] = await Bun.password.hash(data[f?.name]);
+      }
+    }
+  }
+
+  return data;
+}
+
+async function cleanData(data: any, col: Collection) {
+  data = omit(data, ["_id", "id", "createdAt", "updatedAt"]);
+
+  col.fields?.map((f) => {
+    if (f.random && data[f.name]) {
+      try {
+        delete data[f.name];
+      } catch (e) {}
+    }
+  });
+
+  return data;
+}
+
+async function randomCode(
+  data: any,
+  col: Collection,
+  action?: Actions
+): Promise<any> {
+  var code = null;
+  for await (let f of col?.fields || []) {
+    if (f?.random) {
+      code = generateUniqueId({
+        length: f?.random?.length || 6,
+        useLetters: f?.random?.useLetters ?? false,
+        useNumbers: f?.random?.useNumbers ?? true,
+        includeSymbols: f?.random?.includeSymbols || [],
+        excludeSymbols: f?.random?.excludeSymbols || [],
+      });
+
+      if (f?.random?.startWith) {
+        code = f?.random?.startWith + code;
+      }
+
+      if (f?.random?.endWith) {
+        code = code + f?.random?.endWith;
+      }
+
+      if (f?.random?.toLowerCase) {
+        code = code?.toLowerCase();
+      }
+      if (f?.random?.toUpperCase) {
+        code = code?.toUpperCase();
+      }
+
+      if (f?.random?.toNumber) {
+        code = Number(code);
+      }
+
+      data[f.name] = code;
+      // if unique
+      if (f?.unique) {
+        let tenant = Cfg.tenants.find((t) => t.id == col.tenant_id);
+
+        if (tenant) {
+          let doc = await tenant.database.db
+            ?.collection(col.slug)
+            .findOne({ [f.name]: code });
+
+          if (doc) {
+            code = await randomCode(data, col);
+            data[f.name] = code;
+          }
+        }
+      }
+    }
+  }
+  return data;
+}
+
+function formatData(
+  data: any,
+  options: {
+    collection?: string;
+    action?: Actions;
+    tenant_id: string;
+  } = {
+    tenant_id: "_",
+    collection: "",
+  }
+) {
+  let col = getCollection(options.collection, options?.tenant_id);
+  if (col) {
+    data = deepSetId(col, data);
+  }
+  data = toBson(data, {
+    action: options?.action,
+  });
+
+  return data;
+}
+
+export {
+  buildPipeline,
+  deepSetId,
+  toBson,
+  formatData,
+  randomCode,
+  cleanData,
+  hashPasswordAuto,
+  transformAllDate,
+};

package/index.ts

@@ -0,0 +1,11 @@
+import "@colors/colors";
+import { MongoClient, useRest } from "./driver/mongo";
+import { toBson } from "./driver/mongo/utils";
+import { runApp } from "./app";
+import define from "./define";
+import moment from "moment";
+import * as utils from "./utils";
+import * as v from "valibot";
+import * as ai from "./ai";
+
+export { runApp, define, v, utils, useRest, ai };

package/lib/asyncLocalStorage.ts

@@ -0,0 +1,47 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { sessionCtx } from "../types";
+const asyncLocalStorage = new AsyncLocalStorage();
+const key = "___sessionStorage___";
+const stateKey = "____requestState____";
+const sessionStorage = () => ({
+  get(): { state: object; _v: object; token: string } {
+    let store = asyncLocalStorage.getStore() as InstanceType<typeof Map>;
+    return (
+      (store.get(key) as { state: object; _v: object; token: string }) || {
+        state: {},
+        _v: {},
+        token: "",
+      }
+    );
+  },
+  set(
+    input: { state: object; _v?: object; token?: string | undefined | null } = {
+      state: {},
+      _v: {},
+      token: null,
+    }
+  ) {
+    let store = asyncLocalStorage.getStore() as InstanceType<typeof Map>;
+    store.set(key, {
+      ...this.get(),
+      state: {
+        ...this.get().state,
+        ...input.state,
+      },
+      token: input.token || this.get().token,
+    });
+  },
+});
+
+const requestStorage = () => ({
+  set(key: string, data: any): any {
+    let store = asyncLocalStorage.getStore() as InstanceType<typeof Map>;
+    return store.set(key, data);
+  },
+  get(key: string): any {
+    let store = asyncLocalStorage.getStore() as InstanceType<typeof Map>;
+    return store.get(key);
+  },
+});
+
+export { sessionStorage, asyncLocalStorage, requestStorage };

package/lib/collection.ts

@@ -0,0 +1,191 @@
+import cleanDeep from "clean-deep";
+import { omit } from "radash";
+import { deepEqual } from "json-joy/lib/json-equal/deepEqual";
+import type { Collection, Field } from "./../types/index";
+import { Glob } from "bun";
+import { Cfg } from "../config";
+import { useRest } from "../driver/mongo/rest";
+import { buildSchema } from "./schema";
+import { cleanPath, resolvePath } from "../utils";
+
+import path from "path";
+import consola from "consola";
+
+async function loadAllCollections() {
+  let collections: Collection[] = [];
+  if (Cfg.tenants) {
+    for await (let t of Cfg.tenants) {
+      let tenantPath = `${t.dir}/collections/**/**.model.{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) => {
+            collections.push({
+              ...inject?.default,
+              tenant_id: t.id,
+              schema: buildSchema(inject?.default),
+            });
+          })
+          .catch((err) => {
+            consola.error(file || "", err?.message);
+          });
+      }
+    }
+  }
+
+  Cfg.collections = collections;
+}
+
+function getCollection(
+  name: string,
+  tenant_id: string | number
+): Collection | undefined | null {
+  if (Cfg?.collections?.length) {
+    return Cfg.collections.find((col: Collection) => {
+      return col.slug === name && col.tenant_id === tenant_id;
+    });
+  }
+  return null;
+}
+
+function getFieldCollection(name: string, col: Collection): Field | undefined {
+  let field = col?.fields?.find((f) => f.name === name);
+  return field;
+}
+
+async function syncCollectionDatabase() {
+  try {
+    for await (let t of Cfg.tenants) {
+      let collectionsInDatabase = await t.database.db
+        ?.listCollections()
+        .toArray();
+
+      if (t.database.driver == "mongodb") {
+        const collections: Collection[] | undefined = Cfg.collections?.filter(
+          (cn) => cn.tenant_id == t.id
+        );
+
+        if (collections?.length) {
+          for await (let c of collections) {
+            //console.log(c?.slug,c.init)
+            if (c?.init && typeof c?.init == "function") {
+              await c?.init({
+                rest: new useRest({
+                  tenant_id: t.id,
+                }),
+                collection: c?.slug,
+              });
+            }
+
+            let collectionExist = collectionsInDatabase?.find(
+              (col) => col?.name == c.slug
+            );
+
+            //console.log(c.slug, collectionExist);
+
+            if (!collectionExist) {
+              await t.database.db?.createCollection(c.slug);
+            }
+
+            var allIndexes = await t.database.db?.collection(c.slug).indexes();
+
+            for await (let dbIndex of allIndexes || []) {
+              if (
+                dbIndex?.key?.createdAt ||
+                dbIndex?.key?.updatedAt ||
+                dbIndex?.key?._id
+              ) {
+                break;
+              }
+
+              let findexIndexKey = c.fields?.map(
+                (field) => dbIndex.key[field.name]
+              );
+              if (!findexIndexKey)
+                await t.database.db
+                  ?.collection(c?.slug)
+                  .dropIndex(dbIndex?.name as string);
+            }
+
+            //console.log(t.database.db);
+            // 1- Creation des indexes normal
+            await t.database.db
+              ?.collection(c.slug)
+              .createIndex(["createdAt", "updatedAt"])
+              .then((e) => {});
+
+            // 2- Creation des indexes par champs unique/random
+
+            c.fields?.map((f) => {
+              if (f?.unique || f?.random) {
+                t.database.db
+                  ?.collection(c.slug)
+                  .createIndex(
+                    {
+                      [f.name]: 1,
+                    },
+                    {
+                      unique: true,
+                      sparse: true,
+                    }
+                  )
+                  .catch((err) => {
+                    console.log(err);
+                  });
+              }
+            });
+
+            // 3- Creation des indexes par indexes
+
+            for await (let index of c?.indexes || []) {
+              let indexHasAlready = allIndexes?.find((el) => {
+                return deepEqual(
+                  el.key,
+                  omit(index, ["sparse", "unique", "expireAfterSeconds"])
+                );
+              });
+
+              if (indexHasAlready) {
+                await t.database.db
+                  ?.collection(c.slug)
+                  .dropIndex(indexHasAlready?.name)
+                  .catch((err) => {
+                    console.log(err?.message);
+                  });
+              }
+
+              await t.database.db?.collection(c.slug).createIndex(
+                {
+                  ...omit(index, ["sparse", "unique", "expireAfterSeconds"]),
+                },
+                //@ts-expect-error
+                {
+                  ...cleanDeep({
+                    unique: index?.unique || false,
+                    sparse: index?.sparse || false,
+                    expireAfterSeconds: index.expireAfterSeconds ?? null,
+                  }),
+                }
+              );
+            }
+            // Sortie de boule
+          }
+        }
+      }
+    }
+  } catch (err: any) {
+    //
+    console.error(err?.message || err);
+  }
+  consola.success("Database synchronized ");
+}
+
+export {
+  loadAllCollections,
+  getCollection,
+  getFieldCollection,
+  syncCollectionDatabase,
+};

package/lib/endpoint.ts

@@ -0,0 +1,36 @@
+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";
+
+async function loadEndpoints() {
+  let endpoints: Endpoint[] = [];
+  if (Cfg.tenants) {
+    for await (let t of Cfg.tenants) {
+      let tenantPath = `${t.dir}/endpoints/**/**.router.{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) => {
+            endpoints.push({
+              ...inject?.default,
+              tenant_id: t.id,
+            });
+          })
+          .catch((err) => {
+            console.error(err);
+          });
+      }
+    }
+  }
+
+  Cfg.endpoints = endpoints;
+}
+
+export { loadEndpoints };

package/lib/index.ts

@@ -0,0 +1,26 @@
+import { loadAllCollections, syncCollectionDatabase } from "./collection";
+import { connectTenantsDatabase } from "../driver";
+import { loadEndpoints } from "./endpoint";
+import { loadServices } from "./service";
+import { loadSocket } from "./socket";
+// load all ressource
+async function init(cf = { app: null }) {
+  // load all tenants database
+  await connectTenantsDatabase();
+  // load all collections
+  await loadAllCollections();
+
+  // sync all collections database ( Indexes)
+  syncCollectionDatabase();
+
+  // load Service
+  loadServices();
+
+  // load Socket
+  loadSocket();
+
+  // load all loadEndpoints
+  await loadEndpoints();
+}
+
+export { init };