@galaxy05/map.db 1.1.0 → 1.2.0

package/README.md

@@ -1,41 +1,49 @@
-# Map.db
-
-###### A Map that stores data locally and loads it at startup. Written in TypeScript
-
-### How does it work?
-Map.db works just like the JavaScript built-in **Map**, with the same methods and functionalities, and in fact it uses itself a Map, but while the built-in Map only stores data in internal memory, this module **stores data locally in a file and loads it back in the Map at startup**.
-
-The purpose of this module is to make the JavaScript built-in Map an actual **database**, and there comes the name `map.db`: a Map that can be used as a database.
-
-### Differences
-Although this module works in fact the same way as a Map, there are still some little differences between them, which are listed below:
-> - `MapDB#set()` and `MapDB#delete()` return **promises**
-> - `Map#size` in map.db is a **method** (`MapDB#size()`)
-> - There is an additional method, `MapDB#deleteFile()`, which deletes the save file and clears the Map (returns a promise)
-> - When a value is reassigned to a key, it is only saved in the Map but not in the actual save file, so you always have to **set the key/value pair with the new value**.
-
-> Example:
-
-```js
-const MapDB = require('@galaxy05/map.db');
-const mapdb = new MapDB('file.db'); // this is the save file's name + extension
-
-async function sample() {
-    // assuming 'somekey' exists in the Map and has a value { cool: false }
-    const data = mapdb.get('somekey');
-    // reassigning the 'cool' property a new value
-    data.cool = true;
-
-    await mapdb.set('somekey', data);
-    // now 'somekey' has a new value { cool: true }
-}
-```
-
-### Installation
-With **npm**:
-
-`npm i @galaxy05/map.db`
-
-With **yarn**:
-
+# Map.db
+
+###### A Map that stores data locally and loads it at startup. Written in TypeScript
+
+### How does it work?
+Map.db works just like the JavaScript built-in **Map**, with the same methods and functionalities, and in fact it uses itself a Map, but while the built-in Map only stores data in internal memory, this module **stores data locally in a file and loads it back in the Map at startup**.
+
+The purpose of this module is to make the JavaScript built-in Map an actual **database**, and there comes the name `map.db`: a Map that can be used as a database.
+
+The file structure is easily accessible and the data is stored in JSON format, allowing manual editing
+
+![image](img.png)
+
+![image](img2.png)
+
+You also have the option to only use local storage without touching internal memory
+
+### Differences
+Although this module works in fact the same way as a Map, there are still some little differences between them, which are listed below:
+> - `MapDB#set()` and `MapDB#delete()` return **promises**
+> - `Map#size` in map.db is a **method** (`MapDB#size()`)
+> - When a value is reassigned to a key, it is only saved in the Map but not in the actual save file, so you always have to **set the key/value pair with the new value**.
+
+
+> Example:
+
+```js
+const MapDB = require('@galaxy05/map.db');
+const mapdb = new MapDB('file.db'); // this is the save file's name + extension
+
+async function sample() {
+    // assuming 'somekey' exists in the Map and has a value { cool: false }
+    const data = mapdb.get('somekey');
+    // reassigning the 'cool' property a new value
+    data.cool = true;
+
+    await mapdb.set('somekey', data);
+    // now 'somekey' has a new value { cool: true }
+}
+```
+
+### Installation
+With **npm**:
+
+`npm i @galaxy05/map.db`
+
+With **yarn**:
+
 `yarn add @galaxy05/map.db`

package/build/index.js

@@ -1,114 +1,203 @@
-"use strict";
-const util_1 = require("util");
-const fs = require("fs");
-const writeDB = (0, util_1.promisify)(fs.writeFile);
-const deleteDB = (0, util_1.promisify)(fs.unlink);
-class MapDB {
-    map;
-    filename;
-    db;
-    /**
-     * @constructor
-     * @param filename If not set, MapDB will work just like the built-in Map that only stores data in internal memory
-     * @example 'file.db'
-     */
-    constructor(filename) {
-        this.map = new Map();
-        this.filename = filename;
-        if (!fs.existsSync('./data/'))
-            fs.mkdirSync('./data');
-        this.db = this.filename ? `./data/${this.filename}` : null;
-        try {
-            const file = fs.readFileSync(this.db);
-            const data = JSON.parse(file.toString());
-            for (let i = 0; i < data.length; i++) {
-                this.map.set(data[i].key, data[i].value);
-            }
-        }
-        catch { }
-    }
-    /**
-     *
-     * @param key
-     * @param value
-     */
-    async set(key, value) {
-        if (typeof key !== 'string' && typeof key !== 'number') {
-            throw new TypeError('key must be of type string or number');
-        }
-        try {
-            const file = fs.readFileSync(this.db);
-            const data = JSON.parse(file.toString());
-            const i = data.findIndex(pair => pair.key == key);
-            !data[i] ? data.push({ key, value }) : data[i] = { key, value };
-            await writeDB(this.db, JSON.stringify(data));
-        }
-        catch {
-            await writeDB(this.db, `[${JSON.stringify({ key, value })}]`).catch(() => { });
-        }
-        return this.map.set(key, value);
-    }
-    /**
-     *
-     * @param key
-     */
-    get(key) {
-        return this.map.get(key);
-    }
-    /**
-     *
-     * @param key
-     */
-    has(key) {
-        return this.map.has(key);
-    }
-    entries() {
-        return this.map.entries();
-    }
-    keys() {
-        return this.map.keys();
-    }
-    values() {
-        return this.map.values();
-    }
-    /**
-     *
-     * @param callbackfn
-     */
-    forEach(callbackfn) {
-        this.map.forEach(callbackfn);
-    }
-    /**
-     *
-     * @param key
-     */
-    async delete(key) {
-        try {
-            const file = fs.readFileSync(this.db);
-            const data = JSON.parse(file.toString());
-            const i = data.findIndex(pair => pair.key == key);
-            if (data[i]) {
-                data.splice(i, 1);
-                await writeDB(this.db, JSON.stringify(data));
-            }
-        }
-        catch { }
-        return this.map.delete(key);
-    }
-    async clear() {
-        await writeDB(this.db, JSON.stringify([])).catch(() => { });
-        this.map.clear();
-    }
-    size() {
-        return this.map.size;
-    }
-    /**
-     * Deletes the db file and clears the Map
-     */
-    async deleteFile() {
-        await deleteDB(this.db).catch(() => { });
-        this.map.clear();
-        return undefined;
-    }
-}
-module.exports = MapDB;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+const util_1 = require("util");
+const fs = __importStar(require("fs"));
+const writeDB = (0, util_1.promisify)(fs.writeFile);
+const deleteDB = (0, util_1.promisify)(fs.unlink);
+class MapDB {
+    map;
+    filename;
+    db;
+    options;
+    /**
+     * @constructor
+     * @param filename If not set, MapDB will only use internal memory
+     * @example 'file.db'
+     * @param options Options to pass in the constructor
+     * @param options.localOnly When enabled, MapDB will only use local storage, without touching internal memory (requires a filename)
+     */
+    constructor(filename, options) {
+        if (!filename && options?.localOnly)
+            throw new Error('Cannot use local storage without a filename');
+        this.map = !options?.localOnly ? new Map() : null;
+        this.filename = filename;
+        if (!fs.existsSync('./data/'))
+            fs.mkdirSync('./data');
+        this.db = this.filename ? `./data/${this.filename}` : null;
+        if (this.map && this.db) {
+            try {
+                const file = fs.readFileSync(this.db);
+                const data = JSON.parse(file.toString());
+                for (let i = 0; i < data.length; i++) {
+                    this.map.set(data[i].key, data[i].value);
+                }
+            }
+            catch { }
+        }
+    }
+    /**
+     *
+     * @param key
+     * @param value
+     */
+    async set(key, value) {
+        if (typeof key !== 'string' && typeof key !== 'number') {
+            throw new TypeError('key must be of type string or number');
+        }
+        if (this.db) {
+            try {
+                const file = fs.readFileSync(this.db);
+                const data = JSON.parse(file.toString());
+                const i = data.findIndex(pair => pair.key == key);
+                !data[i] ? data.push({ key, value }) : data[i] = { key, value };
+                await writeDB(this.db, JSON.stringify(data));
+                if (!this.map)
+                    return data;
+            }
+            catch {
+                await writeDB(this.db, `[${JSON.stringify({ key, value })}]`).then(() => {
+                    if (!this.map)
+                        return JSON.parse(fs.readFileSync(this.db).toString());
+                });
+            }
+        }
+        return this.map.set(key, value);
+    }
+    /**
+     *
+     * @param key
+     */
+    get(key) {
+        if (this.map) {
+            return this.map.get(key);
+        }
+        else {
+            const file = fs.readFileSync(this.db);
+            const data = JSON.parse(file.toString());
+            return data.find(pair => pair.key == key)?.value || undefined;
+        }
+    }
+    /**
+     *
+     * @param key
+     */
+    has(key) {
+        if (this.map) {
+            return this.map.has(key);
+        }
+        else {
+            const file = fs.readFileSync(this.db);
+            const data = JSON.parse(file.toString());
+            return data.find(pair => pair.key == key) ? true : false;
+        }
+    }
+    entries() {
+        if (this.map) {
+            return this.map.entries();
+        }
+        else {
+            const file = fs.readFileSync(this.db);
+            const data = JSON.parse(file.toString());
+            return data.map(pair => [pair.key, pair.value]);
+        }
+    }
+    keys() {
+        if (this.map) {
+            return this.map.keys();
+        }
+        else {
+            const file = fs.readFileSync(this.db);
+            const data = JSON.parse(file.toString());
+            return data.map(pair => pair.key);
+        }
+    }
+    values() {
+        if (this.map) {
+            return this.map.values();
+        }
+        else {
+            const file = fs.readFileSync(this.db);
+            const data = JSON.parse(file.toString());
+            return data.map(pair => pair.value);
+        }
+    }
+    /**
+     *
+     * @param callbackfn
+     */
+    forEach(callback) {
+        if (this.map) {
+            this.map.forEach(callback);
+        }
+        else {
+            const file = fs.readFileSync(this.db);
+            const data = JSON.parse(file.toString());
+            data.forEach(pair => callback(pair.value, pair.key, this.map));
+        }
+    }
+    /**
+     *
+     * @param key
+     */
+    async delete(key) {
+        if (this.db) {
+            try {
+                const file = fs.readFileSync(this.db);
+                const data = JSON.parse(file.toString());
+                const i = data.findIndex(pair => pair.key == key);
+                if (data[i]) {
+                    data.splice(i, 1);
+                    await writeDB(this.db, JSON.stringify(data));
+                    if (!this.map)
+                        return true;
+                }
+                else if (!this.map) {
+                    return false;
+                }
+            }
+            catch { }
+        }
+        if (this.map) {
+            return this.map.delete(key);
+        }
+    }
+    async clear() {
+        await writeDB(this.db, JSON.stringify([])).catch(() => { });
+        if (this.map) {
+            this.map.clear();
+        }
+    }
+    size() {
+        if (this.map) {
+            return this.map.size;
+        }
+        else {
+            const file = fs.readFileSync(this.db);
+            const data = JSON.parse(file.toString());
+            return data.length;
+        }
+    }
+}
+module.exports = MapDB;

package/package.json

@@ -1,34 +1,34 @@
-{
-  "name": "@galaxy05/map.db",
-  "version": "1.1.0",
-  "description": "A Map that stores data locally and loads it at startup",
-  "types": "types/index.d.ts",
-  "main": "build/index.js",
-  "engines": {
-    "node": ">=12"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/GalaxyVinci05/map.db.git"
-  },
-  "keywords": [
-    "Map",
-    "DB",
-    "MapDB"
-  ],
-  "author": "GalaxyVinci05",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/GalaxyVinci05/map.db/issues"
-  },
-  "homepage": "https://github.com/GalaxyVinci05/map.db#readme",
-  "devDependencies": {
-    "@types/node": "^16.7.10"
-  },
-  "dependencies": {
-    "typescript": "^4.4.2"
-  }
-}
+{
+  "name": "@galaxy05/map.db",
+  "version": "1.2.0",
+  "description": "A Map that stores data locally and loads it at startup",
+  "types": "types/index.d.ts",
+  "main": "build/index.js",
+  "engines": {
+    "node": ">=12"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GalaxyVinci05/map.db.git"
+  },
+  "keywords": [
+    "Map",
+    "DB",
+    "MapDB"
+  ],
+  "author": "GalaxyVinci05",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/GalaxyVinci05/map.db/issues"
+  },
+  "homepage": "https://github.com/GalaxyVinci05/map.db#readme",
+  "devDependencies": {
+    "@types/node": "^16.7.10"
+  },
+  "dependencies": {
+    "typescript": "^4.4.2"
+  }
+}

package/src/index.ts

@@ -8,28 +8,35 @@ class MapDB {
     readonly map;
     filename: string;
     readonly db;
+    options: any;
 
     /**
      * @constructor
-     * @param filename If not set, MapDB will work just like the built-in Map that only stores data in internal memory
+     * @param filename If not set, MapDB will only use internal memory
      * @example 'file.db'
+     * @param options Options to pass in the constructor
+     * @param options.localOnly When enabled, MapDB will only use local storage, without touching internal memory (requires a filename)
      */
-    constructor(filename?: string) {
-        this.map = new Map();
+    constructor(filename?: string, options?: { localOnly: boolean }) {
+        if (!filename && options?.localOnly) throw new Error('Cannot use local storage without a filename');
+
+        this.map = !options?.localOnly ? new Map() : null;
         this.filename = filename;
         
         if (!fs.existsSync('./data/')) fs.mkdirSync('./data');
 
         this.db = this.filename ? `./data/${this.filename}` : null;
         
-        try {
-            const file = fs.readFileSync(this.db);
-            const data: any[] = JSON.parse(file.toString());
-
-            for (let i = 0; i < data.length; i++) {
-                this.map.set(data[i].key, data[i].value);
-            }
-        } catch {}
+        if (this.map && this.db) {
+            try {
+                const file = fs.readFileSync(this.db);
+                const data: any[] = JSON.parse(file.toString());
+    
+                for (let i = 0; i < data.length; i++) {
+                    this.map.set(data[i].key, data[i].value);
+                }
+            } catch {}
+        }
     }
 
     /**
@@ -42,17 +49,22 @@ class MapDB {
             throw new TypeError('key must be of type string or number');
         }
 
-        try {
-            const file = fs.readFileSync(this.db);
-            const data: any[] = JSON.parse(file.toString());
-
-            const i = data.findIndex(pair => pair.key == key);
-
-            !data[i] ? data.push({ key, value }) : data[i] = { key, value };
-
-            await writeDB(this.db, JSON.stringify(data));
-        } catch {
-            await writeDB(this.db, `[${JSON.stringify({ key, value })}]`).catch(() => {});
+        if (this.db) {
+            try {
+                const file = fs.readFileSync(this.db);
+                const data: any[] = JSON.parse(file.toString());
+    
+                const i = data.findIndex(pair => pair.key == key);
+    
+                !data[i] ? data.push({ key, value }) : data[i] = { key, value };
+    
+                await writeDB(this.db, JSON.stringify(data));
+                if (!this.map) return data;
+            } catch {
+                await writeDB(this.db, `[${JSON.stringify({ key, value })}]`).then(() => {
+                    if (!this.map) return JSON.parse(fs.readFileSync(this.db).toString());
+                });
+            }
         }
 
         return this.map.set(key, value);
@@ -64,7 +76,14 @@ class MapDB {
      */
 
     get(key: string | number) {
-        return this.map.get(key);
+        if (this.map) {
+            return this.map.get(key);
+        } else {
+            const file = fs.readFileSync(this.db);
+            const data: any[] = JSON.parse(file.toString());
+
+            return data.find(pair => pair.key == key)?.value || undefined;
+        }
     }
 
     /**
@@ -72,27 +91,62 @@ class MapDB {
      * @param key 
      */
     has(key: string | number) {
-        return this.map.has(key);
+        if (this.map) {
+            return this.map.has(key);
+        } else {
+            const file = fs.readFileSync(this.db);
+            const data: any[] = JSON.parse(file.toString());
+
+            return data.find(pair => pair.key == key) ? true : false;
+        }
     }
 
     entries() {
-        return this.map.entries();
+        if (this.map) {
+            return this.map.entries();
+        } else {
+            const file = fs.readFileSync(this.db);
+            const data: any[] = JSON.parse(file.toString());
+
+            return data.map(pair => [pair.key, pair.value]);
+        }
     }
 
     keys() {
-        return this.map.keys();
+        if (this.map) {
+            return this.map.keys();
+        } else {
+            const file = fs.readFileSync(this.db);
+            const data: any[] = JSON.parse(file.toString());
+
+            return data.map(pair => pair.key);
+        }
     }
 
     values() {
-        return this.map.values();
+        if (this.map) {
+            return this.map.values();
+        } else {
+            const file = fs.readFileSync(this.db);
+            const data: any[] = JSON.parse(file.toString());
+
+            return data.map(pair => pair.value);
+        }
     }
 
     /**
      * 
      * @param callbackfn 
      */
-    forEach(callbackfn: (value: any, key: any, map: Map<any, any>) => void) {
-        this.map.forEach(callbackfn);
+    forEach(callback: (value: any, key: any, map: Map<any, any>) => void) {
+        if (this.map) {
+            this.map.forEach(callback);
+        } else {
+            const file = fs.readFileSync(this.db);
+            const data: any[] = JSON.parse(file.toString());
+
+            data.forEach(pair => callback(pair.value, pair.key, this.map));
+        }
     }
 
     /**
@@ -100,39 +154,46 @@ class MapDB {
      * @param key 
      */
     async delete(key: string | number) {
-        try {
-            const file = fs.readFileSync(this.db);
-            const data: any[] = JSON.parse(file.toString());
-
-            const i = data.findIndex(pair => pair.key == key);
-
-            if (data[i]) {
-                data.splice(i, 1);
-                await writeDB(this.db, JSON.stringify(data));
-            }
-        } catch {}
+        if (this.db) {
+            try {
+                const file = fs.readFileSync(this.db);
+                const data: any[] = JSON.parse(file.toString());
+    
+                const i = data.findIndex(pair => pair.key == key);
+    
+                if (data[i]) {
+                    data.splice(i, 1);
+                    await writeDB(this.db, JSON.stringify(data));
+
+                    if (!this.map) return true;
+                } else if (!this.map) {
+                    return false;
+                }
+            } catch {}
+        }
 
-        return this.map.delete(key);
+        if (this.map) {
+            return this.map.delete(key);
+        }
     }
 
     async clear() {
         await writeDB(this.db, JSON.stringify([])).catch(() => {});
 
-        this.map.clear();
+        if (this.map) {
+            this.map.clear();
+        }
     }
 
     size() {
-        return this.map.size;
-    }
-
-    /**
-     * Deletes the db file and clears the Map
-     */
-    async deleteFile(): Promise<undefined> {
-        await deleteDB(this.db).catch(() => {});
-        this.map.clear();
+        if (this.map) {
+            return this.map.size;
+        } else {
+            const file = fs.readFileSync(this.db);
+            const data: any[] = JSON.parse(file.toString());
 
-        return undefined;
+            return data.length;
+        }
     }
 }
 

package/tsconfig.json

@@ -1,17 +1,19 @@
-{
-    "compilerOptions": {
-        "module": "CommonJS",
-        "target": "ESNext",
-        "noImplicitAny": true,
-        "declaration": true,
-        "watch": true,
-        "outDir": "build",
-        "declarationDir": "types"
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules"
-    ]
+{
+    "compilerOptions": {
+        "module": "CommonJS",
+        "moduleResolution": "node",
+        "target": "ESNext",
+        "noImplicitAny": true,
+        "declaration": true,
+        "watch": true,
+        "outDir": "build",
+        "declarationDir": "types",
+        "esModuleInterop": true   
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules"
+    ]
 }

package/types/index.d.ts

@@ -1,47 +1,48 @@
-declare class MapDB {
-    readonly map: Map<any, any>;
-    filename: string;
-    readonly db: string;
-    /**
-     * @constructor
-     * @param filename If not set, MapDB will work just like the built-in Map that only stores data in internal memory
-     * @example 'file.db'
-     */
-    constructor(filename?: string);
-    /**
-     *
-     * @param key
-     * @param value
-     */
-    set(key: string | number, value: any): Promise<Map<any, any>>;
-    /**
-     *
-     * @param key
-     */
-    get(key: string | number): any;
-    /**
-     *
-     * @param key
-     */
-    has(key: string | number): boolean;
-    entries(): IterableIterator<[any, any]>;
-    keys(): IterableIterator<any>;
-    values(): IterableIterator<any>;
-    /**
-     *
-     * @param callbackfn
-     */
-    forEach(callbackfn: (value: any, key: any, map: Map<any, any>) => void): void;
-    /**
-     *
-     * @param key
-     */
-    delete(key: string | number): Promise<boolean>;
-    clear(): Promise<void>;
-    size(): number;
-    /**
-     * Deletes the db file and clears the Map
-     */
-    deleteFile(): Promise<undefined>;
-}
-export = MapDB;
+declare class MapDB {
+    readonly map: Map<any, any>;
+    filename: string;
+    readonly db: string;
+    options: any;
+    /**
+     * @constructor
+     * @param filename If not set, MapDB will only use internal memory
+     * @example 'file.db'
+     * @param options Options to pass in the constructor
+     * @param options.localOnly When enabled, MapDB will only use local storage, without touching internal memory (requires a filename)
+     */
+    constructor(filename?: string, options?: {
+        localOnly: boolean;
+    });
+    /**
+     *
+     * @param key
+     * @param value
+     */
+    set(key: string | number, value: any): Promise<any[] | Map<any, any>>;
+    /**
+     *
+     * @param key
+     */
+    get(key: string | number): any;
+    /**
+     *
+     * @param key
+     */
+    has(key: string | number): boolean;
+    entries(): IterableIterator<[any, any]> | any[][];
+    keys(): any[] | IterableIterator<any>;
+    values(): any[] | IterableIterator<any>;
+    /**
+     *
+     * @param callbackfn
+     */
+    forEach(callback: (value: any, key: any, map: Map<any, any>) => void): void;
+    /**
+     *
+     * @param key
+     */
+    delete(key: string | number): Promise<boolean>;
+    clear(): Promise<void>;
+    size(): number;
+}
+export = MapDB;