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

package/docs/code-quirks.md

@@ -54,15 +54,15 @@ export class Address extends Persist.Type.Model {
 
 By doing this, you ensure that model references are evaluated lazily, after all models have been initialized, preventing `ReferenceError` issues.
 
-## Using `HTTP` Engine in Browser
+## Using `HTTP` StorageEngine in Browser
 
 When implementing thee `HTTP` engine for code that runs in the web browser, you must pass `fetch` into the engine configuration and bind it to the `window` object.
 
 ```javascript
 import Persist from "@acodeninja/persist";
-import HTTPEngine from "@acodeninja/persist/engine/http";
+import HTTPStorageEngine from "@acodeninja/persist/engine/storage/http";
 
-Persist.addEngine('remote', HTTPEngine, {
+Persist.addEngine('remote', HTTPStorageEngine, {
     host: 'https://api.example.com',
     fetch: fetch.bind(window),
 });

package/docs/search-queries.md

@@ -37,9 +37,9 @@ To search for any `Person` who lives on station road, the following search query
 ```javascript
 import Persist from "@acodeninja/persist";
 import Person from "./Person";
-import FileEngine from "@acodeninja/persist/engine/file"
+import FileStorageEngine from "@acodeninja/persist/engine/storage/file"
 
-FileEngine
+FileStorageEngine
     .configure(configuration)
     .search(Person, 'station road');
 ```

package/docs/storage-engines.md

@@ -2,15 +2,15 @@
 
 Persist makes several storage engines available for use with the library
 
-## Filesystem Storage Engine
+## Filesystem Storage StorageEngine
 
 To store models using the local file system, use the `File` storage engine.
 
 ```javascript
 import Persist from "@acodeninja/persist";
-import FileEngine from "@acodeninja/persist/engine/file";
+import FileStorageEngine from "@acodeninja/persist/engine/storage/file";
 
-Persist.addEngine('local', FileEngine, {
+Persist.addEngine('local', FileStorageEngine, {
     path: '/app/storage',
 });
 
@@ -18,18 +18,18 @@ export class Tag extends Persist.Type.Model {
     static tag = Persist.Type.String.required;
 }
 
-await Persist.getEngine('local', FileEngine).put(new Tag({tag: 'documentation'}));
+await Persist.getEngine('local', FileStorageEngine).put(new Tag({tag: 'documentation'}));
 ```
 
-## HTTP Storage Engine
+## HTTP Storage StorageEngine
 
 To store models using an HTTP server, use the `HTTP` storage engine. When using the `HTTP` engine in the browser, refer to [code quirks](./code-quirks.md#using-http-engine-in-browser).
 
 ```javascript
 import Persist from "@acodeninja/persist";
-import HTTPEngine from "@acodeninja/persist/engine/http";
+import HTTPStorageEngine from "@acodeninja/persist/engine/storage/http";
 
-Persist.addEngine('remote', HTTPEngine, {
+Persist.addEngine('remote', HTTPStorageEngine, {
     host: 'https://api.example.com',
 });
 
@@ -37,18 +37,18 @@ export class Tag extends Persist.Type.Model {
     static tag = Persist.Type.String.required;
 }
 
-await Persist.getEngine('remote', HTTPEngine).put(new Tag({tag: 'documentation'}));
+await Persist.getEngine('remote', HTTPStorageEngine).put(new Tag({tag: 'documentation'}));
 ```
 
-## S3 Storage Engine
+## S3 Storage StorageEngine
 
 To store models using an S3 Bucket, use the `S3` storage engine. To use the `S3` engine you must also add the `@aws-sdk/client-s3` dependency to your `package.json` file.
 
 ```javascript
 import Persist from "@acodeninja/persist";
-import S3Engine from "@acodeninja/persist/engine/s3";
+import S3StorageEngine from "@acodeninja/persist/engine/storage/s3";
 
-Persist.addEngine('remote', S3Engine, {
+Persist.addEngine('remote', S3StorageEngine, {
     bucket: 'test-bucket',
     client: new S3Client(),
 });
@@ -57,5 +57,5 @@ export class Tag extends Persist.Type.Model {
     static tag = Persist.Type.String.required;
 }
 
-await Persist.getEngine('remote', S3Engine).put(new Tag({tag: 'documentation'}));
+await Persist.getEngine('remote', S3StorageEngine).put(new Tag({tag: 'documentation'}));
 ```

package/docs/structured-queries.md

@@ -40,9 +40,9 @@ To query for a `Person` called `Joe Bloggs` an exact query can be written:
 ```javascript
 import Persist from "@acodeninja/persist";
 import Person from "./Person";
-import FileEngine from "@acodeninja/persist/engine/file"
+import FileStorageEngine from "@acodeninja/persist/engine/storage/file"
 
-FileEngine
+FileStorageEngine
     .configure(configuration)
     .find(Person, {
         name: {$is: 'Joe Bloggs'},
@@ -56,9 +56,9 @@ To query for a `Person` with name `Joe` a contains query can be written:
 ```javascript
 import Persist from "@acodeninja/persist";
 import Person from "./Person";
-import FileEngine from "@acodeninja/persist/engine/file"
+import FileStorageEngine from "@acodeninja/persist/engine/storage/file"
 
-FileEngine
+FileStorageEngine
     .configure(configuration)
     .find(Person, {
         name: {$contains: 'Joe'},
@@ -72,9 +72,9 @@ To query for a `Person` who lives at `SW1 1AA` a combination of contains and exa
 ```javascript
 import Persist from "@acodeninja/persist";
 import Person from "./Person";
-import FileEngine from "@acodeninja/persist/engine/file"
+import FileStorageEngine from "@acodeninja/persist/engine/storage/file"
 
-FileEngine
+FileStorageEngine
     .configure(configuration)
     .find(Person, {
         address: {
@@ -92,9 +92,9 @@ To query for anyone called `Joe Bloggs` who lives in the `SW1` postcode area, we
 ```javascript
 import Persist from "@acodeninja/persist";
 import Person from "./Person";
-import FileEngine from "@acodeninja/persist/engine/file"
+import FileStorageEngine from "@acodeninja/persist/engine/storage/file"
 
-FileEngine
+FileStorageEngine
     .configure(configuration)
     .find(Person, {
         name: {$is: 'Joe Bloggs'},

package/docs/transactions.md

@@ -4,9 +4,9 @@ Create transactions to automatically roll back on failure.
 
 ```javascript
 import Persist from "@acodeninja/persist";
-import S3Engine from "@acodeninja/persist/engine/s3";
+import S3StorageEngine from "@acodeninja/persist/engine/storage/s3";
 
-Persist.addEngine('remote', S3Engine, {
+Persist.addEngine('remote', S3StorageEngine, {
     bucket: 'test-bucket',
     client: new S3Client(),
     transactions: true,
@@ -16,7 +16,7 @@ export class Tag extends Persist.Type.Model {
     static tag = Persist.Type.String.required;
 }
 
-const transaction = Persist.getEngine('remote', S3Engine).start();
+const transaction = Persist.getEngine('remote', S3StorageEngine).start();
 
 await transaction.put(new Tag({tag: 'documentation'}));
 await transaction.commit();

package/exports/engine/storage/file.js

@@ -0,0 +1,3 @@
+import FileStorageEngine from '../../../src/engine/storage/FileStorageEngine.js';
+
+export default FileStorageEngine;

package/exports/engine/storage/http.js

@@ -0,0 +1,3 @@
+import HTTPStorageEngine from '../../../src/engine/storage/HTTPStorageEngine.js';
+
+export default HTTPStorageEngine;

package/exports/engine/storage/s3.js

@@ -0,0 +1,3 @@
+import S3StorageEngine from '../../../src/engine/storage/S3StorageEngine.js';
+
+export default S3StorageEngine;

package/jest.config.cjs

@@ -0,0 +1,26 @@
+/** @type {import('jest').Config} */
+const config = {
+    coveragePathIgnorePatterns: [
+        'node_modules',
+        'test/fixtures',
+        'test/mocks',
+        'test/scripts',
+    ],
+    coverageThreshold: {
+        global: {
+            branches: 100,
+            functions: 100,
+            lines: 100,
+            statements: 100,
+        },
+    },
+    testMatch: [
+        '**/*.test.js',
+    ],
+    watchPathIgnorePatterns: [
+        'coverage/',
+        'test/fixtures/minified',
+    ],
+};
+
+module.exports = config;

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@acodeninja/persist",
-  "version": "2.4.1-next.2",
+  "version": "3.0.0-next.2",
   "description": "A JSON based data modelling and persistence module with alternate storage mechanisms.",
   "type": "module",
   "scripts": {
-    "test": "ava",
-    "test:watch": "ava --watch",
-    "test:coverage": "c8 --experimental-monocart --100 --reporter=console-details ava",
-    "test:coverage:report": "c8 --experimental-monocart --100 --lcov --reporter=console-details --reporter=v8 ava",
+    "test": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" npx jest",
+    "test:watch": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" npx jest --watch",
+    "test:coverage": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" npx jest --collect-coverage",
     "lint": "eslint ./",
     "prepare": "husky"
   },
@@ -38,14 +37,12 @@
     "@commitlint/cli": "^19.6.1",
     "@commitlint/config-conventional": "^19.6.0",
     "@eslint/js": "^9.19.0",
+    "@jest/globals": "^29.7.0",
     "@semantic-release/commit-analyzer": "^13.0.1",
-    "ava": "^6.2.0",
-    "c8": "^10.1.3",
     "eslint": "^9.19.0",
     "globals": "^15.14.0",
     "husky": "^9.1.7",
-    "monocart-coverage-reports": "^2.12.0",
-    "semantic-release": "^24.2.1",
-    "sinon": "^19.0.2"
+    "jest": "^29.7.0",
+    "semantic-release": "^24.2.1"
   }
 }

package/src/Query.js

@@ -69,10 +69,10 @@ class Query {
      *
      * @private
      * @param {*} subject - The subject to be matched.
-     * @param {Object} [inputQuery=this.query] - The query to match against. Defaults to `this.query` if not provided.
+     * @param {Object} inputQuery - The query to match against.
      * @returns {boolean} True if the subject matches the query, otherwise false.
      */
-    _matchesQuery(subject, inputQuery = this.query) {
+    _matchesQuery(subject, inputQuery) {
         if (['string', 'number', 'boolean'].includes(typeof inputQuery)) return subject === inputQuery;
 
         if (inputQuery?.$is !== undefined && subject === inputQuery.$is) return true;

package/src/engine/StorageEngine.js

@@ -0,0 +1,250 @@
+import Type from '../type/index.js';
+import _ from 'lodash';
+
+export default class StorageEngine {
+    /**
+     * @param {Object} configuration
+     * @param {Array<Type.Model.constructor>?} models
+     */
+    constructor(configuration = {}, models = null) {
+        this.configuration = configuration;
+        this.models = Object.fromEntries((models ?? []).map(model => [model.name, model]));
+    }
+
+    /**
+     * Persists a model if it has changed, and updates all related models and their indexes
+     * @param {Type.Model} model
+     * @return {Promise<void>}
+     */
+    async put(model) {
+        const processedModels = [];
+        const modelsToPut = [];
+        const modelsToReindex = {};
+
+        /**
+         * @param {Type.Model} modelToProcess
+         * @return {Promise<void>}
+         */
+        const processModel = async (modelToProcess) => {
+            if (processedModels.includes(modelToProcess.id)) return;
+
+            processedModels.push(modelToProcess.id);
+
+            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()));
+
+            if (modelToProcessHasChanged) modelsToPut.push(modelToProcess);
+
+            if (
+                Boolean(modelToProcess.constructor.indexedProperties().length) &&
+                this._indexedFieldsHaveChanged(currentModel, modelToProcess)
+            ) {
+                const modelToProcessConstructor = this.getModelConstructorFromId(modelToProcess.id);
+                modelsToReindex[modelToProcessConstructor] = modelsToReindex[modelToProcessConstructor] || [];
+                modelsToReindex[modelToProcessConstructor].push(modelToProcess);
+            }
+
+            for (const [field, value] of Object.entries(modelToProcess)) {
+                if (Type.Model.isModel(value)) {
+                    await processModel(modelToProcess[field]);
+                }
+            }
+        };
+
+        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 this._putIndex(modelConstructor, {
+                ...index || {},
+                ...Object.fromEntries(models.map(m => [m.id, m.toIndexData()])),
+            });
+        }));
+    }
+
+    /**
+     * 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,
+        );
+    }
+
+    /**
+     * Get a model by its id
+     * @param {string} modelId
+     * @return {Promise<void>}
+     */
+    get(modelId) {
+        try {
+            this.getModelConstructorFromId(modelId);
+        } catch (e) {
+            return Promise.reject(e);
+        }
+        return this._getModel(modelId);
+    }
+
+    /**
+     * Get the model constructor from a model id
+     * @param {string} modelId
+     * @return {Model.constructor}
+     */
+    getModelConstructorFromId(modelId) {
+        const modelName = modelId.split('/')[0];
+        const constructor = this.models[modelName];
+
+        if (!constructor) throw new ModelNotRegisteredStorageEngineError(modelName, this);
+
+        return constructor;
+    }
+
+    /**
+     * Get model classes that are directly linked to the given model in either direction
+     * @param {Type.Model.constructor} model
+     * @return {Record<string, Record<string, Type.Model.constructor>>}
+     */
+    getLinksFor(model) {
+        return Object.fromEntries(
+            Object.entries(this.getAllModelLinks())
+                .filter(([modelName, links]) =>
+                    model.name === modelName ||
+                    Object.values(links).some((link) => link.name === model.name),
+                ),
+        );
+    }
+
+    /**
+     * Get all model links
+     * @return {Record<string, Record<string, Type.Model.constructor>>}
+     */
+    getAllModelLinks() {
+        return Object.entries(this.models)
+            .map(([registeredModelName, registeredModelClass]) =>
+                Object.entries(registeredModelClass)
+                    .map(([propertyName, propertyType]) => [
+                        registeredModelName,
+                        propertyName,
+                        typeof propertyType === 'function' && !Type.Model.isModel(propertyType) ? propertyType() : propertyType,
+                    ])
+                    .filter(([_m, _p, type]) => Type.Model.isModel(type))
+                    .map(([containingModel, propertyName, propertyType]) => ({
+                        containingModel,
+                        propertyName,
+                        propertyType,
+                    })),
+            )
+            .flat()
+            .reduce((accumulator, {containingModel, propertyName, propertyType}) => ({
+                ...accumulator,
+                [containingModel]: {
+                    ...accumulator[containingModel] || {},
+                    [propertyName]: propertyType,
+                },
+            }), {});
+    }
+
+    /**
+     * Update a model
+     * @param {Model} _model
+     * @throws MethodNotImplementedStorageEngineError
+     * @return Promise<void>
+     */
+    _putModel(_model) {
+        return Promise.reject(new MethodNotImplementedStorageEngineError('_putModel', this));
+    }
+
+    /**
+     * Get a model
+     * @param {string} _id
+     * @throws MethodNotImplementedStorageEngineError
+     * @throws ModelNotFoundStorageEngineError
+     * @return Promise<void>
+     */
+    _getModel(_id) {
+        return Promise.reject(new MethodNotImplementedStorageEngineError('_getModel', this));
+    }
+
+    /**
+     * Get a model's index data
+     * @param {Model.constructor} _modelConstructor
+     * @throws MethodNotImplementedStorageEngineError
+     * @return Promise<void>
+     */
+    _getIndex(_modelConstructor) {
+        return Promise.reject(new MethodNotImplementedStorageEngineError('_getIndex', this));
+    }
+
+    /**
+     * Put a model's index data
+     * @param {Model.constructor} _modelConstructor
+     * @param {object} _data
+     * @throws MethodNotImplementedStorageEngineError
+     * @return Promise<void>
+     */
+    _putIndex(_modelConstructor, _data) {
+        return Promise.reject(new MethodNotImplementedStorageEngineError('_putIndex', this));
+    }
+}
+
+/**
+ * @class StorageEngineError
+ * @extends Error
+ */
+export class StorageEngineError extends Error {
+}
+
+/**
+ * @class ModelNotRegisteredStorageEngineError
+ * @extends StorageEngineError
+ */
+export class ModelNotRegisteredStorageEngineError extends StorageEngineError {
+    /**
+     * @param {Type.Model} model
+     * @param {StorageEngine} storageEngine
+     */
+    constructor(model, storageEngine) {
+        const modelName = typeof model === 'string' ? model : model.constructor.name;
+        super(`The model ${modelName} is not registered in the storage engine ${storageEngine.constructor.name}`);
+    }
+}
+
+/**
+ * @class MethodNotImplementedStorageEngineError
+ * @extends StorageEngineError
+ */
+export class MethodNotImplementedStorageEngineError extends StorageEngineError {
+    /**
+     * @param {string} method
+     * @param {StorageEngine} storageEngine
+     */
+    constructor(method, storageEngine) {
+        super(`The method ${method} is not implemented in the storage engine ${storageEngine.constructor.name}`);
+    }
+}
+
+/**
+ * @class ModelNotFoundStorageEngineError
+ * @extends StorageEngineError
+ */
+export class ModelNotFoundStorageEngineError extends StorageEngineError {
+    /**
+     * @param {string} modelId
+     */
+    constructor(modelId) {
+        super(`The model ${modelId} was not found`);
+    }
+}

package/src/engine/{FileEngine.js → storage/FileStorageEngine.js}

@@ -1,35 +1,35 @@
-import Engine, { EngineError, MissConfiguredError } from './Engine.js';
+import StorageEngine, { EngineError, MissConfiguredError } from './StorageEngine.js';
 import { dirname, join } from 'node:path';
 import fs from 'node:fs/promises';
 
 /**
- * Custom error class for FileEngine-related errors.
+ * Custom error class for FileStorageEngine-related errors.
  * Extends the base `EngineError` class.
  */
-class FileEngineError extends EngineError {}
+class FileStorageEngineError extends EngineError {}
 
 /**
- * Error thrown when writing to a file fails in `FileEngine`.
- * Extends the `FileEngineError` class.
+ * Error thrown when writing to a file fails in `FileStorageEngine`.
+ * Extends the `FileStorageEngineError` class.
  */
-class FailedWriteFileEngineError extends FileEngineError {}
+class FailedWriteFileStorageEngineError extends FileStorageEngineError {}
 
 /**
- * `FileEngine` class extends the base `Engine` class to implement
+ * `FileStorageEngine` class extends the base `StorageEngine` class to implement
  * file system-based storage and retrieval of model data.
  *
- * @class FileEngine
- * @extends Engine
+ * @class FileStorageEngine
+ * @extends StorageEngine
  */
-class FileEngine extends Engine {
+class FileStorageEngine extends StorageEngine {
     /**
-     * Configures the FileEngine with a given configuration object.
+     * Configures the FileStorageEngine with a given configuration object.
      * Adds default `filesystem` configuration if not provided.
      *
-     * @param {Object} configuration - Configuration settings for FileEngine.
+     * @param {Object} configuration - Configuration settings for FileStorageEngine.
      * @param {Object} [configuration.filesystem] - Custom filesystem module (default: Node.js fs/promises).
      * @param {Object} [configuration.path] - The absolute path on the filesystem to write models to.
-     * @returns {FileEngine} A configured instance of FileEngine.
+     * @returns {FileStorageEngine} A configured instance of FileStorageEngine.
      */
     static configure(configuration) {
         if (!configuration.filesystem) {
@@ -39,7 +39,7 @@ class FileEngine extends Engine {
     }
 
     /**
-     * Checks if the FileEngine has been configured correctly.
+     * Checks if the FileStorageEngine has been configured correctly.
      * Ensures that `path` and `filesystem` settings are present.
      *
      * @throws {MissConfiguredError} Throws if required configuration is missing.
@@ -94,7 +94,7 @@ class FileEngine extends Engine {
      * Saves a model to the file system.
      *
      * @param {Model} model - The model to save.
-     * @throws {FailedWriteFileEngineError} Throws if the model cannot be written to the file system.
+     * @throws {FailedWriteFileStorageEngineError} Throws if the model cannot be written to the file system.
      */
     static async putModel(model) {
         const filePath = join(this.configuration.path, `${model.id}.json`);
@@ -102,7 +102,7 @@ class FileEngine extends Engine {
             await this.configuration.filesystem.mkdir(dirname(filePath), { recursive: true });
             await this.configuration.filesystem.writeFile(filePath, JSON.stringify(model.toData()));
         } catch (error) {
-            throw new FailedWriteFileEngineError(`Failed to put file://${filePath}`, error);
+            throw new FailedWriteFileStorageEngineError(`Failed to put file://${filePath}`, error);
         }
     }
 
@@ -110,9 +110,16 @@ class FileEngine extends Engine {
      * Saves the index for multiple models to the file system.
      *
      * @param {Object} index - An object where keys are locations and values are key value pairs of models and their ids.
-     * @throws {FailedWriteFileEngineError} Throws if the index cannot be written to the file system.
+     * @throws {FailedWriteFileStorageEngineError} Throws if the index cannot be written to the file system.
      */
     static async putIndex(index) {
+        /**
+         * Process an index of models
+         * @param {string} location
+         * @param {Array<Model>} models
+         * @throws FailedWriteFileStorageEngineError
+         * @return {Promise<void>}
+         */
         const processIndex = async (location, models) => {
             const filePath = join(this.configuration.path, location, '_index.json');
             const currentIndex = JSON.parse((await this.configuration.filesystem.readFile(filePath).catch(() => '{}')).toString());
@@ -125,7 +132,7 @@ class FileEngine extends Engine {
                     ),
                 }));
             } catch (error) {
-                throw new FailedWriteFileEngineError(`Failed to put file://${filePath}`, error);
+                throw new FailedWriteFileStorageEngineError(`Failed to put file://${filePath}`, error);
             }
         };
 
@@ -175,14 +182,14 @@ class FileEngine extends Engine {
      *
      * @param {Model.constructor} model - The model for which the compiled search index is saved.
      * @param {Object} compiledIndex - The compiled search index to save.
-     * @throws {FailedWriteFileEngineError} Throws if the compiled index cannot be written to the file system.
+     * @throws {FailedWriteFileStorageEngineError} Throws if the compiled index cannot be written to the file system.
      */
     static async putSearchIndexCompiled(model, compiledIndex) {
         const filePath = join(this.configuration.path, model.toString(), '_search_index.json');
         try {
             await this.configuration.filesystem.writeFile(filePath, JSON.stringify(compiledIndex));
         } catch (error) {
-            throw new FailedWriteFileEngineError(`Failed to put file://${filePath}`, error);
+            throw new FailedWriteFileStorageEngineError(`Failed to put file://${filePath}`, error);
         }
     }
 
@@ -191,16 +198,16 @@ class FileEngine extends Engine {
      *
      * @param {Model.constructor} model - The model for which the raw search index is saved.
      * @param {Object} rawIndex - The raw search index to save.
-     * @throws {FailedWriteFileEngineError} Throws if the raw index cannot be written to the file system.
+     * @throws {FailedWriteFileStorageEngineError} Throws if the raw index cannot be written to the file system.
      */
     static async putSearchIndexRaw(model, rawIndex) {
         const filePath = join(this.configuration.path, model.toString(), '_search_index_raw.json');
         try {
             await this.configuration.filesystem.writeFile(filePath, JSON.stringify(rawIndex));
         } catch (error) {
-            throw new FailedWriteFileEngineError(`Failed to put file://${filePath}`, error);
+            throw new FailedWriteFileStorageEngineError(`Failed to put file://${filePath}`, error);
         }
     }
 }
 
-export default FileEngine;
+export default FileStorageEngine;

package/src/engine/{HTTPEngine.js → storage/HTTPStorageEngine.js}

@@ -1,22 +1,22 @@
-import Engine, {EngineError, MissConfiguredError} from './Engine.js';
+import StorageEngine, {EngineError, MissConfiguredError} from './StorageEngine.js';
 
 /**
  * Represents an error specific to HTTP engine operations.
- * @class HTTPEngineError
+ * @class HTTPStorageEngineError
  * @extends EngineError
  */
-export class HTTPEngineError extends EngineError {}
+export class HTTPStorageEngineError extends EngineError {}
 
 /**
  * Error indicating a failed HTTP request.
  * @class HTTPRequestFailedError
- * @extends HTTPEngineError
+ * @extends HTTPStorageEngineError
  *
  * @param {string} url - The URL of the failed request.
  * @param {Object} options - The options used in the fetch request.
  * @param {Response} response - The HTTP response object.
  */
-export class HTTPRequestFailedError extends HTTPEngineError {
+export class HTTPRequestFailedError extends HTTPStorageEngineError {
     constructor(url, options, response) {
         const method = options.method?.toLowerCase() || 'get';
         super(`Failed to ${method} ${url}`);
@@ -27,13 +27,13 @@ export class HTTPRequestFailedError extends HTTPEngineError {
 }
 
 /**
- * HTTPEngine is an extension of the Engine class that provides methods for interacting with HTTP-based APIs.
+ * HTTPStorageEngine is an extension of the StorageEngine class that provides methods for interacting with HTTP-based APIs.
  * It uses the Fetch API for sending and receiving data.
  *
- * @class HTTPEngine
- * @extends Engine
+ * @class HTTPStorageEngine
+ * @extends StorageEngine
  */
-class HTTPEngine extends Engine {
+class HTTPStorageEngine extends StorageEngine {
 
     /**
      * Configures the HTTP engine with additional fetch options.
@@ -186,6 +186,12 @@ class HTTPEngine extends Engine {
      * @throws {HTTPRequestFailedError} Thrown if the PUT request fails.
      */
     static async putIndex(index) {
+        /**
+         * Process an index of models
+         * @param {string} location
+         * @param {Array<Model>} models
+         * @return {Promise<void>}
+         */
         const processIndex = async (location, models) => {
             const url = new URL([
                 this.configuration.host,
@@ -315,4 +321,4 @@ class HTTPEngine extends Engine {
     }
 }
 
-export default HTTPEngine;
+export default HTTPStorageEngine;

package/src/engine/{S3Engine.js → storage/S3StorageEngine.js}

@@ -1,28 +1,28 @@
 import {DeleteObjectCommand, GetObjectCommand, PutObjectCommand} from '@aws-sdk/client-s3';
-import Engine, {EngineError, MissConfiguredError} from './Engine.js';
+import StorageEngine, {EngineError, MissConfiguredError} from './StorageEngine.js';
 
 /**
  * Represents an error specific to the S3 engine operations.
- * @class S3EngineError
+ * @class S3StorageEngineError
  * @extends EngineError
  */
-class S3EngineError extends EngineError {}
+class S3StorageEngineError extends EngineError {}
 
 /**
  * Error indicating a failure when putting an object to S3.
- * @class FailedPutS3EngineError
- * @extends S3EngineError
+ * @class FailedPutS3StorageEngineError
+ * @extends S3StorageEngineError
  */
-class FailedPutS3EngineError extends S3EngineError {}
+class FailedPutS3StorageEngineError extends S3StorageEngineError {}
 
 /**
- * S3Engine is an extension of the Engine class that provides methods for interacting with AWS S3.
+ * S3StorageEngine is an extension of the StorageEngine class that provides methods for interacting with AWS S3.
  * It allows for storing, retrieving, and managing model data in an S3 bucket.
  *
- * @class S3Engine
- * @extends Engine
+ * @class S3StorageEngine
+ * @extends StorageEngine
  */
-class S3Engine extends Engine {
+class S3StorageEngine extends StorageEngine {
     /**
      * Configures the S3 engine with additional options.
      *
@@ -92,7 +92,7 @@ class S3Engine extends Engine {
      * @param {Model} model - The model object to upload.
      * @returns {Promise<void>}
      *
-     * @throws {FailedPutS3EngineError} Thrown if there is an error during the S3 PutObject operation.
+     * @throws {FailedPutS3StorageEngineError} Thrown if there is an error during the S3 PutObject operation.
      */
     static async putModel(model) {
         const Key = [this.configuration.prefix, `${model.id}.json`].join('/');
@@ -105,7 +105,7 @@ class S3Engine extends Engine {
                 ContentType: 'application/json',
             }));
         } catch (error) {
-            throw new FailedPutS3EngineError(`Failed to put s3://${this.configuration.bucket}/${Key}`, error);
+            throw new FailedPutS3StorageEngineError(`Failed to put s3://${this.configuration.bucket}/${Key}`, error);
         }
     }
 
@@ -133,9 +133,16 @@ class S3Engine extends Engine {
      *
      * @param {Object} index - An object where keys are locations and values are key value pairs of models and their ids.
      * @returns {Promise<void>}
-     * @throws {FailedPutS3EngineError} Thrown if there is an error during the S3 PutObject operation.
+     * @throws {FailedPutS3StorageEngineError} Thrown if there is an error during the S3 PutObject operation.
      */
     static async putIndex(index) {
+        /**
+         * Process an index of models
+         * @param {string} location
+         * @param {Array<Model>} models
+         * @throws FailedPutS3StorageEngineError
+         * @return {Promise<void>}
+         */
         const processIndex = async (location, models) => {
             const Key = [this.configuration.prefix, location, '_index.json'].filter(e => Boolean(e)).join('/');
             const currentIndex = await this.getIndex(location);
@@ -153,7 +160,7 @@ class S3Engine extends Engine {
                     }),
                 }));
             } catch (error) {
-                throw new FailedPutS3EngineError(`Failed to put s3://${this.configuration.bucket}/${Key}`, error);
+                throw new FailedPutS3StorageEngineError(`Failed to put s3://${this.configuration.bucket}/${Key}`, error);
             }
         };
 
@@ -205,7 +212,7 @@ class S3Engine extends Engine {
      * @param {Object} compiledIndex - The compiled search index data.
      * @returns {Promise<void>}
      *
-     * @throws {FailedPutS3EngineError} Thrown if there is an error during the S3 PutObject operation.
+     * @throws {FailedPutS3StorageEngineError} Thrown if there is an error during the S3 PutObject operation.
      */
     static async putSearchIndexCompiled(model, compiledIndex) {
         const Key = [this.configuration.prefix, model.toString(), '_search_index.json'].join('/');
@@ -218,7 +225,7 @@ class S3Engine extends Engine {
                 ContentType: 'application/json',
             }));
         } catch (error) {
-            throw new FailedPutS3EngineError(`Failed to put s3://${this.configuration.bucket}/${Key}`, error);
+            throw new FailedPutS3StorageEngineError(`Failed to put s3://${this.configuration.bucket}/${Key}`, error);
         }
     }
 
@@ -229,7 +236,7 @@ class S3Engine extends Engine {
      * @param {Object} rawIndex - The raw search index data.
      * @returns {Promise<void>}
      *
-     * @throws {FailedPutS3EngineError} Thrown if there is an error during the S3 PutObject operation.
+     * @throws {FailedPutS3StorageEngineError} Thrown if there is an error during the S3 PutObject operation.
      */
     static async putSearchIndexRaw(model, rawIndex) {
         const Key = [this.configuration.prefix, model.toString(), '_search_index_raw.json'].join('/');
@@ -242,9 +249,9 @@ class S3Engine extends Engine {
                 ContentType: 'application/json',
             }));
         } catch (error) {
-            throw new FailedPutS3EngineError(`Failed to put s3://${this.configuration.bucket}/${Key}`, error);
+            throw new FailedPutS3StorageEngineError(`Failed to put s3://${this.configuration.bucket}/${Key}`, error);
         }
     }
 }
 
-export default S3Engine;
+export default S3StorageEngine;

package/src/engine/{Engine.js → storage/StorageEngine.js}

@@ -1,14 +1,14 @@
-import Query from '../Query.js';
-import Type from '../type/index.js';
+import Query from '../../Query.js';
+import Type from '../../type/index.js';
 import lunr from 'lunr';
 
 /**
- * The `Engine` class provides a base interface for implementing data storage and retrieval engines.
+ * The `StorageEngine` class provides a base interface for implementing data storage and retrieval engines.
  * It includes methods for handling models, indexes, and search functionality.
  *
- * @class Engine
+ * @class StorageEngine
  */
-class Engine {
+class StorageEngine {
     static configuration = undefined;
     static _searchCache = undefined;
 
@@ -186,6 +186,11 @@ class Engine {
         const uploadedModels = [];
         const indexUpdates = {};
 
+        /**
+         * Process a model, putting updates to the model and all linked models.
+         * @param {Model} m
+         * @return {Promise<void>}
+         */
         const processModel = async (m) => {
             if (!uploadedModels.includes(m.id)) {
                 m.validate();
@@ -389,6 +394,11 @@ class Engine {
         this.checkConfiguration();
         const hydratedModels = {};
 
+        /**
+         * Hydrate a model
+         * @param {Model} modelToProcess
+         * @return {Promise<Model>}
+         */
         const hydrateModel = async (modelToProcess) => {
             hydratedModels[modelToProcess.id] = modelToProcess;
 
@@ -405,6 +415,13 @@ class Engine {
             return modelToProcess;
         };
 
+        /**
+         * Hydrate a dry sub model
+         * @param property
+         * @param modelToProcess
+         * @param name
+         * @return {Promise<Model>}
+         */
         const hydrateSubModel = async (property, modelToProcess, name) => {
             if (hydratedModels[property.id]) {
                 return hydratedModels[property.id];
@@ -418,6 +435,13 @@ class Engine {
             return hydratedSubModel;
         };
 
+        /**
+         * Hydrate an array of dry models
+         * @param property
+         * @param modelToProcess
+         * @param name
+         * @return {Promise<Awaited<*>[]>}
+         */
         const hydrateModelList = async (property, modelToProcess, name) => {
             const subModelClass = getSubModelClass(modelToProcess, name, true);
 
@@ -440,6 +464,13 @@ class Engine {
             }));
         };
 
+        /**
+         * Get the class of a sub model
+         * @param modelToProcess
+         * @param name
+         * @param isArray
+         * @return {Model.constructor|Type}
+         */
         function getSubModelClass(modelToProcess, name, isArray = false) {
             const constructorField = modelToProcess.constructor[name];
 
@@ -457,9 +488,13 @@ class Engine {
      * Configures the engine with specific settings.
      *
      * @param {Object} configuration - The configuration settings for the engine.
-     * @returns {Engine} A new engine instance with the applied configuration.
+     * @returns {StorageEngine} A new engine instance with the applied configuration.
      */
     static configure(configuration) {
+        /**
+         * @class ConfiguredStore
+         * @extends StorageEngine
+         */
         class ConfiguredStore extends this {
             static configuration = configuration;
         }
@@ -476,7 +511,7 @@ class Engine {
      * @abstract
      */
     static checkConfiguration() {
-        // Implemented in extending Engine class
+        // Implemented in extending StorageEngine class
     }
 
     /**
@@ -568,9 +603,9 @@ export class MissConfiguredError extends EngineError {
      * @param {Object} configuration - The configuration object that caused the misconfiguration.
      */
     constructor(configuration) {
-        super('Engine is miss-configured');
+        super('StorageEngine is miss-configured');
         this.configuration = configuration;
     }
 }
 
-export default Engine;
+export default StorageEngine;

package/src/type/index.js

@@ -15,23 +15,18 @@ import StringType from './simple/StringType.js';
  * @property {DateType} Date
  * @property {ArrayType} Array
  * @property {CustomType} Custom
- * @property {ResolvedType} Resolved
+ * @property {{Slug: SlugType}} Resolved
  * @property {Model} Model
  */
-const Type = {};
-
-Type.String = StringType;
-Type.Number = NumberType;
-Type.Boolean = BooleanType;
-Type.Date = DateType;
-Type.Array = ArrayType;
-Type.Custom = CustomType;
-
-/**
- * @class ResolvedType
- * @property {SlugType} Slug
- */
-Type.Resolved = {Slug: SlugType};
-Type.Model = Model;
+class Type {
+    static Model = Model;
+    static String = StringType;
+    static Number = NumberType;
+    static Boolean = BooleanType;
+    static Date = DateType;
+    static Array = ArrayType;
+    static Custom = CustomType;
+    static Resolved = {Slug: SlugType};
+}
 
 export default Type;

package/src/type/simple/BooleanType.js

@@ -1,15 +1,15 @@
-import SimpleType from './SimpleType.js';
+import Type from '../Type.js';
 
 /**
  * Class representing a boolean type.
  *
  * This class is used to define and handle data of the boolean type.
- * It extends the {@link SimpleType} class to represent string-specific behavior.
+ * It extends the {@link Type} class to represent string-specific behavior.
  *
  * @class BooleanType
- * @extends SimpleType
+ * @extends Type
  */
-class BooleanType extends SimpleType {
+class BooleanType extends Type {
     static {
         /**
          * @static

package/src/type/simple/DateType.js

@@ -1,15 +1,15 @@
-import SimpleType from './SimpleType.js';
+import Type from '../Type.js';
 
 /**
  * Class representing a date type with ISO date-time format.
  *
  * This class is used to define and handle data of the date type.
- * It extends the {@link SimpleType} class to represent string-specific behavior.
+ * It extends the {@link Type} class to represent string-specific behavior.
  *
  * @class DateType
- * @extends SimpleType
+ * @extends Type
  */
-class DateType extends SimpleType {
+class DateType extends Type {
     static {
         /**
          * @static

package/src/type/simple/NumberType.js

@@ -1,15 +1,15 @@
-import SimpleType from './SimpleType.js';
+import Type from '../Type.js';
 
 /**
  * Class representing a number type.
  *
  * This class is used to define and handle data of the number type.
- * It extends the {@link SimpleType} class to represent string-specific behavior.
+ * It extends the {@link Type} class to represent string-specific behavior.
  *
  * @class NumberType
- * @extends SimpleType
+ * @extends Type
  */
-class NumberType extends SimpleType {
+class NumberType extends Type {
     static {
         /**
          * @static

package/src/type/simple/StringType.js

@@ -1,15 +1,15 @@
-import SimpleType from './SimpleType.js';
+import Type from '../Type.js';
 
 /**
  * Class representing a string type.
  *
  * This class is used to define and handle data of the string type.
- * It extends the {@link SimpleType} class to represent string-specific behavior.
+ * It extends the {@link Type} class to represent string-specific behavior.
  *
  * @class StringType
- * @extends SimpleType
+ * @extends Type
  */
-class StringType extends SimpleType {
+class StringType extends Type {
     static {
         /**
          * @static

package/exports/engine/file.js

@@ -1,3 +0,0 @@
-import FileEngine from '../../src/engine/FileEngine.js';
-
-export default FileEngine;

package/exports/engine/http.js

@@ -1,3 +0,0 @@
-import HTTPEngine from '../../src/engine/HTTPEngine.js';
-
-export default HTTPEngine;

package/exports/engine/s3.js

@@ -1,3 +0,0 @@
-import S3Engine from '../../src/engine/S3Engine.js';
-
-export default S3Engine;

package/src/type/simple/SimpleType.js

@@ -1,14 +0,0 @@
-import Type from '../Type.js';
-
-/**
- * Class representing a simple type.
- *
- * This serves as a base class for primitive or simple types such as string, number, or boolean.
- *
- * @class SimpleType
- * @extends Type
- */
-class SimpleType extends Type {
-}
-
-export default SimpleType;