v2

Author: Snowflake107

README.md

@@ -10,12 +10,15 @@ Quick mongodb wrapper for beginners.
 - Easy
 - Simple
 - Fast
+- Very similar to **[quick.db](https://npmjs.com/package/quick.db)**
+- Best alternative to quick.db
+- Dot notation support
 - Import & export support
 - Key value based
-- More than 25 methods
+- More than 30 methods
 - Beginner friendly
-
-> Btw, `quick.db` users can easily export their data to `quickmongo`.
+- Asynchronous
+- Multiple model/schema support
 
 # Quick Example
 
@@ -46,7 +49,7 @@ function exportData() {
     });    
 }
 
-exportData();
+mongo.on("ready", () => exportData());
 ```
 
 # Exporting data from quick.db tables (and custom schema names)
@@ -56,7 +59,8 @@ const db = require("quick.db");
 const table = new db.table("mytable");
 
 const { Database } = require("quickmongo");
-const mongo = new Database("mongodb://localhost/quickmongo", "mytable"); // custom schema name (acts like quickdb table)
+const mdb = new Database("mongodb://localhost/quickmongo");
+const mongo = mdb.table("mytable"); // custom schema/model, (acts like quickdb table) with all the features of main Database
 
 function exportData() {
     const data = table.all();
@@ -65,7 +69,22 @@ function exportData() {
     });    
 }
 
-exportData();
+mdb.on("ready", () => exportData());
+```
+
+# Exporting data from QuickMongo to QuickDB
+
+```js
+const db = require("quick.db");
+const { Database } = require("quickmongo");
+const mdb = new Database("mongodb://localhost/quickmongo");
+
+mdb.on("ready", () => exportData());
+
+function exportData() {
+    mdb.exportToQuickDB(db)
+        .then(console.log);
+}
 ```
 
 # Links
@@ -109,22 +128,4 @@ db.export("rawdata").then(path => {
 db.import(quickdb.all()).then(() => {
     console.log("Data imported!");
 });
-```
-
-# Value Targets (Path)
-Value target (Like `key.target` of `quick.db`) support is not yet available in this package. It will be available soon :)
-
-But you can still use it like this:
-
-```js
-const { Database } = require("quickmongo");
-const db = new Database("mongodb://localhost/quickmongo");
-
-// set data
-db.set("user", { items: [] });
-
-// update items
-let data = await db.get("user");
-data.items = ["keyboard"];
-db.set("user", data); // { items: ["keyboard"] }
 ```

index.d.ts

@@ -96,7 +96,7 @@ export class Database extends Base {
   public subtract(key: string, value: number): Promise<any>;
   public get uptime(): number;
   public export(fileName?: string, path?: string): Promise<string>;
-  public import(data?: any[], ordered?: boolean): Promise<void>;
+  public import(data?: DataSet[], ops?: { overwriteExisting?: boolean, validate?: boolean }): Promise<boolean>;
   public disconnect(): Promise<void>;
   public connect(url: string): Promise<void>;
   public get name(): string;
@@ -125,6 +125,7 @@ export class Database extends Base {
   public entries(): Promise<number>;
   public raw(params?: Mongoose.QueryFindOptions): Promise<Mongoose.Document>;
   public random(limit?: number): Promise<DataSet[]>;
+  public table(name: string): Database;
   public exportToQuickDB(): Promise<DataSet[]>;
   public get utils(): Util;
   public toString(): string;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickmongo",
-  "version": "1.1.5",
+  "version": "2.0.0",
   "description": "Quick mongodb wrapper for beginners.",
   "main": "index.js",
   "types": "index.d.ts",

src/Base.js

@@ -49,6 +49,8 @@ class Base extends EventEmitter {
      * @ignore
      */
     _create(url) {
+        // do not create multiple connections
+        if (mongoose.connection.readyState) return;
         this.emit("debug", "Creating database connection...");
         if (url && typeof url === "string") this.dbURL = url;
         if (!this.dbURL || typeof this.dbURL !== "string") throw new Error("Database url was not provided!", "MongoError");

src/Error.js

@@ -4,7 +4,7 @@ class QuickError extends Error {
         super();
         Error.captureStackTrace(this, this.constructor);
         this.message = message;
-        this.name = name || "QuickMongoError";
+        this.name = name || "TypeError";
     }
 
 }

src/Main.js

@@ -36,21 +36,22 @@ class Database extends Base {
     async set(key, value) {
         if (!Util.isKey(key)) throw new Error("Invalid key specified!", "KeyError");
         if (!Util.isValue(value)) throw new Error("Invalid value specified!", "ValueError");
+        const parsed = Util.parseKey(key);
         let raw = await this.schema.findOne({
-            ID: key
+            ID: parsed.key
         });
         if (!raw) {
             let data = new this.schema({
-                ID: key,
-                data: value
+                ID: parsed.key,
+                data: parsed.target ? Util.setData(key, {}, value) : value
             });
             await data.save()
                 .catch(e => {
                     return this.emit("error", e);
                 });
             return data.data;
         } else {
-            raw.data = value;
+            raw.data = parsed.target ? Util.setData(key, Object.assign({}, raw.data), value) : value;
             await raw.save()
                 .catch(e => {
                     return this.emit("error", e);
@@ -66,11 +67,21 @@ class Database extends Base {
      */
     async delete(key) {
         if (!Util.isKey(key)) throw new Error("Invalid key specified!", "KeyError");
-        let data = await this.schema.findOneAndDelete({ ID: key })
-            .catch(e => {
-                return this.emit("error", e);
-            });
-        return data;
+        const parsed = Util.parseKey(key);
+        const raw = await this.schema.findOne({ ID: parsed.key });
+        if (!raw) return false;
+        if (parsed.target) {
+            let data = Util.unsetData(key, Object.assign({}, raw.data));
+            raw.data = data;
+            raw.save().catch(e => this.emit("error", e));
+            return data;
+        } else {
+            let data = await this.schema.findOneAndDelete({ ID: parsed.key })
+                .catch(e => {
+                    return this.emit("error", e);
+                });
+            return data;
+        }
     }
 
     /**
@@ -100,12 +111,17 @@ class Database extends Base {
      */
     async get(key) {
         if (!Util.isKey(key)) throw new Error("Invalid key specified!", "KeyError");
-        let get = await this.schema.findOne({ ID: key })
+        const parsed = Util.parseKey(key);
+
+        let get = await this.schema.findOne({ ID: parsed.key })
             .catch(e => {
                 return this.emit("error", e);
             });
         if (!get) return null;
-        return get.data;
+        let item;
+        if (parsed.target) item = Util.getData(key, Object.assign({}, get.data));
+        else item = get.data;
+        return item ? item : null;
     }
 
     /**
@@ -285,19 +301,32 @@ class Database extends Base {
      * [{ ID: "foo", data: "bar" }, { ID: "hi", data: "hello" }]
      * ```
      * @param {Array} data Array of data
-     * @param {boolean} ordered If set to false, it will insert valid documents before throwing errors (if any)
+     * @param {object} ops Import options
+     * @param {boolean} [ops.validate=false] If set to true, it will insert valid documents only
+     * @param {boolean} [ops.overwriteExisting=false] If it should overwrite existing value (slow)
      * @example const data = QuickDB.all(); // imports data from quick.db to quickmongo
      * QuickMongo.import(data);
      * @returns {Promise<Boolean>}
      */
-    import(data=[], ordered = true) {
-        return new Promise((resolve, reject) => {
+    import(data=[], ops = { overwriteExisting: false, validate: false }) {
+        return new Promise(async (resolve, reject) => {
             if (!Array.isArray(data)) return reject(new Error(`Data type must be Array, received ${typeof data}!`, "DataTypeError"));
             if (data.length < 1) return resolve(false);
-            this.schema.insertMany(data, { ordered: !!ordered }, (error) => {
-                if (error) return reject(new Error(`${error}`, "DataImportError"));
+            if (!ops.overwriteExisting) {
+                this.schema.insertMany(data, { ordered: !ops.validate }, (error) => {
+                    if (error) return reject(new Error(`${error}`, "DataImportError"));
+                    return resolve(true);
+                });
+            } else {
+                data.forEach((x, i) => {
+                    if (!ops.validate && (!x.ID || !x.data)) return;
+                    else if (!!ops.validate && (!x.ID || !x.data)) return reject(new Error(`Data is missing ${!x.ID ? "ID" : "data"} path!`, "DataImportError"));
+                    setTimeout(() => {
+                        this.set(x.ID, x.data);
+                    }, 457 * (i + 1));
+                });
                 return resolve(true);
-            });
+            }
         });
     }
 
@@ -481,20 +510,27 @@ class Database extends Base {
 
     /**
      * Returns random entry from the database
-     * @param {number} total total entries to return
+     * @param {number} n Number entries to return
      * @returns {Promise<any[]>}
      * @example const random = await db.random();
      * console.log(random);
      */
-    async random(total = 1) {
-        if (typeof total !== "number" || total < 1) total = 1;
+    async random(n = 1) {
+        if (typeof n !== "number" || n < 1) n = 1;
         const data = await this.all();
-        const arr = [];
-        for (let i = 0; i < total; i++) {
-            const entry = data[Math.floor(Math.random() * data.length)];
-            if (!arr.includes(entry)) arr.push(entry);
-        }
-        return arr;
+        if (n > data.length) throw new RangeError("Random value length may not exceed total length.");
+        const shuffled = data.sort(() => 0.5 - Math.random());
+        return shuffled.slice(0, n);
+    }
+
+    /**
+     * This method acts like `quick.db#table`. It will return new instance of itself.
+     * @param {string} name Schema/Model name 
+     */
+    table(name) {
+        if (!name || typeof name !== "string") throw new Error("Invalid model name");
+        const CustomModel = new Database(this.dbURL, name, this.options);
+        return CustomModel;
     }
 
     /**
@@ -526,7 +562,7 @@ class Database extends Base {
      * @example console.log(db.toString());
      */
     toString() {
-        return `<${this.constructor.name} QuickMongo>`;
+        return `${this.schema.modelName}`;
     }
 
     /**

src/Util.js

@@ -77,7 +77,7 @@ class Util {
         let parsed = this.parseKey(key);
         if (typeof data === "object" && parsed.target) {
             return _.set(data, parsed.target, value);
-        } else if (parsed.target) throw new Error("Cannot target non-object.", "SyntaxError");
+        } else if (parsed.target) throw new Error("Cannot target non-object.", "TargetError");
         return data;
     }
 
@@ -93,7 +93,7 @@ class Util {
         let item = data;
         if (typeof data === "object" && parsed.target) {
             _.unset(item, parsed.target);
-        } else if (parsed.target) throw new Error("Cannot target non-object.", "SyntaxError");
+        } else if (parsed.target) throw new Error("Cannot target non-object.", "TargetError");
         return item;
     }
 

test/test.js

@@ -1,9 +1,12 @@
 const { Database } = require("../index");
 const db = new Database("mongodb://localhost/test");
 
-db.on("ready", () => {
-    console.log("Hey, im connected!");
-    db.set("foo", "bar").then(() => db.export("./database.json"))
+db.on("ready", async () => {
+    console.log(`Hey, im connected! ${db.toString()}`);
+    console.log(await db.all(), `${db}`);
+
+    const mydb = db.table("TEST");
+    console.log(await mydb.all(), `${mydb}`);
 });
 
 db.on("error", console.error);