@acodeninja/persist 1.1.0 → 2.1.0

package/README.md

@@ -17,6 +17,7 @@ export class SimpleModel extends Persist.Type.Model {
     static boolean = Persist.Type.Boolean;
     static string = Persist.Type.String;
     static number = Persist.Type.Number;
+    static date = Persist.Type.Date;
 }
 ```
 
@@ -29,6 +30,7 @@ export class SimpleModel extends Persist.Type.Model {
     static requiredBoolean = Persist.Type.Boolean.required;
     static requiredString = Persist.Type.String.required;
     static requiredNumber = Persist.Type.Number.required;
+    static requiredDate = Persist.Type.Date.required;
 }
 ```
 
@@ -41,6 +43,11 @@ export class SimpleModel extends Persist.Type.Model {
     static arrayOfBooleans = Persist.Type.Array.of(Type.Boolean);
     static arrayOfStrings = Persist.Type.Array.of(Type.String);
     static arrayOfNumbers = Persist.Type.Array.of(Type.Number);
+    static arrayOfDates = Persist.Type.Array.of(Type.Date);
+    static requiredArrayOfBooleans = Persist.Type.Array.of(Type.Boolean).required;
+    static requiredArrayOfStrings = Persist.Type.Array.of(Type.String).required;
+    static requiredArrayOfNumbers = Persist.Type.Array.of(Type.Number).required;
+    static requiredArrayOfDates = Persist.Type.Array.of(Type.Date).required;
 }
 ```
 
@@ -144,10 +151,10 @@ export class Tag extends Persist.Type.Model {
 
 const tag = new Tag({tag: 'documentation', description: 'How to use the persist library'});
 
-FileEngine.find(Tag, {tag: 'documentation'});
+await FileEngine.find(Tag, {tag: 'documentation'});
 // [Tag {tag: 'documentation', description: 'How to use the persist library'}]
 
-FileEngine.search(Tag, 'how to');
+await FileEngine.search(Tag, 'how to');
 // [Tag {tag: 'documentation', description: 'How to use the persist library'}]
 ```
 
@@ -169,7 +176,26 @@ export class Tag extends Persist.Type.Model {
   static tag = Persist.Type.String.required;
 }
 
-Persist.getEngine('local', FileEngine).put(new Tag({tag: 'documentation'}));
+await Persist.getEngine('local', FileEngine).put(new Tag({tag: 'documentation'}));
+```
+
+### HTTP Storage Engine
+
+To store models using an S3 Bucket, use the `S3` storage engine.
+
+```javascript
+import Persist from "@acodeninja/persist";
+import HTTPEngine from "@acodeninja/persist/engine/http";
+
+Persist.addEngine('remote', HTTPEngine, {
+  host: 'https://api.example.com',
+});
+
+export class Tag extends Persist.Type.Model {
+  static tag = Persist.Type.String.required;
+}
+
+await Persist.getEngine('remote', HTTPEngine).put(new Tag({tag: 'documentation'}));
 ```
 
 ### S3 Storage Engine
@@ -189,5 +215,29 @@ export class Tag extends Persist.Type.Model {
   static tag = Persist.Type.String.required;
 }
 
-Persist.getEngine('remote', S3Engine).put(new Tag({tag: 'documentation'}));
+await Persist.getEngine('remote', S3Engine).put(new Tag({tag: 'documentation'}));
+```
+
+## Transactions
+
+Create transactions to automatically roll back on failure to update.
+
+```javascript
+import Persist from "@acodeninja/persist";
+import S3Engine from "@acodeninja/persist/engine/s3";
+
+Persist.addEngine('remote', S3Engine, {
+  bucket: 'test-bucket',
+  client: new S3Client(),
+  transactions: true,
+});
+
+export class Tag extends Persist.Type.Model {
+  static tag = Persist.Type.String.required;
+}
+
+const transaction = Persist.getEngine('remote', S3Engine).start();
+
+await transaction.put(new Tag({tag: 'documentation'}));
+await transaction.commit();
 ```

package/exports/engine/http.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acodeninja/persist",
-  "version": "1.1.0",
+  "version": "2.1.0",
   "description": "A JSON based data modelling and persistence module with alternate storage mechanisms.",
   "type": "module",
   "scripts": {
@@ -25,6 +25,7 @@
   "dependencies": {
     "ajv": "^8.16.0",
     "ajv-errors": "^3.0.0",
+    "ajv-formats": "^3.0.1",
     "lunr": "^2.3.9",
     "slugify": "^1.6.6",
     "ulid": "^2.3.0"
@@ -43,7 +44,7 @@
     "globals": "^15.8.0",
     "husky": "^9.1.1",
     "lodash": "^4.17.21",
-    "monocart-coverage-reports": "^2.9.2",
+    "monocart-coverage-reports": "^2.10.2",
     "semantic-release": "^24.0.0",
     "sinon": "^18.0.0"
   }

package/src/Persist.js

@@ -1,4 +1,5 @@
 import Type from '../src/type/index.js';
+import enableTransactions from './Transactions.js';
 
 /**
  * @class Persist
@@ -35,6 +36,9 @@ export default class Persist {
     static addEngine(group, engine, configuration) {
         if (!this._engine[group]) this._engine[group] = {};
 
-        this._engine[group][engine.name] = engine.configure(configuration);
+        this._engine[group][engine.name] =
+            configuration.transactions ?
+                enableTransactions(engine.configure(configuration)) :
+                engine.configure(configuration);
     }
 }

package/src/SchemaCompiler.js

@@ -1,6 +1,7 @@
 import Type from './type/index.js';
 import ajv from 'ajv';
 import ajvErrors from 'ajv-errors';
+import ajvFormats from 'ajv-formats';
 
 /**
  * @class SchemaCompiler
@@ -15,6 +16,7 @@ export default class SchemaCompiler {
         const validation = new ajv({allErrors: true});
 
         ajvErrors(validation);
+        ajvFormats(validation);
 
         const schema = {
             type: 'object',
@@ -58,9 +60,17 @@ export default class SchemaCompiler {
 
             schema.properties[name] = {type: property?._type};
 
+            if (property?._format) {
+                schema.properties[name].format = property._format;
+            }
+
             if (property?._type === 'array') {
                 schema.properties[name].items = {type: property?._items._type};
 
+                if (property?._items?._format) {
+                    schema.properties[name].items.format = property?._items._format;
+                }
+
                 if (Type.Model.isModel(property?._items)) {
                     schema.properties[name].items = {
                         type: 'object',
@@ -102,11 +112,14 @@ export class CompiledSchema {
      * @throws {ValidationError}
      */
     static validate(data) {
-        let inputData = data;
+        let inputData = Object.assign({}, data);
+
         if (Type.Model.isModel(data)) {
             inputData = data.toData();
         }
+
         const valid = this._validator?.(inputData);
+
         if (valid) return valid;
 
         throw new ValidationError(inputData, this._validator.errors);

package/src/Transactions.js

@@ -0,0 +1,67 @@
+class TransactionError extends Error {
+}
+
+export class TransactionCommittedError extends TransactionError {
+    message = 'Transaction was already committed.';
+}
+
+export default function enableTransactions(engine) {
+    class TransactionalEngine extends engine {
+    }
+
+    TransactionalEngine.start = () => {
+        class Transaction extends TransactionalEngine {
+            static transactions = [];
+            static committed = false;
+            static failed = false;
+
+            static async put(model) {
+                this.transactions.push({
+                    hasRun: false,
+                    hasRolledBack: false,
+                    model,
+                });
+            }
+
+            static _checkCommitted() {
+                if (this.committed) throw new TransactionCommittedError();
+            }
+
+            static async commit() {
+                this._checkCommitted();
+
+                try {
+                    for (const [index, {model}] of this.transactions.entries()) {
+                        try {
+                            this.transactions[index].original = await engine.get(model.constructor, model.id);
+                        } catch (_) {
+                            this.transactions[index].original = null;
+                        }
+
+                        await engine.put(model);
+                        this.transactions[index].hasRun = true;
+                    }
+                } catch (e) {
+                    this.committed = true;
+                    this.failed = true;
+                    for (const [index, {original}] of this.transactions.entries()) {
+                        if (original) {
+                            await engine.put(this.transactions[index].original);
+                        }
+                        this.transactions[index].hasRolledBack = true;
+                    }
+                    throw e;
+                }
+
+                this.committed = true;
+                this.failed = false;
+            }
+        }
+
+        return Transaction;
+    };
+
+    Object.defineProperty(TransactionalEngine, 'name', {value: `${engine.toString()}`});
+
+    return TransactionalEngine;
+}

package/src/engine/Engine.js

@@ -40,36 +40,35 @@ export default class Engine {
     }
 
     static async search(model, query) {
-        this._checkConfiguration?.();
-        const index = await this.getSearchIndexCompiled(model);
+        this.checkConfiguration();
 
-        try {
-            const searchIndex = lunr.Index.load(index);
-
-            const results = searchIndex.search(query);
-            const output = [];
-            for (const result of results) {
-                output.push({
-                    ...result,
-                    model: await this.get(model, result.ref),
-                });
-            }
+        const index = await this.getSearchIndexCompiled(model).catch(() => {
+            throw new EngineError(`The model ${model.toString()} does not have a search index available.`);
+        });
+
+        const searchIndex = lunr.Index.load(index);
 
-            return output;
-        } catch (_) {
-            throw new NotImplementedError(`The model ${model.name} does not have a search index available.`);
+        const results = searchIndex.search(`*${query}*`);
+
+        const output = [];
+        for (const result of results) {
+            output.push({
+                ...result,
+                model: await this.get(model, result.ref),
+            });
         }
+
+        return output;
     }
 
     static async find(model, parameters) {
-        this._checkConfiguration?.();
+        this.checkConfiguration();
         const response = await this.findByValue(model, parameters);
-
         return response.map(m => model.fromData(m));
     }
 
     static async put(model) {
-        this._checkConfiguration?.();
+        this.checkConfiguration();
         const uploadedModels = [];
         const indexUpdates = {};
 
@@ -77,9 +76,9 @@ export default class Engine {
             if (uploadedModels.includes(model.id)) return false;
             model.validate();
 
-            uploadedModels.push(model.id);
-
             await this.putModel(model);
+
+            uploadedModels.push(model.id);
             indexUpdates[model.constructor.name] = (indexUpdates[model.constructor.name] ?? []).concat([model]);
 
             if (model.constructor.searchProperties().length > 0) {
@@ -87,6 +86,7 @@ export default class Engine {
                     ...await this.getSearchIndexRaw(model.constructor),
                     [model.id]: model.toSearchData(),
                 };
+
                 await this.putSearchIndexRaw(model.constructor, rawSearchIndex);
 
                 const compiledIndex = lunr(function () {
@@ -121,18 +121,19 @@ export default class Engine {
     }
 
     static async get(model, id) {
-        this._checkConfiguration?.();
-        const found = await this.getById(id);
+        this.checkConfiguration();
 
         try {
+            const found = await this.getById(id);
             return model.fromData(found);
-        } catch (_error) {
-            throw new NotFoundEngineError(`${this.name}.get(${id}) model not found`);
+        } catch (error) {
+            if (error.constructor === NotImplementedError) throw error;
+            throw new NotFoundEngineError(`${this.name}.get(${id}) model not found`, error);
         }
     }
 
     static async hydrate(model) {
-        this._checkConfiguration?.();
+        this.checkConfiguration();
         const hydratedModels = {};
 
         const hydrateModel = async (modelToProcess) => {
@@ -205,12 +206,21 @@ export default class Engine {
         return ConfiguredStore;
     }
 
+    static checkConfiguration() {
+
+    }
+
     static toString() {
         return this.name;
     }
 };
 
 export class EngineError extends Error {
+    underlyingError;
+    constructor(message, error = undefined) {
+        super(message);
+        this.underlyingError = error;
+    }
 }
 
 export class NotFoundEngineError extends EngineError {

package/src/engine/FileEngine.js

@@ -1,7 +1,11 @@
+import Engine, {EngineError, MissConfiguredError} from './Engine.js';
 import {dirname, join} from 'node:path';
-import Engine from './Engine.js';
 import fs from 'node:fs/promises';
 
+class FileEngineError extends EngineError {}
+
+class FailedWriteFileEngineError extends FileEngineError {}
+
 /**
  * @class FileEngine
  * @extends Engine
@@ -14,18 +18,22 @@ export default class FileEngine extends Engine {
         return super.configure(configuration);
     }
 
+    static checkConfiguration() {
+        if (
+            !this._configuration?.path ||
+            !this._configuration?.filesystem
+        ) throw new MissConfiguredError(this._configuration);
+    }
+
     static async getById(id) {
         const filePath = join(this._configuration.path, `${id}.json`);
 
-        try {
-            return JSON.parse(await this._configuration.filesystem.readFile(filePath).then(f => f.toString()));
-        } catch (_) {
-            return null;
-        }
+        return JSON.parse(await this._configuration.filesystem.readFile(filePath).then(f => f.toString()));
     }
 
     static async findByValue(model, parameters) {
         const index = JSON.parse((await this._configuration.filesystem.readFile(join(this._configuration.path, model.name, '_index.json')).catch(() => '{}')).toString());
+
         return Object.values(index)
             .filter((model) =>
                 Object.entries(parameters)
@@ -36,8 +44,12 @@ export default class FileEngine extends Engine {
     static async putModel(model) {
         const filePath = join(this._configuration.path, `${model.id}.json`);
 
-        await this._configuration.filesystem.mkdir(dirname(filePath), {recursive: true});
-        await this._configuration.filesystem.writeFile(filePath, JSON.stringify(model.toData()));
+        try {
+            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);
+        }
     }
 
     static async putIndex(index) {
@@ -46,10 +58,14 @@ export default class FileEngine extends Engine {
             const filePath = join(this._configuration.path, location, '_index.json');
             const currentIndex = JSON.parse((await this._configuration.filesystem.readFile(filePath).catch(() => '{}')).toString());
 
-            await this._configuration.filesystem.writeFile(filePath, JSON.stringify({
-                ...currentIndex,
-                ...modelIndex,
-            }));
+            try {
+                await this._configuration.filesystem.writeFile(filePath, JSON.stringify({
+                    ...currentIndex,
+                    ...modelIndex,
+                }));
+            } catch (error) {
+                throw new FailedWriteFileEngineError(`Failed to put file://${filePath}`, error);
+            }
         };
 
         for (const [location, models] of Object.entries(index)) {
@@ -60,20 +76,34 @@ export default class FileEngine extends Engine {
     }
 
     static async getSearchIndexCompiled(model) {
-        return JSON.parse((await this._configuration.filesystem.readFile(join(this._configuration.path, model.name, '_search_index.json')).catch(() => '{}')).toString());
+        return await this._configuration.filesystem.readFile(join(this._configuration.path, model.name, '_search_index.json'))
+            .then(b => b.toString())
+            .then(JSON.parse);
     }
 
     static async getSearchIndexRaw(model) {
-        return JSON.parse((await this._configuration.filesystem.readFile(join(this._configuration.path, model.name, '_search_index_raw.json')).catch(() => '{}')).toString());
+        return await this._configuration.filesystem.readFile(join(this._configuration.path, model.name, '_search_index_raw.json'))
+            .then(b => b.toString())
+            .then(JSON.parse)
+            .catch(() => ({}));
     }
 
     static async putSearchIndexCompiled(model, compiledIndex) {
         const filePath = join(this._configuration.path, model.name, '_search_index.json');
-        await this._configuration.filesystem.writeFile(filePath, JSON.stringify(compiledIndex));
+
+        try {
+            await this._configuration.filesystem.writeFile(filePath, JSON.stringify(compiledIndex));
+        } catch (error) {
+            throw new FailedWriteFileEngineError(`Failed to put file://${filePath}`, error);
+        }
     }
 
     static async putSearchIndexRaw(model, rawIndex) {
         const filePath = join(this._configuration.path, model.name, '_search_index_raw.json');
-        await this._configuration.filesystem.writeFile(filePath, JSON.stringify(rawIndex));
+        try {
+            await this._configuration.filesystem.writeFile(filePath, JSON.stringify(rawIndex));
+        } catch (error) {
+            throw new FailedWriteFileEngineError(`Failed to put file://${filePath}`, error);
+        }
     }
 }

package/src/engine/HTTPEngine.js

@@ -1,4 +1,17 @@
-import Engine, {MissConfiguredError} from './Engine.js';
+import Engine, {EngineError, MissConfiguredError} from './Engine.js';
+
+export class HTTPEngineError extends EngineError {
+}
+
+export class HTTPRequestFailedError extends HTTPEngineError {
+    constructor(url, options, response) {
+        const method = options.method?.toLowerCase() || 'get';
+        super(`Failed to ${method} ${url}`);
+        this.response = response;
+        this.url = url;
+        this.options = options;
+    }
+}
 
 export default class HTTPEngine extends Engine {
     static configure(configuration = {}) {
@@ -13,7 +26,7 @@ export default class HTTPEngine extends Engine {
         return super.configure(configuration);
     }
 
-    static _checkConfiguration() {
+    static checkConfiguration() {
         if (
             !this._configuration?.host
         ) throw new MissConfiguredError(this._configuration);
@@ -34,19 +47,32 @@ export default class HTTPEngine extends Engine {
         };
     }
 
+    static async _processFetch(url, options, defaultValue = undefined) {
+        return this._configuration.fetch(url, options)
+            .then(response => {
+                if (!response.ok) {
+                    if (defaultValue !== undefined) {
+                        return {json: () => Promise.resolve(defaultValue)};
+                    }
+
+                    throw new HTTPRequestFailedError(url, options, response);
+                }
+
+                return response;
+            })
+            .then(r => r.json());
+    }
+
     static async getById(id) {
-        this._checkConfiguration();
+        this.checkConfiguration();
+
         const url = new URL([
             this._configuration.host,
             this._configuration.prefix,
             `${id}.json`,
         ].filter(e => !!e).join('/'));
 
-        try {
-            return await this._configuration.fetch(url, this._getReadOptions()).then(r => r.json());
-        } catch (_error) {
-            return undefined;
-        }
+        return await this._processFetch(url, this._getReadOptions());
     }
 
     static async findByValue(model, parameters) {
@@ -65,14 +91,10 @@ export default class HTTPEngine extends Engine {
             `${model.id}.json`,
         ].filter(e => !!e).join('/'));
 
-        try {
-            return await this._configuration.fetch(url, {
-                ...this._getWriteOptions(),
-                body: JSON.stringify(model.toData()),
-            }).then(r => r.json());
-        } catch (_error) {
-            return undefined;
-        }
+        return await this._processFetch(url, {
+            ...this._getWriteOptions(),
+            body: JSON.stringify(model.toData()),
+        });
     }
 
     static async putIndex(index) {
@@ -85,19 +107,13 @@ export default class HTTPEngine extends Engine {
                 '_index.json',
             ].filter(e => !!e).join('/'));
 
-            const currentIndex = await this.getIndex(location);
-
-            try {
-                return await this._configuration.fetch(url, {
-                    ...this._getWriteOptions(),
-                    body: JSON.stringify({
-                        ...currentIndex,
-                        ...modelIndex,
-                    }),
-                }).then(r => r.json());
-            } catch (_error) {
-                return undefined;
-            }
+            return await this._processFetch(url, {
+                ...this._getWriteOptions(),
+                body: JSON.stringify({
+                    ...await this.getIndex(location),
+                    ...modelIndex,
+                }),
+            });
         };
 
         for (const [location, models] of Object.entries(index)) {
@@ -108,33 +124,31 @@ export default class HTTPEngine extends Engine {
     }
 
     static async getIndex(location) {
-        const url = new URL(this._configuration.host + '/' + [this._configuration.prefix, location, '_index.json'].filter(e => !!e).join('/'));
+        const url = new URL([this._configuration.host, this._configuration.prefix, location, '_index.json'].filter(e => !!e).join('/'));
 
-        try {
-            return await this._configuration.fetch(url, this._getReadOptions()).then(r => r.json());
-        } catch (_error) {
-            return {};
-        }
+        return await this._processFetch(url, this._getReadOptions(), {});
     }
 
     static async getSearchIndexCompiled(model) {
-        const url = new URL(this._configuration.host + '/' + [this._configuration.prefix].concat([model.name]).concat(['_search_index.json']).join('/'));
+        const url = new URL([
+            this._configuration.host,
+            this._configuration.prefix,
+            model.toString(),
+            '_search_index.json',
+        ].join('/'));
 
-        try {
-            return await this._configuration.fetch(url, this._getReadOptions()).then(r => r.json());
-        } catch (_error) {
-            return {};
-        }
+        return await this._processFetch(url, this._getReadOptions());
     }
 
     static async getSearchIndexRaw(model) {
-        const url = new URL(this._configuration.host + '/' + [this._configuration.prefix].concat([model.name]).concat(['_search_index_raw.json']).join('/'));
+        const url = new URL([
+            this._configuration.host,
+            this._configuration.prefix,
+            model.toString(),
+            '_search_index_raw.json',
+        ].join('/'));
 
-        try {
-            return await this._configuration.fetch(url, this._getReadOptions()).then(r => r.json());
-        } catch (_error) {
-            return {};
-        }
+        return await this._processFetch(url, this._getReadOptions()).catch(() => ({}));
     }
 
     static async putSearchIndexCompiled(model, compiledIndex) {
@@ -145,14 +159,10 @@ export default class HTTPEngine extends Engine {
             '_search_index.json',
         ].filter(e => !!e).join('/'));
 
-        try {
-            return await this._configuration.fetch(url, {
-                ...this._getWriteOptions(),
-                body: JSON.stringify(compiledIndex),
-            }).then(r => r.json());
-        } catch (_error) {
-            return undefined;
-        }
+        return this._processFetch(url, {
+            ...this._getWriteOptions(),
+            body: JSON.stringify(compiledIndex),
+        });
     }
 
     static async putSearchIndexRaw(model, rawIndex) {
@@ -163,13 +173,9 @@ export default class HTTPEngine extends Engine {
             '_search_index_raw.json',
         ].filter(e => !!e).join('/'));
 
-        try {
-            return await this._configuration.fetch(url, {
-                ...this._getWriteOptions(),
-                body: JSON.stringify(rawIndex),
-            }).then(r => r.json());
-        } catch (_error) {
-            return undefined;
-        }
+        return await this._processFetch(url, {
+            ...this._getWriteOptions(),
+            body: JSON.stringify(rawIndex),
+        });
     }
 }

package/src/engine/S3Engine.js

@@ -1,23 +1,32 @@
+import Engine, {EngineError, MissConfiguredError} from './Engine.js';
 import {GetObjectCommand, PutObjectCommand} from '@aws-sdk/client-s3';
-import Engine from './Engine.js';
+
+class S3EngineError extends EngineError {}
+
+class FailedPutS3EngineError extends S3EngineError {}
 
 export default class S3Engine extends Engine {
+    static checkConfiguration() {
+        if (
+            !this._configuration?.bucket ||
+            !this._configuration?.client
+        ) throw new MissConfiguredError(this._configuration);
+    }
+
     static async getById(id) {
         const objectPath = [this._configuration.prefix, `${id}.json`].join('/');
 
-        try {
-            const data = await this._configuration.client.send(new GetObjectCommand({
-                Bucket: this._configuration.bucket,
-                Key: objectPath,
-            }));
-            return JSON.parse(await data.Body.transformToString());
-        } catch (_error) {
-            return undefined;
-        }
+        const data = await this._configuration.client.send(new GetObjectCommand({
+            Bucket: this._configuration.bucket,
+            Key: objectPath,
+        }));
+
+        return JSON.parse(await data.Body.transformToString());
     }
 
     static async findByValue(model, parameters) {
         const index = await this.getIndex(model.name);
+
         return Object.values(index)
             .filter((model) =>
                 Object.entries(parameters)
@@ -28,23 +37,27 @@ export default class S3Engine extends Engine {
     static async putModel(model) {
         const Key = [this._configuration.prefix, `${model.id}.json`].join('/');
 
-        await this._configuration.client.send(new PutObjectCommand({
-            Key,
-            Body: JSON.stringify(model.toData()),
-            Bucket: this._configuration.bucket,
-            ContentType: 'application/json',
-        }));
+        try {
+            await this._configuration.client.send(new PutObjectCommand({
+                Key,
+                Body: JSON.stringify(model.toData()),
+                Bucket: this._configuration.bucket,
+                ContentType: 'application/json',
+            }));
+        } catch (error) {
+            throw new FailedPutS3EngineError(`Failed to put s3://${this._configuration.bucket}/${Key}`, error);
+        }
     }
 
     static async getIndex(location) {
         try {
             const data = await this._configuration.client.send(new GetObjectCommand({
-                Key: [this._configuration.prefix].concat([location]).concat(['_index.json']).filter(e => !!e).join('/'),
+                Key: [this._configuration.prefix, location, '_index.json'].filter(e => !!e).join('/'),
                 Bucket: this._configuration.bucket,
             }));
 
             return JSON.parse(await data.Body.transformToString());
-        } catch (_error) {
+        } catch (_) {
             return {};
         }
     }
@@ -52,19 +65,23 @@ export default class S3Engine extends Engine {
     static async putIndex(index) {
         const processIndex = async (location, models) => {
             const modelIndex = Object.fromEntries(models.map(m => [m.id, m.toIndexData()]));
-            const Key = [this._configuration.prefix].concat([location]).concat(['_index.json']).filter(e => !!e).join('/');
+            const Key = [this._configuration.prefix, location, '_index.json'].filter(e => !!e).join('/');
 
             const currentIndex = await this.getIndex(location);
 
-            await this._configuration.client.send(new PutObjectCommand({
-                Key,
-                Bucket: this._configuration.bucket,
-                ContentType: 'application/json',
-                Body: JSON.stringify({
-                    ...currentIndex,
-                    ...modelIndex,
-                }),
-            }));
+            try {
+                await this._configuration.client.send(new PutObjectCommand({
+                    Key,
+                    Bucket: this._configuration.bucket,
+                    ContentType: 'application/json',
+                    Body: JSON.stringify({
+                        ...currentIndex,
+                        ...modelIndex,
+                    }),
+                }));
+            } catch (error) {
+                throw new FailedPutS3EngineError(`Failed to put s3://${this._configuration.bucket}/${Key}`, error);
+            }
         };
 
         for (const [location, models] of Object.entries(index)) {
@@ -75,50 +92,49 @@ export default class S3Engine extends Engine {
     }
 
     static async getSearchIndexCompiled(model) {
-        try {
-            const data = await this._configuration.client.send(new GetObjectCommand({
-                Key: [this._configuration.prefix].concat([model.name]).concat(['_search_index.json']).join('/'),
-                Bucket: this._configuration.bucket,
-            }));
-
-            return JSON.parse(await data.Body.transformToString());
-        } catch (_error) {
-            return {};
-        }
+        return await this._configuration.client.send(new GetObjectCommand({
+            Key: [this._configuration.prefix, model.name, '_search_index.json'].join('/'),
+            Bucket: this._configuration.bucket,
+        })).then(data => data.Body.transformToString())
+            .then(JSON.parse);
     }
 
     static async getSearchIndexRaw(model) {
-        try {
-            const data = await this._configuration.client.send(new GetObjectCommand({
-                Key: [this._configuration.prefix].concat([model.name]).concat(['_search_index_raw.json']).join('/'),
-                Bucket: this._configuration.bucket,
-            }));
-
-            return JSON.parse(await data.Body.transformToString());
-        } catch (_error) {
-            return {};
-        }
+        return await this._configuration.client.send(new GetObjectCommand({
+            Key: [this._configuration.prefix, model.name, '_search_index_raw.json'].join('/'),
+            Bucket: this._configuration.bucket,
+        })).then(data => data.Body.transformToString())
+            .then(JSON.parse)
+            .catch(() => ({}));
     }
 
     static async putSearchIndexCompiled(model, compiledIndex) {
         const Key = [this._configuration.prefix, model.name, '_search_index.json'].join('/');
 
-        await this._configuration.client.send(new PutObjectCommand({
-            Key,
-            Body: JSON.stringify(compiledIndex),
-            Bucket: this._configuration.bucket,
-            ContentType: 'application/json',
-        }));
+        try {
+            await this._configuration.client.send(new PutObjectCommand({
+                Key,
+                Body: JSON.stringify(compiledIndex),
+                Bucket: this._configuration.bucket,
+                ContentType: 'application/json',
+            }));
+        } catch (error) {
+            throw new FailedPutS3EngineError(`Failed to put s3://${this._configuration.bucket}/${Key}`, error);
+        }
     }
 
     static async putSearchIndexRaw(model, rawIndex) {
         const Key = [this._configuration.prefix, model.name, '_search_index_raw.json'].join('/');
 
-        await this._configuration.client.send(new PutObjectCommand({
-            Key,
-            Body: JSON.stringify(rawIndex),
-            Bucket: this._configuration.bucket,
-            ContentType: 'application/json',
-        }));
+        try {
+            await this._configuration.client.send(new PutObjectCommand({
+                Key,
+                Body: JSON.stringify(rawIndex),
+                Bucket: this._configuration.bucket,
+                ContentType: 'application/json',
+            }));
+        } catch (error) {
+            throw new FailedPutS3EngineError(`Failed to put s3://${this._configuration.bucket}/${Key}`, error);
+        }
     }
 }

package/src/type/Model.js

@@ -93,6 +93,17 @@ export default class Model {
 
         for (const [name, value] of Object.entries(data)) {
             if (this[name]?._resolved) continue;
+
+            if (this[name].name.endsWith('DateType')) {
+                model[name] = new Date(value);
+                continue;
+            }
+
+            if (this[name].name.endsWith('ArrayOf(Date)Type')) {
+                model[name] = data[name].map(d => new Date(d));
+                continue;
+            }
+
             model[name] = value;
         }
 

package/src/type/complex/ArrayType.js

@@ -7,7 +7,7 @@ export default class ArrayType {
             static _items = type;
 
             static toString() {
-                return `ArrayOf(${type})`;
+                return `ArrayOf(${type.toString()})`;
             }
 
             static get required() {
@@ -25,6 +25,8 @@ export default class ArrayType {
             }
         }
 
+        Object.defineProperty(ArrayOf, 'name', {value: `${ArrayOf.toString()}Type`});
+
         return ArrayOf;
     }
 }

package/src/type/index.js

@@ -1,6 +1,7 @@
 import ArrayType from './complex/ArrayType.js';
 import BooleanType from './simple/BooleanType.js';
 import CustomType from './complex/CustomType.js';
+import DateType from './simple/DateType.js';
 import Model from './Model.js';
 import NumberType from './simple/NumberType.js';
 import SlugType from './resolved/SlugType.js';
@@ -11,6 +12,7 @@ const Type = {};
 Type.String = StringType;
 Type.Number = NumberType;
 Type.Boolean = BooleanType;
+Type.Date = DateType;
 Type.Array = ArrayType;
 Type.Custom = CustomType;
 Type.Resolved = {Slug: SlugType};

package/src/type/simple/DateType.js

@@ -0,0 +1,10 @@
+import SimpleType from './SimpleType.js';
+
+export default class DateType extends SimpleType {
+    static _type = 'string';
+    static _format = 'iso-date-time';
+
+    static isDate(possibleDate) {
+        return possibleDate instanceof Date || !isNaN(new Date(possibleDate));
+    }
+}