@acodeninja/persist 3.0.0-next.7 → 3.0.0-next.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acodeninja/persist",
-  "version": "3.0.0-next.7",
+  "version": "3.0.0-next.9",
   "description": "A JSON based data modelling and persistence module with alternate storage mechanisms.",
   "type": "module",
   "scripts": {

package/src/SchemaCompiler.js

@@ -79,7 +79,11 @@ class SchemaCompiler {
                     schema.properties[name].items.format = property?._items._format;
                 }
 
-                if (Type.Model.isModel(property?._items)) {
+                const prop = typeof property?._items === 'function' &&
+                !/^class/.test(Function.prototype.toString.call(property?._items)) ?
+                    property?._items() : property?._items;
+
+                if (Type.Model.isModel(prop)) {
                     schema.properties[name].items = {
                         type: 'object',
                         additionalProperties: false,
@@ -87,7 +91,7 @@ class SchemaCompiler {
                         properties: {
                             id: {
                                 type: 'string',
-                                pattern: `^${property?._items.toString()}/[A-Z0-9]+$`,
+                                pattern: `^${prop.toString()}/[A-Z0-9]+$`,
                             },
                         },
                     };

package/src/engine/StorageEngine.js

@@ -86,7 +86,7 @@ export default class StorageEngine {
 
                 await this._putSearchIndex(modelConstructor, {
                     ...index || {},
-                    ...Object.fromEntries(models.map(m => [m.id, m.toIndexData()])),
+                    ...Object.fromEntries(models.map(m => [m.id, m.toSearchData()])),
                 });
             })),
         ]);
@@ -108,26 +108,118 @@ export default class StorageEngine {
     }
 
     /**
-     *
+     * Delete a model and update indexes that reference it
      * @param {Type.Model} model
      * @throws {ModelNotRegisteredStorageEngineError}
      * @throws {ModelNotFoundStorageEngineError}
      */
     async delete(model) {
-        if (!Object.keys(this.models).includes(model.constructor.name))
-            throw new ModelNotRegisteredStorageEngineError(model, this);
+        const modelsToDelete = [];
+        const modelsToPut = [];
+        const indexCache = {};
+        const indexActions = {};
+        const searchIndexCache = {};
+        const searchIndexActions = {};
+
+        const processModel = async (modelToProcess) => {
+            if (!Object.keys(this.models).includes(modelToProcess.constructor.name))
+                throw new ModelNotRegisteredStorageEngineError(modelToProcess, this);
 
-        const currentModel = await this.get(model.id);
+            const currentModel = await this.get(model.id);
 
-        await this._deleteModel(currentModel.id);
+            modelsToDelete.push(currentModel.id);
 
-        const currentIndex = this._getIndex(currentModel.constructor);
+            const modelToProcessConstructor = this.getModelConstructorFromId(modelToProcess.id);
+            indexActions[modelToProcessConstructor] = indexActions[modelToProcessConstructor] ?? [];
+            searchIndexActions[modelToProcessConstructor] = searchIndexActions[modelToProcessConstructor] ?? [];
 
-        await this._putIndex(currentModel.constructor, _.omit(currentIndex, [currentModel.id]));
+            if (currentModel.constructor.indexedPropertiesResolved().length) {
+                indexActions[modelToProcessConstructor].push(['delete', modelToProcess]);
+            }
 
-        const currentSearchIndex = this._getSearchIndex(currentModel.constructor);
+            if (currentModel.constructor.searchProperties().length) {
+                searchIndexActions[modelToProcessConstructor].push(['delete', modelToProcess]);
+            }
+
+            const linkedModels = await this.getInstancesLinkedTo(modelToProcess, indexCache);
+            const links = this.getLinksFor(modelToProcess.constructor);
+            Object.values(Object.fromEntries(await Promise.all(
+                Object.entries(linkedModels)
+                    .map(async ([constructor, updatableModels]) => [
+                        constructor,
+                        await Promise.all(updatableModels.map(m => this.get(m.id))),
+                    ]),
+            ))).flat(1)
+                .forEach(m =>
+                    Object.entries(links[m.constructor.name])
+                        .forEach(([linkName, _]) => {
+                            m[linkName] = undefined;
+                            modelsToPut.push(m);
+
+                            const modelToProcessConstructor = this.getModelConstructorFromId(m.id);
+                            indexActions[modelToProcessConstructor].push(['reindex', m]);
+
+                            if (m.constructor.searchProperties().length) {
+                                const modelToProcessConstructor = this.getModelConstructorFromId(m.id);
+                                searchIndexActions[modelToProcessConstructor].push(['reindex', m]);
+                            }
+                        }),
+                );
+        };
+
+        await processModel(model);
+
+        await Promise.all([
+            Promise.all(Object.entries(indexActions).map(async ([constructorName, actions]) => {
+                const modelConstructor = this.models[constructorName];
+                indexCache[constructorName] = indexCache[constructorName] ?? await this._getIndex(modelConstructor);
+
+                actions.forEach(([action, model]) => {
+                    switch (action) {
+                        case 'delete':
+                            indexCache[constructorName] = _.omit(indexCache[constructorName], [model.id]);
+                            break;
+                        case 'reindex':
+                            indexCache[constructorName] = {
+                                ...indexCache[constructorName],
+                                [model.id]: model.toIndexData(),
+                            };
+                            break;
+                    }
+                });
+            })),
+            Promise.all(Object.entries(searchIndexActions).map(async ([constructorName, actions]) => {
+                const modelConstructor = this.models[constructorName];
+                searchIndexCache[constructorName] = searchIndexCache[constructorName] ?? await this._getSearchIndex(modelConstructor);
+
+                actions.forEach(([action, model]) => {
+                    switch (action) {
+                        case 'delete':
+                            searchIndexCache[constructorName] = _.omit(searchIndexCache[constructorName], [model.id]);
+                            break;
+                        case 'reindex':
+                            searchIndexCache[constructorName] = {
+                                ...searchIndexCache[constructorName],
+                                [model.id]: model.toSearchData(),
+                            };
+                            break;
+                    }
+                });
+            })),
+        ]);
 
-        await this._putSearchIndex(currentModel.constructor, _.omit(currentSearchIndex, [currentModel.id]));
+        await Promise.all([
+            Promise.all(modelsToDelete.map(m => this._deleteModel(m))),
+            Promise.all(modelsToPut.map(m => this._putModel(m))),
+            Promise.all(
+                Object.entries(indexCache)
+                    .map(([constructorName, _]) => this._putIndex(this.models[constructorName], indexCache[constructorName])),
+            ),
+            Promise.all(
+                Object.entries(searchIndexCache)
+                    .map(([constructorName, _]) => this._putSearchIndex(this.models[constructorName], searchIndexCache[constructorName])),
+            ),
+        ]);
     }
 
     /**
@@ -144,6 +236,36 @@ export default class StorageEngine {
         return constructor;
     }
 
+    /**
+     * Get model instance that are directly linked to the given model in either direction
+     * @param {Type.Model} model
+     * @param {object} cache
+     * @return {Record<string, Record<string, Type.Model>>}
+     */
+    async getInstancesLinkedTo(model, cache = {}) {
+        return Object.fromEntries(
+            Object.entries(
+                await Promise.all(
+                    Object.entries(this.getLinksFor(model.constructor))
+                        .map(([name, _]) =>
+                            cache[name] ? Promise.resolve([name, Object.values(cache[name])]) :
+                                this._getIndex(this.models[name])
+                                    .then(i => {
+                                        cache[name] = i;
+                                        return [name, Object.values(i)];
+                                    }),
+                        ),
+                ).then(Object.fromEntries),
+            ).map(([name, i]) => [
+                name,
+                i.map(i => Object.fromEntries(
+                    Object.entries(i)
+                        .filter(([name, property]) => name === 'id' || property?.id === model.id),
+                )).filter(i => Object.keys(i).length > 1),
+            ]),
+        );
+    }
+
     /**
      * Get model classes that are directly linked to the given model in either direction
      * @param {Type.Model.constructor} model
@@ -171,9 +293,9 @@ export default class StorageEngine {
                         registeredModelName,
                         propertyName,
                         typeof propertyType === 'function' &&
-                            !/^class/.test(Function.prototype.toString.call(propertyType)) &&
-                            !Type.Model.isModel(propertyType) ?
-                                propertyType() : propertyType,
+                        !/^class/.test(Function.prototype.toString.call(propertyType)) &&
+                        !Type.Model.isModel(propertyType) ?
+                            propertyType() : propertyType,
                     ])
                     .filter(([_m, _p, type]) => Type.Model.isModel(type))
                     .map(([containingModel, propertyName, propertyType]) => ({
@@ -279,18 +401,14 @@ export default class StorageEngine {
 
 
 /**
- * Decide if two models indexable fields have changed
+ * Decide if two models indexable fields are different
  * @param {Type.Model} currentModel
  * @param {Type.Model} modelToProcess
  * @return {boolean}
  * @private
  */
 function indexedFieldsHaveChanged(currentModel, modelToProcess) {
-    return !currentModel || Boolean(
-        modelToProcess.constructor.indexedProperties()
-            .filter(field => JSON.stringify(_.get(currentModel, field)) !== JSON.stringify(_.get(modelToProcess, field)))
-            .length,
-    );
+    return !currentModel || JSON.stringify(currentModel.toIndexData()) !== JSON.stringify(modelToProcess.toIndexData());
 }
 
 /**
@@ -301,11 +419,7 @@ function indexedFieldsHaveChanged(currentModel, modelToProcess) {
  * @private
  */
 function searchableFieldsHaveChanged(currentModel, modelToProcess) {
-    return !currentModel || Boolean(
-        modelToProcess.constructor.searchProperties()
-            .filter(field => JSON.stringify(_.get(currentModel, field)) !== JSON.stringify(_.get(modelToProcess, field)))
-            .length,
-    );
+    return !currentModel || JSON.stringify(currentModel.toSearchData()) !== JSON.stringify(modelToProcess.toSearchData());
 }
 
 /**

package/src/type/Model.js

@@ -100,11 +100,11 @@ class Model {
 
     /**
      * Extracts data from the model based on the indexed properties defined in the class.
-     *
+     * Includes the ID of any linked models.
      * @returns {Object} - A representation of the model's indexed data.
      */
     toIndexData() {
-        return this._extractData(this.constructor.indexedProperties());
+        return this._extractData(this.constructor.indexedPropertiesResolved());
     }
 
     /**
@@ -187,6 +187,39 @@ class Model {
         return [];
     }
 
+    /**
+     * Returns a list of properties that are indexed including links to other models.
+     *
+     * @returns {Array<string>} - The indexed properties.
+     * @abstract
+     * @static
+     */
+    static indexedPropertiesResolved() {
+        return []
+            .concat(
+                Object.entries(this)
+                    .filter(([_, type]) =>
+                        this.isModel(
+                            typeof type === 'function' &&
+                            !/^class/.test(Function.prototype.toString.call(type)) ?
+                                type() : type,
+                        ),
+                    )
+                    .map(([name, _]) => `${name}.id`),
+            )
+            .concat(
+                Object.entries(this)
+                    .filter(([_, type]) =>
+                            type?._type === 'array' && this.isModel(
+                                typeof type._items === 'function' &&
+                                !/^class/.test(Function.prototype.toString.call(type._items)) ?
+                                    type._items() : type._items,
+                            ),
+                    ).map(([name, _]) => `${name}.[*].id`),
+            )
+            .concat(this.indexedProperties());
+    }
+
     /**
      * Returns a list of properties used for search.
      *