beanbagdb 0.8.2 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beanbagdb",
-  "version": "0.8.2",
+  "version": "0.8.5",
   "description": "A JS library to introduce a schema layer to a No-SQL local database",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/index.js

@@ -39,11 +39,12 @@ export class BeanBagDB {
    * @param {function} db_instance.utils.decrypt - Decrypts a document.
    * @param {function} db_instance.utils.ping - Checks the database connection.
    * @param {function} db_instance.utils.validate_schema - Validates the database schema.
+   * @param {function} db_instance.utils.compile_template - Compiles a text template with data. {}
    */
   constructor(db_instance) {
     this.util_check_required_fields(["name", "encryption_key", "api", "utils", "db_name"],db_instance)
     this.util_check_required_fields(["insert", "update", "delete", "search", "get", "createIndex"],db_instance.api)
-    this.util_check_required_fields(["encrypt", "decrypt", "ping", "validate_schema"],db_instance.utils)
+    this.util_check_required_fields(["encrypt", "decrypt", "ping", "validate_schema","compile_template"],db_instance.utils)
 
     if (db_instance.encryption_key.length < 20) {
       throw new ValidationError([{ message: BeanBagDB.error_codes.key_short }]);
@@ -445,6 +446,7 @@ export class BeanBagDB {
  * @param {string} [criteria.schema] - The schema name used when searching by primary keys.
  * @param {Object} [criteria.data] - Data object containing the schema's primary keys for search.
  * @param {string} [criteria.include_schema] - Whether to include the schema object in the returned result.
+ * @param {string} [criteria.text_template] - The name of the text template. If provided, an additional field called 'view' is returned with the document in the specified text format. 
  * 
  * @returns {Promise<Object>} - Returns an object with the document (`doc`) and optionally the schema (`schema`).
  * 
@@ -491,6 +493,12 @@ export class BeanBagDB {
     // decrypt the document 
     obj.doc = await this._decrypt_doc(data_schema["data"], obj.doc)
 
+    if(criteria.text_template){
+      let doc_view = this._compile_template(criteria.text_template,data_schema["data"],obj.doc)
+      obj["view"] = doc_view
+    }
+
+
     return obj;
   }
 
@@ -721,10 +729,38 @@ export class BeanBagDB {
     //if (!criteria["selector"]["schema"]) {
     //  throw new Error("The search criteria must contain the schema");
     //}
-    const results = await this.db_api.search(criteria);
+    let results = await this.db_api.search(criteria);
+    let def_options = {decrypt_docs:false}
+    let options = { ...def_options, ...criteria?.options||{},  }
+    // console.log(options)
+    if(options["decrypt_docs"]){
+      if(results.docs.length>0){
+        results = await this._decrypt_docs(results)
+      }       
+    }
+
     return results;
   }
 
+  async _decrypt_docs(search_results){
+    const uniqueSchemas = [...new Set(search_results.docs.map(item => item.schema))];
+    let schemaSearch = await this.db_api.search({
+      selector: { schema: "schema", "data.name":{ "$in":uniqueSchemas } },
+    });
+    //console.log(schemaSearch)
+    let schema = {}
+    schemaSearch.docs.map(itm=>{
+      schema[itm.data.name] = itm.data
+    })
+    //console.log(schema)
+    let d_results = []
+    for (let index = 0; index < search_results.docs.length; index++) {
+      const element = search_results.docs[index];
+      d_results.push(await this._decrypt_doc(schema[element.schema],element))
+    }
+    return {docs:d_results}
+  }
+
 /**
  * Retrieves special types of documents from the database, such as schema documents or blank documents 
  * for a given schema. It handles system-related data and throws errors for invalid document types 
@@ -1017,6 +1053,80 @@ _check_nodes_edge(node1Rule, node2Rule, schema1, schema2) {
 //////////////// Internal methods ////////////////////////
 //////////////////////////////////////////////////////////
 
+_compile_template(template_name,schema_doc,doc_obj){
+  /**
+   * generates text for the doc by compiling the provided template.
+   */
+  try {
+    if(!template_name||!schema_doc||!doc_obj){
+      throw new Error("Incomplete info provided")
+    }
+    let template_info = schema_doc.settings?.text_templates[template_name]
+    if(!template_info){
+      throw Error("Template not found")
+    }
+    if (template_info.engine == "js_script") {
+      
+      const runScript = (script, data) => {
+        const cleanScript = script
+          .replace(/\\n/g, '\n')
+          .replace(/\\t/g, '\t')
+          .trim();
+
+        if (!cleanScript) {
+          throw new Error("Empty script provided");
+        }
+
+        const funcBody = `
+          "use strict";
+          const {doc, schema} = arguments[0] || {};
+          ${cleanScript}
+        `;
+
+        try {
+          const func = new Function(funcBody);
+          const result = func(data);
+          if (result && typeof result.text === 'string') {
+            return result;
+          }
+          throw new Error("Script must return {text: '...'}");
+        } catch (parseError) {
+          throw new Error(`Script parse error: ${parseError.message}\nScript: ${cleanScript.substring(0, 100)}...`);
+        }
+      };
+      
+      let result = runScript(template_info.template, {
+        doc: doc_obj,
+        schema: schema_doc,
+      });
+      // if (!result.text) {
+      //   throw new Error("js_script template must return {'text': '...'}");
+      // }
+      return result.text;
+    } else if (this.utils.compile_template[template_info.engine]) {
+      let result = this.utils.compile_template[template_info.engine](
+        template_info.template,
+        {
+          doc: doc_obj,
+          schema: schema_doc,
+        },
+      );
+      if (!result.text) {
+        throw new Error(`${template_name} template must return {'text': '...'}`);
+      }
+      return result.text
+    } else {
+      throw Error(
+        `The engine ${template_info.engine} is not available in the current instance of BBDB.`,
+      );
+    }
+
+  } catch (error) {
+    let text = `Unable to compile the template ${template_name}.Error: ${error.message}`
+    return text
+  }
+}
+
 
 async _upgrade_schema_in_bulk(schemas,log_upgrade=false,log_message="Schema Upgrade in bulk"){
   // TODO add a check to now allow default system schema to be updated from this method

package/src/system_schema.js

@@ -11,7 +11,7 @@ export const default_app = {
       active: true,
       description: "Meta-schema or the schema for defining other schemas",
       system_generated: true,
-      version: 1.25,
+      version: 1.30,
       title: "Schema document",
       schema: {
         type: "object",
@@ -133,6 +133,39 @@ export const default_app = {
                 default: "human",
                 description:
                   "The height and width should be 25px",
+              },
+              text_templates: {
+                "type": "object",
+                "title":"Text templates for the schema",
+                "description":"Define templates that compile and generate text  for an individual document in the database",
+                "default":{ "json_string":{engine:"js_script","format":"plain",template: "const pretty = JSON.stringify(doc, null, 2);\nreturn {text: pretty};","description":"Generates a stringified JSON as plain text"}  },
+                "patternProperties": {
+                  "^[a-zA-Z_][a-zA-Z0-9_]*$": {
+                    "type": "object",
+                    "required": ["engine", "template"],
+                    "properties": {
+                      "engine": {
+                        "type": "string",
+                        "enum": ["handlebars","ejs","js_script","mustache"],
+                        "description": "The templating engine used to render the template. js_script is when the template is code in javascript. All template compiler must returns an object `{text:'...'}`"
+                      },
+                      "format": {
+                        "type": "string",
+                        "description": "The output format of the template. Eg plain,markdown,html,tex"
+                      },
+                      "description": {
+                        "type": "string",
+                        "description": "A human-readable description of the template"
+                      },
+                      "template": {
+                        "type": "string",
+                        "description": "The actual template string (must be compatible with the selected engine). Assume that the engine has access to the following json: { doc:{meta, data, app, _schema, schema, id}  , ... other related data}"
+                      },
+                    },
+                    "additionalProperties": false
+                  }
+                },
+                "additionalProperties": false,
               }
             },
             required: [
@@ -390,7 +423,7 @@ export const default_app = {
       schema: {
         type: "object",
         additionalProperties: true,
-        required: ["script","type","version"],
+        required: ["script","type","version","name"],
         properties: {
           type: {
             type: "string",

package/test/operations.test.js

@@ -1040,6 +1040,24 @@ describe("Doc read tests", async () => {
     let data = await database3.read({schema:"book",data:{"title":record_good_book1.title,"author":record_good_book1.author},include_schema:false})
     assert(Object.keys(data).length==1)
   })
+
+  it('check if view is not included', async () => {
+    let data = await database3.read({schema:"book",data:{"title":record_good_book1.title,"author":record_good_book1.author}})
+    assert(!data.view, "view property should not exist");
+  })
+
+
+    it('check if view is included even if template name not found', async () => {
+    let data = await database3.read({schema:"book",data:{"title":record_good_book1.title,"author":record_good_book1.author},text_template:"json"})
+    console.log(data)
+    assert('view' in data);
+  })
+
+   it('check if view is included , template name is found', async () => {
+    let data = await database3.read({schema:"book",data:{"title":record_good_book1.title,"author":record_good_book1.author},text_template:"json_string"})
+    console.log(data)
+    assert('view' in data);
+  })
 })
 
 /**

package/test/pouchdb.js

@@ -122,6 +122,11 @@ const pdb = new PouchDB(dbname);
         const valid = validate(data_copy);
 
         return {valid,validate,data:data_copy}
+      },
+      "compile_template":{
+        "ejs":()=>{
+          return {text:""}
+        }
       }
     },
   }