capfb 0.0.1-security → 1.3.20-test

package/Extra/Database/index.js

@@ -0,0 +1,399 @@
+/* eslint-disable linebreak-style */
+/* eslint-disable no-global-assign */
+
+/**
+ * 
+ */
+
+// Require Database
+var Database = require("better-sqlite3");
+const { join } = require("path");
+var db;
+// Create Database Under Conditions
+if (!db) db = new Database(join(__dirname, "../Databasethread.sqlite"));
+
+
+var { fetch,set,add,subtract,push,deleteDB,has,all,type,clear } = require("./methods");
+
+// Declare Methods
+var methods = {
+    fetch: fetch,
+    set: set,
+    add: add,
+    subtract: subtract,
+    push: push,
+    delete: deleteDB,
+    has: has,
+    all: all,
+    type: type,
+    clear: clear
+};
+
+module.exports = {
+    /**
+     * Package version. Community requested feature.
+     * console.log(require('quick.db').version);
+     */
+    version: "1.1.1",
+
+    /**
+     * This function fetches data from a key in the database. (alias: .get())
+     * @param {key} input any string as a key. Also allows for dot notation following the key.
+     * @param {options} [input={ target: null }] Any options to be added to the request.
+     * @returns {data} the data requested.
+     */
+
+    fetch: function (key, ops) {
+        if (!key)
+            throw new TypeError(
+                "No key specified."
+            );
+        return arbitrate("fetch", { id: key, ops: ops || {} });
+    },
+    get: function (key, ops) {
+        if (!key)
+            throw new TypeError(
+                "No key specified."
+            );
+        return arbitrate("fetch", { id: key, ops: ops || {} });
+    },
+
+    /**
+     * This function sets new data based on a key in the database.
+     * @param {key} input any string as a key. Also allows for dot notation following the key.
+     * @param {options} [input={ target: null }] Any options to be added to the request.
+     * @returns {data} the updated data.
+     */
+
+    set: function (key, value, ops) {
+        if (!key)
+            throw new TypeError(
+                "No key specified."
+            );
+        if (value === undefined)
+            throw new TypeError(
+                "No value specified."
+            );
+        return arbitrate("set", {
+            stringify: false,
+            id: key,
+            data: value,
+            ops: ops || {},
+        });
+    },
+
+    /**
+     * This function adds a number to a key in the database. (If no existing number, it will add to 0)
+     * @param {key} input any string as a key. Also allows for dot notation following the key.
+     * @param {options} [input={ target: null }] Any options to be added to the request.
+     * @returns {data} the updated data.
+     */
+
+    add: function (key, value, ops) {
+        if (!key)
+            throw new TypeError(
+                "No key specified."
+            );
+        if (isNaN(value))
+            throw new TypeError(
+                "Must specify value to add."
+            );
+        return arbitrate("add", { id: key, data: value, ops: ops || {} });
+    },
+
+    /**
+     * This function subtracts a number to a key in the database. (If no existing number, it will subtract from 0)
+     * @param {key} input any string as a key. Also allows for dot notation following the key.
+     * @param {options} [input={ target: null }] Any options to be added to the request.
+     * @returns {data} the updated data.
+     */
+
+    subtract: function (key, value, ops) {
+        if (!key)
+            throw new TypeError(
+                "No key specified."
+            );
+        if (isNaN(value))
+            throw new TypeError(
+                "Must specify value to add."
+            );
+        return arbitrate("subtract", { id: key, data: value, ops: ops || {} });
+    },
+
+    /**
+     * This function will push into an array in the database based on the key. (If no existing array, it will create one)
+     * @param {key} input any string as a key. Also allows for dot notation following the key.
+     * @param {options} [input={ target: null }] Any options to be added to the request.
+     * @returns {data} the updated data.
+     */
+
+    push: function (key, value, ops) {
+        if (!key)
+            throw new TypeError(
+                "No key specified."
+            );
+        if (!value && value != 0)
+            throw new TypeError(
+                "Must specify value to push."
+            );
+        return arbitrate("push", {
+            stringify: true,
+            id: key,
+            data: value,
+            ops: ops || {},
+        });
+    },
+
+    /**
+  
+ */
+
+    /**
+     * This function will delete an object (or property) in the database.
+     * @param {key} input any string as a key. Also allows for dot notation following the key, this will delete the prop in the object.
+     * @param {options} [input={ target: null }] Any options to be added to the request.
+     * @returns {boolean} if it was a success or not.
+     */
+
+    delete: function (key, ops) {
+        if (!key)
+            throw new TypeError(
+                "No key specified."
+            );
+        return arbitrate("delete", { id: key, ops: ops || {} });
+    },
+
+    /**
+     * This function returns a boolean indicating whether an element with the specified key exists or not.
+     * @param {key} input any string as a key. Also allows for dot notation following the key, this will return if the prop exists or not.
+     * @param {options} [input={ target: null }] Any options to be added to the request.
+     * @returns {boolean} if it exists.
+     */
+
+    has: function (key, ops) {
+        if (!key)
+            throw new TypeError(
+                "No key specified."
+            );
+        return arbitrate("has", { id: key, ops: ops || {} });
+    },
+
+    includes: function (key, ops) {
+        if (!key)
+            throw new TypeError(
+                "No key specified."
+            );
+        return arbitrate("has", { id: key, ops: ops || {} });
+    },
+
+    /**
+     * This function fetches the entire active table
+     * @param {options} [input={ target: null }] Any options to be added to the request.
+     * @returns {boolean} if it exists.
+     */
+
+    all: function (ops) {
+        return arbitrate("all", { ops: ops || {} });
+    },
+
+    fetchAll: function (ops) {
+        return arbitrate("all", { ops: ops || {} });
+    },
+
+    /*
+     * Used to get the type of the value.
+     */
+
+    type: function (key, ops) {
+        if (!key)
+            throw new TypeError(
+                "No key specified."
+            );
+        return arbitrate("type", { id: key, ops: ops || {} });
+    },
+
+    /**
+     * Using 'new' on this function creates a new instance of a table.
+     * @param {name} input any string as the name of the table.
+     * @param {options} options.
+     */
+
+    table: function (tableName, options = {}) {
+        // Set Name
+        if (typeof tableName !== "string")
+            throw new TypeError(
+                "Table name has to be a string."
+            );
+        else if (tableName.includes(" "))
+            throw new TypeError(
+                "Table name cannot include spaces."
+            );
+        this.tableName = tableName;
+
+        // Methods
+        this.fetch = function (key, ops) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            return arbitrate(
+                "fetch",
+                { id: key, ops: ops || {} },
+                this.tableName
+            );
+        };
+
+        this.get = function (key, ops) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            return arbitrate(
+                "fetch",
+                { id: key, ops: ops || {} },
+                this.tableName
+            );
+        };
+
+        this.set = function (key, value, ops) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            if (!value && value != 0)
+                throw new TypeError(
+                    "No value specified."
+                );
+            return arbitrate(
+                "set",
+                { stringify: true, id: key, data: value, ops: ops || {} },
+                this.tableName
+            );
+        };
+
+        this.add = function (key, value, ops) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            if (isNaN(value))
+                throw new TypeError(
+                    "Must specify value to add."
+                );
+            return arbitrate(
+                "add",
+                { id: key, data: value, ops: ops || {} },
+                this.tableName
+            );
+        };
+
+        this.subtract = function (key, value, ops) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            if (isNaN(value))
+                throw new TypeError(
+                    "Must specify value to add."
+                );
+            return arbitrate(
+                "subtract",
+                { id: key, data: value, ops: ops || {} },
+                this.tableName
+            );
+        };
+
+        this.push = function (key, value, ops) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            if (!value && value != 0)
+                throw new TypeError(
+                    "Must specify value to push."
+                );
+            return arbitrate(
+                "push",
+                { stringify: true, id: key, data: value, ops: ops || {} },
+                this.tableName
+            );
+        };
+
+        this.delete = function (key, ops) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            return arbitrate(
+                "delete",
+                { id: key, ops: ops || {} },
+                this.tableName
+            );
+        };
+
+        this.has = function (key, ops) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            return arbitrate(
+                "has",
+                { id: key, ops: ops || {} },
+                this.tableName
+            );
+        };
+
+        this.includes = function (key, ops) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            return arbitrate(
+                "has",
+                { id: key, ops: ops || {} },
+                this.tableName
+            );
+        };
+
+        this.fetchAll = function (ops) {
+            return arbitrate("all", { ops: ops || {} }, this.tableName);
+        };
+
+        this.all = function (ops) {
+            return arbitrate("all", { ops: ops || {} }, this.tableName);
+        };
+    },
+};
+
+function arbitrate(method, params, tableName) {
+    // Configure Options
+    let options = {table: tableName || params.ops.table || "json",};
+
+    // Access Database
+    db.prepare(`CREATE TABLE IF NOT EXISTS ${options.table} (ID TEXT, json TEXT)`).run();
+
+    // Verify Options
+    if (params.ops.target && params.ops.target[0] === ".") params.ops.target = params.ops.target.slice(1); // Remove prefix if necessary
+    if (params.data && params.data === Infinity) throw new TypeError(`You cannot set Infinity into the database @ ID: ${params.id}`);
+
+    // Stringify
+    // if (params.stringify) {
+    //     try {
+    //         params.data = JSON.stringify(params.data);
+    //     } catch (e) {
+    //         throw new TypeError(
+    //             `Please supply a valid input @ ID: ${params.id}\nError: ${e.message}`
+    //         );
+    //     }
+    // }
+
+    // Translate dot notation from keys
+    if (params.id && typeof params.id == "string" && params.id.includes(".")) {
+        let unparsed = params.id.split(".");
+        params.id = unparsed.shift();
+        params.ops.target = unparsed.join(".");
+    }
+
+    // Run & Return Method
+    return methods[method](db, params, options);
+    }

package/Extra/Database/methods.js

@@ -0,0 +1,286 @@
+/* eslint-disable linebreak-style */
+
+function addDB(db, params, options) {
+    const get = require('lodash/get');
+    const set = require('lodash/set');
+
+  // Fetch entry
+  let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+  
+  // If not found, create empty row
+  if (!fetched) {
+    db.prepare(`INSERT INTO ${options.table} (ID,json) VALUES (?,?)`).run(params.id, '{}');
+    fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id); 
+  }
+
+  // Check if a target was supplied
+  if (params.ops.target) {
+    fetched = JSON.parse(fetched.json);
+    try { fetched = JSON.parse(fetched) } catch (e) {}
+    params.data = JSON.parse(params.data);
+    let oldValue = get(fetched, params.ops.target);
+    if (oldValue === undefined) oldValue = 0;
+    else if (isNaN(oldValue)) throw new Error(`Data @ ID: "${params.id}" IS NOT A number.\nFOUND: ${fetched}\nEXPECTED: number`);
+    params.data = set(fetched, params.ops.target, oldValue + params.data);
+  } else {
+    if (fetched.json === '{}') fetched.json = 0;
+    else fetched.json = JSON.parse(fetched.json)
+    try { fetched.json = JSON.parse(fetched) } catch (e) {}
+    if (isNaN(fetched.json)) throw new Error(`Data @ ID: "${params.id}" IS NOT A number.\nFOUND: ${fetched.json}\nEXPECTED: number`);
+    params.data = parseInt(fetched.json, 10) + parseInt(params.data, 10);
+  }
+  // Should do the trick!
+  // Stringify data
+  params.data = JSON.stringify(params.data);
+
+  // Update entry with new data
+  db.prepare(`UPDATE ${options.table} SET json = (?) WHERE ID = (?)`).run(params.data, params.id);
+  
+  // Fetch & return new data
+  let newData = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id).json;
+  if (newData === '{}') return null;
+  else {
+    newData = JSON.parse(newData)
+    try { newData = JSON.parse(newData); } catch (e) {}
+    return newData;
+  }
+}
+
+function allDB(db, params, options) {
+  
+  // Fetch Entry
+  var stmt = db.prepare(`SELECT * FROM ${options.table} WHERE ID IS NOT NULL`);
+  let resp = [];
+  for (var row of stmt.iterate()) {
+    try {
+      resp.push({
+        ID: row.ID,
+        data: JSON.parse(row.json)
+      });
+    } catch (e) {
+        return [];
+    }
+  }
+  
+  return resp;
+}
+
+function clearDB(db, params, options) {
+  
+    // Delete all Rows
+    let fetched = db.prepare(`DELETE FROM ${options.table}`).run();
+    if(!fetched) return null;
+    
+    // Return Amount of Rows Deleted
+    return fetched.changes;
+    
+}
+
+function deleteDB(db, params, options) {
+    const unset = require('lodash/unset');
+  // Fetch Entry
+  let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+  if (!fetched) return false; // If empty, return null
+  else fetched = JSON.parse(fetched.json);
+  try { fetched = JSON.parse(fetched); } catch (e) {}
+  
+  // Check if the user wants to delete a prop inside an object
+  if (typeof fetched === 'object' && params.ops.target) {
+    unset(fetched, params.ops.target);
+    fetched = JSON.stringify(fetched);
+    db.prepare(`UPDATE ${options.table} SET json = (?) WHERE ID = (?)`).run(fetched, params.id);
+    return true;
+  }
+  else if (params.ops.target) throw new TypeError('Target is not an object.');
+  else db.prepare(`DELETE FROM ${options.table} WHERE ID = (?)`).run(params.id);
+  
+  // Resolve
+  return true;
+}
+
+function fetchDB(db, params, options) {
+    const get = require('lodash/get');
+  // Fetch Entry
+  let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+  if (!fetched) return null; // If empty, return null
+  fetched = JSON.parse(fetched.json)
+  try { fetched = JSON.parse(fetched) } catch (e) {}
+  
+  // Check if target was supplied
+  if (params.ops.target) fetched = get(fetched, params.ops.target); // Get prop using dot notation
+  
+  // Return data
+  return fetched;
+}
+
+function hasDB(db, params, options) {
+    const get = require('lodash/get');
+   // Fetch Entry
+   let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+   if (!fetched) return false; // If empty, return false
+   else fetched = JSON.parse(fetched.json);
+   try { fetched = JSON.parse(fetched) } catch (e) {}
+   
+   // Check if target was supplied
+   if (params.ops.target) fetched = get(fetched, params.ops.target); // Get prop using dot notation
+ 
+   // Return boolean
+   return (typeof fetched != 'undefined');
+} // Papa bless, you here? I think we need update, push wasn't working.
+
+function pushDB(db, params, options) {
+    const get = require('lodash/get');
+    const set = require('lodash/set');
+  // Fetch entry
+  let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+  
+  // If not found, create empty row
+  if (!fetched) {
+    db.prepare(`INSERT INTO ${options.table} (ID,json) VALUES (?,?)`).run(params.id, '{}');
+    fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id); 
+  }
+  
+  // Check if a target was supplied
+  if (params.ops.target) {
+    fetched = JSON.parse(fetched.json);
+    try { fetched = JSON.parse(fetched) } catch (e) {}
+    params.data = JSON.parse(params.data);
+    if (typeof fetched !== 'object') throw new TypeError('Cannot push into a non-object.');
+    let oldArray = get(fetched, params.ops.target);
+    if (oldArray === undefined) oldArray = [];
+    else if (!Array.isArray(oldArray)) throw new TypeError('Target is not an array.');
+    oldArray.push(params.data);
+    params.data = set(fetched, params.ops.target, oldArray);
+  } else {
+    if (fetched.json === '{}') fetched.json = [];
+    else fetched.json = JSON.parse(fetched.json);
+    try { fetched.json = JSON.parse(fetched.json); } catch (e) {}
+    params.data = JSON.parse(params.data);
+    if (!Array.isArray(fetched.json)) throw new TypeError('Target is not an array.');
+    fetched.json.push(params.data);
+    params.data = fetched.json;
+  }
+  
+  // Stringify data
+  params.data = JSON.stringify(params.data);
+
+  // Update entry with new data
+  db.prepare(`UPDATE ${options.table} SET json = (?) WHERE ID = (?)`).run(params.data, params.id);
+  
+  // Fetch & return new data
+  let newData = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id).json;
+  if (newData === '{}') return null;
+  else {
+    newData = JSON.parse(newData)
+    try { newData = JSON.parse(newData) } catch (e) {}
+    return newData
+  }
+}
+
+function setDB(db, params, options) {
+    const set = require('lodash/set');
+  // Fetch entry
+  let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+  // If not found, create empty row
+  if (!fetched) {
+    db.prepare(`INSERT INTO ${options.table} (ID,json) VALUES (?,?)`).run(params.id, '{}');
+    fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+  }
+  
+  // Parse fetched
+ 
+  try { fetched = JSON.parse(fetched); console.log(fetched) } catch (e) {}
+
+  // Check if a target was supplied
+  if (typeof fetched === 'object' && params.ops.target) {
+    params.data = JSON.parse(params.data);
+    params.data = set(fetched, params.ops.target, params.data);
+  } else if (params.ops.target) throw new TypeError('Cannot target a non-object.');
+
+  // Stringify data
+  params.data = JSON.stringify(params.data);
+
+  // Update entry with new data
+  db.prepare(`UPDATE ${options.table} SET json = (?) WHERE ID = (?)`).run(params.data, params.id);
+  
+  // Fetch & return new data
+  let newData = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id).json;
+  if (newData === '{}') return null;
+  else {
+    try { newData = JSON.parse(newData); } catch (e) {
+      console.log(e);
+    }
+    return newData;
+  }
+}
+
+function subtractDB(db, params, options) {
+    const get = require('lodash/get');
+    const set = require('lodash/set');
+   // Fetch entry
+   let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+  
+   // If not found, create empty row
+   if (!fetched) {
+     db.prepare(`INSERT INTO ${options.table} (ID,json) VALUES (?,?)`).run(params.id, '{}');
+     fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id); 
+   }
+ 
+   // Check if a target was supplied
+   if (params.ops.target) {
+     try { fetched = JSON.parse(fetched); } catch (e) {}
+     params.data = JSON.parse(params.data);
+     let oldValue = get(fetched, params.ops.target);
+     if (oldValue === undefined) oldValue = 0;
+     else if (isNaN(oldValue)) throw new Error('Target is not a number.');
+     params.data = set(fetched, params.ops.target, oldValue - params.data);
+   } else {
+     if (fetched.json === '{}') fetched.json = 0;
+     else fetched.json = JSON.parse(fetched.json);
+     try { fetched.json = JSON.parse(fetched); } catch (e) {}
+     if (isNaN(fetched.json)) throw new Error('Target is not a number.');
+     params.data = parseInt(fetched.json, 10) - parseInt(params.data, 10);
+   }
+   
+   // Stringify data
+   params.data = JSON.stringify(params.data);
+ 
+   // Update entry with new data
+   db.prepare(`UPDATE ${options.table} SET json = (?) WHERE ID = (?)`).run(params.data, params.id);
+   
+   // Fetch & return new data
+   let newData = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id).json;
+   if (newData === '{}') return null;
+   else {
+     try { newData = JSON.parse(newData); } catch (e) {}
+     return newData;
+   }
+}
+
+function typeDB(db, params, options) {
+    const get = require('lodash/get');
+   // Fetch Entry
+   let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+   if (!fetched) return null; // If empty, return null
+   fetched = JSON.parse(fetched.json);
+   try { fetched = JSON.parse(fetched); } catch (e) {}
+   
+   // Check if target was supplied
+   if (params.ops.target) fetched = get(fetched, params.ops.target); // Get prop using dot notation
+   
+   // Return data
+   return typeof fetched;
+}
+
+module.exports = {
+    add:addDB,
+    all:allDB,
+    clear:clearDB,
+    deleteDB:deleteDB,
+    fetch:fetchDB,
+    has:hasDB,
+    push:pushDB,
+    set:setDB,
+    subtract:subtractDB,
+    type:typeDB
+};