@acodeninja/persist 1.0.0 → 1.1.0

package/package.json

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

package/src/engine/Engine.js

@@ -40,6 +40,7 @@ export default class Engine {
     }
 
     static async search(model, query) {
+        this._checkConfiguration?.();
         const index = await this.getSearchIndexCompiled(model);
 
         try {
@@ -61,12 +62,14 @@ export default class Engine {
     }
 
     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 = {};
 
@@ -87,7 +90,7 @@ export default class Engine {
                 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,6 +121,7 @@ export default class Engine {
     }
 
     static async get(model, id) {
+        this._checkConfiguration?.();
         const found = await this.getById(id);
 
         try {
@@ -128,6 +132,7 @@ export default class Engine {
     }
 
     static async hydrate(model) {
+        this._checkConfiguration?.();
         const hydratedModels = {};
 
         const hydrateModel = async (modelToProcess) => {
@@ -142,7 +147,7 @@ export default class Engine {
             }
 
             return modelToProcess;
-        }
+        };
 
         const hydrateSubModel = async (property, modelToProcess, name) => {
             if (hydratedModels[property.id]) {
@@ -155,7 +160,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 +182,7 @@ export default class Engine {
                 hydratedModels[hydratedSubModel.id] = hydratedSubModel;
                 return hydratedSubModel;
             }));
-        }
+        };
 
         function getSubModelClass(modelToProcess, name, isArray = false) {
             const constructorField = modelToProcess.constructor[name];
@@ -195,7 +200,7 @@ export default class Engine {
             static _configuration = configuration;
         }
 
-        Object.defineProperty(ConfiguredStore, 'name', {value: `${this.toString()}`})
+        Object.defineProperty(ConfiguredStore, 'name', {value: `${this.toString()}`});
 
         return ConfiguredStore;
     }
@@ -213,3 +218,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/HTTPEngine.js

@@ -0,0 +1,175 @@
+import Engine, {MissConfiguredError} from './Engine.js';
+
+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 getById(id) {
+        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;
+        }
+    }
+
+    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('/'));
+
+        try {
+            return await this._configuration.fetch(url, {
+                ...this._getWriteOptions(),
+                body: JSON.stringify(model.toData()),
+            }).then(r => r.json());
+        } catch (_error) {
+            return undefined;
+        }
+    }
+
+    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('/'));
+
+            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;
+            }
+        };
+
+        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('/'));
+
+        try {
+            return await this._configuration.fetch(url, this._getReadOptions()).then(r => r.json());
+        } catch (_error) {
+            return {};
+        }
+    }
+
+    static async getSearchIndexCompiled(model) {
+        const url = new URL(this._configuration.host + '/' + [this._configuration.prefix].concat([model.name]).concat(['_search_index.json']).join('/'));
+
+        try {
+            return await this._configuration.fetch(url, this._getReadOptions()).then(r => r.json());
+        } catch (_error) {
+            return {};
+        }
+    }
+
+    static async getSearchIndexRaw(model) {
+        const url = new URL(this._configuration.host + '/' + [this._configuration.prefix].concat([model.name]).concat(['_search_index_raw.json']).join('/'));
+
+        try {
+            return await this._configuration.fetch(url, this._getReadOptions()).then(r => r.json());
+        } catch (_error) {
+            return {};
+        }
+    }
+
+    static async putSearchIndexCompiled(model, compiledIndex) {
+        const url = new URL([
+            this._configuration.host,
+            this._configuration.prefix,
+            model.name,
+            '_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;
+        }
+    }
+
+    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('/'));
+
+        try {
+            return await this._configuration.fetch(url, {
+                ...this._getWriteOptions(),
+                body: JSON.stringify(rawIndex),
+            }).then(r => r.json());
+        } catch (_error) {
+            return undefined;
+        }
+    }
+}

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})`;