@acodeninja/persist 3.0.0-next.23 → 3.0.0-next.25

package/package.json

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

package/src/Connection.js

@@ -17,12 +17,6 @@ export default class Connection {
      */
     #storage;
 
-    /**
-     * @private
-     * @property {CacheEngine|undefined}
-     */
-    #cache;
-
     /**
      * @private
      * @property {Record<String, Model.constructor>}
@@ -32,12 +26,10 @@ export default class Connection {
     /**
      * Create a new connection
      * @param {StorageEngine} storage
-     * @param {CacheEngine|undefined} cache
      * @param {Array<Model.constructor>} models
      */
-    constructor(storage, cache, models) {
+    constructor(storage, models) {
         this.#storage = storage;
-        this.#cache = cache;
         this.#models = Object.fromEntries((models ?? []).map(model => [model.name, model]));
 
         if (!this.#storage) throw new MissingArgumentsConnectionError('No storage engine provided');
@@ -50,11 +42,11 @@ export default class Connection {
      * @return {Promise<Model>}
      */
     async get(modelId) {
-        const constructor = this.#getModelConstructorFromId(modelId);
+        const modelConstructor = this.#getModelConstructorFromId(modelId);
 
         const data = await this.#storage.getModel(modelId);
 
-        return constructor.fromData(data);
+        return modelConstructor.fromData(data);
     }
 
     /**
@@ -165,33 +157,37 @@ export default class Connection {
                 throw new ModelNotRegisteredConnectionError(modelToProcess, this.#storage);
 
             modelToProcess.validate();
-            const currentModel = await this.get(modelToProcess.id).catch(() => null);
+
+            const modelToProcessConstructor = this.#getModelConstructorFromId(modelToProcess.id);
+            const currentModel = await this.hydrate(modelToProcess).catch(() => null);
 
             const modelToProcessHasChanged = !_.isEqual(currentModel?.toData() || {}, modelToProcess.toData());
 
             if (modelToProcessHasChanged) modelsToPut.push(modelToProcess);
 
-            const modelToProcessConstructor = this.#getModelConstructorFromId(modelToProcess.id).name;
+            const modelToProcessConstructorName = modelToProcessConstructor.name;
 
             if (
                 Boolean(modelToProcess.constructor.indexedProperties().length) &&
                 (!currentModel || !_.isEqual(currentModel.toIndexData(), modelToProcess.toIndexData()))
             ) {
-                modelsToReindex[modelToProcessConstructor] = modelsToReindex[modelToProcessConstructor] || [];
-                modelsToReindex[modelToProcessConstructor].push(modelToProcess);
+                modelsToReindex[modelToProcessConstructorName] = modelsToReindex[modelToProcessConstructorName] || [];
+                modelsToReindex[modelToProcessConstructorName].push(modelToProcess);
             }
 
             if (
                 Boolean(modelToProcess.constructor.searchProperties().length) &&
                 (!currentModel || !_.isEqual(currentModel.toSearchData(), modelToProcess.toSearchData()))
             ) {
-                modelsToReindexSearch[modelToProcessConstructor] = modelsToReindexSearch[modelToProcessConstructor] || [];
-                modelsToReindexSearch[modelToProcessConstructor].push(modelToProcess);
+                modelsToReindexSearch[modelToProcessConstructorName] = modelsToReindexSearch[modelToProcessConstructorName] || [];
+                modelsToReindexSearch[modelToProcessConstructorName].push(modelToProcess);
             }
 
-            for (const [field, value] of Object.entries(modelToProcess)) {
-                if (Model.isModel(value)) {
-                    await processModel(modelToProcess[field]);
+            for (const [_name, property] of Object.entries(modelToProcess)) {
+                if (Model.isModel(property)) {
+                    await processModel(property);
+                } else if (Array.isArray(property) && Model.isModel(property[0])) {
+                    await Promise.all(property.map(processModel));
                 }
             }
         };
@@ -259,25 +255,23 @@ export default class Connection {
 
             if (!modelsToDelete.includes(currentModel.id)) modelsToDelete.push(currentModel.id);
 
-            const modelToProcessConstructor = this.#getModelConstructorFromId(modelToProcess.id).name;
+            const modelToProcessConstructor = this.#getModelConstructorFromId(modelToProcess.id);
 
-            indexActions[modelToProcessConstructor] = indexActions[modelToProcessConstructor] ?? [];
-            searchIndexActions[modelToProcessConstructor] = searchIndexActions[modelToProcessConstructor] ?? [];
+            indexActions[modelToProcessConstructor.name] = indexActions[modelToProcessConstructor.name] ?? [];
+            searchIndexActions[modelToProcessConstructor.name] = searchIndexActions[modelToProcessConstructor.name] ?? [];
 
-            if (currentModel.constructor.indexedPropertiesResolved().length) {
-                indexActions[modelToProcessConstructor].push(['delete', modelToProcess]);
-            }
+            indexActions[modelToProcessConstructor.name].push(['delete', modelToProcess]);
 
             if (currentModel.constructor.searchProperties().length) {
-                searchIndexActions[modelToProcessConstructor].push(['delete', modelToProcess]);
+                searchIndexActions[modelToProcessConstructor.name].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,
+                    .map(async ([modelConstructor, updatableModels]) => [
+                        modelConstructor,
                         await Promise.all(updatableModels.map(async m => {
                             const upToDateModel = modelCache[m.id] ?? await this.get(m.id);
                             modelCache[upToDateModel.id] = upToDateModel;
@@ -297,13 +291,16 @@ export default class Connection {
                                 if (!modelsToDelete.includes(m.id)) modelsToDelete.push(m.id);
                                 modelsToProcess.push(m);
                             } else {
+                                const modelConstructor = this.#getModelConstructorFromId(m.id);
                                 m[linkName] = undefined;
                                 modelsToPut.push(m);
 
-                                indexActions[this.#getModelConstructorFromId(m.id)].push(['reindex', m]);
+                                indexActions[modelConstructor.name] = indexActions[modelConstructor.name] ?? [];
+                                indexActions[modelConstructor.name].push(['reindex', m]);
 
                                 if (m.constructor.searchProperties().length) {
-                                    searchIndexActions[this.#getModelConstructorFromId(m.id)].push(['reindex', m]);
+                                    searchIndexActions[modelConstructor.name] = searchIndexActions[modelConstructor.name] ?? [];
+                                    searchIndexActions[modelConstructor.name].push(['reindex', m]);
                                 }
                             }
                         }),
@@ -317,6 +314,7 @@ export default class Connection {
         await processModel(model);
 
         const unrequestedDeletions = modelsToDelete.filter(m => !propagateTo.includes(m));
+
         if (unrequestedDeletions.length) {
             throw new DeleteHasUnintendedConsequencesStorageEngineError(model.id, {
                 willDelete: unrequestedDeletions,
@@ -359,8 +357,8 @@ export default class Connection {
         ]);
 
         await Promise.all([
-            Promise.all(modelsToDelete.map(m => this.#storage.deleteModel(m))),
             Promise.all(modelsToPut.map(m => this.#storage.putModel(m.toData()))),
+            Promise.all(modelsToDelete.map(m => this.#storage.deleteModel(m))),
             Promise.all(
                 Object.entries(indexCache)
                     .map(([constructorName, index]) => this.#storage.putIndex(this.#models[constructorName], index)),
@@ -385,13 +383,13 @@ export default class Connection {
      *   Must include: '+foo bar' must include 'foo' and may include 'bar'
      *   Must not include: '-foo bar' must not include 'foo' and may include 'bar'
      *   Mixed include: '+foo -bar' must include 'foo' must not include 'bar'
-     * @param {Model.constructor} constructor
+     * @param {Model.constructor} modelConstructor
      * @param {string} query
      * @return {Promise<Array<SearchResult>>}
      */
-    async search(constructor, query) {
-        const searchIndex = await this.#storage.getSearchIndex(constructor)
-            .then(index => new SearchIndex(constructor, index));
+    async search(modelConstructor, query) {
+        const searchIndex = await this.#storage.getSearchIndex(modelConstructor)
+            .then(index => new SearchIndex(modelConstructor, index));
 
         return searchIndex.search(query);
     }
@@ -399,13 +397,13 @@ export default class Connection {
     /**
      * Find using a structured query and indexed fields.
      *
-     * @param {Model.constructor} constructor
+     * @param {Model.constructor} modelConstructor
      * @param {Object} query
      * @return {Promise<Array<SearchResult>>}
      */
-    async find(constructor, query) {
-        const findIndex = await this.#storage.getIndex(constructor)
-            .then(index => new FindIndex(constructor, index));
+    async find(modelConstructor, query) {
+        const findIndex = await this.#storage.getIndex(modelConstructor)
+            .then(index => new FindIndex(modelConstructor, index));
 
         return findIndex.query(query);
     }
@@ -420,7 +418,7 @@ export default class Connection {
 
         const engine = CreateTransactionalStorageEngine(operations, this.#storage);
 
-        const transaction = new this.constructor(engine, this.#cache, Object.values(this.#models));
+        const transaction = new this.constructor(engine, Object.values(this.#models));
 
         transaction.commit = async () => {
             try {
@@ -475,11 +473,11 @@ export default class Connection {
      */
     #getModelConstructorFromId(modelId) {
         const modelName = modelId.split('/')[0];
-        const constructor = this.#models[modelName];
+        const modelConstructor = this.#models[modelName];
 
-        if (!constructor) throw new ModelNotRegisteredConnectionError(modelName, this.#storage);
+        if (!modelConstructor) throw new ModelNotRegisteredConnectionError(modelName, this.#storage);
 
-        return constructor;
+        return modelConstructor;
     }
 
     /**
@@ -585,11 +583,11 @@ export class MissingArgumentsConnectionError extends ConnectionError {
  */
 export class ModelNotRegisteredConnectionError extends ConnectionError {
     /**
-     * @param {Model|String} constructor
+     * @param {Model|String} modelConstructor
      * @param {Connection} connection
      */
-    constructor(constructor, connection) {
-        const modelName = typeof constructor === 'string' ? constructor : constructor.constructor.name;
+    constructor(modelConstructor, connection) {
+        const modelName = typeof modelConstructor === 'string' ? modelConstructor : modelConstructor.constructor.name;
         super(`The model ${modelName} is not registered in the storage engine ${connection.constructor.name}`);
     }
 }

package/src/data/Model.js

@@ -199,6 +199,7 @@ class Model {
                 .filter(([_name, type]) => !type._type && !this.isModel(type) && !type._items?._type && (this.isModel(type._items) || this.isModel(type()._items)))
                 .map(([name, _type]) => `${name}.[*].id`),
             ...this.indexedProperties(),
+            'id',
         ];
     }