@acodeninja/persist 1.0.0

package/README.md

@@ -0,0 +1,193 @@
+# @acodeninja/persist
+
+A JSON based data modelling and persistence library with alternate storage mechanisms.
+
+## Models
+
+The `Model` and `Type` classes allow creating representations of data objects
+
+### Defining Models
+
+##### A model using all available basic types
+
+```javascript
+import Persist from "@acodeninja/persist";
+
+export class SimpleModel extends Persist.Type.Model {
+    static boolean = Persist.Type.Boolean;
+    static string = Persist.Type.String;
+    static number = Persist.Type.Number;
+}
+```
+
+##### A simple model using required types
+
+```javascript
+import Persist from "@acodeninja/persist";
+
+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;
+}
+```
+
+##### A simple model using arrays of basic types
+
+```javascript
+import Persist from "@acodeninja/persist";
+
+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);
+}
+```
+
+<details>
+  <summary>Complex relationships are also supported</summary>
+
+#### One-to-One Relationships
+
+##### A one-to-one relationship
+
+```javascript
+import Persist from "@acodeninja/persist";
+
+export class ModelB extends Persist.Type.Model {
+}
+
+export class ModelA extends Persist.Type.Model {
+    static linked = ModelB;
+}
+```
+
+##### A circular one-to-one relationship
+
+```javascript
+import Persist from "@acodeninja/persist";
+
+export class ModelA extends Persist.Type.Model {
+    static linked = () => ModelB;
+}
+
+export class ModelB extends Persist.Type.Model {
+    static linked = ModelA;
+}
+```
+
+#### One-to-Many Relationships
+
+##### A one-to-many relationship
+
+```javascript
+import Persist from "@acodeninja/persist";
+
+export class ModelB extends Persist.Type.Model {
+}
+
+export class ModelA extends Persist.Type.Model {
+    static linked = Persist.Type.Array.of(ModelB);
+}
+```
+
+##### A circular one-to-many relationship
+
+```javascript
+import Persist from "@acodeninja/persist";
+
+export class ModelA extends Persist.Type.Model {
+    static linked = () => Type.Array.of(ModelB);
+}
+
+export class ModelB extends Persist.Type.Model {
+    static linked = ModelA;
+}
+```
+
+#### Many-to-Many Relationships
+
+##### A many-to-many relationship
+
+```javascript
+import Persist from "@acodeninja/persist";
+
+export class ModelA extends Persist.Type.Model {
+    static linked = Persist.Type.Array.of(ModelB);
+}
+
+export class ModelB extends Persist.Type.Model {
+    static linked = Persist.Type.Array.of(ModelA);
+}
+```
+</details>
+
+## Find and Search
+
+Models may expose a `searchProperties()` and `indexProperties()` static method to indicate which 
+fields should be indexed for storage engine `find()` and `search()` methods.
+
+Use `find()` for a low usage exact string match on any indexed attribute of a model.
+
+Use `search()` for a medium usage fuzzy string match on any search indexed attribute of a model.
+
+```javascript
+import Persist from "@acodeninja/persist";
+import FileEngine from "@acodeninja/persist/engine/file";
+
+export class Tag extends Persist.Type.Model {
+    static tag = Persist.Type.String.required;
+    static description = Persist.Type.String;
+    static searchProperties = () => ['tag', 'description'];
+    static indexProperties = () => ['tag'];
+}
+
+const tag = new Tag({tag: 'documentation', description: 'How to use the persist library'});
+
+FileEngine.find(Tag, {tag: 'documentation'});
+// [Tag {tag: 'documentation', description: 'How to use the persist library'}]
+
+FileEngine.search(Tag, 'how to');
+// [Tag {tag: 'documentation', description: 'How to use the persist library'}]
+```
+
+## Storage
+
+### Filesystem Storage Engine
+
+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";
+
+Persist.addEngine('local', FileEngine, {
+  path: '/app/storage',
+});
+
+export class Tag extends Persist.Type.Model {
+  static tag = Persist.Type.String.required;
+}
+
+Persist.getEngine('local', FileEngine).put(new Tag({tag: 'documentation'}));
+```
+
+### S3 Storage Engine
+
+To store models using an S3 Bucket, use the `S3` storage engine.
+
+```javascript
+import Persist from "@acodeninja/persist";
+import S3Engine from "@acodeninja/persist/engine/s3";
+
+Persist.addEngine('remote', S3Engine, {
+  bucket: 'test-bucket',
+  client: new S3Client(),
+});
+
+export class Tag extends Persist.Type.Model {
+  static tag = Persist.Type.String.required;
+}
+
+Persist.getEngine('remote', S3Engine).put(new Tag({tag: 'documentation'}));
+```

package/exports/default.js

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

package/exports/engine/file.js

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

package/exports/engine/s3.js

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

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@acodeninja/persist",
+  "version": "1.0.0",
+  "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",
+    "lint": "eslint ./",
+    "prepare": "husky"
+  },
+  "exports": {
+    ".": "./exports/default.js",
+    "./engine/*": "./exports/engine/*.js"
+  },
+  "repository": {
+    "url": "https://github.com/acodeninja/persist"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "ajv": "^8.16.0",
+    "ajv-errors": "^3.0.0",
+    "lunr": "^2.3.9",
+    "slugify": "^1.6.6",
+    "ulid": "^2.3.0"
+  },
+  "optionalDependencies": {
+    "@aws-sdk/client-s3": "^3.614.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.3.0",
+    "@commitlint/config-conventional": "^19.2.2",
+    "@eslint/js": "^9.6.0",
+    "@semantic-release/commit-analyzer": "^13.0.0",
+    "ava": "^6.1.3",
+    "c8": "^10.1.2",
+    "eslint": "^9.6.0",
+    "globals": "^15.8.0",
+    "husky": "^9.1.1",
+    "lodash": "^4.17.21",
+    "monocart-coverage-reports": "^2.9.2",
+    "semantic-release": "^24.0.0",
+    "sinon": "^18.0.0"
+  }
+}

package/src/Persist.js

@@ -0,0 +1,40 @@
+import Type from '../src/type/index.js';
+
+/**
+ * @class Persist
+ */
+export default class Persist {
+    static _engine = {};
+    /**
+     * @memberof Persist
+     * @type {Type}
+     * @static
+     */
+    static Type = Type;
+
+    /**
+     * @function getEngine
+     * @memberof Persist
+     * @static
+     * @param {string} group - Name of the group containing the engine
+     * @param {Engine} engine - The engine class you wish to retrieve
+     * @return {Engine|null}
+     */
+    static getEngine(group, engine) {
+        return this._engine[group]?.[engine.name] ?? null;
+    }
+
+    /**
+     * @function addEngine
+     * @memberof Persist
+     * @static
+     * @param {string} group - Name of the group containing the engine
+     * @param {Engine} engine - The engine class you wish to configure and add to the group
+     * @param {object?} configuration - The configuration to use with the engine
+     */
+    static addEngine(group, engine, configuration) {
+        if (!this._engine[group]) this._engine[group] = {};
+
+        this._engine[group][engine.name] = engine.configure(configuration);
+    }
+}

package/src/SchemaCompiler.js

@@ -0,0 +1,128 @@
+import Type from './type/index.js';
+import ajv from 'ajv';
+import ajvErrors from 'ajv-errors';
+
+/**
+ * @class SchemaCompiler
+ */
+export default class SchemaCompiler {
+    /**
+     * @method compile
+     * @param {Model|object} rawSchema
+     * @return {CompiledSchema}
+     */
+    static compile(rawSchema) {
+        const validation = new ajv({allErrors: true});
+
+        ajvErrors(validation);
+
+        const schema = {
+            type: 'object',
+            additionalProperties: false,
+            properties: {},
+            required: [],
+        };
+
+        if (Type.Model.isModel(rawSchema)) {
+            schema.required.push('id');
+            schema.properties['id'] = {type: 'string'};
+        }
+
+        for (const [name, type] of Object.entries(rawSchema)) {
+            if (['indexedProperties', 'searchProperties'].includes(name)) continue;
+
+            const property = type instanceof Function && !type.prototype ? type() : type;
+
+            if (property?._required || property?._items?._type?._required)
+                schema.required.push(name);
+
+            if (Type.Model.isModel(property)) {
+                schema.properties[name] = {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['id'],
+                    properties: {
+                        id: {
+                            type: 'string',
+                            pattern: `^${property.toString()}/[A-Z0-9]+$`,
+                        },
+                    },
+                };
+                continue;
+            }
+
+            if (property?._schema) {
+                schema.properties[name] = property._schema;
+                continue;
+            }
+
+            schema.properties[name] = {type: property?._type};
+
+            if (property?._type === 'array') {
+                schema.properties[name].items = {type: property?._items._type};
+
+                if (Type.Model.isModel(property?._items)) {
+                    schema.properties[name].items = {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: ['id'],
+                        properties: {
+                            id: {
+                                type: 'string',
+                                pattern: `^${property?._items.toString()}/[A-Z0-9]+$`,
+                            },
+                        },
+                    };
+                }
+            }
+        }
+
+        class Schema extends CompiledSchema {
+            static _schema = schema;
+            static _validator = validation.compile(schema);
+        }
+
+        return Schema;
+    }
+}
+
+/**
+ * @class CompiledSchema
+ * @property {object} _schema
+ * @property {Function} _validator
+ */
+export class CompiledSchema {
+    static _schema = null;
+    static _validator = null;
+
+    /**
+     * @method validate
+     * @param data
+     * @return {boolean}
+     * @throws {ValidationError}
+     */
+    static validate(data) {
+        let inputData = 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);
+    }
+}
+
+/**
+ * @class ValidationError
+ * @extends Error
+ * @property {object[]} errors
+ * @property {object} data
+ */
+export class ValidationError extends Error {
+    constructor(data, errors) {
+        super('Validation failed');
+        this.errors = errors;
+        this.data = data;
+    }
+}

package/src/engine/Engine.js

@@ -0,0 +1,215 @@
+import Type from '../type/index.js';
+import lunr from 'lunr';
+
+/**
+ * @class Engine
+ */
+export default class Engine {
+    static _configuration = undefined;
+
+    static async getById(_id) {
+        throw new NotImplementedError(`${this.name} must implement .getById()`);
+    }
+
+    static async putModel(_data) {
+        throw new NotImplementedError(`${this.name} must implement .putModel()`);
+    }
+
+    static async putIndex(_index) {
+        throw new NotImplementedError(`${this.name} does not implement .putIndex()`);
+    }
+
+    static async getSearchIndexCompiled(_model) {
+        throw new NotImplementedError(`${this.name} does not implement .getSearchIndexCompiled()`);
+    }
+
+    static async getSearchIndexRaw(_model) {
+        throw new NotImplementedError(`${this.name} does not implement .getSearchIndexRaw()`);
+    }
+
+    static async putSearchIndexCompiled(_model, _compiledIndex) {
+        throw new NotImplementedError(`${this.name} does not implement .putSearchIndexCompiled()`);
+    }
+
+    static async putSearchIndexRaw(_model, _rawIndex) {
+        throw new NotImplementedError(`${this.name} does not implement .putSearchIndexRaw()`);
+    }
+
+    static async findByValue(_model, _parameters) {
+        throw new NotImplementedError(`${this.name} does not implement .findByValue()`);
+    }
+
+    static async search(model, query) {
+        const index = await this.getSearchIndexCompiled(model);
+
+        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),
+                });
+            }
+
+            return output;
+        } catch (_) {
+            throw new NotImplementedError(`The model ${model.name} does not have a search index available.`);
+        }
+    }
+
+    static async find(model, parameters) {
+        const response = await this.findByValue(model, parameters);
+
+        return response.map(m => model.fromData(m));
+    }
+
+    static async put(model) {
+        const uploadedModels = [];
+        const indexUpdates = {};
+
+        const processModel = async (model) => {
+            if (uploadedModels.includes(model.id)) return false;
+            model.validate();
+
+            uploadedModels.push(model.id);
+
+            await this.putModel(model);
+            indexUpdates[model.constructor.name] = (indexUpdates[model.constructor.name] ?? []).concat([model]);
+
+            if (model.constructor.searchProperties().length > 0) {
+                const rawSearchIndex = {
+                    ...await this.getSearchIndexRaw(model.constructor),
+                    [model.id]: model.toSearchData(),
+                };
+                await this.putSearchIndexRaw(model.constructor, rawSearchIndex);
+
+                const compiledIndex = lunr(function () {
+                    this.ref('id')
+
+                    for (const field of model.constructor.searchProperties()) {
+                        this.field(field);
+                    }
+
+                    Object.values(rawSearchIndex).forEach(function (doc) {
+                        this.add(doc);
+                    }, this)
+                });
+
+                await this.putSearchIndexCompiled(model.constructor, compiledIndex);
+            }
+
+            for (const [_, property] of Object.entries(model)) {
+                if (Type.Model.isModel(property)) {
+                    await processModel(property);
+                }
+                if (Array.isArray(property) && Type.Model.isModel(property[0])) {
+                    for (const subModel of property) {
+                        await processModel(subModel);
+                    }
+                }
+            }
+        };
+
+        await processModel(model);
+        await this.putIndex(indexUpdates);
+    }
+
+    static async get(model, id) {
+        const found = await this.getById(id);
+
+        try {
+            return model.fromData(found);
+        } catch (_error) {
+            throw new NotFoundEngineError(`${this.name}.get(${id}) model not found`);
+        }
+    }
+
+    static async hydrate(model) {
+        const hydratedModels = {};
+
+        const hydrateModel = async (modelToProcess) => {
+            hydratedModels[modelToProcess.id] = modelToProcess;
+
+            for (const [name, property] of Object.entries(modelToProcess)) {
+                if (Type.Model.isDryModel(property)) {
+                    modelToProcess[name] = await hydrateSubModel(property, modelToProcess, name);
+                } else if (Array.isArray(property) && Type.Model.isDryModel(property[0])) {
+                    modelToProcess[name] = await hydrateModelList(property, modelToProcess, name);
+                }
+            }
+
+            return modelToProcess;
+        }
+
+        const hydrateSubModel = async (property, modelToProcess, name) => {
+            if (hydratedModels[property.id]) {
+                return hydratedModels[property.id];
+            }
+
+            const subModelClass = getSubModelClass(modelToProcess, name);
+            const subModel = await this.get(subModelClass, property.id);
+
+            const hydratedSubModel = await hydrateModel(subModel);
+            hydratedModels[property.id] = hydratedSubModel;
+            return hydratedSubModel;
+        }
+
+        const hydrateModelList = async (property, modelToProcess, name) => {
+            const subModelClass = getSubModelClass(modelToProcess, name, true);
+
+            const newModelList = await Promise.all(property.map(async subModel => {
+                if (hydratedModels[subModel.id]) {
+                    return hydratedModels[subModel.id];
+                }
+
+                return await this.get(subModelClass, subModel.id);
+            }));
+
+            return await Promise.all(newModelList.map(async subModel => {
+                if (hydratedModels[subModel.id]) {
+                    return hydratedModels[subModel.id];
+                }
+
+                const hydratedSubModel = await hydrateModel(subModel);
+                hydratedModels[hydratedSubModel.id] = hydratedSubModel;
+                return hydratedSubModel;
+            }));
+        }
+
+        function getSubModelClass(modelToProcess, name, isArray = false) {
+            const constructorField = modelToProcess.constructor[name];
+            if (constructorField instanceof Function && !constructorField.prototype) {
+                return isArray ? constructorField()._items : constructorField();
+            }
+            return isArray ? constructorField._items : constructorField;
+        }
+
+        return await hydrateModel(await this.get(model.constructor, model.id));
+    }
+
+    static configure(configuration) {
+        class ConfiguredStore extends this {
+            static _configuration = configuration;
+        }
+
+        Object.defineProperty(ConfiguredStore, 'name', {value: `${this.toString()}`})
+
+        return ConfiguredStore;
+    }
+
+    static toString() {
+        return this.name;
+    }
+};
+
+export class EngineError extends Error {
+}
+
+export class NotFoundEngineError extends EngineError {
+}
+
+export class NotImplementedError extends EngineError {
+}

package/src/engine/FileEngine.js

@@ -0,0 +1,79 @@
+import {dirname, join} from 'node:path';
+import Engine from './Engine.js';
+import fs from 'node:fs/promises';
+
+/**
+ * @class FileEngine
+ * @extends Engine
+ */
+export default class FileEngine extends Engine {
+    static configure(configuration) {
+        if (!configuration.filesystem) {
+            configuration.filesystem = fs;
+        }
+        return super.configure(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;
+        }
+    }
+
+    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)
+                    .some(([name, value]) => model[name] === value),
+            );
+    }
+
+    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()));
+    }
+
+    static async putIndex(index) {
+        const processIndex = async (location, models) => {
+            const modelIndex = Object.fromEntries(models.map(m => [m.id, m.toIndexData()]));
+            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,
+            }));
+        };
+
+        for (const [location, models] of Object.entries(index)) {
+            await processIndex(location, models);
+        }
+
+        await processIndex('', Object.values(index).flat());
+    }
+
+    static async getSearchIndexCompiled(model) {
+        return JSON.parse((await this._configuration.filesystem.readFile(join(this._configuration.path, model.name, '_search_index.json')).catch(() => '{}')).toString());
+    }
+
+    static async getSearchIndexRaw(model) {
+        return JSON.parse((await this._configuration.filesystem.readFile(join(this._configuration.path, model.name, '_search_index_raw.json')).catch(() => '{}')).toString());
+    }
+
+    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));
+    }
+
+    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));
+    }
+}

package/src/engine/S3Engine.js

@@ -0,0 +1,124 @@
+import {GetObjectCommand, PutObjectCommand} from '@aws-sdk/client-s3';
+import Engine from './Engine.js';
+
+export default class S3Engine extends Engine {
+    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;
+        }
+    }
+
+    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 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',
+        }));
+    }
+
+    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('/'),
+                Bucket: this._configuration.bucket,
+            }));
+
+            return JSON.parse(await data.Body.transformToString());
+        } catch (_error) {
+            return {};
+        }
+    }
+
+    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 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,
+                }),
+            }));
+        };
+
+        for (const [location, models] of Object.entries(index)) {
+            await processIndex(location, models);
+        }
+
+        await processIndex(null, Object.values(index).flat());
+    }
+
+    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 {};
+        }
+    }
+
+    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 {};
+        }
+    }
+
+    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',
+        }));
+    }
+
+    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',
+        }));
+    }
+}

package/src/type/Model.js

@@ -0,0 +1,115 @@
+import SchemaCompiler from '../SchemaCompiler.js';
+import StringType from './simple/StringType.js';
+import {monotonicFactory} from 'ulid';
+
+const createID = monotonicFactory();
+
+export default class Model {
+    static id = StringType.required;
+    static _required = false;
+
+    constructor(data = {}) {
+        this.id = `${this.constructor.name}/${createID()}`;
+
+        for (const [key, value] of Object.entries(this.constructor)) {
+            if (data?.[key] !== undefined) {
+                this[key] = data[key];
+            }
+            if (value?._resolved) {
+                Object.defineProperty(this, key, {
+                    get: function () {
+                        return value.resolve(this);
+                    },
+                });
+            }
+        }
+    }
+
+    toData() {
+        const model = {...this};
+
+        for (const [name, property] of Object.entries(this.constructor)) {
+            if (property._resolved) {
+                model[name] = property.resolve(this);
+            }
+        }
+
+        return JSON.parse(JSON.stringify(model, (key, value) => {
+            if (key && this.constructor.isModel(value)) {
+                return {id: value.id};
+            }
+            return value;
+        }));
+    }
+
+    validate() {
+        return SchemaCompiler.compile(this.constructor).validate(this);
+    }
+
+    toIndexData() {
+        const indexData = {id: this.id};
+
+        for (const name of this.constructor.indexedProperties()) {
+            indexData[name] = this[name];
+        }
+
+        return indexData;
+    }
+
+    toSearchData() {
+        const indexData = {id: this.id};
+
+        for (const name of this.constructor.searchProperties()) {
+            indexData[name] = this[name];
+        }
+
+        return indexData;
+    }
+
+    static toString() {
+        return this['name'];
+    }
+
+    static get required() {
+        class Required extends this {
+            static _required = true;
+        }
+
+        Object.defineProperty(Required, 'name', {value: `${this.toString()}`})
+
+        return Required;
+    }
+
+    static indexedProperties() {
+        return [];
+    }
+
+    static searchProperties() {
+        return [];
+    }
+
+    static fromData(data) {
+        const model = new this();
+
+        for (const [name, value] of Object.entries(data)) {
+            if (this[name]?._resolved) continue;
+            model[name] = value;
+        }
+
+        return model;
+    }
+
+    static isModel(possibleModel) {
+        return (
+            possibleModel?.prototype instanceof Model ||
+            possibleModel?.constructor?.prototype instanceof Model
+        );
+    }
+
+    static isDryModel(possibleDryModel) {
+        return (
+            Object.keys(possibleDryModel).includes('id') &&
+            !!possibleDryModel.id.match(/[A-Za-z]+\/[A-Z0-9]+/)
+        );
+    }
+}

package/src/type/Type.js

@@ -0,0 +1,33 @@
+/**
+ * @class Type
+ * @property {string} _type
+ * @property {boolean} _required
+ * @property {boolean} _resolved
+ * @property {map?} _properties
+ * @property {map?} _items
+ * @property {map?} _schema
+ */
+export default class Type {
+    static _required = false;
+    static _resolved = false;
+    static _properties = undefined;
+    static _items = undefined;
+    static _schema = undefined;
+
+    static toString() {
+        return this.name?.replace(/Type$/, '');
+    }
+
+    /**
+     * @return {Type}
+     */
+    static get required() {
+        class Required extends this {
+            static _required = true;
+        }
+
+        Object.defineProperty(Required, 'name', {value: `Required${this.toString()}Type`});
+
+        return Required;
+    }
+}

package/src/type/complex/ArrayType.js

@@ -0,0 +1,30 @@
+import Type from '../Type.js';
+
+export default class ArrayType {
+    static of(type) {
+        class ArrayOf extends Type {
+            static _type = 'array'
+            static _items = type;
+
+            static toString() {
+                return `ArrayOf(${type})`;
+            }
+
+            static get required() {
+                class Required extends this {
+                    static _required = true;
+
+                    static toString() {
+                        return `RequiredArrayOf(${type})`;
+                    }
+                }
+
+                Object.defineProperty(Required, 'name', {value: `Required${this.toString()}Type`})
+
+                return Required;
+            }
+        }
+
+        return ArrayOf;
+    }
+}

package/src/type/complex/CustomType.js

@@ -0,0 +1,15 @@
+import Type from '../Type.js';
+import ajv from 'ajv';
+
+export default class CustomType {
+    static of(schema) {
+        new ajv().compile(schema);
+
+        class Custom extends Type {
+            static _type = 'object';
+            static _schema = schema;
+        }
+
+        return Custom;
+    }
+}

package/src/type/index.js

@@ -0,0 +1,19 @@
+import ArrayType from './complex/ArrayType.js';
+import BooleanType from './simple/BooleanType.js';
+import CustomType from './complex/CustomType.js';
+import Model from './Model.js';
+import NumberType from './simple/NumberType.js';
+import SlugType from './resolved/SlugType.js';
+import StringType from './simple/StringType.js';
+
+const Type = {};
+
+Type.String = StringType;
+Type.Number = NumberType;
+Type.Boolean = BooleanType;
+Type.Array = ArrayType;
+Type.Custom = CustomType;
+Type.Resolved = {Slug: SlugType};
+Type.Model = Model;
+
+export default Type;

package/src/type/resolved/ResolvedType.js

@@ -0,0 +1,19 @@
+import Type from '../Type.js';
+
+export default class ResolvedType extends Type {
+    static _resolved = true;
+
+    static resolve(_model) {
+        throw new Error(`${this.name} does not implement resolve(model)`);
+    }
+
+    static of(property) {
+        class ResolvedTypeOf extends ResolvedType {
+            static toString() {
+                return `ResolvedTypeOf(${property})`;
+            }
+        }
+
+        return ResolvedTypeOf;
+    }
+}

package/src/type/resolved/SlugType.js

@@ -0,0 +1,24 @@
+import ResolvedType from './ResolvedType.js';
+import slugify from 'slugify';
+
+export default class SlugType extends ResolvedType {
+    static of(property) {
+        class SlugOf extends ResolvedType {
+            static _type = 'string'
+
+            static toString() {
+                return `SlugOf(${property})`;
+            }
+
+            static resolve(model) {
+                if (typeof model?.[property] !== 'string') return '';
+
+                return slugify(model?.[property], {
+                    lower: true,
+                });
+            }
+        }
+
+        return SlugOf;
+    }
+}

package/src/type/simple/BooleanType.js

@@ -0,0 +1,5 @@
+import SimpleType from './SimpleType.js';
+
+export default class BooleanType extends SimpleType {
+    static _type = 'boolean';
+}

package/src/type/simple/NumberType.js

@@ -0,0 +1,5 @@
+import SimpleType from './SimpleType.js';
+
+export default class NumberType extends SimpleType {
+    static _type = 'number';
+}

package/src/type/simple/SimpleType.js

@@ -0,0 +1,4 @@
+import Type from '../Type.js';
+
+export default class SimpleType extends Type {
+}

package/src/type/simple/StringType.js

@@ -0,0 +1,5 @@
+import SimpleType from './SimpleType.js';
+
+export default class StringType extends SimpleType {
+    static _type = 'string';
+}