@magek/core 0.0.1

package/dist/magek.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Magek = void 0;
+const common_1 = require("@magek/common");
+const importer_1 = require("./importer");
+const event_store_1 = require("./services/event-store");
+const entity_migrated_1 = require("./core-concepts/data-migration/events/entity-migrated");
+const data_migration_entity_1 = require("./core-concepts/data-migration/entities/data-migration-entity");
+const data_migration_started_1 = require("./core-concepts/data-migration/events/data-migration-started");
+const data_migration_finished_1 = require("./core-concepts/data-migration/events/data-migration-finished");
+const authorizer_1 = require("./authorizer");
+const entity_touched_1 = require("./core-concepts/touch-entity/events/entity-touched");
+const read_model_searcher_1 = require("./services/read-model-searcher");
+const delete_event_dispatcher_1 = require("./delete-event-dispatcher");
+const event_search_1 = require("./event-search");
+const core_1 = require("@oclif/core");
+/**
+ * Main class to interact with Magek and configure it.
+ * Sensible defaults are used whenever possible:
+ * - `appName`: `new-magek-app`
+ *
+ */
+class Magek {
+    static configureCurrentEnv(configurator) {
+        configurator(this.config);
+    }
+    /**
+     * Allows to configure the Magek project.
+     *
+     * @param environment The name of the environment you want to configure
+     * @param configurator A function that receives the configuration object to set the values
+     */
+    static configure(environment, configurator) {
+        this.configuredEnvironments.add(environment);
+        if (this.config.environmentName === environment) {
+            configurator(this.config);
+        }
+    }
+    /**
+     * Initializes the Magek project
+     */
+    static start(codeRootPath) {
+        var _a;
+        if (!this.config.eventStoreAdapter) {
+            throw new Error('No eventStoreAdapter configured. Please add one in MagekConfig.');
+        }
+        if (!this.config.readModelStoreAdapter) {
+            throw new Error('No readModelStoreAdapter configured. Please add one in MagekConfig.');
+        }
+        if (this.config.enableSubscriptions && !this.config.sessionStoreAdapter) {
+            throw new Error('No sessionStoreAdapter configured. Please add one in MagekConfig.');
+        }
+        const projectRootPath = codeRootPath.replace(new RegExp(this.config.codeRelativePath + '$'), '');
+        this.config.userProjectRootPath = projectRootPath;
+        importer_1.Importer.importUserProjectFiles(codeRootPath);
+        this.configureMagekConcepts();
+        this.config.validate();
+        const args = process.argv;
+        if (((_a = process.env['MAGEK_CLI_HOOK']) === null || _a === void 0 ? void 0 : _a.trim()) !== 'true') {
+            return;
+        }
+        const injectable = this.config.injectable;
+        if (injectable) {
+            const { commands } = injectable;
+            // Run the injectable CLI commands using oclif
+            this.runInjectableCommands(args, commands, projectRootPath).catch((error) => {
+                if (error instanceof core_1.Errors.ExitError) {
+                    process.exit(error.oclif.exit);
+                }
+                console.error(error);
+                process.exit(1);
+            });
+        }
+    }
+    static async runInjectableCommands(args, commands, projectRootPath) {
+        // Get the subcommand from args (skip node and script path)
+        const subcommand = args[2];
+        if (!subcommand || !commands[subcommand]) {
+            console.log('Available commands:', Object.keys(commands).join(', '));
+            return;
+        }
+        const CommandClass = commands[subcommand];
+        // Create a minimal oclif config
+        const config = await core_1.Config.load({ root: projectRootPath });
+        // Instantiate and run the command
+        const instance = new CommandClass(args.slice(3), config);
+        await instance.run();
+    }
+    /**
+     * This function returns a "Searcher" configured to search instances of the read model class passed as param.
+     * For more information, check the Searcher class.
+     * @param readModelClass The class of the read model you what to run searches for
+     */
+    static readModel(readModelClass) {
+        return (0, read_model_searcher_1.readModelSearcher)(this.config, readModelClass);
+    }
+    static async events(request) {
+        return (0, event_search_1.eventSearch)(this.config, request);
+    }
+    static async entitiesIDs(entityTypeName, limit, afterCursor) {
+        return await this.config.eventStore.searchEntitiesIDs(this.config, limit, afterCursor, entityTypeName);
+    }
+    static async deleteEvent(parameters) {
+        return await delete_event_dispatcher_1.MagekDeleteEventDispatcher.deleteEvent(this.config, parameters);
+    }
+    /**
+     * Fetches the last known version of an entity
+     * @param entityClass Name of the entity class
+     * @param entityID
+     */
+    static async entity(entityClass, entityID) {
+        const eventStore = new event_store_1.EventStore(this.config);
+        const entitySnapshotEnvelope = await eventStore.fetchEntitySnapshot(entityClass.name, entityID);
+        return entitySnapshotEnvelope ? (0, common_1.createInstance)(entityClass, entitySnapshotEnvelope.value) : undefined;
+    }
+    static configureMagekConcepts() {
+        this.configureDataMigrations();
+        this.configureTouchEntities();
+    }
+    static configureDataMigrations() {
+        this.config.events[entity_migrated_1.MagekEntityMigrated.name] = {
+            class: entity_migrated_1.MagekEntityMigrated,
+        };
+        this.config.events[data_migration_started_1.MagekDataMigrationStarted.name] = {
+            class: data_migration_started_1.MagekDataMigrationStarted,
+        };
+        this.config.reducers[data_migration_started_1.MagekDataMigrationStarted.name] = {
+            class: data_migration_entity_1.MagekDataMigrationEntity,
+            methodName: 'started',
+        };
+        this.config.events[data_migration_finished_1.MagekDataMigrationFinished.name] = {
+            class: data_migration_finished_1.MagekDataMigrationFinished,
+        };
+        this.config.reducers[data_migration_finished_1.MagekDataMigrationFinished.name] = {
+            class: data_migration_entity_1.MagekDataMigrationEntity,
+            methodName: 'finished',
+        };
+        this.config.entities[data_migration_entity_1.MagekDataMigrationEntity.name] = {
+            class: data_migration_entity_1.MagekDataMigrationEntity,
+            eventStreamAuthorizer: authorizer_1.MagekAuthorizer.denyAccess,
+        };
+    }
+    static configureTouchEntities() {
+        this.config.events[entity_touched_1.MagekEntityTouched.name] = {
+            class: entity_touched_1.MagekEntityTouched,
+        };
+    }
+}
+exports.Magek = Magek;
+Magek.configuredEnvironments = new Set();
+Magek.config = new common_1.MagekConfig(checkAndGetCurrentEnv());
+function checkAndGetCurrentEnv() {
+    const env = process.env.MAGEK_ENV;
+    if (!env || env.trim().length == 0) {
+        throw new Error('Magek environment is missing. You need to provide an environment to configure your Magek project');
+    }
+    return env;
+}

package/dist/query-dispatcher.d.ts

@@ -0,0 +1,8 @@
+import { MagekConfig, QueryEnvelope } from '@magek/common';
+import { GraphQLResolverContext } from './services/graphql/common';
+export declare class MagekQueryDispatcher {
+    readonly config: MagekConfig;
+    private readonly globalErrorDispatcher;
+    constructor(config: MagekConfig);
+    dispatchQuery(queryEnvelope: QueryEnvelope, context: GraphQLResolverContext): Promise<unknown>;
+}

package/dist/query-dispatcher.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekQueryDispatcher = void 0;
+const common_1 = require("@magek/common");
+const global_error_dispatcher_1 = require("./global-error-dispatcher");
+const filter_helpers_1 = require("./services/filter-helpers");
+class MagekQueryDispatcher {
+    constructor(config) {
+        this.config = config;
+        this.globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(config);
+    }
+    async dispatchQuery(queryEnvelope, context) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekQueryDispatcher#dispatchQuery');
+        logger.debug('Dispatching the following query envelope: ', queryEnvelope);
+        if (!queryEnvelope.version) {
+            throw new common_1.InvalidParameterError('The required query "version" was not present');
+        }
+        const queryMetadata = this.config.queryHandlers[queryEnvelope.typeName];
+        if (!queryMetadata) {
+            throw new common_1.NotFoundError(`Could not find a proper handler for ${queryEnvelope.typeName}`);
+        }
+        await queryMetadata.authorizer(queryEnvelope.currentUser, queryEnvelope);
+        const queryClass = queryMetadata.class;
+        logger.debug('Found the following query:', queryClass.name);
+        let result;
+        try {
+            const queryInfo = {
+                requestID: queryEnvelope.requestID,
+                responseHeaders: context.responseHeaders,
+                currentUser: queryEnvelope.currentUser,
+                context: queryEnvelope.context,
+            };
+            const queryInput = await (0, filter_helpers_1.applyBeforeFunctions)(queryEnvelope.value, queryMetadata.before, queryEnvelope.currentUser);
+            const queryInstance = (0, common_1.createInstance)(queryClass, queryInput);
+            logger.debug('Calling "handle" method on query: ', queryClass);
+            result = await queryClass.handle(queryInstance, queryInfo);
+        }
+        catch (err) {
+            const e = err;
+            const error = await this.globalErrorDispatcher.dispatch(new common_1.QueryHandlerGlobalError(queryEnvelope, e));
+            if (error)
+                throw error;
+        }
+        return result;
+    }
+}
+exports.MagekQueryDispatcher = MagekQueryDispatcher;

package/dist/read-model-schema-migrator.d.ts

@@ -0,0 +1,14 @@
+import { MagekConfig, ReadModelInterface } from '@magek/common';
+export declare class ReadModelSchemaMigrator {
+    private config;
+    constructor(config: MagekConfig);
+    /**
+     * **NOTE:** Read model schema migration is deprecated. Prefer data migration.
+     */
+    migrate<TMigratableReadModel extends ReadModelInterface>(readModel: TMigratableReadModel, readModelName: string): Promise<TMigratableReadModel>;
+    private checkVersionRange;
+    private needsMigration;
+    private applyAllMigrations;
+    private applyMigration;
+    private static readModelSchemaVersion;
+}

package/dist/read-model-schema-migrator.js

@@ -0,0 +1,80 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadModelSchemaMigrator = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const instrumentation_1 = require("./instrumentation");
+class ReadModelSchemaMigrator {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * **NOTE:** Read model schema migration is deprecated. Prefer data migration.
+     */
+    async migrate(readModel, readModelName) {
+        this.checkVersionRange(readModel, readModelName);
+        if (this.needsMigration(readModel, readModelName)) {
+            return await this.applyAllMigrations(readModel, readModelName);
+        }
+        return readModel; // The current version is exactly the same as the version of the concept
+    }
+    checkVersionRange(readModel, readModelName) {
+        const readModelVersion = ReadModelSchemaMigrator.readModelSchemaVersion(readModel);
+        if (readModelVersion < 1) {
+            throw new common_1.InvalidVersionError(`Received an invalid schema version value, ${readModelVersion}, for ${readModelName}. ` +
+                'Versions must be greater than 0');
+        }
+        const currentVersion = this.config.currentVersionFor(readModelName);
+        if (currentVersion < readModelVersion) {
+            throw new common_1.InvalidVersionError(`Can not migrate schema an unknown version: The current schema version of ${readModelName} is ${currentVersion}, which is ` +
+                `lower than the received version ${readModelVersion}`);
+        }
+    }
+    needsMigration(readModel, readModelName) {
+        const currentVersion = this.config.currentVersionFor(readModelName);
+        return currentVersion > ReadModelSchemaMigrator.readModelSchemaVersion(readModel);
+    }
+    async applyAllMigrations(oldReadModel, readModelName) {
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelSchemaMigrator#applyAllMigrations');
+        const oldVersion = ReadModelSchemaMigrator.readModelSchemaVersion(oldReadModel);
+        const currentVersion = this.config.currentVersionFor(readModelName);
+        logger.info(`Migrating Schema ${readModelName} from version ${oldVersion} to version ${currentVersion}`);
+        logger.debug('ReadModel before schema migration:\n', oldReadModel);
+        const migrations = this.config.schemaMigrations[readModelName];
+        let migratedValue = oldReadModel;
+        for (let toVersion = oldVersion + 1; toVersion <= currentVersion; toVersion++) {
+            migratedValue = await this.applyMigration(migratedValue, migrations.get(toVersion));
+        }
+        const newReadModel = Object.assign(migratedValue, {
+            magekMetadata: {
+                ...oldReadModel.magekMetadata,
+                schemaVersion: currentVersion,
+            },
+        });
+        logger.debug('ReadModel after schema migration:\n', newReadModel);
+        return newReadModel;
+    }
+    async applyMigration(oldValue, migration) {
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelSchemaMigrator#applyMigration');
+        if (!migration) {
+            throw new common_1.InvalidVersionError('Received an undefined schema migration value. Are there "gaps" between the versions of the schema migrations?');
+        }
+        const oldConcept = Object.assign(new migration.fromSchema(), oldValue);
+        const migrationMethod = new migration.migrationClass()[migration.methodName];
+        const newConcept = await migrationMethod(oldConcept);
+        logger.debug(`Partial schema migration finished. Schema migrated from oldValue=${JSON.stringify(oldConcept)} to newValue=${JSON.stringify(newConcept)}`);
+        return newConcept;
+    }
+    static readModelSchemaVersion(readModel) {
+        var _a, _b;
+        return (_b = (_a = readModel.magekMetadata) === null || _a === void 0 ? void 0 : _a.schemaVersion) !== null && _b !== void 0 ? _b : 1;
+    }
+}
+exports.ReadModelSchemaMigrator = ReadModelSchemaMigrator;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.READ_MODEL_SCHEMA_MIGRATOR_MIGRATE),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [typeof (_a = typeof TMigratableReadModel !== "undefined" && TMigratableReadModel) === "function" ? _a : Object, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], ReadModelSchemaMigrator.prototype, "migrate", null);

package/dist/read-models-reader.d.ts

@@ -0,0 +1,31 @@
+import { AnyClass, MagekConfig, FilterFor, GraphQLOperation, ProjectionFor, ReadModelInterface, ReadModelListResult, ReadModelRequestEnvelope, ReadOnlyNonEmptyArray, SequenceKey, SortFor, UUID } from '@magek/common';
+export declare class MagekReadModelsReader {
+    readonly config: MagekConfig;
+    constructor(config: MagekConfig);
+    findById(readModelRequest: ReadModelRequestEnvelope<ReadModelInterface>): Promise<ReadModelInterface | ReadOnlyNonEmptyArray<ReadModelInterface>>;
+    search(readModelRequest: ReadModelRequestEnvelope<ReadModelInterface>): Promise<Array<ReadModelInterface> | ReadModelListResult<ReadModelInterface>>;
+    readModelSearch<TReadModel extends ReadModelInterface>(readModelClass: AnyClass, filters: FilterFor<unknown>, sort?: SortFor<unknown>, limit?: number, afterCursor?: any, paginatedVersion?: boolean, select?: ProjectionFor<TReadModel>): Promise<Array<TReadModel> | ReadModelListResult<TReadModel>>;
+    finderByIdFunction<TReadModel extends ReadModelInterface>(readModelClass: AnyClass, id: UUID, sequenceKey?: SequenceKey): Promise<ReadOnlyNonEmptyArray<TReadModel> | TReadModel>;
+    private migrateReadModels;
+    private createReadModelInstances;
+    /**
+     * Creates instances of the read model class with the calculated properties included
+     * @param searchResult The search result
+     * @param readModelClass The read model class
+     * @param propertiesToInclude The properties to include in the response
+     * @private
+     */
+    private createReadModelInstancesWithCalculatedProperties;
+    subscribe(connectionID: string, readModelRequest: ReadModelRequestEnvelope<ReadModelInterface>, operation: GraphQLOperation): Promise<unknown>;
+    unsubscribe(connectionID: string, subscriptionID: string): Promise<void>;
+    unsubscribeAll(connectionID: string): Promise<void>;
+    private validateByIdRequest;
+    private validateRequest;
+    private processSubscription;
+    /**
+     * Returns the dependencies of the calculated fields of a read model
+     * @param readModelClass The read model class
+     * @private
+     */
+    private getCalculatedFieldsDependencies;
+}

package/dist/read-models-reader.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekReadModelsReader = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const magek_1 = require("./magek");
+const filter_helpers_1 = require("./services/filter-helpers");
+const read_model_schema_migrator_1 = require("./read-model-schema-migrator");
+const instrumentation_1 = require("./instrumentation");
+class MagekReadModelsReader {
+    constructor(config) {
+        this.config = config;
+    }
+    async findById(readModelRequest) {
+        await this.validateByIdRequest(readModelRequest);
+        const readModelMetadata = this.config.readModels[readModelRequest.class.name];
+        const readModelTransformedRequest = await (0, filter_helpers_1.applyReadModelRequestBeforeFunctions)(readModelRequest, readModelMetadata.before, readModelRequest.currentUser);
+        const key = readModelTransformedRequest.key;
+        if (!key) {
+            throw 'Tried to run a findById operation without providing a key. An ID is required to perform this operation.';
+        }
+        const currentReadModel = await magek_1.Magek.readModel(readModelMetadata.class).findById(key.id, key.sequenceKey);
+        if (currentReadModel) {
+            const readModelInstance = (0, common_1.createInstance)(readModelMetadata.class, currentReadModel);
+            const readModelName = readModelMetadata.class.name;
+            const readModelSchemaMigrator = new read_model_schema_migrator_1.ReadModelSchemaMigrator(this.config);
+            if (Array.isArray(readModelInstance)) {
+                return [await readModelSchemaMigrator.migrate(readModelInstance[0], readModelName)];
+            }
+            return readModelSchemaMigrator.migrate(readModelInstance, readModelName);
+        }
+        return currentReadModel;
+    }
+    async search(readModelRequest) {
+        await this.validateRequest(readModelRequest);
+        const readModelMetadata = this.config.readModels[readModelRequest.class.name];
+        const readModelTransformedRequest = await (0, filter_helpers_1.applyReadModelRequestBeforeFunctions)(readModelRequest, readModelMetadata.before, readModelRequest.currentUser);
+        return await this.readModelSearch(readModelMetadata.class, readModelTransformedRequest.filters, readModelTransformedRequest.sortBy, readModelTransformedRequest.limit, readModelTransformedRequest.afterCursor, readModelTransformedRequest.paginatedVersion, readModelTransformedRequest.select);
+    }
+    async readModelSearch(readModelClass, filters, sort, limit, afterCursor, paginatedVersion, select) {
+        const readModelName = readModelClass.name;
+        let selectWithDependencies = undefined;
+        const calculatedFieldsDependencies = this.getCalculatedFieldsDependencies(readModelClass);
+        if (select && Object.keys(calculatedFieldsDependencies).length > 0) {
+            const extendedSelect = new Set(select);
+            select.forEach((field) => {
+                const topLevelField = field.split('.')[0].replace('[]', '');
+                if (calculatedFieldsDependencies[topLevelField]) {
+                    calculatedFieldsDependencies[topLevelField].map((dependency) => extendedSelect.add(dependency));
+                }
+            });
+            selectWithDependencies = Array.from(extendedSelect);
+        }
+        const searchResult = await this.config.readModelStore.search(this.config, readModelName, filters !== null && filters !== void 0 ? filters : {}, sort !== null && sort !== void 0 ? sort : {}, limit, afterCursor, paginatedVersion !== null && paginatedVersion !== void 0 ? paginatedVersion : false, selectWithDependencies !== null && selectWithDependencies !== void 0 ? selectWithDependencies : select);
+        const readModels = this.createReadModelInstances(searchResult, readModelClass);
+        if (select) {
+            return this.createReadModelInstancesWithCalculatedProperties(searchResult, readModelClass, select !== null && select !== void 0 ? select : []);
+        }
+        return this.migrateReadModels(readModels, readModelName);
+    }
+    async finderByIdFunction(readModelClass, id, sequenceKey) {
+        const result = await this.config.readModelStore.fetch(this.config, readModelClass.name, id, sequenceKey);
+        if (!result) {
+            throw new Error(`Read model not found: ${readModelClass.name} with id ${id}`);
+        }
+        // The adapter returns ReadOnlyNonEmptyArray<TReadModel> | undefined
+        // For backward compatibility, we return a single item if sequenceKey is not provided
+        return sequenceKey ? result : result[0];
+    }
+    async migrateReadModels(readModels, readModelName) {
+        const readModelSchemaMigrator = new read_model_schema_migrator_1.ReadModelSchemaMigrator(this.config);
+        if (Array.isArray(readModels)) {
+            return Promise.all(readModels.map((readModel) => readModelSchemaMigrator.migrate(readModel, readModelName)));
+        }
+        readModels.items = await Promise.all(readModels.items.map((readModel) => readModelSchemaMigrator.migrate(readModel, readModelName)));
+        return readModels;
+    }
+    createReadModelInstances(searchResult, readModelClass) {
+        if (Array.isArray(searchResult)) {
+            return (0, common_1.createInstances)(readModelClass, searchResult);
+        }
+        return {
+            ...searchResult,
+            items: (0, common_1.createInstances)(readModelClass, searchResult.items),
+        };
+    }
+    /**
+     * Creates instances of the read model class with the calculated properties included
+     * @param searchResult The search result
+     * @param readModelClass The read model class
+     * @param propertiesToInclude The properties to include in the response
+     * @private
+     */
+    async createReadModelInstancesWithCalculatedProperties(searchResult, readModelClass, propertiesToInclude) {
+        const processInstance = async (raw) => {
+            const instance = await (0, common_1.createInstanceWithCalculatedProperties)(readModelClass, raw, propertiesToInclude);
+            return instance;
+        };
+        if (Array.isArray(searchResult)) {
+            return await Promise.all(searchResult.map(processInstance));
+        }
+        else {
+            const processedItems = await Promise.all(searchResult.items.map(processInstance));
+            return {
+                ...searchResult,
+                items: processedItems,
+            };
+        }
+    }
+    async subscribe(connectionID, readModelRequest, operation) {
+        await this.validateRequest(readModelRequest);
+        return this.processSubscription(connectionID, readModelRequest, operation);
+    }
+    async unsubscribe(connectionID, subscriptionID) {
+        return this.config.sessionStore.deleteSubscription(this.config, connectionID, subscriptionID);
+    }
+    async unsubscribeAll(connectionID) {
+        return this.config.sessionStore.deleteSubscriptionsForConnection(this.config, connectionID);
+    }
+    async validateByIdRequest(readModelByIdRequest) {
+        var _a;
+        const logger = (0, common_1.getLogger)(this.config, 'MagekReadModelsReader#validateByIdRequest');
+        logger.debug('Validating the following read model by id request: ', readModelByIdRequest);
+        if (!readModelByIdRequest.version) {
+            throw new common_1.InvalidParameterError('The required request "version" was not present');
+        }
+        const readModelMetadata = this.config.readModels[readModelByIdRequest.class.name];
+        if (!readModelMetadata) {
+            throw new common_1.NotFoundError(`Could not find read model ${readModelByIdRequest.class.name}`);
+        }
+        await readModelMetadata.authorizer(readModelByIdRequest.currentUser, readModelByIdRequest);
+        if (((_a = readModelByIdRequest === null || readModelByIdRequest === void 0 ? void 0 : readModelByIdRequest.key) === null || _a === void 0 ? void 0 : _a.sequenceKey) &&
+            readModelByIdRequest.key.sequenceKey.name !== this.config.readModelSequenceKeys[readModelByIdRequest.class.name]) {
+            throw new common_1.InvalidParameterError(`Could not find a sort key defined for ${readModelByIdRequest.class.name} named '${readModelByIdRequest.key.sequenceKey.name}'.`);
+        }
+    }
+    async validateRequest(readModelRequest) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekReadModelsReader#validateRequest');
+        logger.debug('Validating the following read model request: ', readModelRequest);
+        if (!readModelRequest.version) {
+            throw new common_1.InvalidParameterError('The required request "version" was not present');
+        }
+        const readModelMetadata = this.config.readModels[readModelRequest.class.name];
+        if (!readModelMetadata) {
+            throw new common_1.NotFoundError(`Could not find read model ${readModelRequest.class.name}`);
+        }
+        await readModelMetadata.authorizer(readModelRequest.currentUser, readModelRequest);
+    }
+    async processSubscription(connectionID, readModelRequest, operation) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekReadModelsReader#processSubscription');
+        logger.info(`Processing subscription of connection '${connectionID}' to read model '${readModelRequest.class.name}' with the following data: `, readModelRequest);
+        const readModelMetadata = this.config.readModels[readModelRequest.class.name];
+        const newReadModelRequest = await (0, filter_helpers_1.applyReadModelRequestBeforeFunctions)(readModelRequest, readModelMetadata.before, readModelRequest.currentUser);
+        const nowEpoch = Math.floor(new Date().getTime() / 1000);
+        const subscription = {
+            ...newReadModelRequest,
+            expirationTime: nowEpoch + this.config.subscriptions.maxDurationInSeconds,
+            connectionID,
+            operation,
+        };
+        // Store subscription using session store adapter
+        await this.config.sessionStore.storeSubscription(this.config, connectionID, operation.id || subscription.requestID, subscription);
+    }
+    /**
+     * Returns the dependencies of the calculated fields of a read model
+     * @param readModelClass The read model class
+     * @private
+     */
+    getCalculatedFieldsDependencies(readModelClass) {
+        const readModelMetadata = this.config.readModels[readModelClass.name];
+        const dependenciesMap = {};
+        readModelMetadata === null || readModelMetadata === void 0 ? void 0 : readModelMetadata.properties.map((property) => {
+            dependenciesMap[property.name] = property.dependencies;
+        });
+        return dependenciesMap;
+    }
+}
+exports.MagekReadModelsReader = MagekReadModelsReader;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.READ_MODEL_FIND_BY_ID),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekReadModelsReader.prototype, "findById", null);
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.GRAPHQL_READ_MODEL_SEARCH),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekReadModelsReader.prototype, "search", null);
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.READ_MODEL_SEARCH),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object, Object, Number, Object, Boolean, Array]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekReadModelsReader.prototype, "readModelSearch", null);

package/dist/register-handler.d.ts

@@ -0,0 +1,11 @@
+import { MagekConfig, Register } from '@magek/common';
+export declare class RegisterHandler {
+    static handle(config: MagekConfig, register: Register): Promise<void>;
+    static flush(record: Register): Promise<void>;
+    private static wrapEvent;
+    private static getSuperKind;
+    private static getTopicName;
+    private static getPartitionKey;
+    private static getDefaultStateEventEntityId;
+    private static getDefaultNotificationPartitionId;
+}

package/dist/register-handler.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterHandler = void 0;
+const common_1 = require("@magek/common");
+const entity_migrated_1 = require("./core-concepts/data-migration/events/entity-migrated");
+const data_migration_started_1 = require("./core-concepts/data-migration/events/data-migration-started");
+const data_migration_finished_1 = require("./core-concepts/data-migration/events/data-migration-finished");
+const magek_1 = require("./magek");
+const entity_touched_1 = require("./core-concepts/touch-entity/events/entity-touched");
+const eventsTypesNames = [
+    entity_migrated_1.MagekEntityMigrated.name,
+    data_migration_started_1.MagekDataMigrationStarted.name,
+    data_migration_finished_1.MagekDataMigrationFinished.name,
+    entity_touched_1.MagekEntityTouched.name,
+];
+class RegisterHandler {
+    static async handle(config, register) {
+        if (register.eventList.length == 0) {
+            return;
+        }
+        await config.eventStore.store(register.eventList.map((event) => RegisterHandler.wrapEvent(config, event, register)), config);
+    }
+    static async flush(record) {
+        return RegisterHandler.handle(magek_1.Magek.config, record);
+    }
+    static wrapEvent(config, event, register) {
+        const eventTypeName = event.constructor.name;
+        const entityTypeName = RegisterHandler.getTopicName(eventTypeName, event, config);
+        if (!entityTypeName) {
+            throw new common_1.NotFoundError(`Couldn't find information about event ${eventTypeName}. Is the event handled by an entity?`);
+        }
+        const entityID = RegisterHandler.getPartitionKey(event, config);
+        if (!entityID) {
+            throw new Error(`Event ${eventTypeName} has an empty 'entityID' or the required 'entityID' method was not implemented. Make sure to return a string-compatible value identifying the entity this event belongs to.`);
+        }
+        return {
+            version: config.currentVersionFor(eventTypeName),
+            kind: 'event',
+            superKind: RegisterHandler.getSuperKind(eventTypeName),
+            entityID,
+            requestID: register.requestID,
+            currentUser: register.currentUser,
+            entityTypeName,
+            typeName: eventTypeName,
+            value: event,
+        };
+    }
+    static getSuperKind(eventTypeName) {
+        return eventsTypesNames.includes(eventTypeName) ? common_1.MAGEK_SUPER_KIND : common_1.DOMAIN_SUPER_KIND;
+    }
+    static getTopicName(eventTypeName, event, config) {
+        var _a, _b;
+        if (eventTypeName === entity_migrated_1.MagekEntityMigrated.name) {
+            return event.oldEntityName;
+        }
+        if (eventTypeName === entity_touched_1.MagekEntityTouched.name) {
+            return event.entityName;
+        }
+        if (eventTypeName in config.notifications) {
+            return (_a = config.eventToTopic[eventTypeName]) !== null && _a !== void 0 ? _a : 'defaultTopic';
+        }
+        const reducerInfo = config.reducers[eventTypeName];
+        return (_b = reducerInfo === null || reducerInfo === void 0 ? void 0 : reducerInfo.class) === null || _b === void 0 ? void 0 : _b.name;
+    }
+    static getPartitionKey(event, config) {
+        const eventName = event.constructor.name;
+        const evtObject = event;
+        const entityIdField = config.partitionKeys[eventName];
+        if (entityIdField && entityIdField in evtObject && typeof evtObject[entityIdField] === 'string') {
+            return evtObject[entityIdField];
+        }
+        if (eventName in config.notifications) {
+            return RegisterHandler.getDefaultNotificationPartitionId(event);
+        }
+        return RegisterHandler.getDefaultStateEventEntityId(event);
+    }
+    static getDefaultStateEventEntityId(event) {
+        const entityID = event.entityID();
+        if (entityID) {
+            return entityID;
+        }
+        throw new Error(`Event ${event.constructor.name} has no specification for the entity ID. Make sure to specify a string-compatible value identifying the entity this event belongs to.
+
+      You can do it by:
+
+      1. Adding an entityID method to the event`);
+    }
+    static getDefaultNotificationPartitionId(event) {
+        if (event.partitionId && typeof event.partitionId === 'string') {
+            return event.partitionId;
+        }
+        return 'default';
+    }
+}
+exports.RegisterHandler = RegisterHandler;

package/dist/rocket-dispatcher.d.ts

@@ -0,0 +1,6 @@
+import { MagekConfig } from '@magek/common';
+export declare class MagekRocketDispatcher {
+    readonly config: MagekConfig;
+    constructor(config: MagekConfig);
+    dispatch(request: unknown): Promise<unknown>;
+}