@dnax/core 0.0.1

package/types/index.ts

@@ -0,0 +1,377 @@
+import { updateParams } from "./../driver/mongo/@types";
+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 { Server as ServerIO, Socket as SocketType } from "socket.io";
+
+type Io = InstanceType<typeof ServerIO>;
+
+import { fn } from "../utils";
+import type {
+  findOneParam,
+  findParam,
+  updateParams,
+} from "../driver/mongo/@types";
+import type { RouterRoute } from "hono/types";
+
+export type Socket = {
+  enabled: boolean;
+  handler: (ctx: { rest: useRest; io: Io; session: sessionCtx }) => void;
+};
+
+export type Tenant = {
+  id: string;
+  name?: string;
+  enabled?: boolean;
+  dir: string;
+  database: {
+    driver: "mongodb";
+    /**
+     * Connection URI string to connect
+     */
+    uri: string;
+    client?: InstanceType<typeof MongoClient>;
+    db?: Db;
+    isConnected?: boolean;
+  };
+};
+export type Actions =
+  | "findOneAndUpdate"
+  | "find"
+  | "findOne"
+  | "insertOne"
+  | "insertMany"
+  | "updateOne"
+  | "updateMany"
+  | "deleteOne"
+  | "deleteMany"
+  | "aggregate";
+
+export type Field = {
+  name: string;
+  type:
+    | "boolean"
+    | "ipv4"
+    | "ipv6"
+    | "url"
+    | "date"
+    | "datetime-local"
+    | "email"
+    | "array"
+    | "file"
+    | "number"
+    | "integer"
+    | "password"
+    | "random"
+    | "relationship"
+    | "string"
+    | "enum"
+    | "textarea"
+    | "richText"
+    | "json"
+    | "geojson";
+  studio?: {
+    display?: string;
+    suffix?: string;
+    prefix?: string;
+  };
+
+  random?: {
+    length?: number;
+    useLetters?: boolean;
+    useNumbers?: boolean;
+    includeSymbols?: Array<any>;
+    excludeSymbols?: Array<any>;
+    startWith?: string;
+    endWith?: string;
+    toUpperCase?: boolean;
+    toLowerCase?: boolean;
+    toNumber?: boolean;
+  };
+  enum?: {
+    multiple?: boolean;
+    items: Array<any>;
+  };
+  nullable?: boolean;
+  defaultValue?: any;
+  unique?: boolean;
+  index?: boolean | "text" | "2dsphere";
+  description?: string;
+  sparse?: boolean;
+  relationType?: "ref-to-one" | "ref-to-many";
+  validate?: Array<any>;
+  relationTo?: string;
+};
+
+export type accessCtx = (ctx: {
+  token?: string;
+  action?: Actions;
+  c?: Context;
+  isAuth: boolean;
+  rest: InstanceType<typeof useRest>;
+  session: sessionCtx;
+}) => boolean | undefined | void;
+
+export type sessionCtx = {
+  set: (session: { state: object | any; token?: string; _v?: object }) => void;
+  get: () => { state: object; _v: object };
+};
+
+export type hooksCtx = (ctx: {
+  filter?: any;
+  result?: any;
+  driver?: "mongodb" | "postgres";
+  data?: object;
+  params?: findParam;
+  options?: {};
+  id?: string;
+  ids?: string[];
+  update?: updateParams;
+  pipeline?: Array<object>;
+  sharedData?: any;
+  store?: any;
+  action?: Actions;
+  c?: Context;
+  rest: InstanceType<typeof useRest>;
+  session?: sessionCtx;
+  io: Io;
+}) => any;
+
+export type ctxApi = {
+  rest: useRest;
+  data?: any;
+  session?: sessionCtx;
+  io?: Io;
+  params?: findParam;
+  id?: string;
+  ids?: string[];
+  update?: updateParams;
+};
+
+export type Collection = {
+  init?: (ctx: {
+    rest: InstanceType<typeof useRest>;
+    collection: string;
+  }) => void;
+  type?: "document" | "media";
+  media?: {
+    /**
+     * Folder name to store files in directory uploads
+     * It take slug name as default name
+     */
+    overwriteFolderName?: string;
+    /**
+     * Enable or disable theses : upload / serve file
+     */
+    enabled: boolean;
+    /**
+     * Visibility of the files
+     */
+    visibility?: "private" | "public";
+    /**
+     * Mimie type to accept
+     */
+    accept?: Array<string> | string;
+  };
+  customApi?: {
+    insertOne?: (ctx: ctxApi) => object | null | undefined;
+    insertMany?: (ctx: ctxApi) => Array<object> | null | undefined;
+    updateOne?: (ctx: ctxApi) => object | null | undefined;
+    updateMany?: (ctx: ctxApi) => object | null | undefined;
+    deleteOne?: (ctx: ctxApi) => object | null | undefined;
+    deleteMany?: (ctx: ctxApi) => object | null | undefined;
+    find?: (ctx: ctxApi) => Array<object> | null | undefined;
+    findOne?: (ctx: ctxApi) => object;
+  };
+  schema?: object;
+  auth?: {
+    enabled?: boolean;
+    handler?: (ctx: {
+      data: {
+        payload?: object | undefined;
+      };
+      error: typeof fn.error;
+      c: Context;
+      rest: InstanceType<typeof useRest>;
+      session: sessionCtx;
+    }) => boolean | any;
+  };
+  hooks?: {
+    beforeOperation?: hooksCtx;
+    beforeFind?: hooksCtx;
+    afterFind?: hooksCtx;
+    beforeUpdate?: hooksCtx;
+    afterUpdate?: hooksCtx;
+    beforeDelete?: hooksCtx;
+    afterDelete?: hooksCtx;
+    beforeInsert?: hooksCtx;
+    afterInsert?: hooksCtx;
+    beforeAggregate?: hooksCtx;
+    afterAggregate?: hooksCtx;
+  };
+  access?: {
+    beforeAction?: accessCtx;
+    allAction?: accessCtx;
+    find?: accessCtx;
+    findOne?: accessCtx;
+    findOneAndUpdate?: accessCtx;
+    insertOne?: accessCtx;
+    insertMany?: accessCtx;
+    updateMany?: accessCtx;
+    updateOne?: accessCtx;
+    deleteOne?: accessCtx;
+    deleteMany?: accessCtx;
+    aggregate?: accessCtx;
+    upload?: accessCtx;
+  };
+  tenant_id?: string;
+  slug: string;
+  timestamps?: boolean;
+  description?: string;
+  fields?: Field[];
+  privateFields?: string[];
+  allow?: ["dropCollection", "renameCollection"];
+  indexes?: Array<{
+    [key: string]: any;
+    unique?: Boolean;
+    expireAfterSeconds?: number;
+  }>;
+};
+
+export type Config = {
+  studio?: {
+    /**
+     * Enable or disable the studio
+     */
+    enabled?: boolean;
+    /**
+     * Allow access by IP
+     */
+    enableIps?: boolean;
+    /**
+     * WhiteLists IP adresses : ['192.168.1.1']
+     */
+    whiteListIps?: Array<string>;
+    /**
+     * Secret key for studio
+     */
+    secretKey: string;
+  };
+  debug?: boolean;
+  ai?: {
+    driver: "mistral" | "openai" | "gemini";
+    key: string;
+  };
+
+  server: {
+    cors?: {
+      origin: string[];
+    };
+    socket?: {
+      /**
+       * Socket port
+       * Default  port is 9000
+       */
+      port?: Number;
+    };
+
+    /**
+     * Port to run the server
+     */
+    port: number;
+  };
+  /**
+   * Tenants database for API
+   */
+  tenants: Tenant[];
+
+  /**
+   * Dont touch it automatically generated
+   */
+  collections?: Array<Collection>;
+  /**
+   * Dont touch it automatically generated
+   */
+  endpoints?: Array<Endpoint>;
+  /**
+   * Dont touch it automatically generated
+   */
+  services?: Array<Service>;
+  /**
+   * Dont touch it automatically generated
+   */
+  cwd?: string;
+  io?: any;
+};
+
+export type Q = {
+  name: string;
+  useCache: boolean;
+  cleanDeep: boolean;
+  collection: string;
+  action:
+    | "findOneAndUpdate"
+    | "find"
+    | "findOne"
+    | "insertOne"
+    | "insertMany"
+    | "deleteMany"
+    | "deleteOne"
+    | "updateOne"
+    | "updateMany"
+    | "aggregate"
+    | "authCollection"
+    | "auth"
+    | "upload"
+    | "execService";
+};
+
+export type endpointCtx = {
+  enabled: boolean;
+  handler: (ctx: {
+    router: {
+      post: (path: string, clb: (c: Context) => void) => {};
+      get: (path: string, clb: (c: Context) => void) => {};
+    };
+  }) => any;
+};
+
+export type Endpoint = endpointCtx;
+
+export type Service = {
+  /**
+   * Dont touch it automatically generated
+   */
+  tenant_id?: string;
+  /**
+   * Service's name
+   */
+  name: string;
+  /**
+   * Function to execute when service is calling
+   * @param ctx
+   * @returns
+   */
+  fx: (ctx: {
+    /**
+     * Incomming data [payload]
+     */
+    data: object;
+    /**
+     * Local rest linked to  current tenant
+     */
+    rest: InstanceType<typeof useRest>;
+    error: typeof fn.error;
+    /**
+     * Session of request
+     */
+    session: sessionCtx;
+    /**
+     *  authenticated user or no
+     */
+    isAuth: boolean;
+    io: Io;
+  }) => any;
+};

package/utils/index.ts

@@ -0,0 +1,251 @@
+import { ObjectId } from "mongodb";
+import moment from "moment";
+import { mapKeys } from "radash";
+import { cleanDoubleSlashes } from "ufo";
+import path from "path";
+import { parse, format } from "@lukeed/ms";
+import jwto from "jsonwebtoken";
+import generateUniqueId from "generate-unique-id";
+
+const JWT_SECRET = process?.env?.JWT_SECRET || "secret-libv";
+import * as _ from "radash";
+
+const jwt = {
+  verify: (token: string): { decode: any; valid: boolean; error: any } => {
+    let decode = null;
+    let valid = true;
+    let error = null;
+    try {
+      decode = jwto.verify(token, JWT_SECRET);
+    } catch (err: any) {
+      valid = false;
+      error = err?.message;
+    }
+
+    return { decode, valid, error };
+  },
+  getToken: (prefix = "Bearer", input: string): string | null => {
+    if (input?.startsWith(prefix)) {
+      let token = input?.slice(prefix?.length + 1);
+      if (!token || token?.replace(/\s/g, "") === "") return null;
+    } else {
+      return null;
+    }
+  },
+
+  sign: (
+    payload: any,
+    options: { expiresIn: string } = {
+      expiresIn: "7d",
+    }
+  ) => {
+    return jwto.sign(payload, JWT_SECRET, {
+      ...options,
+    });
+  },
+  auth: (
+    payload: any = {},
+    options: { expiresIn: string } = {
+      expiresIn: "7d",
+    }
+  ) => {
+    return jwto.sign(
+      {
+        ...payload,
+        _v: {
+          isAuth: true,
+          authAt: new Date(),
+        },
+      },
+      JWT_SECRET,
+      {
+        ...options,
+      }
+    );
+  },
+};
+
+function toJson(data: object) {
+  let obj = JSON.stringify(data);
+  return JSON.parse(obj);
+}
+
+function isDate(date: string): boolean {
+  const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+  let isDate_ = !isNaN(Date.parse(date)) && dateRegex.test(date);
+  return isDate_;
+}
+
+async function hashPassword(
+  password: string,
+  algorithm: "argon2d" | "bcrypt" = "argon2d"
+) {
+  return await Bun.password.hash(password, {
+    algorithm: algorithm || "argon2d",
+  });
+}
+
+async function verifyHashPassword(
+  password: string,
+  hash: string,
+  algorithm: "argon2d" | "bcrypt" = "argon2d"
+) {
+  try {
+    if (await Bun.password.verify(password, hash, algorithm)) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (err) {
+    return false;
+  }
+}
+
+function toDate(data: object | string): object | string {
+  if (data) {
+    if (typeof data == "string" && isDate(data)) {
+      data = new Date(data);
+    }
+    // for object
+    if (typeof data == "object") {
+      mapKeys(data, (key: string, value: any) => {
+        data[key] = toDate(value);
+      });
+    }
+  }
+  return data;
+}
+
+function deepMerge(target: object, source: object) {
+  // Itérer à travers toutes les propriétés de la source
+  for (const key in source) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+
+    // Si les deux valeurs sont des objets, faire un appel récursif
+    if (
+      typeof sourceValue === "object" &&
+      sourceValue &&
+      !Array.isArray(sourceValue) &&
+      typeof targetValue === "object" &&
+      targetValue &&
+      !Array.isArray(targetValue)
+    ) {
+      target[key] = deepMerge({ ...targetValue }, sourceValue);
+    } else {
+      // Pour tout autre type ou lorsque les types ne correspondent pas, écraser avec la valeur source
+      target[key] = sourceValue;
+    }
+  }
+  return target;
+}
+
+function cleanPath(path: string) {
+  return cleanDoubleSlashes(path).toString();
+}
+
+function resolvePath(filepath: string) {
+  return path.resolve(cleanDoubleSlashes(filepath).toString());
+}
+
+function freeze(data: object, keys: string[]): object {
+  keys.forEach((cle) => {
+    const clePath = cle.split("."); // Divise la clé en parties selon les points
+    let currentObjet = data;
+
+    // Parcourir jusqu'à l'avant-dernier élément pour atteindre l'objet contenant la propriété
+    for (let i = 0; i < clePath.length - 1; i++) {
+      if (currentObjet.hasOwnProperty(clePath[i])) {
+        currentObjet = currentObjet[clePath[i]];
+      } else {
+        return; // Si le chemin n'existe pas, sortir de la fonction
+      }
+    }
+
+    // La dernière partie de clePath est la clé à rendre en lecture seule
+    const lastKey = clePath[clePath.length - 1];
+    if (currentObjet.hasOwnProperty(lastKey)) {
+      Object.defineProperty(currentObjet, lastKey, {
+        writable: false,
+        configurable: false,
+      });
+    }
+  });
+
+  return data;
+}
+
+/**
+ *
+ * @param {object|array} data - data
+ * @param {string[]} keysToRemove - keys to remove
+ * @returns {Array|Object} - data without the keys
+ */
+function omit(data: object[] | object, keysToRemove: string[]) {
+  var json = data;
+  function removeKey(obj: any, keys: any): any {
+    if (!obj || keys.length === 0) {
+      return obj;
+    }
+
+    const [currentKey, ...remainingKeys] = keys;
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => removeKey(item, keys));
+    } else if (typeof obj === "object" && obj !== null) {
+      if (remainingKeys.length === 0) {
+        const { [currentKey]: _, ...rest } = obj;
+        return rest;
+      } else {
+        if (obj.hasOwnProperty(currentKey)) {
+          return {
+            ...obj,
+            [currentKey]: removeKey(obj[currentKey], remainingKeys),
+          };
+        }
+      }
+    }
+    return obj;
+  }
+
+  keysToRemove.forEach((keyPath) => {
+    const keys = keyPath.split(".");
+    json = removeKey(json, keys);
+  });
+  return json;
+}
+
+class contextError extends Error {
+  constructor(message: string, code: number) {
+    super(message);
+    this.code = code;
+  }
+}
+
+const fn = {
+  error: (message: string, code: number) => {
+    throw new contextError(message || "unknow", code);
+  },
+};
+
+const $ = Bun.$;
+
+export {
+  moment,
+  $,
+  fn,
+  deepMerge,
+  toDate,
+  toJson,
+  hashPassword,
+  verifyHashPassword,
+  cleanPath,
+  freeze,
+  resolvePath,
+  isDate,
+  contextError,
+  jwt,
+  _,
+  generateUniqueId,
+  omit,
+};