@acodeninja/persist 3.0.0-next.2 → 3.0.0-next.4

package/package.json

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

package/src/engine/StorageEngine.js

@@ -20,34 +20,46 @@ export default class StorageEngine {
         const processedModels = [];
         const modelsToPut = [];
         const modelsToReindex = {};
+        const modelsToReindexSearch = {};
 
         /**
          * @param {Type.Model} modelToProcess
          * @return {Promise<void>}
          */
         const processModel = async (modelToProcess) => {
-            if (processedModels.includes(modelToProcess.id)) return;
+            if (processedModels.includes(modelToProcess.id))
+                return;
 
             processedModels.push(modelToProcess.id);
 
-            if (!Object.keys(this.models).includes(modelToProcess.constructor.name)) throw new ModelNotRegisteredStorageEngineError(modelToProcess, this);
+            if (!Object.keys(this.models).includes(modelToProcess.constructor.name))
+                throw new ModelNotRegisteredStorageEngineError(modelToProcess, this);
 
             modelToProcess.validate();
             const currentModel = await this.get(modelToProcess.id).catch(() => null);
 
-            const modelToProcessHasChanged = (JSON.stringify(currentModel?.toData() || {}) !== JSON.stringify(modelToProcess.toData()));
+            const modelToProcessHasChanged = JSON.stringify(currentModel?.toData() || {}) !== JSON.stringify(modelToProcess.toData());
 
             if (modelToProcessHasChanged) modelsToPut.push(modelToProcess);
 
             if (
                 Boolean(modelToProcess.constructor.indexedProperties().length) &&
-                this._indexedFieldsHaveChanged(currentModel, modelToProcess)
+                indexedFieldsHaveChanged(currentModel, modelToProcess)
             ) {
                 const modelToProcessConstructor = this.getModelConstructorFromId(modelToProcess.id);
                 modelsToReindex[modelToProcessConstructor] = modelsToReindex[modelToProcessConstructor] || [];
                 modelsToReindex[modelToProcessConstructor].push(modelToProcess);
             }
 
+            if (
+                Boolean(modelToProcess.constructor.searchProperties().length) &&
+                searchableFieldsHaveChanged(currentModel, modelToProcess)
+            ) {
+                const modelToProcessConstructor = this.getModelConstructorFromId(modelToProcess.id);
+                modelsToReindexSearch[modelToProcessConstructor] = modelsToReindexSearch[modelToProcessConstructor] || [];
+                modelsToReindexSearch[modelToProcessConstructor].push(modelToProcess);
+            }
+
             for (const [field, value] of Object.entries(modelToProcess)) {
                 if (Type.Model.isModel(value)) {
                     await processModel(modelToProcess[field]);
@@ -57,37 +69,34 @@ export default class StorageEngine {
 
         await processModel(model);
 
-        await Promise.all(modelsToPut.map(m => this._putModel(m.toData())));
-        await Promise.all(Object.entries(modelsToReindex).map(async ([constructor, models]) => {
-            const modelConstructor = this.models[constructor];
-            const index = await this._getIndex(modelConstructor);
+        await Promise.all([
+            Promise.all(modelsToPut.map(m => this._putModel(m.toData()))),
+            Promise.all(Object.entries(modelsToReindex).map(async ([constructorName, models]) => {
+                const modelConstructor = this.models[constructorName];
+                const index = await this._getIndex(modelConstructor);
 
-            await this._putIndex(modelConstructor, {
-                ...index || {},
-                ...Object.fromEntries(models.map(m => [m.id, m.toIndexData()])),
-            });
-        }));
-    }
+                await this._putIndex(modelConstructor, {
+                    ...index || {},
+                    ...Object.fromEntries(models.map(m => [m.id, m.toIndexData()])),
+                });
+            })),
+            Promise.all(Object.entries(modelsToReindexSearch).map(async ([constructorName, models]) => {
+                const modelConstructor = this.models[constructorName];
+                const index = await this._getSearchIndex(modelConstructor);
 
-    /**
-     * Decide if two models indexable fields have changed
-     * @param {Type.Model} currentModel
-     * @param {Type.Model} modelToProcess
-     * @return {boolean}
-     * @private
-     */
-    _indexedFieldsHaveChanged(currentModel, modelToProcess) {
-        return !currentModel || Boolean(
-            modelToProcess.constructor.indexedProperties()
-                .filter(field => JSON.stringify(_.get(currentModel, field)) !== JSON.stringify(_.get(modelToProcess, field)))
-                .length,
-        );
+                await this._putSearchIndex(modelConstructor, {
+                    ...index || {},
+                    ...Object.fromEntries(models.map(m => [m.id, m.toIndexData()])),
+                });
+            })),
+        ]);
     }
 
     /**
      * Get a model by its id
      * @param {string} modelId
-     * @return {Promise<void>}
+     * @throws {ModelNotFoundStorageEngineError}
+     * @return {Promise<Type.Model>}
      */
     get(modelId) {
         try {
@@ -98,6 +107,21 @@ export default class StorageEngine {
         return this._getModel(modelId);
     }
 
+    /**
+     *
+     * @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 currentModel = await this.get(model.id);
+
+        await this._deleteModel(currentModel.id);
+    }
+
     /**
      * Get the model constructor from a model id
      * @param {string} modelId
@@ -172,12 +196,23 @@ export default class StorageEngine {
      * @param {string} _id
      * @throws MethodNotImplementedStorageEngineError
      * @throws ModelNotFoundStorageEngineError
-     * @return Promise<void>
+     * @return Promise<Model>
      */
     _getModel(_id) {
         return Promise.reject(new MethodNotImplementedStorageEngineError('_getModel', this));
     }
 
+    /**
+     * Delete a model
+     * @param {string} _id
+     * @throws MethodNotImplementedStorageEngineError
+     * @throws ModelNotFoundStorageEngineError
+     * @return Promise<void>
+     */
+    _deleteModel(_id) {
+        return Promise.reject(new MethodNotImplementedStorageEngineError('_deleteModel', this));
+    }
+
     /**
      * Get a model's index data
      * @param {Model.constructor} _modelConstructor
@@ -198,6 +233,68 @@ export default class StorageEngine {
     _putIndex(_modelConstructor, _data) {
         return Promise.reject(new MethodNotImplementedStorageEngineError('_putIndex', this));
     }
+
+    /**
+     * Get a model's raw search index data
+     * @param {Model.constructor} _modelConstructor
+     * @throws MethodNotImplementedStorageEngineError
+     * @return Promise<void>
+     */
+    _getSearchIndex(_modelConstructor) {
+        return Promise.reject(new MethodNotImplementedStorageEngineError('_getSearchIndex', this));
+    }
+
+    /**
+     * Get a model's raw search index data
+     * @param {Model.constructor} _modelConstructor
+     * @throws MethodNotImplementedStorageEngineError
+     * @return Promise<void>
+     */
+    _getSearchIndexCompiled(_modelConstructor) {
+        return Promise.reject(new MethodNotImplementedStorageEngineError('_getSearchIndexCompiled', this));
+    }
+
+    /**
+     * Put a model's raw and compiled search index data
+     * @param {Model.constructor} _modelConstructor
+     * @param {object} _data
+     * @throws MethodNotImplementedStorageEngineError
+     * @return Promise<void>
+     */
+    _putSearchIndex(_modelConstructor, _data) {
+        return Promise.reject(new MethodNotImplementedStorageEngineError('_putSearchIndex', this));
+    }
+}
+
+
+/**
+ * Decide if two models indexable fields have changed
+ * @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,
+    );
+}
+
+/**
+ * Decide if two models searchable fields have changed
+ * @param {Type.Model} currentModel
+ * @param {Type.Model} modelToProcess
+ * @return {boolean}
+ * @private
+ */
+function searchableFieldsHaveChanged(currentModel, modelToProcess) {
+    return !currentModel || Boolean(
+        modelToProcess.constructor.searchProperties()
+            .filter(field => JSON.stringify(_.get(currentModel, field)) !== JSON.stringify(_.get(modelToProcess, field)))
+            .length,
+    );
 }
 
 /**