@acodeninja/persist 3.0.0-next.27 → 3.0.0-next.29

package/README.md

@@ -41,10 +41,10 @@ import Persist from '@acodeninja/persist';
 
 class Person extends Persist.Model {
     static {
-        this.name = Persist.Property.String.required;
-        this.dateOfBirth = Persist.Property.Date.required;
-        this.height = Persist.Property.Number.required;
-        this.isStudent = Persist.Property.Boolean.required;
+        Person.name = Persist.Property.String.required;
+        Person.dateOfBirth = Persist.Property.Date.required;
+        Person.height = Persist.Property.Number.required;
+        Person.isStudent = Persist.Property.Boolean.required;
     }
 }
 ```

package/docs/code-quirks.md

@@ -14,10 +14,10 @@ To avoid this problem, you have two options:
 ```javascript
 import Persist from "@acodeninja/persist";
 
-export class Person extends Persist.Type.Model {
+export class Person extends Persist.Model {
     static {
-        this.withName('Person');
-        this.name = Persist.Type.String.required;
+        Person.withName('Person');
+        Person.name = Persist.Property.String.required;
     }
 }
 ```
@@ -37,17 +37,17 @@ To avoid these errors, always define model relationships using arrow functions.
 ```javascript
 import Persist from "@acodeninja/persist";
 
-export class Person extends Persist.Type.Model {
+export class Person extends Persist.Model {
     static {
-        this.address = () => Address;
+        Person.address = () => Address;
     }
 }
 
-export class Address extends Persist.Type.Model {
+export class Address extends Persist.Model {
     static {
-        this.person = () => Person;
-        this.address = Persist.Type.String.required;
-        this.postcode = Persist.Type.String.required;
+        Address.person = () => Person;
+        Address.address = Persist.Property.String.required;
+        Address.postcode = Persist.Property.String.required;
     }
 }
 ```

package/docs/defining-models.md

@@ -28,10 +28,10 @@ import Persist from '@acodeninja/persist';
 
 class Person extends Persist.Model {
     static {
-        this.name = Persist.Property.String.required;
-        this.dateOfBirth = Persist.Property.Date.required;
-        this.height = Persist.Property.Number.required;
-        this.isStudent = Persist.Property.Boolean.required;
+        Person.name = Persist.Property.String.required;
+        Person.dateOfBirth = Persist.Property.Date.required;
+        Person.height = Persist.Property.Number.required;
+        Person.isStudent = Persist.Property.Boolean.required;
     }
 }
 ```
@@ -45,15 +45,15 @@ Models can be linked to other models by declaring them as properties.
 ```javascript
 class Address extends Persist.Model {
     static {
-        this.address = Persist.Property.String.required;
-        this.postcode = Persist.Property.String.required;
+        Address.address = Persist.Property.String.required;
+        Address.postcode = Persist.Property.String.required;
     }
 }
 
 class Person extends Persist.Model {
     static {
-        this.name = Persist.Property.String.required;
-        this.address = Address;
+        Person.name = Persist.Property.String.required;
+        Person.address = Address;
     }
 }
 ```

package/docs/model-properties.md

@@ -13,8 +13,8 @@ import Persist from '@acodeninja/persist';
 
 class Person extends Persist.Model {
     static {
-        this.firstName = Persist.Property.String;
-        this.lastName = Persist.Property.String;
+        Person.firstName = Persist.Property.String;
+        Person.lastName = Persist.Property.String;
     }
 }
 ```
@@ -30,8 +30,8 @@ import Persist from '@acodeninja/persist';
 
 class Person extends Persist.Model {
     static {
-        this.firstName = Persist.Property.String;
-        this.lastName = Persist.Property.String.required;
+        Person.firstName = Persist.Property.String;
+        Person.lastName = Persist.Property.String.required;
     }
 }
 ```
@@ -45,8 +45,8 @@ import Persist from '@acodeninja/persist';
 
 class Person extends Persist.Model {
     static {
-        this.markettingEmailsActive = Persist.Property.Boolean;
-        this.accountActive = Persist.Property.Boolean.required;
+        Person.marketingEmailsActive = Persist.Property.Boolean;
+        Person.accountActive = Persist.Property.Boolean.required;
     }
 }
 ```
@@ -60,8 +60,8 @@ import Persist from '@acodeninja/persist';
 
 class Person extends Persist.Model {
     static {
-        this.loginToken = Persist.Property.Number;
-        this.accountId = Persist.Property.Number.required;
+        Person.loginToken = Persist.Property.Number;
+        Person.accountId = Persist.Property.Number.required;
     }
 }
 ```
@@ -77,8 +77,8 @@ import Persist from '@acodeninja/persist';
 
 class Person extends Persist.Model {
     static {
-        this.lastLogin = Persist.Property.Date;
-        this.createdAt = Persist.Property.Date.required;
+        Person.lastLogin = Persist.Property.Date;
+        Person.createdAt = Persist.Property.Date.required;
     }
 }
 ```
@@ -94,8 +94,8 @@ import Persist from '@acodeninja/persist';
 
 class Person extends Persist.Model {
     static {
-        this.failedLoginAttempts = Persist.Property.Array.of(Persist.Property.Date);
-        this.fullName = Persist.Property.Array.of(Persist.Property.String).required;
+        Person.failedLoginAttempts = Persist.Property.Array.of(Persist.Property.Date);
+        Person.fullName = Persist.Property.Array.of(Persist.Property.String).required;
     }
 }
 ```
@@ -109,7 +109,7 @@ import Persist from '@acodeninja/persist';
 
 class Person extends Persist.Model {
     static {
-        this.address = Persist.Property.Custom.of({
+        Person.address = Persist.Property.Custom.of({
             type: 'object',
             additionalProperties: false,
             required: ['line1', 'city', 'postcode'],
@@ -140,8 +140,8 @@ import Persist from '@acodeninja/persist';
 
 class Page extends Persist.Model {
     static {
-        this.title = Persist.Property.String;
-        this.slug = Persist.Property.Resolved.Slug.of('title');
+        Page.title = Persist.Property.String;
+        Page.slug = Persist.Property.Resolved.Slug.of('title');
     }
 }
 
@@ -162,14 +162,14 @@ Most types support the `.required` modifier, which will alter validation to enfo
 ```javascript
 class RequiredStringModel extends Persist.Model {
     static {
-        this.requiredString = Type.String.required;
-        this.requiredNumber = Type.Number.required;
-        this.requiredBoolean = Type.Boolean.required;
-        this.requiredDate = Type.Date.required;
-        this.requiredArrayOfString = Type.Array.of(Type.String).required;
-        this.requiredArrayOfNumber = Type.Array.of(Type.Number).required;
-        this.requiredArrayOfBoolean = Type.Array.of(Type.Boolean).required;
-        this.requiredArrayOfDate = Type.Array.of(Type.Date).required;
+        RequiredStringModel.requiredString = Persist.Property.String.required;
+        RequiredStringModel.requiredNumber = Persist.Property.Number.required;
+        RequiredStringModel.requiredBoolean = Persist.Property.Boolean.required;
+        RequiredStringModel.requiredDate = Persist.Property.Date.required;
+        RequiredStringModel.requiredArrayOfString = Persist.Property.Array.of(Persist.Property.String).required;
+        RequiredStringModel.requiredArrayOfNumber = Persist.Property.Array.of(Persist.Property.Number).required;
+        RequiredStringModel.requiredArrayOfBoolean = Persist.Property.Array.of(Persist.Property.Boolean).required;
+        RequiredStringModel.requiredArrayOfDate = Persist.Property.Array.of(Persist.Property.Date).required;
     }
 }
 ```
@@ -186,11 +186,11 @@ import Persist from '@acodeninja/persist';
 class IPv4Type extends Persist.Property.Type {
     static {
         // Set the type of the property to string
-        this._type = 'string';
+        IPv4Type._type = 'string';
         // Use the ajv extended format "ipv4"
-        this._format = 'ipv4';
+        IPv4Type._format = 'ipv4';
         // Ensure that even when minified, the name of the constructor is IPv4
-        Object.defineProperty(this, 'name', {value: 'IPv4'});
+        Object.defineProperty(IPv4Type, 'name', {value: 'IPv4'});
     }
 }
 ```

package/docs/models-as-properties.md

@@ -9,14 +9,14 @@ import Persist from "@acodeninja/persist";
 
 export class Person extends Persist.Model {
     static {
-        this.name = Persist.Property.String.required;
+        Person.name = Persist.Property.String.required;
     }
 }
 
 export class Address extends Persist.Model {
     static {
-        this.address = Persist.Property.String.required;
-        this.postcode = Persist.Property.String.required;
+        Address.address = Persist.Property.String.required;
+        Address.postcode = Persist.Property.String.required;
     }
 }
 ```
@@ -30,15 +30,15 @@ import Persist from "@acodeninja/persist";
 
 export class Person extends Persist.Model {
     static {
-        this.name = Persist.Property.String.required;
-        this.address = () => Address;
+        Person.name = Persist.Property.String.required;
+        Person.address = () => Address;
     }
 }
 
 export class Address extends Persist.Model {
     static {
-        this.address = Persist.Property.String.required;
-        this.postcode = Persist.Property.String.required;
+        Address.address = Persist.Property.String.required;
+        Address.postcode = Persist.Property.String.required;
     }
 }
 ```
@@ -57,16 +57,16 @@ import Persist from "@acodeninja/persist";
 
 export class Person extends Persist.Model {
     static {
-        this.name = Persist.Property.String.required;
-        this.address = () => Address;
+        Person.name = Persist.Property.String.required;
+        Person.address = () => Address;
     }
 }
 
 export class Address extends Persist.Model {
     static {
-        this.person = () => Person;
-        this.address = Persist.Property.String.required;
-        this.postcode = Persist.Property.String.required;
+        Address.person = () => Person;
+        Address.address = Persist.Property.String.required;
+        Address.postcode = Persist.Property.String.required;
     }
 }
 ```
@@ -80,16 +80,16 @@ import Persist from "@acodeninja/persist";
 
 export class Person extends Persist.Model {
     static {
-        this.name = Persist.Property.String.required;
-        this.addresses = () => Persist.Property.Array.of(Address);
+        Person.name = Persist.Property.String.required;
+        Person.addresses = () => Persist.Property.Array.of(Address);
     }
 }
 
 export class Address extends Persist.Model {
     static {
-        this.person = () => Person;
-        this.address = Persist.Property.String.required;
-        this.postcode = Persist.Property.String.required;
+        Address.person = () => Person;
+        Address.address = Persist.Property.String.required;
+        Address.postcode = Persist.Property.String.required;
     }
 }
 ```
@@ -105,16 +105,16 @@ import Persist from "@acodeninja/persist";
 
 export class Person extends Persist.Model {
     static {
-        this.name = Persist.Property.String.required;
-        this.addresses = () => Persist.Property.Array.of(Address);
+        Person.name = Persist.Property.String.required;
+        Person.addresses = () => Persist.Property.Array.of(Address);
     }
 }
 
 export class Address extends Persist.Model {
     static {
-        this.people = () => Persist.Property.Array.of(Person);
-        this.address = Persist.Property.String.required;
-        this.postcode = Persist.Property.String.required;
+        Address.people = () => Persist.Property.Array.of(Person);
+        Address.address = Persist.Property.String.required;
+        Address.postcode = Persist.Property.String.required;
     }
 }
 ```
@@ -130,24 +130,24 @@ import Persist from "@acodeninja/persist";
 
 export class Person extends Persist.Model {
     static {
-        this.name = Persist.Property.String.required;
-        this.addresses = () => Persist.Property.Array.of(Abode);
+        Person.name = Persist.Property.String.required;
+        Person.addresses = () => Persist.Property.Array.of(Abode);
     }
 }
 
 export class Abode extends Persist.Model {
     static {
-        this.moveInDate = Persist.Property.Date.required;
-        this.address = () => Address;
-        this.person = () => Person;
+        Abode.moveInDate = Persist.Property.Date.required;
+        Abode.address = () => Address;
+        Abode.person = () => Person;
     }
 }
 
 export class Address extends Persist.Model {
     static {
-        this.people = () => Persist.Property.Array.of(Person);
-        this.address = Persist.Property.String.required;
-        this.postcode = Persist.Property.String.required;
+        Address.people = () => Persist.Property.Array.of(Person);
+        Address.address = Persist.Property.String.required;
+        Address.postcode = Persist.Property.String.required;
     }
 }
 ```

package/docs/search-queries.md

@@ -11,19 +11,19 @@ Let's consider the following models:
 ```javascript
 import Persist from "@acodeninja/persist";
 
-export class Person extends Persist.Type.Model {
+export class Person extends Persist.Model {
     static {
-        this.name = Persist.Type.String.required;
-        this.address = () => Address;
-        this.searchProperties = () => ['name', 'address.address'];
+        Person.name = Persist.Property.String.required;
+        Person.address = () => Address;
+        Person.searchProperties = () => ['name', 'address.address'];
     }
 }
 
-export class Address extends Persist.Type.Model {
+export class Address extends Persist.Model {
     static {
-        this.address = Persist.Type.String.required;
-        this.postcode = Persist.Type.String.required;
-        this.searchProperties = () => ['address', 'postcode'];
+        Address.address = Persist.Property.String.required;
+        Address.postcode = Persist.Property.String.required;
+        Address.searchProperties = () => ['address', 'postcode'];
     }
 }
 ```

package/docs/structured-queries.md

@@ -4,7 +4,7 @@ Use structured queries when you need to filter a collection of models using a se
 
 ## Indexing Data
 
-To set index properties on a model, define the static function `indexProperties` as an arrow function that returns an array of fields that should be indexed for querying.
+To set index properties on a model, define the static function `indexedProperties` as an arrow function that returns an array of fields that should be indexed for querying.
 
 Let's consider the following models:
 
@@ -13,18 +13,18 @@ import Persist from "@acodeninja/persist";
 
 export class Person extends Persist.Model {
     static {
-        this.name = Persist.Property.String.required;
-        this.address = () => Address;
-        this.indexProperties = () => ['name', 'address.postcode'];
+        Person.name = Persist.Property.String.required;
+        Person.address = () => Address;
+        Person.indexedProperties = () => ['name', 'address.postcode'];
     }
 }
 
 export class Address extends Persist.Model {
     static {
-        this.address = Persist.Property.String.required;
-        this.postcode = Persist.Property.String.required;
-        this.people = () => Persist.Property.Array.of(Person)
-        this.indexProperties = () => ['postcode', 'people.[*].name'];
+        Address.address = Persist.Property.String.required;
+        Address.postcode = Persist.Property.String.required;
+        Address.people = () => Persist.Property.Array.of(Person)
+        Address.indexedProperties = () => ['postcode', 'people.[*].name'];
     }
 }
 ```

package/package.json

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

package/src/Connection.js

@@ -7,6 +7,104 @@ import Model from './data/Model.js';
 import SearchIndex from './data/SearchIndex.js';
 import _ from 'lodash';
 
+/**
+ * @class State
+ */
+class State {
+    /**
+     * @private
+     * @property {StorageEngine}
+     */
+    #storage;
+
+    constructor(storage) {
+        this.modelCache = new Map();
+        this.indexCache = new Map();
+        this.searchIndexCache = new Map();
+        this.#storage = storage;
+    }
+
+    /**
+     * Get a given index
+     * @param {Model.constructor} modelConstructor
+     * @return {Object}
+     */
+    async getIndex(modelConstructor) {
+        const modelConstructorName = modelConstructor.name;
+
+        if (!this.indexCache.has(modelConstructorName)) {
+            this.indexCache.set(modelConstructorName, {
+                changed: false,
+                index: await this.#storage.getIndex(modelConstructor),
+            });
+        }
+
+        return this.indexCache.get(modelConstructorName)?.index;
+    }
+
+    /**
+     * Get a Map of indexes that have been tainted
+     * @return {Map<String, Object>}
+     */
+    getTaintedIndexes() {
+        return new Map(
+            this.indexCache
+                .entries()
+                .filter(([_name, cache]) => cache.changed)
+                .map(([name, {index}]) => [name, index]),
+        );
+    }
+
+    /**
+     * Update a given index
+     * @param {string} modelConstructorName
+     * @return {Object}
+     */
+    updateIndex(modelConstructorName, index) {
+        this.indexCache.set(modelConstructorName, {index, changed: true});
+    }
+
+    /**
+     * Get a given search index
+     * @param {Model.constructor} modelConstructor
+     * @return {Object}
+     */
+    async getSearchIndex(modelConstructor) {
+        const modelConstructorName = modelConstructor.name;
+
+        if (!this.searchIndexCache.has(modelConstructorName)) {
+            this.searchIndexCache.set(modelConstructorName, {
+                changed: false,
+                index: await this.#storage.getSearchIndex(modelConstructor),
+            });
+        }
+
+        return this.searchIndexCache.get(modelConstructorName)?.index;
+    }
+
+    /**
+     * Get a Map of search indexes that have been tainted
+     * @return {Map<String, Object>}
+     */
+    getTaintedSearchIndexes() {
+        return new Map(
+            this.searchIndexCache
+                .entries()
+                .filter(([_name, cache]) => cache.changed)
+                .map(([name, {index}]) => [name, index]),
+        );
+    }
+
+    /**
+     * Update a given search index
+     * @param {string} modelConstructorName
+     * @return {Object}
+     */
+    updateSearchIndex(modelConstructorName, index) {
+        this.searchIndexCache.set(modelConstructorName, {index, changed: true});
+    }
+}
+
 /**
  * @class Connection
  */
@@ -75,7 +173,7 @@ export default class Connection {
                 if (Model.isDryModel(property)) {
                     // skipcq: JS-0129
                     modelToProcess[name] = await hydrateSubModel(property);
-                } else if (Array.isArray(property) && Model.isDryModel(property[0])) {
+                } else if (Array.isArray(property) && property.length && Model.isDryModel(property[0])) {
                     // skipcq: JS-0129
                     modelToProcess[name] = await hydrateModelList(property);
                 }
@@ -133,6 +231,7 @@ export default class Connection {
      * Persists a model if it has changed, and updates all related models and their indexes
      * @param {Model} model
      * @return {Promise<void>}
+     * @throws {ValidationError|ModelNotRegisteredConnectionError}
      */
     async put(model) {
         const processedModels = [];
@@ -222,31 +321,19 @@ export default class Connection {
      * @throws {ModelNotFoundStorageEngineError}
      */
     async delete(subject, propagateTo = []) {
-        const modelCache = new Map();
+        const state = new State(this.#storage);
         const modelsToCheck = this.#findLinkedModelClasses(subject);
         const modelsToDelete = new Set([subject.id]);
         const modelsToUpdate = new Set();
         const indexesToUpdate = new Set();
         const searchIndexesToUpdate = new Set();
 
-        subject = await this.hydrate(subject, modelCache);
+        subject = await this.hydrate(subject, state.modelCache);
 
         if (!propagateTo.includes(subject.id)) {
             propagateTo.push(subject.id);
         }
 
-        // Populate index and search index cache.
-        const [indexCache, searchIndexCache] = await this.#getModelIndexes(modelsToCheck);
-
-        // Add model to be removed to index caches.
-        if (!indexCache.has(subject.constructor.name)) {
-            indexCache.set(subject.constructor.name, (await this.#storage.getIndex(subject.constructor)));
-        }
-
-        if (!searchIndexCache.has(subject.constructor.name)) {
-            searchIndexCache.set(subject.constructor.name, (await this.#storage.getSearchIndex(subject.constructor)));
-        }
-
         // Populate model cache
         for (const [[modelName, propertyName, type, direction], _modelConstructor] of modelsToCheck) {
             const query = {};
@@ -270,11 +357,11 @@ export default class Connection {
                     (
                         Array.isArray(subject[propertyName]) ?
                             subject[propertyName] : [subject[propertyName]]
-                    ) : new FindIndex(this.#models.get(modelName), indexCache.get(modelName)).query(query);
+                    ) : new FindIndex(this.#models.get(modelName), await state.getIndex(this.#models.get(modelName))).query(query);
 
             for (const foundModel of foundModels) {
-                if (!modelCache.has(foundModel.id)) {
-                    modelCache.set(foundModel.id, await this.hydrate(foundModel, modelCache));
+                if (!state.modelCache.has(foundModel.id)) {
+                    state.modelCache.set(foundModel.id, await this.hydrate(foundModel, state.modelCache));
                 }
             }
 
@@ -282,7 +369,7 @@ export default class Connection {
             if (direction === 'up') {
                 if (type === 'one') {
                     for (const foundModel of foundModels) {
-                        const cachedModel = modelCache.get(foundModel.id);
+                        const cachedModel = state.modelCache.get(foundModel.id);
 
                         if (foundModel.constructor[propertyName]._required) {
                             modelsToDelete.add(foundModel.id);
@@ -290,17 +377,17 @@ export default class Connection {
                         }
 
                         cachedModel[propertyName] = undefined;
-                        modelCache.set(foundModel.id, cachedModel);
+                        state.modelCache.set(foundModel.id, cachedModel);
                         modelsToUpdate.add(foundModel.id);
                     }
                 }
 
                 if (type === 'many') {
                     for (const foundModel of foundModels) {
-                        const cachedModel = modelCache.get(foundModel.id);
+                        const cachedModel = state.modelCache.get(foundModel.id);
 
                         cachedModel[propertyName] = cachedModel[propertyName].filter(m => m.id !== subject.id);
-                        modelCache.set(foundModel.id, cachedModel);
+                        state.modelCache.set(foundModel.id, cachedModel);
                         modelsToUpdate.add(foundModel.id);
                     }
                 }
@@ -312,52 +399,70 @@ export default class Connection {
 
         if (unrequestedDeletions.length || unrequestedUpdates.length) {
             throw new DeleteHasUnintendedConsequencesStorageEngineError(subject.id, {
-                willDelete: unrequestedDeletions.map(id => modelCache.get(id)),
-                willUpdate: unrequestedUpdates.map(id => modelCache.get(id)),
+                willDelete: unrequestedDeletions.map(id => state.modelCache.get(id)),
+                willUpdate: unrequestedUpdates.map(id => state.modelCache.get(id)),
             });
         }
 
-        for (const modelId of [...modelsToDelete, ...modelsToUpdate]) {
-            const modelConstructorName = modelId.split('/')[0];
-            indexesToUpdate.add(modelConstructorName);
-            if (this.#models.get(modelConstructorName)?.searchProperties().length) {
-                searchIndexesToUpdate.add(modelConstructorName);
-            }
-        }
+        await Promise.all(
+            new Set([...modelsToDelete, ...modelsToUpdate].map(this.#getModelConstructorFromId.bind(this)))
+                .values()
+                .map(async modelConstructor => {
+                    await state.getIndex(modelConstructor);
+                    indexesToUpdate.add(modelConstructor.name);
+
+                    if (modelConstructor.searchProperties().length) {
+                        await state.getSearchIndex(modelConstructor);
+                        searchIndexesToUpdate.add(modelConstructor.name);
+                    }
+                }),
+        );
 
         for (const indexName of searchIndexesToUpdate) {
-            const index = searchIndexCache.get(indexName);
+            const index = await state.getSearchIndex(this.#models.get(indexName));
 
             for (const model of [...modelsToUpdate].filter(i => i.startsWith(indexName))) {
-                index[model] = modelCache.get(model).toSearchData();
+                index[model] = state.modelCache.get(model).toSearchData();
             }
 
             for (const model of [...modelsToDelete].filter(i => i.startsWith(indexName))) {
                 delete index[model];
             }
 
-            searchIndexCache.set(indexName, index);
+            state.updateSearchIndex(indexName, index);
         }
 
         for (const indexName of indexesToUpdate) {
-            const index = indexCache.get(indexName);
+            const index = await state.getIndex(this.#models.get(indexName));
 
             for (const model of [...modelsToUpdate].filter(i => i.startsWith(indexName))) {
-                index[model] = modelCache.get(model).toIndexData();
+                index[model] = state.modelCache.get(model).toIndexData();
             }
 
             for (const model of [...modelsToDelete].filter(i => i.startsWith(indexName))) {
                 delete index[model];
             }
 
-            indexCache.set(indexName, index);
+            state.updateIndex(indexName, index);
         }
 
         await Promise.all([
-            Promise.all([...modelsToUpdate].map(id => this.#storage.putModel(modelCache.get(id).toData()))),
+            Promise.all([...modelsToUpdate].map(id => this.#storage.putModel(state.modelCache.get(id).toData()))),
             Promise.all([...modelsToDelete].map(id => this.#storage.deleteModel(id))),
-            Promise.all([...indexesToUpdate].map(index => this.#storage.putIndex(this.#models.get(index), indexCache.get(index)))),
-            Promise.all([...searchIndexesToUpdate].map(index => this.#storage.putSearchIndex(this.#models.get(index), searchIndexCache.get(index)))),
+            Promise.all(state
+                .getTaintedIndexes()
+                .entries()
+                .map(([modelConstructorName, index]) =>
+                    this.#storage.putIndex(this.#models.get(modelConstructorName), index),
+                ),
+            ),
+            Promise.all(state
+                .getTaintedSearchIndexes()
+                .entries()
+                .map(([modelConstructorName, index]) =>
+                    this.#storage.putSearchIndex(this.#models.get(modelConstructorName), index),
+                ),
+            ),
         ]);
     }
 
@@ -405,7 +510,7 @@ export default class Connection {
 
         const engine = CreateTransactionalStorageEngine(operations, this.#storage);
 
-        const transaction = new this.constructor(engine, this.#models.values());
+        const transaction = new this.constructor(engine, [...this.#models.values()]);
 
         transaction.commit = async () => {
             try {
@@ -432,7 +537,7 @@ export default class Connection {
                     }
                 }
             } catch (error) {
-                for (const operation of operations) {
+                for (const operation of operations.slice().reverse()) {
                     if (operation.committed && operation.original) {
                         if (['putModel', 'deleteModel'].includes(operation.method))
                             await this.#storage.putModel(operation.original);
@@ -443,6 +548,10 @@ export default class Connection {
                         if (operation.method === 'putSearchIndex')
                             await this.#storage.putSearchIndex(operation.args[0], operation.original);
                     }
+
+                    if (operation.method === 'putModel' && operation.committed && !operation.original) {
+                        await this.#storage.deleteModel(operation.args[0].id);
+                    }
                 }
 
                 throw new CommitFailedTransactionError(operations, error);
@@ -467,42 +576,6 @@ export default class Connection {
         return modelConstructor;
     }
 
-    /**
-     * Retrieves and caches index and search index information for specified models.
-     *
-     * @private
-     * @async
-     * @param {Array<Array<string, *>>} modelsToCheck - An array of arrays where the first element
-     *   of each inner array is the model name to retrieve indexes for
-     * @returns {Promise<[Map<string, *>, Map<string, *>]>} A promise that resolves to a tuple containing:
-     *   - indexCache: A Map of model names to their corresponding indexes
-     *   - searchIndexCache: A Map of model names to their corresponding search indexes
-     *
-     * @description
-     * This method populates two caches for the specified models:
-     * 1. A regular index cache retrieved via storage.getIndex()
-     * 2. A search index cache retrieved via storage.getSearchIndex()
-     *
-     * If a model's indexes are already cached, they won't be fetched again.
-     * The method uses the internal storage interface to retrieve the indexes.
-     */
-    async #getModelIndexes(modelsToCheck) {
-        const indexCache = new Map();
-        const searchIndexCache = new Map();
-
-        for (const [[modelName]] of modelsToCheck) {
-            if (!indexCache.has(modelName)) {
-                indexCache.set(modelName, await this.#storage.getIndex(this.#models.get(modelName)));
-            }
-
-            if (!searchIndexCache.has(modelName)) {
-                searchIndexCache.set(modelName, await this.#storage.getSearchIndex(this.#models.get(modelName)));
-            }
-        }
-
-        return [indexCache, searchIndexCache];
-    }
-
     /**
      * Finds all model classes that are linked to the specified subject model.
      *

package/src/Schema.js

@@ -14,7 +14,7 @@ class Schema {
      * It uses AJV for the validation process and integrates with model types and their specific validation rules.
      *
      * @param {Object|Model} rawSchema - The raw schema or model definition to be compiled.
-     * @returns {CompiledSchema} - A class that extends `CompiledSchema`, with the compiled schema and validator attached.
+     * @returns {CompiledSchema} - A compiled schema, ready to validate instances of the model.
      *
      * @example
      * const schemaClass = Schema.compile(MyModelSchema);

package/src/data/Model.js

@@ -151,6 +151,8 @@ class Model {
      * @static
      */
     static get required() {
+        const ModelClass = this;
+
         /**
          * A subclass of the current model with the `_required` flag set to `true`.
          * Used to indicate that the property is required during validation or schema generation.
@@ -159,11 +161,11 @@ class Model {
          * @extends {Model}
          * @private
          */
-        class Required extends this {
+        class Required extends ModelClass {
             static _required = true;
         }
 
-        Object.defineProperty(Required, 'name', {value: this.name});
+        Object.defineProperty(Required, 'name', {value: ModelClass.name});
 
         return Required;
     }
@@ -191,20 +193,21 @@ class Model {
      * @static
      */
     static indexedPropertiesResolved() {
+        const ModelClass = this;
         return [
-            ...Object.entries(this.properties)
-                .filter(([name, type]) => !['indexedProperties', 'searchProperties'].includes(name) && !type._type && (this.isModel(type) || (typeof type === 'function' && this.isModel(type()))))
+            ...Object.entries(ModelClass.properties)
+                .filter(([name, type]) => !['indexedProperties', 'searchProperties'].includes(name) && !type._type && (ModelClass.isModel(type) || (typeof type === 'function' && ModelClass.isModel(type()))))
                 .map(([name, _type]) => `${name}.id`),
-            ...Object.entries(this.properties)
+            ...Object.entries(ModelClass.properties)
                 .filter(([_name, type]) => {
                     return !Model.isModel(type) && (
-                        (type._type === 'array' && this.isModel(type._items))
+                        (type._type === 'array' && ModelClass.isModel(type._items))
                         ||
-                        (!type._type && typeof type === 'function' && this.isModel(type()._items))
+                        (!type._type && typeof type === 'function' && ModelClass.isModel(type()._items))
                     );
                 })
                 .map(([name, _type]) => `${name}.[*].id`),
-            ...this.indexedProperties(),
+            ...ModelClass.indexedProperties(),
             'id',
         ];
     }
@@ -228,17 +231,18 @@ class Model {
      * @static
      */
     static fromData(data) {
-        const model = new this();
+        const ModelClass = this;
+        const model = new ModelClass();
 
         for (const [name, value] of Object.entries(data)) {
-            if (this[name]?._resolved) continue;
+            if (ModelClass[name]?._resolved) continue;
 
-            if (this[name]?.name.endsWith('Date')) {
+            if (ModelClass[name]?.name.endsWith('Date')) {
                 model[name] = new Date(value);
                 continue;
             }
 
-            if (this[name]?.name.endsWith('ArrayOf(Date)')) {
+            if (ModelClass[name]?.name.endsWith('ArrayOf(Date)')) {
                 model[name] = data[name].map(d => new Date(d));
                 continue;
             }
@@ -273,7 +277,7 @@ class Model {
     static isDryModel(possibleDryModel) {
         try {
             return (
-                !this.isModel(possibleDryModel) &&
+                !Model.isModel(possibleDryModel) &&
                 Object.keys(possibleDryModel).includes('id') &&
                 new RegExp(/[A-Za-z]+\/[A-Z0-9]+/).test(possibleDryModel.id)
             );
@@ -291,15 +295,16 @@ class Model {
      * @static
      *
      * @example
-     * export default class TestModel {
+     * export default class TestModel extends Model {
      *     static {
-     *         this.withName('TestModel');
-     *         this.string = Persist.Type.String;
+     *         TestModel.withName('TestModel');
+     *         TestModel.string = Persist.Property.String;
      *     }
      * }
      */
     static withName(name) {
-        Object.defineProperty(this, 'name', {value: name});
+        const ModelClass = this;
+        Object.defineProperty(ModelClass, 'name', {value: name});
     }
 
     /**
@@ -308,10 +313,11 @@ class Model {
      * @return {Model}
      */
     static get properties() {
+        const ModelClass = this;
         const props = {};
         const chain = [];
 
-        let current = this;
+        let current = ModelClass;
         while (current !== Function.prototype) {
             chain.push(current);
             current = Object.getPrototypeOf(current);
@@ -344,7 +350,7 @@ class Model {
             }
         }
 
-        return Object.assign(this, props);
+        return Object.assign(ModelClass, props);
     }
 }
 

package/src/data/properties/ArrayType.js

@@ -51,12 +51,14 @@ class ArrayType {
              * const requiredArrayOfStrings = ArrayType.of(StringType).required;
              */
             static get required() {
+                const ThisType = this;
+
                 /**
                  * @class RequiredArrayOf
                  * @extends ArrayOf
                  * Represents a required array of a specific type.
                  */
-                class Required extends this {
+                class Required extends ThisType {
                     /** @type {boolean} Indicates that the array is required */
                     static _required = true;
 
@@ -70,7 +72,7 @@ class ArrayType {
                     }
                 }
 
-                Object.defineProperty(Required, 'name', {value: `Required${this.toString()}`});
+                Object.defineProperty(Required, 'name', {value: `Required${ThisType.name}`});
 
                 return Required;
             }

package/src/data/properties/BooleanType.js

@@ -15,9 +15,9 @@ class BooleanType extends Type {
          * @static
          * @property {string} _type - The type identifier for BooleanType, set to `'boolean'`.
          */
-        this._type = 'boolean';
+        BooleanType._type = 'boolean';
 
-        Object.defineProperty(this, 'name', {value: 'Boolean'});
+        Object.defineProperty(BooleanType, 'name', {value: 'Boolean'});
     }
 }
 

package/src/data/properties/CustomType.js

@@ -37,12 +37,12 @@ class CustomType {
         class Custom extends Type {
             static {
                 /** @type {string} The data type, which is 'object' */
-                this._type = 'object';
+                Custom._type = 'object';
 
                 /** @type {Object} The JSON schema that defines the structure and validation rules */
-                this._schema = schema;
+                Custom._schema = schema;
 
-                Object.defineProperty(this, 'name', {value: 'Custom'});
+                Object.defineProperty(Custom, 'name', {value: 'Custom'});
             }
         }
 
@@ -50,7 +50,7 @@ class CustomType {
     }
 
     static {
-        Object.defineProperty(this, 'name', {value: 'Custom'});
+        Object.defineProperty(CustomType, 'name', {value: 'Custom'});
     }
 }
 

package/src/data/properties/DateType.js

@@ -15,15 +15,15 @@ class DateType extends Type {
          * @static
          * @property {string} _type - The type identifier for DateType, set to `'string'`.
          */
-        this._type = 'string';
+        DateType._type = 'string';
 
         /**
          * @static
          * @property {string} _format - The format for DateType, set to `'iso-date-time'`.
          */
-        this._format = 'iso-date-time';
+        DateType._format = 'iso-date-time';
 
-        Object.defineProperty(this, 'name', {value: 'Date'});
+        Object.defineProperty(DateType, 'name', {value: 'Date'});
     }
 
     /**

package/src/data/properties/NumberType.js

@@ -15,9 +15,9 @@ class NumberType extends Type {
          * @static
          * @property {string} _type - The type identifier for NumberType, set to `'number'`.
          */
-        this._type = 'number';
+        NumberType._type = 'number';
 
-        Object.defineProperty(this, 'name', {value: 'Number'});
+        Object.defineProperty(NumberType, 'name', {value: 'Number'});
     }
 }
 

package/src/data/properties/SlugType.js

@@ -65,7 +65,7 @@ class SlugType extends ResolvedType {
     }
 
     static {
-        Object.defineProperty(this, 'name', {value: 'Slug'});
+        Object.defineProperty(SlugType, 'name', {value: 'Slug'});
     }
 }
 

package/src/data/properties/StringType.js

@@ -15,9 +15,9 @@ class StringType extends Type {
          * @static
          * @property {string} _type - The type identifier for the string type.
          */
-        this._type = 'string';
+        StringType._type = 'string';
 
-        Object.defineProperty(this, 'name', {value: 'String'});
+        Object.defineProperty(StringType, 'name', {value: 'String'});
     }
 }
 

package/src/data/properties/Type.js

@@ -53,6 +53,8 @@ class Type {
      * @returns {Type} A subclass of the current type with `_required` set to `true`.
      */
     static get required() {
+        const ThisType = this;
+
         /**
          * A subclass of the current type with the `_required` flag set to `true`.
          * Used to indicate that the property is required during validation or schema generation.
@@ -61,18 +63,18 @@ class Type {
          * @extends {Type}
          * @private
          */
-        class Required extends this {
+        class Required extends ThisType {
             static _required = true;
         }
 
         // Define the class name as "Required<OriginalTypeName>"
-        Object.defineProperty(Required, 'name', {value: `Required${this.name}`});
+        Object.defineProperty(Required, 'name', {value: `Required${ThisType.name}`});
 
         return Required;
     }
 
     static {
-        Object.defineProperty(this, 'name', {value: 'Type'});
+        Object.defineProperty(Type, 'name', {value: 'Type'});
     }
 }