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

package/exports/engine/storage/file.js

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

package/exports/engine/storage/http.js

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

package/exports/engine/storage/s3.js

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

package/src/SchemaCompiler.js

@@ -1,192 +0,0 @@
-import Type from './type/index.js';
-import ajv from 'ajv';
-import ajvErrors from 'ajv-errors';
-import ajvFormats from 'ajv-formats';
-
-/**
- * A class responsible for compiling raw schema definitions into a format that can be validated using the AJV (Another JSON Validator) library.
- */
-class SchemaCompiler {
-    /**
-     * Compiles a raw schema into a validation-ready schema, and returns a class that extends `CompiledSchema`.
-     *
-     * This method converts a given schema into a JSON schema-like format, setting up properties, types, formats, and validation rules.
-     * It uses AJV for the validation process and integrates with model types and their specific validation rules.
-     *
-     * @param {Object|Model} rawSchema - The raw schema or model definition to be compiled.
-     * @returns {CompiledSchema} - A class that extends `CompiledSchema`, with the compiled schema and validator attached.
-     *
-     * @example
-     * const schemaClass = SchemaCompiler.compile(MyModelSchema);
-     * const isValid = schemaClass.validate(data); // Throws ValidationError if data is invalid.
-     */
-    static compile(rawSchema) {
-        const validation = new ajv({allErrors: true});
-
-        ajvErrors(validation);
-        ajvFormats(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?._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',
-                        additionalProperties: false,
-                        required: ['id'],
-                        properties: {
-                            id: {
-                                type: 'string',
-                                pattern: `^${property?._items.toString()}/[A-Z0-9]+$`,
-                            },
-                        },
-                    };
-                }
-            }
-        }
-
-        class Schema extends CompiledSchema {
-            /**
-             * The compiled schema definition.
-             * @type {Object}
-             * @static
-             * @private
-             */
-            static _schema = schema;
-
-            /**
-             * The AJV validator function compiled from the schema.
-             * @type {Function}
-             * @static
-             * @private
-             */
-            static _validator = validation.compile(schema);
-        }
-
-        return Schema;
-    }
-}
-
-
-/**
- * Represents a compiled schema used for validating data models.
- * This class provides a mechanism to validate data using a precompiled schema and a validator function.
- */
-export class CompiledSchema {
-    /**
-     * The schema definition for validation, typically a precompiled JSON schema or similar.
-     * @type {?Object}
-     * @static
-     * @private
-     */
-    static _schema = null;
-
-    /**
-     * The validator function used to validate data against the schema.
-     * @type {?Function}
-     * @static
-     * @private
-     */
-    static _validator = null;
-
-    /**
-     * Validates the given data against the compiled schema.
-     *
-     * If the data is an instance of a model, it will be converted to a plain object via `toData()` before validation.
-     *
-     * @param {Object|Model} data - The data or model instance to be validated.
-     * @returns {boolean} - Returns `true` if the data is valid according to the schema.
-     * @throws {ValidationError} - Throws a `ValidationError` if the data is invalid.
-     */
-    static validate(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);
-    }
-}
-
-/**
- * Represents a validation error that occurs when a model or data fails validation.
- * Extends the built-in JavaScript `Error` class.
- */
-export class ValidationError extends Error {
-    /**
-     * Creates an instance of `ValidationError`.
-     *
-     * @param {Object} data - The data that failed validation.
-     * @param {Array<Object>} errors - A list of validation errors, each typically containing details about what failed.
-     */
-    constructor(data, errors) {
-        super('Validation failed');
-        /**
-         * An array of validation errors, containing details about each failed validation.
-         * @type {Array<Object>}
-         */
-        this.errors = errors;
-        /**
-         * The data that caused the validation error.
-         * @type {Object}
-         */
-        this.data = data;
-    }
-}
-
-export default SchemaCompiler;

package/src/Transactions.js

@@ -1,145 +0,0 @@
-/**
- * Class representing a transaction-related error.
- *
- * @class TransactionError
- * @extends Error
- */
-class TransactionError extends Error {
-}
-
-/**
- * Error thrown when a transaction is already committed.
- *
- * @class TransactionCommittedError
- * @extends TransactionError
- */
-export class TransactionCommittedError extends TransactionError {
-    /**
-     * Creates an instance of TransactionCommittedError.
-     * This error is thrown when attempting to commit an already committed transaction.
-     * @property {string} message - The error message.
-     */
-    message = 'Transaction was already committed.';
-}
-
-/**
- * Enables transaction support for the provided engine.
- *
- * This function enhances an engine class with transaction capabilities, allowing multiple
- * changes to be grouped into a single transaction that can be committed or rolled back.
- *
- * @param {Engine.constructor} engine - The base engine class to be enhanced with transaction support.
- * @returns {TransactionalEngine.constructor} TransactionalEngine - The enhanced engine class with transaction functionality.
- */
-export default function enableTransactions(engine) {
-    /**
-     * A class representing an engine with transaction capabilities.
-     * @class TransactionalEngine
-     * @extends {engine}
-     */
-    class TransactionalEngine extends engine {
-    }
-
-    /**
-     * Starts a transaction on the engine. Returns a Transaction class that can handle
-     * put, commit, and rollback actions for the transaction.
-     *
-     * @returns {Transaction.constructor} Transaction - A class that manages the transaction's operations.
-     */
-    TransactionalEngine.start = () => {
-        /**
-         * A class representing an active transaction on the engine.
-         * Contains methods to put changes, commit the transaction, or roll back in case of failure.
-         *
-         * @class Transaction
-         */
-        class Transaction extends TransactionalEngine {
-            /**
-             * @property {Array<Object>} transactions - An array storing all the operations within the transaction.
-             * @static
-             */
-            static transactions = [];
-
-            /**
-             * @property {boolean} committed - Indicates if the transaction has been committed.
-             * @static
-             */
-            static committed = false;
-
-            /**
-             * @property {boolean} failed - Indicates if the transaction has failed.
-             * @static
-             */
-            static failed = false;
-
-            /**
-             * Adds a model to the transaction queue.
-             *
-             * @param {Object} model - The model to be added to the transaction.
-             * @returns {Promise<void>} A promise that resolves once the model is added.
-             */
-            static put(model) {
-                this.transactions.push({
-                    hasRun: false,
-                    hasRolledBack: false,
-                    model,
-                });
-
-                return Promise.resolve();
-            }
-
-            /**
-             * Checks if the transaction has already been committed. If true, throws a TransactionCommittedError.
-             *
-             * @throws {TransactionCommittedError} If the transaction has already been committed.
-             * @private
-             */
-            static _checkCommitted() {
-                if (this.committed) throw new TransactionCommittedError();
-            }
-
-            /**
-             * Commits the transaction, applying all the changes to the engine.
-             * Rolls back if any part of the transaction fails.
-             *
-             * @returns {Promise<void>} A promise that resolves once the transaction is committed, or rejects if an error occurs.
-             * @throws {Error} If any operation in the transaction fails.
-             */
-            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 (_error) {
-                            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/StorageEngine.js

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