@acodeninja/persist 1.0.0 → 2.0.0

package/README.md

@@ -144,10 +144,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 +169,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 +208,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.0.0",
+  "version": "2.0.0",
   "description": "A JSON based data modelling and persistence module with alternate storage mechanisms.",
   "type": "module",
   "scripts": {
@@ -43,7 +43,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/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,33 +40,35 @@ export default class Engine {
     }
 
     static async search(model, query) {
-        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();
         const response = await this.findByValue(model, parameters);
-
         return response.map(m => model.fromData(m));
     }
 
     static async put(model) {
+        this.checkConfiguration();
         const uploadedModels = [];
         const indexUpdates = {};
 
@@ -74,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) {
@@ -84,10 +86,11 @@ export default class Engine {
                     ...await this.getSearchIndexRaw(model.constructor),
                     [model.id]: model.toSearchData(),
                 };
+
                 await this.putSearchIndexRaw(model.constructor, rawSearchIndex);
 
                 const compiledIndex = lunr(function () {
-                    this.ref('id')
+                    this.ref('id');
 
                     for (const field of model.constructor.searchProperties()) {
                         this.field(field);
@@ -95,7 +98,7 @@ export default class Engine {
 
                     Object.values(rawSearchIndex).forEach(function (doc) {
                         this.add(doc);
-                    }, this)
+                    }, this);
                 });
 
                 await this.putSearchIndexCompiled(model.constructor, compiledIndex);
@@ -118,16 +121,19 @@ export default class Engine {
     }
 
     static async get(model, id) {
-        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();
         const hydratedModels = {};
 
         const hydrateModel = async (modelToProcess) => {
@@ -142,7 +148,7 @@ export default class Engine {
             }
 
             return modelToProcess;
-        }
+        };
 
         const hydrateSubModel = async (property, modelToProcess, name) => {
             if (hydratedModels[property.id]) {
@@ -155,7 +161,7 @@ export default class Engine {
             const hydratedSubModel = await hydrateModel(subModel);
             hydratedModels[property.id] = hydratedSubModel;
             return hydratedSubModel;
-        }
+        };
 
         const hydrateModelList = async (property, modelToProcess, name) => {
             const subModelClass = getSubModelClass(modelToProcess, name, true);
@@ -177,7 +183,7 @@ export default class Engine {
                 hydratedModels[hydratedSubModel.id] = hydratedSubModel;
                 return hydratedSubModel;
             }));
-        }
+        };
 
         function getSubModelClass(modelToProcess, name, isArray = false) {
             const constructorField = modelToProcess.constructor[name];
@@ -195,17 +201,26 @@ export default class Engine {
             static _configuration = configuration;
         }
 
-        Object.defineProperty(ConfiguredStore, 'name', {value: `${this.toString()}`})
+        Object.defineProperty(ConfiguredStore, 'name', {value: `${this.toString()}`});
 
         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 {
@@ -213,3 +228,12 @@ export class NotFoundEngineError extends EngineError {
 
 export class NotImplementedError extends EngineError {
 }
+
+export class MissConfiguredError extends EngineError {
+    configuration;
+
+    constructor(configuration) {
+        super('Engine is miss-configured');
+        this.configuration = configuration;
+    }
+}

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

@@ -0,0 +1,181 @@
+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 = {}) {
+        configuration.fetchOptions = {
+            ...(configuration.fetchOptions ?? {}),
+            headers: {
+                ...(configuration.fetchOptions?.headers ?? {}),
+                Accept: 'application/json',
+            },
+        };
+
+        return super.configure(configuration);
+    }
+
+    static checkConfiguration() {
+        if (
+            !this._configuration?.host
+        ) throw new MissConfiguredError(this._configuration);
+    }
+
+    static _getReadOptions() {
+        return this._configuration.fetchOptions;
+    }
+
+    static _getWriteOptions() {
+        return {
+            ...this._getReadOptions(),
+            headers: {
+                ...this._getReadOptions().headers,
+                'Content-Type': 'application/json',
+            },
+            method: 'PUT',
+        };
+    }
+
+    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();
+
+        const url = new URL([
+            this._configuration.host,
+            this._configuration.prefix,
+            `${id}.json`,
+        ].filter(e => !!e).join('/'));
+
+        return await this._processFetch(url, this._getReadOptions());
+    }
+
+    static async findByValue(model, parameters) {
+        const index = await this.getIndex(model.name);
+        return Object.values(index)
+            .filter((model) =>
+                Object.entries(parameters)
+                    .some(([name, value]) => model[name] === value),
+            );
+    }
+
+    static async putModel(model) {
+        const url = new URL([
+            this._configuration.host,
+            this._configuration.prefix,
+            `${model.id}.json`,
+        ].filter(e => !!e).join('/'));
+
+        return await this._processFetch(url, {
+            ...this._getWriteOptions(),
+            body: JSON.stringify(model.toData()),
+        });
+    }
+
+    static async putIndex(index) {
+        const processIndex = async (location, models) => {
+            const modelIndex = Object.fromEntries(models.map(m => [m.id, m.toIndexData()]));
+            const url = new URL([
+                this._configuration.host,
+                this._configuration.prefix,
+                location,
+                '_index.json',
+            ].filter(e => !!e).join('/'));
+
+            return await this._processFetch(url, {
+                ...this._getWriteOptions(),
+                body: JSON.stringify({
+                    ...await this.getIndex(location),
+                    ...modelIndex,
+                }),
+            });
+        };
+
+        for (const [location, models] of Object.entries(index)) {
+            await processIndex(location, models);
+        }
+
+        await processIndex(null, Object.values(index).flat());
+    }
+
+    static async getIndex(location) {
+        const url = new URL([this._configuration.host, this._configuration.prefix, location, '_index.json'].filter(e => !!e).join('/'));
+
+        return await this._processFetch(url, this._getReadOptions(), {});
+    }
+
+    static async getSearchIndexCompiled(model) {
+        const url = new URL([
+            this._configuration.host,
+            this._configuration.prefix,
+            model.toString(),
+            '_search_index.json',
+        ].join('/'));
+
+        return await this._processFetch(url, this._getReadOptions());
+    }
+
+    static async getSearchIndexRaw(model) {
+        const url = new URL([
+            this._configuration.host,
+            this._configuration.prefix,
+            model.toString(),
+            '_search_index_raw.json',
+        ].join('/'));
+
+        return await this._processFetch(url, this._getReadOptions()).catch(() => ({}));
+    }
+
+    static async putSearchIndexCompiled(model, compiledIndex) {
+        const url = new URL([
+            this._configuration.host,
+            this._configuration.prefix,
+            model.name,
+            '_search_index.json',
+        ].filter(e => !!e).join('/'));
+
+        return this._processFetch(url, {
+            ...this._getWriteOptions(),
+            body: JSON.stringify(compiledIndex),
+        });
+    }
+
+    static async putSearchIndexRaw(model, rawIndex) {
+        const url = new URL([
+            this._configuration.host,
+            this._configuration.prefix,
+            model.name,
+            '_search_index_raw.json',
+        ].filter(e => !!e).join('/'));
+
+        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

@@ -75,7 +75,7 @@ export default class Model {
             static _required = true;
         }
 
-        Object.defineProperty(Required, 'name', {value: `${this.toString()}`})
+        Object.defineProperty(Required, 'name', {value: `${this.toString()}`});
 
         return Required;
     }

package/src/type/complex/ArrayType.js

@@ -3,7 +3,7 @@ import Type from '../Type.js';
 export default class ArrayType {
     static of(type) {
         class ArrayOf extends Type {
-            static _type = 'array'
+            static _type = 'array';
             static _items = type;
 
             static toString() {
@@ -19,7 +19,7 @@ export default class ArrayType {
                     }
                 }
 
-                Object.defineProperty(Required, 'name', {value: `Required${this.toString()}Type`})
+                Object.defineProperty(Required, 'name', {value: `Required${this.toString()}Type`});
 
                 return Required;
             }

package/src/type/resolved/SlugType.js

@@ -4,7 +4,7 @@ import slugify from 'slugify';
 export default class SlugType extends ResolvedType {
     static of(property) {
         class SlugOf extends ResolvedType {
-            static _type = 'string'
+            static _type = 'string';
 
             static toString() {
                 return `SlugOf(${property})`;