@dnax/core 0.4.3 → 0.4.5

package/driver/mongo/rest.ts

@@ -239,6 +239,12 @@ class useRest {
 
         var { valid, output, error } = this.validator(collection, data);
         if (!valid) fn.error(error, 400);
+        data = {
+          ...data,
+          ...(output || {}),
+        };
+
+        //console.log(data);
 
         if (col?.hooks?.beforeOperation && useHook) {
           await col.hooks.beforeOperation({
@@ -340,6 +346,10 @@ class useRest {
           d = deepSetId(col, d);
           var { valid, output, error } = this.validator(collection, d);
           if (!valid) fn.error(error, 400);
+          d = {
+            ...d,
+            ...(output || {}),
+          };
         }
 
         if (col?.hooks?.beforeOperation && useHook) {

package/index.ts

@@ -6,6 +6,7 @@ import Joi from "joi";
 import define from "./define";
 import moment from "moment";
 import * as utils from "./utils";
+import { searchEngine } from "./lib/orama";
 
 /**
  *  v is internal data validation and based of Joi validation.
@@ -14,4 +15,4 @@ import * as utils from "./utils";
  */
 const v = Joi;
 
-export { runApp, define, utils, useRest, v };
+export { runApp, define, utils, useRest, v, searchEngine };

package/lib/collection.ts

@@ -123,6 +123,7 @@ async function syncCollectionDatabase() {
               .then((e) => {});
 
             // 3- suppression des indexes
+            //
             c.fields?.map((f) => {
               if (!f?.unique && allIndexes?.find((e) => e?.key[f.name])) {
                 //@ts-expect-error

package/lib/orama/@types.ts

@@ -0,0 +1,39 @@
+type Vector<N extends number> = `vector[${N}]`;
+export type optionsType = {
+  store: {
+    path?: string;
+    filename: string;
+  };
+  schema: {
+    [key: string]:
+      | "string"
+      | "number"
+      | "boolean"
+      | Vector<number>
+      | "geopoint";
+  };
+  settings?: {
+    primaryKey?: string;
+    language: "french" | "english";
+  };
+};
+
+export type searchType = {
+  mode?: "fulltext" | "hybrid" | "vector";
+  term: string;
+  limit?: number;
+  offset?: number;
+  tolerance?: number;
+  properties?: string[];
+  exact?: boolean;
+  vector?: {
+    value: number[];
+    property: string;
+  };
+  hybridWeights?: {
+    text: number;
+    vector: number;
+  };
+  similarity?: number;
+  includeVectors?: boolean;
+};

package/lib/orama/index.ts

@@ -0,0 +1,90 @@
+import type { optionsType, searchType } from "./@types";
+import * as orama from "@orama/orama";
+import fs from "fs-extra";
+import _ from "lodash";
+import { ObjectId } from "mongodb";
+import path from "path";
+class searchEngine {
+  #options: optionsType;
+  #db: any;
+  #dataPath: string;
+  constructor(options: optionsType) {
+    this.#options = options;
+    this.#dataPath = path.join(
+      this.#options.store?.path || process.cwd() + "/data",
+      this.#options.store?.filename || "search.db"
+    );
+  }
+
+  async initialize() {
+    this.#db = await orama.create({
+      schema: this.#options.schema,
+      language: this.#options.settings?.language || "english",
+    });
+
+    try {
+      let restoreData = await Bun.file(this.#dataPath).json();
+
+      if (restoreData) {
+        // console.log(restoreData);
+        await orama.load(this.#db, restoreData);
+      }
+    } catch (err) {}
+  }
+
+  async save() {
+    try {
+      let jsonExport = await orama.save(this.#db);
+      let jsonData = JSON.stringify(jsonExport);
+      let saveTo = Bun.write(this.#dataPath, jsonData);
+    } catch (error) {
+      console.log(error?.message);
+    }
+  }
+
+  async add(documents: Array<object>) {
+    try {
+      let ids = [];
+      if (Array.isArray(documents)) {
+        documents.map((doc) => {
+          doc.id = doc?._id || doc?.id || new ObjectId().toString();
+          doc._id = doc?.id;
+        });
+        let ids = await orama.insertMultiple(this.#db, documents);
+        await this.save();
+        return ids;
+      }
+    } catch (error) {
+      console.log(error?.message);
+    }
+  }
+
+  async search(search: searchType) {
+    return await orama.search(this.#db, search);
+  }
+
+  async find() {
+    let docs: Array<object> = [];
+    let data = await orama.save(this.#db);
+    docs = Object.values(data.docs?.docs || []);
+    //let docs = Object.values(data.docs[0]);
+    return docs;
+  }
+
+  async remove(ids: Array<string>) {
+    try {
+      await orama.remove(this.#db, ids);
+      await this.save();
+    } catch (error) {
+      console.log(error?.message);
+    }
+  }
+
+  async drop() {
+    fs.unlink(this.#dataPath).catch((err) => {
+      //console.log(err);
+    });
+  }
+}
+
+export { searchEngine };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "module": "index.ts",
   "type": "module",
   "bin": {
@@ -17,6 +17,7 @@
     "@clack/prompts": "^0.7.0",
     "@colors/colors": "^1.6.0",
     "@lukeed/ms": "^2.0.2",
+    "@orama/orama": "^2.0.23",
     "@types/jsonwebtoken": "^9.0.6",
     "boxen": "^7.1.1",
     "chokidar": "^3.6.0",
@@ -26,6 +27,7 @@
     "cookie": "^0.6.0",
     "croner": "^8.1.1",
     "find-open-port": "^2.0.3",
+    "fs-extra": "^11.2.0",
     "generate-unique-id": "^2.0.3",
     "hono": "^4.5.4",
     "joi": "^17.13.3",