brackets-memory-db 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { CrudInterface, OmitId, Table, Database } from 'brackets-manager';
+import { CrudInterface, OmitId, Table, Database } from 'brackets-model';
+type Filter = Record<string, any>;
 export declare class InMemoryDatabase implements CrudInterface {
     protected data: Database;
     /**
@@ -8,7 +9,7 @@ export declare class InMemoryDatabase implements CrudInterface {
     /**
      * @param partial Filter
      */
-    makeFilter(partial: any): (entry: any) => boolean;
+    makeFilter(partial: Filter): (entry: Filter) => boolean;
     /**
      * Clearing all of the data
      */
@@ -70,4 +71,24 @@ export declare class InMemoryDatabase implements CrudInterface {
      * @param filter An object to filter data.
      */
     delete<T>(table: Table, filter: Partial<T>): Promise<boolean>;
+    /**
+     * Find the index of a table entity by its id
+     *
+     * @param table
+     * @param id
+     * @returns
+     */
+    getEntityIndexById(table: Table, id: number): number;
+    /**
+     * Set a table entity value by its index
+     *
+     * @param table
+     * @param index
+     * @param value
+     */
+    setEntityByIndex<T>(table: Table, index: number, value: T): void;
+    private getTable;
+    private setTable;
+    private isObject;
 }
+export {};

package/dist/index.js

@@ -49,13 +49,13 @@ class InMemoryDatabase {
      * @param values What to insert.
      */
     insert(table, values) {
-        let id = this.data[table].length > 0
-            ? (Math.max(...this.data[table].map(d => d.id)) + 1)
+        const rows = this.getTable(table);
+        let id = rows.length > 0
+            ? (Math.max(...rows.map(d => d.id)) + 1)
             : 0;
         if (!Array.isArray(values)) {
             try {
-                // @ts-ignore
-                this.data[table].push({ id, ...values });
+                rows.push({ id, ...values });
             }
             catch (error) {
                 return new Promise((resolve) => {
@@ -68,8 +68,7 @@ class InMemoryDatabase {
         }
         try {
             values.map((object) => {
-                // @ts-ignore
-                this.data[table].push({ id: id++, ...object });
+                rows.push({ id: id++, ...object });
             });
         }
         catch (error) {
@@ -89,19 +88,17 @@ class InMemoryDatabase {
         try {
             if (arg === undefined) {
                 return new Promise((resolve) => {
-                    // @ts-ignore
-                    resolve(this.data[table].map(clone));
+                    resolve(this.getTable(table).map(clone));
                 });
             }
             if (typeof arg === 'number') {
                 return new Promise((resolve) => {
-                    // @ts-ignore
-                    resolve(clone(this.data[table].find(d => d.id === arg)));
+                    const found = this.getTable(table).find(d => d.id === arg);
+                    resolve(found ? clone(found) : null);
                 });
             }
             return new Promise((resolve) => {
-                // @ts-ignore
-                resolve(this.data[table].filter(this.makeFilter(arg)).map(clone));
+                resolve(this.getTable(table).filter(this.makeFilter(arg)).map(clone));
             });
         }
         catch (error) {
@@ -120,8 +117,8 @@ class InMemoryDatabase {
     update(table, arg, value) {
         if (typeof arg === 'number') {
             try {
-                // @ts-ignore
-                this.data[table][arg] = value;
+                const index = this.getEntityIndexById(table, arg);
+                this.setEntityByIndex(table, index, value);
                 return new Promise((resolve) => {
                     resolve(true);
                 });
@@ -132,27 +129,25 @@ class InMemoryDatabase {
                 });
             }
         }
-        // @ts-ignore
-        const values = this.data[table].filter(this.makeFilter(arg));
+        const values = this.getTable(table).filter(this.makeFilter(arg));
         if (!values) {
             return new Promise((resolve) => {
                 resolve(false);
             });
         }
         values.forEach((v) => {
-            const existing = this.data[table][v.id];
-            for (const key in value) {
-                // @ts-ignore
-                if (existing[key] && typeof existing[key] === 'object' && typeof value[key] === 'object') {
-                    // @ts-ignore
-                    Object.assign(existing[key], value[key]); // For opponent objects, this does a deep merge of level 2.
+            const index = this.getEntityIndexById(table, v.id);
+            const existing = this.getTable(table)[index];
+            const updateValue = value;
+            for (const key in updateValue) {
+                if (this.isObject(existing[key]) && this.isObject(updateValue[key])) {
+                    Object.assign(existing[key], updateValue[key]); // For opponent objects, this does a deep merge of level 2.
                 }
                 else {
-                    // @ts-ignore
-                    existing[key] = value[key]; // Otherwise, do a simple value assignment.
+                    existing[key] = updateValue[key]; // Otherwise, do a simple value assignment.
                 }
             }
-            this.data[table][v.id] = existing;
+            this.setEntityByIndex(table, index, existing);
         });
         return new Promise((resolve) => {
             resolve(true);
@@ -179,11 +174,43 @@ class InMemoryDatabase {
         }
         const predicate = this.makeFilter(filter);
         const negativeFilter = (value) => !predicate(value);
-        // @ts-ignore
-        this.data[table] = values.filter(negativeFilter);
+        this.setTable(table, this.getTable(table).filter(negativeFilter));
         return new Promise((resolve) => {
             resolve(true);
         });
     }
+    /**
+     * Find the index of a table entity by its id
+     *
+     * @param table
+     * @param id
+     * @returns
+     */
+    getEntityIndexById(table, id) {
+        const index = this.getTable(table).findIndex(e => e.id === id);
+        if (index === -1) {
+            throw new Error(`Entity in ${table} with id ${id} not found.`);
+        }
+        return index;
+    }
+    /**
+     * Set a table entity value by its index
+     *
+     * @param table
+     * @param index
+     * @param value
+     */
+    setEntityByIndex(table, index, value) {
+        this.getTable(table)[index] = value;
+    }
+    getTable(table) {
+        return this.data[table];
+    }
+    setTable(table, values) {
+        this.data[table] = values;
+    }
+    isObject(value) {
+        return typeof value === 'object' && value !== null;
+    }
 }
 exports.InMemoryDatabase = InMemoryDatabase;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "brackets-memory-db",
-    "version": "1.0.4",
+    "version": "1.0.6",
     "description": "An in-memory database for brackets-manager.js",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -18,6 +18,7 @@
     ],
     "scripts": {
         "build": "tsc",
+        "test": "node --test ../test/implementations/memory.test.js",
         "prepare": "npm run build",
         "prepublishOnly": "npm run build"
     },
@@ -35,7 +36,7 @@
         "typescript": "^4.4.4"
     },
     "peerDependencies": {
-        "brackets-manager": "^1.3.9"
+        "brackets-model": "^1.7.0"
     },
     "dependencies": {
         "rfdc": "^1.3.0"