@galaxy05/map.db 1.0.1 → 1.2.0

package/README.md

@@ -1,41 +1,49 @@
-# Map.db
-
-###### A Map that stores data locally and loads it at startup
-
-### How does it work?
-Map.db works just like the NodeJS 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 NodeJS 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

@@ -0,0 +1,203 @@
+"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,10 +1,14 @@
 {
   "name": "@galaxy05/map.db",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "A Map that stores data locally and loads it at startup",
-  "main": "index.js",
+  "types": "types/index.d.ts",
+  "main": "build/index.js",
+  "engines": {
+    "node": ">=12"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc"
   },
   "repository": {
     "type": "git",
@@ -20,5 +24,11 @@
   "bugs": {
     "url": "https://github.com/GalaxyVinci05/map.db/issues"
   },
-  "homepage": "https://github.com/GalaxyVinci05/map.db#readme"
+  "homepage": "https://github.com/GalaxyVinci05/map.db#readme",
+  "devDependencies": {
+    "@types/node": "^16.7.10"
+  },
+  "dependencies": {
+    "typescript": "^4.4.2"
+  }
 }

package/src/index.ts

@@ -0,0 +1,200 @@
+import { promisify } from 'util';
+import * as fs from 'fs';
+
+const writeDB = promisify(fs.writeFile);
+const deleteDB = promisify(fs.unlink);
+
+class MapDB {
+    readonly map;
+    filename: string;
+    readonly db;
+    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 }) {
+        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: any[] = 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: string | number, value: any) {
+        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: 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);
+    }
+
+    /**
+     * 
+     * @param key 
+     */
+
+    get(key: string | number) {
+        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;
+        }
+    }
+
+    /**
+     * 
+     * @param key 
+     */
+    has(key: string | number) {
+        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() {
+        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() {
+        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() {
+        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(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));
+        }
+    }
+
+    /**
+     * 
+     * @param key 
+     */
+    async delete(key: string | number) {
+        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 {}
+        }
+
+        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: any[] = JSON.parse(file.toString());
+
+            return data.length;
+        }
+    }
+}
+
+export = MapDB;

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "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

@@ -0,0 +1,48 @@
+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;

package/index.d.ts

@@ -1,46 +0,0 @@
-export = MapDB;
-declare class MapDB {
-    /**
-     * @constructor
-     * @param {string} [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);
-    filename: string;
-    /**
-     *
-     * @param {string | number} key
-     * @param {*} value
-     */
-    set(key: string | number, value: any): Promise<Map<any, any>>;
-    /**
-     *
-     * @param {string | number} key
-     */
-    get(key: string | number): any;
-    /**
-     *
-     * @param {string | number} key
-     */
-    has(key: string | number): boolean;
-    entries(): IterableIterator<[any, any]>;
-    keys(): IterableIterator<any>;
-    values(): IterableIterator<any>;
-    /**
-     *
-     * @param {function} fn
-     */
-    forEach(fn: Function): void;
-    /**
-     *
-     * @param {string | number} key
-     */
-    delete(key: string | number): Promise<boolean>;
-    clear(): Promise<void>;
-    size(): number;
-    /**
-     * Deletes the db file and clears the Map
-     */
-    deleteFile(): Promise<any>;
-    #private;
-}

package/index.js

@@ -1,140 +0,0 @@
-const { promisify } = require('util');
-const fs = require('fs');
-
-const writeDB = promisify(fs.writeFile);
-const deleteDB = promisify(fs.unlink);
-
-module.exports = class MapDB {
-    #map;
-    filename;
-    #db;
-
-    /**
-     * @constructor
-     * @param {string} [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);
-
-            for (let i = 0; i < data.length; i++) {
-                this.#map.set(data[i].key, data[i].value);
-            }
-        } catch {}
-    }
-
-    /**
-     * 
-     * @param {string | number} 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');
-        }
-
-        console.log(value);
-
-        try {
-            const file = fs.readFileSync(this.#db);
-            const data = JSON.parse(file);
-
-            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 {
-            console.log('entered catch');
-            await writeDB(this.#db, `[${JSON.stringify({ key, value })}]`).catch(() => {});
-        }
-
-        return this.#map.set(key, value);
-    }
-
-    /**
-     * 
-     * @param {string | number} key 
-     */
-
-    get(key) {
-        return this.#map.get(key);
-    }
-
-    /**
-     * 
-     * @param {string | number} key 
-     */
-    has(key) {
-        return this.#map.has(key);
-    }
-
-    entries() {
-        return this.#map.entries();
-    }
-
-    keys() {
-        return this.#map.keys();
-    }
-
-    values() {
-        return this.#map.values();
-    }
-
-    /**
-     * 
-     * @param {function} fn 
-     */
-    forEach(fn) {
-        this.#map.forEach(fn);
-    }
-
-    /**
-     * 
-     * @param {string | number} key 
-     */
-    async delete(key) {
-        try {
-            const file = fs.readFileSync(this.#db);
-            const data = JSON.parse(file);
-
-            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;
-    }
-}