beanbagdb 0.5.77 → 0.6.0

package/test/operations.test.js

@@ -16,9 +16,176 @@ let database; // this is the global db object
 let database1
 let database2
 
+let good_book_schema_1  = {
+  name:"book",
+  active:true,
+  description:"Test schema 1",
+  title:"Book",
+  schema: {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        minLength: 1,
+        description: "The title of the book",
+      },
+      author: {
+        type: "string",
+        minLength: 1,
+        description: "The author of the book",
+      },
+      isbn: {
+        type: "string",
+        pattern: "^(97(8|9))?\\d{9}(\\d|X)$",
+        description: "The ISBN of the book, can be 10 or 13 digits",
+      },
+      publicationYear: {
+        type: "integer",
+        minimum: 1450,
+        maximum: 2024,
+        description:
+          "The year the book was published (between 1450 and 2024)",
+      },
+      genre: {
+        type: "string",
+        enum: [
+          "Fiction",
+          "Non-Fiction",
+          "Science",
+          "History",
+          "Fantasy",
+          "Biography",
+          "Children",
+          "Mystery",
+          "Horror",
+        ],
+        description: "The genre of the book",
+      },
+      language: {
+        type: "string",
+        description: "The language of the book",
+        default: "English",
+      },
+      publisher: {
+        type: "string",
+        description: "The publisher of the book",
+        minLength: 1,
+      },
+      pages: {
+        type: "integer",
+        minimum: 1,
+        description: "The number of pages in the book",
+      },
+    },
+    required: ["title", "author", "isbn", "publicationYear", "genre"],
+    additionalProperties: false,
+  },
+  settings : {
+    primary_keys:['title','author'],
+    encrypted_fields:[],
+    non_editable_fields:[],
+  }
+}
+
+const record_good_book1 = {
+  title: "Harry Potter",
+  author: "J.K. Rowling",
+  isbn: "9780439139601",
+  publicationYear: 1999,
+  genre: "Fantasy",
+  publisher: "ABC DEF"
+}
+
+let good_book_schema_2 =  {
+  name:"book",
+  title:"Book",
+  active:true,
+  description:"Test schema 1",
+  schema: {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        minLength: 1,
+        description: "The title of the book",
+      },
+      author: {
+        type: "string",
+        minLength: 1,
+        description: "The author of the book",
+      },
+      isbn: {
+        type: "string",
+        pattern: "^(97(8|9))?\\d{9}(\\d|X)$",
+        description: "The ISBN of the book, can be 10 or 13 digits",
+      },
+      publicationYear: {
+        type: "integer",
+        minimum: 1450,
+        maximum: 2024,
+        description:
+          "The year the book was published (between 1450 and 2024)",
+      },
+      genre: {
+        type: "string",
+        enum: [
+          "Fiction",
+          "Non-Fiction",
+          "Science",
+          "History",
+          "Fantasy",
+          "Biography",
+          "Children",
+          "Mystery",
+          "Horror",
+        ],
+        description: "The genre of the book",
+      },
+      language: {
+        type: "string",
+        description: "The language of the book",
+        default: "English",
+      },
+      publisher: {
+        type: "string",
+        description: "The publisher of the book",
+        minLength: 1,
+      },
+      pages: {
+        type: "integer",
+        minimum: 1,
+        description: "The number of pages in the book",
+      },
+      secret: {
+        type: "string",
+        description: "Super secret related to the book",
+        minLength: 1,
+      },
+    },
+    required: ["title", "author", "isbn", "publicationYear", "genre"],
+    additionalProperties: false,
+  },
+  settings : {
+    primary_keys:['title','author'],
+    encrypted_fields:['secret'],
+    non_editable_fields:[],
+  }
+};
+const record_good_book2 = {
+  title: "Harry Potter",
+  author: "J.K. Rowling",
+  isbn: "9780439139601",
+  publicationYear: 1999,
+  genre: "Fantasy",
+  publisher: "ABC DEF",
+  secret: "Super secret 1"
+}
+
 describe("Successful database class init (required for further testing) ", async () => {
   it("DB init successful", () => {
-    let doc_obj = get_pdb_doc("test_database_25", "qwertyuiopaqwsde1254");
+    let doc_obj = get_pdb_doc("test_database_25", "qwertyuiopaqwsde12542323");
     database = new BeanBagDB(doc_obj);
     strictEqual(
       database instanceof BeanBagDB,
@@ -399,7 +566,7 @@ describe("Schema doc insertion gives errors when", async () => {
   ];
 
   before(async () => {
-    let doc_obj = get_pdb_doc("test_database_25", "qwertyuiopaqwsde1254");
+    let doc_obj = get_pdb_doc("test_database_25", "qwertyuiopaqwsde12544343");
     database = new BeanBagDB(doc_obj);
     await database.ready(); // Ensure the database is ready before running tests
     console.log("Ready for more tests...");
@@ -408,14 +575,14 @@ describe("Schema doc insertion gives errors when", async () => {
   schema_docs_invalid.forEach((element, index) => {
     it(`${element[0]}`, async () => {
       await rejects(async () => {
-        await database.create("schema", element[1]);
+        await database.create({schema: "schema", data: element[1]});
       }, ValidationError);
     });
   });
 });
 
 describe("Doc insertion tests", async () => {
-  let schema_docs_invalid = [
+  let book_docs_invalid = [
     [
       "error when title empty",
       {
@@ -561,86 +728,16 @@ describe("Doc insertion tests", async () => {
     ],
   ];
 
-  const test_schema = {
-    name:"book",
-    description:"Test schema 1",
-    title:"Book",
-    schema: {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      type: "object",
-      properties: {
-        title: {
-          type: "string",
-          minLength: 1,
-          description: "The title of the book",
-        },
-        author: {
-          type: "string",
-          minLength: 1,
-          description: "The author of the book",
-        },
-        isbn: {
-          type: "string",
-          pattern: "^(97(8|9))?\\d{9}(\\d|X)$",
-          description: "The ISBN of the book, can be 10 or 13 digits",
-        },
-        publicationYear: {
-          type: "integer",
-          minimum: 1450,
-          maximum: 2024,
-          description:
-            "The year the book was published (between 1450 and 2024)",
-        },
-        genre: {
-          type: "string",
-          enum: [
-            "Fiction",
-            "Non-Fiction",
-            "Science",
-            "History",
-            "Fantasy",
-            "Biography",
-            "Children",
-            "Mystery",
-            "Horror",
-          ],
-          description: "The genre of the book",
-        },
-        language: {
-          type: "string",
-          description: "The language of the book",
-          default: "English",
-        },
-        publisher: {
-          type: "string",
-          description: "The publisher of the book",
-          minLength: 1,
-        },
-        pages: {
-          type: "integer",
-          minimum: 1,
-          description: "The number of pages in the book",
-        },
-      },
-      required: ["title", "author", "isbn", "publicationYear", "genre"],
-      additionalProperties: false,
-    },
-    settings : {
-      primary_keys:['title','author'],
-      encrypted_fields:[],
-      non_editable_fields:[],
-      single_record:false
-    }
-  }
+  
 
   before(async () => {
     // adding a schema
-    let doc_obj = get_pdb_doc("test_database_26", "qwertyuiopaqwsde1254");
+    let doc_obj = get_pdb_doc("test_database_26", "qwertyuiopaqwsde12541234");
     database = new BeanBagDB(doc_obj);
     await database.ready(); // Ensure the database is ready before running tests
     try {
       //console.log(test_schema)
-      let a = await database.create("schema",test_schema)
+      let a = await database.create({schema:"schema",data:good_book_schema_1})
       console.log("Ready for more tests...");  
     } catch (error) {
       console.log("error in before")
@@ -660,7 +757,7 @@ describe("Doc insertion tests", async () => {
   it(`when inserting the book schema again, must throw error`, async () => {
     await rejects(async () => {
       try {
-        await database.create("schema", test_schema);   
+        await database.create({schema:"schema",data: good_book_schema_1});   
       } catch (error) {
         console.log(error)
         throw error
@@ -668,23 +765,23 @@ describe("Doc insertion tests", async () => {
     }, DocCreationError);
   })
 
-  schema_docs_invalid.forEach((element, index) => {
+  book_docs_invalid.forEach((element, index) => {
     it(`${element[0]}`, async () => {
       await rejects(async () => {
-        await database.create("schema", element[1]);
+        await database.create({schema:"book", data:element[1]});
       }, ValidationError);
     })
   })
 
   it('successfully inserts a book doc', async () => {
-    await expect(database.create("book", book1)).to.eventually.have.property("_id");
+    await expect(database.create({schema:"book", data: book1})).to.eventually.have.property("_id");
   });
 
 
   let invalid_meta = [
-    ["invalid field",{tabs:[]}],
-    ["invalid tags",{tags:"a,b,c"}],
-    ["invalid link",{link:{'1':1}}],
+    ["invalid meta field",{tabs:[]}],
+    ["invalid meta.tags",{tags:"a,b,c"}],
+    ["invalid meta.link",{link:{'1':1}}],
   ]
 
   invalid_meta.forEach((element, index) => {
@@ -692,7 +789,7 @@ describe("Doc insertion tests", async () => {
       let bd = {...book1}
       bd.title = bd.title+" "+index
       await rejects(async () => {
-        await database.create("schema",bd,element[1]);
+        await database.create({schema:"book",data:bd,meta:element[1]});
       }, ValidationError);
     })
   })
@@ -700,7 +797,7 @@ describe("Doc insertion tests", async () => {
   it('successfully inserts a book doc with a link', async () => {
     let bd = {...book1}
     bd.title = bd.title+" test1"
-    let new_rec = await database.create("book", bd,{link:"sample1"})
+    let new_rec = await database.create({schema:"book", data: bd,meta:{link:"sample1"}})
     assert(new_rec.meta.link=="sample1")
   });
 
@@ -709,10 +806,10 @@ describe("Doc insertion tests", async () => {
       try {
         let bd = {...book1}
         bd.title = bd.title+" test1234"
-        await database.create("book", bd,{link:"sample1"});   
+        await database.create({schema:"book",data: bd,meta:{link:"sample1"}});   
       } catch (error) {
-        console.log(error)
-        console.log("22222")
+      //  console.log(error)
+        //console.log("22222")
         throw error
       }
     }, DocCreationError);
@@ -723,7 +820,7 @@ describe("Doc insertion tests", async () => {
     let bd = {...book1}
     bd.title = bd.title+" test2"
     let tags1 = ["tag1"]
-    let new_rec = await database.create("book", bd,{tags:tags1})
+    let new_rec = await database.create({schema:"book", data:bd,meta:{tags:tags1}})
     assert(new_rec.meta.tags===tags1)
   });
 
@@ -732,10 +829,9 @@ describe("Doc insertion tests", async () => {
       try {
         let bd = {...book1}
         bd.title = bd.title+" test1234"
-        await database.create("", bd,{link:"sample1"});   
+        await database.create({data:bd,meta:{link:"sample1"}});   
       } catch (error) {
-        console.log(error)
-        console.log("22222")
+     //   console.log(error)
         throw error
       }
     }, DocCreationError);
@@ -746,9 +842,9 @@ describe("Doc insertion tests", async () => {
       try {
         let bd = {...book1}
         bd.title = bd.title+" test1234"
-        await database.create("book",{},{link:"sample1"});   
+        await database.create({schema:"book",meta:{link:"sample1"}});   
       } catch (error) {
-        console.log(error)
+       // console.log(error)
         throw error
       }
     }, DocCreationError);
@@ -758,95 +854,20 @@ describe("Doc insertion tests", async () => {
 })
 
 describe("Doc insertion tests with encryption", async () => {
-  const test_schema = {
-    name:"book",
-    title:"Book",
-    description:"Test schema 1",
-    schema: {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      type: "object",
-      properties: {
-        title: {
-          type: "string",
-          minLength: 1,
-          description: "The title of the book",
-        },
-        author: {
-          type: "string",
-          minLength: 1,
-          description: "The author of the book",
-        },
-        isbn: {
-          type: "string",
-          pattern: "^(97(8|9))?\\d{9}(\\d|X)$",
-          description: "The ISBN of the book, can be 10 or 13 digits",
-        },
-        publicationYear: {
-          type: "integer",
-          minimum: 1450,
-          maximum: 2024,
-          description:
-            "The year the book was published (between 1450 and 2024)",
-        },
-        genre: {
-          type: "string",
-          enum: [
-            "Fiction",
-            "Non-Fiction",
-            "Science",
-            "History",
-            "Fantasy",
-            "Biography",
-            "Children",
-            "Mystery",
-            "Horror",
-          ],
-          description: "The genre of the book",
-        },
-        language: {
-          type: "string",
-          description: "The language of the book",
-          default: "English",
-        },
-        publisher: {
-          type: "string",
-          description: "The publisher of the book",
-          minLength: 1,
-        },
-        pages: {
-          type: "integer",
-          minimum: 1,
-          description: "The number of pages in the book",
-        },
-        secret: {
-          type: "string",
-          description: "Super secret related to the book",
-          minLength: 1,
-        },
-      },
-      required: ["title", "author", "isbn", "publicationYear", "genre"],
-      additionalProperties: false,
-    },
-    settings : {
-      primary_keys:['title','author'],
-      encrypted_fields:['secret'],
-      non_editable_fields:[],
-      single_record:false
-    }
-  };
+  
 
   before(async () => {
     // adding a schema
-    let doc_obj_orig = get_pdb_doc("test_database_27", "qwertyuiopaqwsde1254");
-    let doc_obj_dupl = get_pdb_doc("test_database_27", "qwertyuiopaqwsde12545");
+    let doc_obj_orig = get_pdb_doc("test_database_27", "123456789012345612341234");
+    let doc_obj_dupl = get_pdb_doc("test_database_27", "098765432109876565432345");
     database1 = new BeanBagDB(doc_obj_orig);
     await database1.ready(); // Ensure the database is ready before running tests
     console.log(database1.encryption_key)
     database2 = new BeanBagDB(doc_obj_dupl);
     await database2.ready(); // Ensure the database is ready before running tests
     try {
-      //console.log(test_schema)
-      let a = await database1.create("schema",test_schema)
+      console.log(good_book_schema_2)
+      let a = await database1.create({schema:"schema",data:good_book_schema_2})
     } catch (error) {
       console.log("error in before")
       console.log(error)
@@ -856,9 +877,9 @@ describe("Doc insertion tests with encryption", async () => {
   it(`when inserting the book schema again in db1, must throw error`, async () => {
     await rejects(async () => {
       try {
-        await database1.create("schema", test_schema);   
+        await database1.create({schema:"schema",data:good_book_schema_2});   
       } catch (error) {
-        //console.log(error)
+        console.log(error)
         throw error
       }
     }, DocCreationError);
@@ -867,7 +888,7 @@ describe("Doc insertion tests with encryption", async () => {
   it(`when inserting the book schema again in db2 , must throw error`, async () => {
     await rejects(async () => {
       try {
-        await database2.create("schema", test_schema);   
+        await database2.create({schema:"schema",data:good_book_schema_2});   
       } catch (error) {
         //console.log(error)
         throw error
@@ -876,31 +897,15 @@ describe("Doc insertion tests with encryption", async () => {
   });
 
   it('successfully inserts a book doc with some secret', async () => {
-    const book1 = {
-        title: "Harry Potter",
-        author: "J.K. Rowling",
-        isbn: "9780439139601",
-        publicationYear: 1999,
-        genre: "Fantasy",
-        publisher: "ABC DEF",
-        secret: "Super secret 1"
-    }
-    await expect(database1.create("book", book1)).to.eventually.have.property("_id");
+    
+      await expect(database1.create({schema:"book",data:record_good_book2})).to.eventually.have.property("_id");
   });
 
   it('gives error when inserting the same doc again', async () => {
-    const book1 = {
-        title: "Harry Potter",
-        author: "J.K. Rowling",
-        isbn: "9780439139601",
-        publicationYear: 1999,
-        genre: "Fantasy",
-        publisher: "ABC DEF",
-        secret: "Super secret 1"
-    };
+    
     await rejects(async () => {
       try {
-        await database1.create("book", book1);   
+        await database1.create({schema:"book",data: record_good_book2});   
       } catch (error) {
         //console.log(error)
         throw error
@@ -909,34 +914,16 @@ describe("Doc insertion tests with encryption", async () => {
   })
 
   it('fetches the doc and the encrypted field is returned successfully', async () => {
-    const book1 = {
-        title: "Harry Potter",
-        author: "J.K. Rowling",
-        isbn: "9780439139601",
-        publicationYear: 1999,
-        genre: "Fantasy",
-        publisher: "ABC DEF",
-        secret: "Super secret 1"
-    };
-    let data = await database1.read({schema:"book",data:{"title":book1.title,"author":book1.author}})
+   
+    let data = await database1.read({schema:"book",data:{"title":record_good_book2.title,"author":record_good_book2.author}})
     //console.log(data)
-    assert(data.doc.data.secret == book1.secret) 
+    assert(data.doc.data.secret == record_good_book2.secret) 
   })
   
   it('should throw encryption error when using the incorrect key', async () => {
-    const book1 = {
-        title: "Harry Potter",
-        author: "J.K. Rowling",
-        isbn: "9780439139601",
-        publicationYear: 1999,
-        genre: "Fantasy",
-        publisher: "ABC DEF",
-        secret: "Super secret 1"
-    }
-
     await rejects(async () => {
       try {
-        let d = await database2.read({schema:"book",data:{"title":book1.title,"author":book1.author}});   
+        let d = await database2.read({schema:"book",data:{"title":record_good_book2.title,"author":record_good_book2.author}});   
       } catch (error) {
         //console.log(error)
         throw error
@@ -946,7 +933,6 @@ describe("Doc insertion tests with encryption", async () => {
 
 })
 
-
 /**
  * read 
  */
@@ -955,90 +941,6 @@ describe("Doc read tests", async () => {
   let database3
 
 
-  const test_schema = {
-    name:"book",
-    description:"Test schema 1",
-    title:"Book",
-    schema: {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      type: "object",
-      properties: {
-        title: {
-          type: "string",
-          minLength: 1,
-          description: "The title of the book",
-        },
-        author: {
-          type: "string",
-          minLength: 1,
-          description: "The author of the book",
-        },
-        isbn: {
-          type: "string",
-          pattern: "^(97(8|9))?\\d{9}(\\d|X)$",
-          description: "The ISBN of the book, can be 10 or 13 digits",
-        },
-        publicationYear: {
-          type: "integer",
-          minimum: 1450,
-          maximum: 2024,
-          description:
-            "The year the book was published (between 1450 and 2024)",
-        },
-        genre: {
-          type: "string",
-          enum: [
-            "Fiction",
-            "Non-Fiction",
-            "Science",
-            "History",
-            "Fantasy",
-            "Biography",
-            "Children",
-            "Mystery",
-            "Horror",
-          ],
-          description: "The genre of the book",
-        },
-        language: {
-          type: "string",
-          description: "The language of the book",
-          default: "English",
-        },
-        publisher: {
-          type: "string",
-          description: "The publisher of the book",
-          minLength: 1,
-        },
-        pages: {
-          type: "integer",
-          minimum: 1,
-          description: "The number of pages in the book",
-        },
-        secret:{
-          type:"string"
-        }
-      },
-      required: ["title", "author"],
-      additionalProperties: false,
-    },
-    settings : {
-      primary_keys:['title','author'],
-      encrypted_fields:[],
-      non_editable_fields:["secret"],
-      single_record:false
-    }
-  }
-
-  const book1 = {
-    title: "Harry Potter",
-    author: "J.K. Rowling",
-    isbn: "9780439139601",
-    publicationYear: 1999,
-    genre: "Fantasy",
-    publisher: "ABC DEF",
-    secret:"Super secret1"
-  }
   const meta = {
     link:"sample1"
   }
@@ -1046,44 +948,49 @@ describe("Doc read tests", async () => {
 
   before(async () => {
     // adding a schema
-    let doc_obj = get_pdb_doc("test_database_28", "qwertyuiopaqwsde1254");
+    let doc_obj = get_pdb_doc("test_database_28", "qwertyuiopaqwsde12544532");
     database3 = new BeanBagDB(doc_obj);
     await database3.ready(); // Ensure the database is ready before running tests
     try {
-      let a = await database3.create("schema",test_schema)
-      doc_inserted = await database3.create("book",book1,meta)
+      let a = await database3.create({schema:"schema",data:good_book_schema_1})
+      
       console.log("Ready for more tests...");  
     } catch (error) {
       //console.log("error in before")
       console.log(error)
     }
+    try {
+      doc_inserted = await database3.create({schema:"book",data:record_good_book1,meta:meta})
+    } catch (error) {
+      console.log(error)
+    }
   })
 
   it('fetches the doc and the encrypted field is returned unencrypted successfully', async () => {
-    let data = await database3.read({schema:"book",data:{"title":book1.title,"author":book1.author}})
-    assert(data.doc.data.secret == book1.secret) 
+    let data = await database3.read({schema:"book",data:{"title":record_good_book1.title,"author":record_good_book1.author}})
+    assert(data.doc.data.secret == record_good_book1.secret) 
   })
 
 
   it('read doc using _id', async () => {
     let data = await database3.read({"_id":doc_inserted._id})
-    assert(data.doc.data.secret == book1.secret) 
+    assert(data.doc.data.secret == record_good_book1.secret) 
   })
 
   it('read doc using link', async () => {
     let data = await database3.read({"link":meta.link})
-    assert(data.doc.data.secret == book1.secret) 
+    assert(data.doc.data.secret == record_good_book1.secret) 
   })
   
   it('read doc using primary key', async () => {
-    let data = await database3.read({schema:"book",data:{title:book1.title,author:book1.author}})
-    assert(data.doc.data.secret == book1.secret) 
+    let data = await database3.read({schema:"book",data:{title:record_good_book1.title,author:record_good_book1.author}})
+    assert(data.doc.data.secret == record_good_book1.secret) 
   })
 
   it('throws error when  incomplete  primary key given', async () => {
     await rejects(async () => {
       try {
-        let a = await database3.read({"schema":"book","data":{title:book1.title}});   
+        let a = await database3.read({"schema":"book","data":{title:record_good_book1.title}});   
       } catch (error) {
         //console.log(error)
         throw error
@@ -1125,12 +1032,12 @@ describe("Doc read tests", async () => {
   })
   
   it('check if schema included', async () => {
-    let data = await database3.read({schema:"book",data:{"title":book1.title,"author":book1.author}},true)
+    let data = await database3.read({schema:"book",data:{"title":record_good_book1.title,"author":record_good_book1.author},include_schema:true})
     assert(Object.keys(data).length==2)
   })
 
   it('check if schema not included', async () => {
-    let data = await database3.read({schema:"book",data:{"title":book1.title,"author":book1.author}},false)
+    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)
   })
 })
@@ -1145,89 +1052,6 @@ describe("Doc read tests", async () => {
 describe("Doc update tests", async () => {
   let database3
 
-  const test_schema = {
-    name:"book",
-    description:"Test schema 1",
-    title:"Book",
-    schema: {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      type: "object",
-      properties: {
-        title: {
-          type: "string",
-          minLength: 1,
-          description: "The title of the book",
-        },
-        author: {
-          type: "string",
-          minLength: 1,
-          description: "The author of the book",
-        },
-        isbn: {
-          type: "string",
-          pattern: "^(97(8|9))?\\d{9}(\\d|X)$",
-          description: "The ISBN of the book, can be 10 or 13 digits",
-        },
-        publicationYear: {
-          type: "integer",
-          minimum: 1450,
-          maximum: 2024,
-          description:
-            "The year the book was published (between 1450 and 2024)",
-        },
-        genre: {
-          type: "string",
-          enum: [
-            "Fiction",
-            "Non-Fiction",
-            "Science",
-            "History",
-            "Fantasy",
-            "Biography",
-            "Children",
-            "Mystery",
-            "Horror",
-          ],
-          description: "The genre of the book",
-        },
-        language: {
-          type: "string",
-          description: "The language of the book",
-          default: "English",
-        },
-        publisher: {
-          type: "string",
-          description: "The publisher of the book",
-          minLength: 1,
-        },
-        pages: {
-          type: "integer",
-          minimum: 1,
-          description: "The number of pages in the book",
-        },
-        secret:{
-          type:"string"
-        }
-      },
-      required: ["title", "author"],
-      additionalProperties: false,
-    },
-    settings : {
-      primary_keys:['title','author'],
-      non_editable_fields:['pages','genre'],
-      encrypted_fields:["secret"]
-    }
-  }
-
-  const book1 = {
-    title: "Harry Potter",
-    author: "J.K. Rowling",
-    isbn: "9780439139601",
-    publicationYear: 1999,
-    genre: "Fantasy",
-    publisher: "ABC DEF",
-    secret:"Super secret1"
-  }
   const meta = {
     link:"sample1",
     tags:["tag1"]
@@ -1236,13 +1060,16 @@ describe("Doc update tests", async () => {
 
   before(async () => {
     // adding a schema
-    let doc_obj = get_pdb_doc("test_database_29", "qwertyuiopaqwsde1254");
+    let doc_obj = get_pdb_doc("test_database_29", "qwertyuiopaqwsde12456754");
     database3 = new BeanBagDB(doc_obj);
     await database3.ready(); // Ensure the database is ready before running tests
     try {
-      let a = await database3.create("schema",test_schema)
-      doc_inserted = await database3.create("book",book1,meta)
-      let b = await database3.create("book",{...book1,title:"HP2"},{...meta,link:"sample2"})
+      let test_schema  = {...good_book_schema_2}
+      test_schema["settings"]["non_editable_fields"] = ['pages','genre']
+      test_schema["settings"]["primary_keys"] = ['title','author']
+      let a = await database3.create({schema:"schema",data:test_schema})
+      doc_inserted = await database3.create({schema:"book",data:record_good_book2,meta:meta})
+      let b = await database3.create({schema:"book",data:{...record_good_book2,title:"HP2"},meta:{...meta,link:"sample2"}})
       //console.log(b)
       console.log("Ready for more tests...");  
     } catch (error) {
@@ -1254,24 +1081,24 @@ describe("Doc update tests", async () => {
   it('error when nothing to update ', async () => {
     await rejects(async () => {
       try {
-        let udata = await database3.update({"_id":doc_inserted._id},{})
+        let udata = await database3.update({criteria:{"_id":doc_inserted._id}})
       } catch (error) {
-        //console.log(error)
+        console.log(error)
         throw error
       }
     }, DocUpdateError)
 })
 
-  it('update selected fields -1 ', async () => {
+  it('update selected fields - 1 ', async () => {
     let updates = {publisher:"Something else"}
-    let udata = await database3.update({"_id":doc_inserted._id},{data:updates})
+    let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{data:updates}})
     let rdata= await database3.read({_id:doc_inserted._id})
     assert(rdata.doc.data.publisher === updates.publisher )
   })
 
   it('update selected fields - primary key', async () => {
     let updates = {title:"Something else"}
-    let udata = await database3.update({"_id":doc_inserted._id},{data:updates})
+    let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{data:updates}})
     let rdata= await database3.read({_id:doc_inserted._id})
     assert(rdata.doc.data.title === updates.title )
   })
@@ -1282,9 +1109,8 @@ describe("Doc update tests", async () => {
     //assert(data.doc.data.secret == book1.secret) 
     await rejects(async () => {
       try {
-        let udata = await database3.update({"_id":doc_inserted._id},{data:updates})
+        let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{data:updates}})
       } catch (error) {
-        //console.log(error)
         throw error
       }
     }, DocUpdateError)
@@ -1298,14 +1124,14 @@ describe("Doc update tests", async () => {
 
   it('updating encrypted field', async () => {
     let updates = {secret:"Something else"}
-    let udata = await database3.update({"_id":doc_inserted._id},{data:updates})
+    let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{data:updates}})
     let rdata= await database3.read({_id:doc_inserted._id})
     assert(rdata.doc.data.secret === updates.secret )
   })
 
   it('updating  meta.link', async () => {
     let updates = {title:"Something else"}
-    let udata = await database3.update({"_id":doc_inserted._id},{meta:{link:"this-is-new"}})
+    let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{meta:{link:"this-is-new"}}})
     //console.log(udata)
     let rdata= await database3.read({_id:doc_inserted._id})
     //console.log(rdata)
@@ -1315,7 +1141,7 @@ describe("Doc update tests", async () => {
     it('error updating  meta.link not valid ', async () => {
       await rejects(async () => {
         try {
-          let udata = await database3.update({"_id":doc_inserted._id},{meta:{link:1234}})
+          let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{meta:{link:1234}}})
         } catch (error) {
           //console.log(error)
           throw error
@@ -1326,7 +1152,7 @@ describe("Doc update tests", async () => {
   it('error updating  meta.link already exists ', async () => {
     await rejects(async () => {
       try {
-        let udata = await database3.update({"_id":doc_inserted._id},{meta:{link:"sample2"}})
+        let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{meta:{link:"sample2"}}})
       } catch (error) {
         //console.log(error)
         throw error
@@ -1337,14 +1163,14 @@ describe("Doc update tests", async () => {
 
   it('updating  meta.tags,link at the same time ', async () => {
     let updates = {tags:["something","in","the","way"],link:"something-in-the-way"}
-    let udata = await database3.update({"_id":doc_inserted._id},{meta:updates})
+    let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{meta:updates}})
     let rdata= await database3.read({_id:doc_inserted._id})
     assert(rdata.doc.meta.tags.join(",") == updates.tags.join(",") && rdata.doc.meta.link === updates.link )
   })
 
   it('updating  meta.tags ', async () => {
     let updates = {tags:["something","in","the","way","all","apologies"]}
-    let udata = await database3.update({"_id":doc_inserted._id},{meta:updates})
+    let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{meta:updates}})
     let rdata= await database3.read({_id:doc_inserted._id})
     assert(rdata.doc.meta.tags.join(",") == updates.tags.join(","))
   })
@@ -1354,7 +1180,7 @@ describe("Doc update tests", async () => {
     await rejects(async () => {
       try {
         let updates = {text1:"sample text 1"}
-        let udata = await database3.update({"_id":doc_inserted._id},{data:updates})
+        let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{data:updates}})
       } catch (error) {
         //console.log(error)
         throw error
@@ -1365,8 +1191,8 @@ describe("Doc update tests", async () => {
   it('updating only non editable fields generates error', async () => {
     await rejects(async () => {
       try {
-        let updates = {page:1234,genre:"Horror"}
-        let udata = await database3.update({"_id":doc_inserted._id},{data:updates})
+        let updates1 = {page:1234,genre:"Horror"}
+        let udata = await database3.update({criteria:{"_id":doc_inserted._id},"updates":{data:updates1}})
       } catch (error) {
         //console.log(error)
         throw error
@@ -1376,7 +1202,7 @@ describe("Doc update tests", async () => {
 
   it('updating  non editable fields not allowed', async () => {
     let updates = {title:"HP1234",genre:"Horror"}
-    let udata = await database3.update({"_id":doc_inserted._id},{data:updates})
+    let udata = await database3.update({criteria:{"_id":doc_inserted._id},updates:{data:updates}})
     let rdata= await database3.read({_id:doc_inserted._id})
     assert(rdata.doc.data.title == updates.title && rdata.doc.data.genre != updates.genre )
   })
@@ -1389,80 +1215,6 @@ describe("Doc update tests", async () => {
 describe("Doc delete tests", async () => {
   let database3
 
-  const test_schema = {
-    name:"book",
-    description:"Test schema 1",
-    title:"Book",
-    schema: {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      type: "object",
-      properties: {
-        title: {
-          type: "string",
-          minLength: 1,
-          description: "The title of the book",
-        },
-        author: {
-          type: "string",
-          minLength: 1,
-          description: "The author of the book",
-        },
-        isbn: {
-          type: "string",
-          pattern: "^(97(8|9))?\\d{9}(\\d|X)$",
-          description: "The ISBN of the book, can be 10 or 13 digits",
-        },
-        publicationYear: {
-          type: "integer",
-          minimum: 1450,
-          maximum: 2024,
-          description:
-            "The year the book was published (between 1450 and 2024)",
-        },
-        genre: {
-          type: "string",
-          enum: [
-            "Fiction",
-            "Non-Fiction",
-            "Science",
-            "History",
-            "Fantasy",
-            "Biography",
-            "Children",
-            "Mystery",
-            "Horror",
-          ],
-          description: "The genre of the book",
-        },
-        language: {
-          type: "string",
-          description: "The language of the book",
-          default: "English",
-        },
-        publisher: {
-          type: "string",
-          description: "The publisher of the book",
-          minLength: 1,
-        },
-        pages: {
-          type: "integer",
-          minimum: 1,
-          description: "The number of pages in the book",
-        },
-        secret:{
-          type:"string"
-        }
-      },
-      required: ["title", "author"],
-      additionalProperties: false,
-    },
-    settings : {
-      primary_keys:['title','author'],
-      non_editable_fields:['pages','genre'],
-      encrypted_fields:["secret"]
-    }
-  }
-
   const book1 = {
     title: "Harry Potter",
     author: "J.K. Rowling",
@@ -1479,14 +1231,17 @@ describe("Doc delete tests", async () => {
   let doc_inserted 
 
   before(async () => {
-    // adding a schema
-    let doc_obj = get_pdb_doc("test_database_30", "qwertyuiopaqwsde1254");
-    database3 = new BeanBagDB(doc_obj);
-    await database3.ready(); // Ensure the database is ready before running tests
     try {
-      let a = await database3.create("schema",test_schema)
-      doc_inserted = await database3.create("book",book1,meta)
-      let b = await database3.create("book",{...book1,title:"HP2"},{...meta,link:"sample2"})
+      let doc_obj = get_pdb_doc("test_database_30", "qwertyuiopaqwsde45451254");
+      database3 = new BeanBagDB(doc_obj);
+      let test_schema  = {...good_book_schema_2}
+      test_schema["settings"]["non_editable_fields"] = ['pages','genre']
+      test_schema["settings"]["primary_keys"] = ['title','author']
+
+      await database3.ready(); // Ensure the database is ready before running tests
+      let a = await database3.create({schema:"schema",data:test_schema})
+      doc_inserted = await database3.create({schema:"book",data:book1,meta:meta})
+      let b = await database3.create({schema:"book",data:{...book1,title:"HP2"},meta:{...meta,link:"sample2"}})
       //console.log(b)
       console.log("Ready for more tests...");  
     } catch (error) {
@@ -1556,81 +1311,6 @@ describe("Doc delete tests", async () => {
 // search 
 describe("Doc search tests", async () => {
   let database3
-
-  const test_schema = {
-    name:"book",
-    title:"Book",
-    description:"Test schema 1",
-    schema: {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      type: "object",
-      properties: {
-        title: {
-          type: "string",
-          minLength: 1,
-          description: "The title of the book",
-        },
-        author: {
-          type: "string",
-          minLength: 1,
-          description: "The author of the book",
-        },
-        isbn: {
-          type: "string",
-          pattern: "^(97(8|9))?\\d{9}(\\d|X)$",
-          description: "The ISBN of the book, can be 10 or 13 digits",
-        },
-        publicationYear: {
-          type: "integer",
-          minimum: 1450,
-          maximum: 2024,
-          description:
-            "The year the book was published (between 1450 and 2024)",
-        },
-        genre: {
-          type: "string",
-          enum: [
-            "Fiction",
-            "Non-Fiction",
-            "Science",
-            "History",
-            "Fantasy",
-            "Biography",
-            "Children",
-            "Mystery",
-            "Horror",
-          ],
-          description: "The genre of the book",
-        },
-        language: {
-          type: "string",
-          description: "The language of the book",
-          default: "English",
-        },
-        publisher: {
-          type: "string",
-          description: "The publisher of the book",
-          minLength: 1,
-        },
-        pages: {
-          type: "integer",
-          minimum: 1,
-          description: "The number of pages in the book",
-        },
-        secret:{
-          type:"string"
-        }
-      },
-      required: ["title", "author"],
-      additionalProperties: false,
-    },
-    settings : {
-      primary_keys:['title','author'],
-      non_editable_fields:['pages','genre'],
-      encrypted_fields:["secret"]
-    }
-  }
-
   const book1 = {
     title: "Harry Potter",
     author: "J.K. Rowling",
@@ -1658,13 +1338,16 @@ describe("Doc search tests", async () => {
   let doc_inserted 
   before(async () => {
     // adding a schema
-    let doc_obj = get_pdb_doc("test_database_31", "qwertyuiopaqwsde1254");
+    let doc_obj = get_pdb_doc("test_database_31", "qwertyuiopaqwsde12544545");
     database3 = new BeanBagDB(doc_obj);
+    let test_schema  = {...good_book_schema_2}
+    test_schema["settings"]["non_editable_fields"] = ['pages','genre']
+    test_schema["settings"]["primary_keys"] = ['title','author']
     await database3.ready(); // Ensure the database is ready before running tests
     try {
-      let a = await database3.create("schema",test_schema)
-      doc_inserted = await database3.create("book",book1,meta)
-      let b = await database3.create("book",book2,{...meta,link:"sample2"})
+      let a = await database3.create({schema:"schema",data:test_schema})
+      doc_inserted = await database3.create({schema:"book",data:book1,meta:meta})
+      let b = await database3.create({schema:"book",data:book2,meta:{...meta,link:"sample2"}})
       //console.log(b)
       console.log("Ready for more tests...");  
     } catch (error) {