prettier

Author: Snowflake107

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devsnowflake/jsql",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Use JSON as SQL.",
   "main": "index.js",
   "types": "typings/index.d.ts",

src/jsql/Database.js

@@ -6,7 +6,7 @@ const handlers = {
     insert: require('../util/methods/insert'),
     drop: require('../util/methods/drop'),
     update: require('../util/methods/update'),
-    delete: require("../util/methods/delete"),
+    delete: require('../util/methods/delete'),
 };
 
 class Database {

src/util/Util.js

@@ -3,5 +3,5 @@ module.exports = {
         const nm = [];
         for (let i = 0; i < arr.length; i += len) nm.push(arr.slice(i, i + len));
         return nm;
-    }
-};
+    },
+};

src/util/methods/delete.js

@@ -1,4 +1,4 @@
-const { chunk } = require("../Util");
+const { chunk } = require('../Util');
 
 module.exports = (ast, db) => {
     if (ast.type.toLowerCase() !== 'delete') throw new TypeError('invalid query type');
@@ -7,33 +7,33 @@ module.exports = (ast, db) => {
     if (!data[table]) throw new Error(`Table "${table}" does not exist`);
 
     const point = { left: ast.where.left.value, op: ast.where.operator, right: ast.where.right.value };
-    if (!data[table].keys.some(x => x.column === point.left)) throw new Error(`Column "${set.col}" does not exists in table "${table}"`);
+    if (!data[table].keys.some((x) => x.column === point.left)) throw new Error(`Column "${set.col}" does not exists in table "${table}"`);
     const bin = binOp(data[table], point);
     if (bin.index < 0) return;
 
-    bin.data.forEach(d => {
+    bin.data.forEach((d) => {
         data[table].data.splice(data[table].data.indexOf(d), 1);
     });
 
     db.write(data);
-}
+};
 
 function binOp(data, clause) {
     switch (clause.op) {
-        case "=":
+        case '=':
             const child = chunk(data.data, 2);
-            const fnx = m => m.key === clause.left && m.data === clause.right;
-            const fn = x => x.find(fnx);
+            const fnx = (m) => m.key === clause.left && m.data === clause.right;
+            const fn = (x) => x.find(fnx);
 
             try {
                 const data = child.find(fn);
                 if (!data) throw new Error(`Could not verify operation "${clause.left} = ${clause.right}"`);
                 return {
                     data: data,
-                    index: child.findIndex(fn)
+                    index: child.findIndex(fn),
                 };
             } catch {
                 throw new Error(`Could not verify operation "${clause.left} = ${clause.right}"`);
             }
     }
-}
+}

src/util/methods/select.js

@@ -1,4 +1,4 @@
-const { chunk } = require("../Util");
+const { chunk } = require('../Util');
 
 module.exports = (ast, db) => {
     if (ast.type.toLowerCase() !== 'select') throw new TypeError('invalid query type');

src/util/methods/update.js

@@ -1,41 +1,41 @@
-const { chunk } = require("../Util");
+const { chunk } = require('../Util');
 
 module.exports = (ast, db) => {
     if (ast.type.toLowerCase() !== 'update') throw new TypeError('invalid query type');
     const table = ast.table[0].table;
     const data = db.db;
     if (!data[table]) throw new Error(`Table "${table}" does not exist`);
-    
+
     const set = { col: ast.set[0].column, val: ast.set[0].value.value };
     const point = { left: ast.where.left.value, op: ast.where.operator, right: ast.where.right.value, set };
-    if (!data[table].keys.some(x => x.column === set.col)) throw new Error(`Column "${set.col}" does not exists in table "${table}"`);
+    if (!data[table].keys.some((x) => x.column === set.col)) throw new Error(`Column "${set.col}" does not exists in table "${table}"`);
     const bin = binOp(data[table], point);
     if (bin.index < 0) return;
 
     const dataAt = data[table].data[bin.index + bin.idx];
     data[table].data.splice(bin.index + bin.idx, 1, {
         ...dataAt,
-        data: set.val
+        data: set.val,
     });
 
     db.write(data);
-}
+};
 
 function binOp(data, clause) {
-    switch(clause.op) {
-        case "=":
+    switch (clause.op) {
+        case '=':
             const child = chunk(data.data, 2);
-            const fnx = m => m.key === clause.left && m.data === clause.right;
-            const fn = x => x.find(fnx);
+            const fnx = (m) => m.key === clause.left && m.data === clause.right;
+            const fn = (x) => x.find(fnx);
 
             try {
                 return {
                     data: child.find(fn),
                     index: child.findIndex(fn),
-                    idx: child.find(fn).findIndex(x => x.key === clause.set.col)
+                    idx: child.find(fn).findIndex((x) => x.key === clause.set.col),
                 };
             } catch {
                 throw new Error(`Could not verify operation "${clause.left} = ${clause.right}"`);
             }
     }
-}
+}