@magek/core 0.0.5 → 0.0.7

package/dist/services/event-store.js

@@ -10,251 +10,248 @@ const entity_touched_1 = require("../core-concepts/touch-entity/events/entity-to
 const instrumentation_1 = require("../instrumentation");
 const originOfTime = new Date(0).toISOString(); // Unix epoch
 const reducibleEventsTypesNames = [entity_migrated_1.MagekEntityMigrated.name, entity_touched_1.MagekEntityTouched.name];
-class EventStore {
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * Will fetch the latest snapshot for an entity by applying a reduction
-     * since the time of creation of the last snapshot or from the origin of time
-     * if no snapshot is found.
-     *
-     * Also, in order to make next calls faster, this method caches the newly calculated
-     * snapshot storing it at the end of the process.
-     */
-    async fetchEntitySnapshot(entityName, entityID) {
-        var _a;
-        const logger = (0, common_1.getLogger)(this.config, 'EventStore#fetchEntitySnapshot');
-        logger.debug(`Fetching snapshot for entity ${entityName} with ID ${entityID}`);
-        const latestSnapshotEnvelope = await this.loadLatestSnapshot(entityName, entityID);
-        const lastVisitedTime = (_a = latestSnapshotEnvelope === null || latestSnapshotEnvelope === void 0 ? void 0 : latestSnapshotEnvelope.snapshottedEventCreatedAt) !== null && _a !== void 0 ? _a : originOfTime;
-        const pendingEvents = await this.loadEventStreamSince(entityName, entityID, lastVisitedTime);
-        if (pendingEvents.length <= 0) {
-            return latestSnapshotEnvelope;
+let EventStore = (() => {
+    let _instanceExtraInitializers = [];
+    let _fetchEntitySnapshot_decorators;
+    let _storeDispatchedEvent_decorators;
+    let _storeSnapshot_decorators;
+    let _loadLatestSnapshot_decorators;
+    let _loadEventStreamSince_decorators;
+    let _entityReducer_decorators;
+    return class EventStore {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _fetchEntitySnapshot_decorators = [(0, instrumentation_1.trace)(common_1.TraceActionTypes.FETCH_ENTITY_SNAPSHOT)];
+            _storeDispatchedEvent_decorators = [(0, instrumentation_1.trace)(common_1.TraceActionTypes.CUSTOM)];
+            _storeSnapshot_decorators = [(0, instrumentation_1.trace)(common_1.TraceActionTypes.STORE_SNAPSHOT)];
+            _loadLatestSnapshot_decorators = [(0, instrumentation_1.trace)(common_1.TraceActionTypes.LOAD_LATEST_SNAPSHOT)];
+            _loadEventStreamSince_decorators = [(0, instrumentation_1.trace)(common_1.TraceActionTypes.LOAD_EVENT_STREAM_SINCE)];
+            _entityReducer_decorators = [(0, instrumentation_1.trace)(common_1.TraceActionTypes.ENTITY_REDUCER)];
+            tslib_1.__esDecorate(this, null, _fetchEntitySnapshot_decorators, { kind: "method", name: "fetchEntitySnapshot", static: false, private: false, access: { has: obj => "fetchEntitySnapshot" in obj, get: obj => obj.fetchEntitySnapshot }, metadata: _metadata }, null, _instanceExtraInitializers);
+            tslib_1.__esDecorate(this, null, _storeDispatchedEvent_decorators, { kind: "method", name: "storeDispatchedEvent", static: false, private: false, access: { has: obj => "storeDispatchedEvent" in obj, get: obj => obj.storeDispatchedEvent }, metadata: _metadata }, null, _instanceExtraInitializers);
+            tslib_1.__esDecorate(this, null, _storeSnapshot_decorators, { kind: "method", name: "storeSnapshot", static: false, private: false, access: { has: obj => "storeSnapshot" in obj, get: obj => obj.storeSnapshot }, metadata: _metadata }, null, _instanceExtraInitializers);
+            tslib_1.__esDecorate(this, null, _loadLatestSnapshot_decorators, { kind: "method", name: "loadLatestSnapshot", static: false, private: false, access: { has: obj => "loadLatestSnapshot" in obj, get: obj => obj.loadLatestSnapshot }, metadata: _metadata }, null, _instanceExtraInitializers);
+            tslib_1.__esDecorate(this, null, _loadEventStreamSince_decorators, { kind: "method", name: "loadEventStreamSince", static: false, private: false, access: { has: obj => "loadEventStreamSince" in obj, get: obj => obj.loadEventStreamSince }, metadata: _metadata }, null, _instanceExtraInitializers);
+            tslib_1.__esDecorate(this, null, _entityReducer_decorators, { kind: "method", name: "entityReducer", static: false, private: false, access: { has: obj => "entityReducer" in obj, get: obj => obj.entityReducer }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        else {
-            logger.debug(`Looking for the reducer for entity ${entityName} with ID ${entityID}`);
-            // In this assignment we discard the `createdAt` field because it's not needed in the reduction process
-            let newEntitySnapshot = latestSnapshotEnvelope;
-            for (const pendingEvent of pendingEvents) {
-                // We double-check that what we are reducing is an event
-                if (pendingEvent.kind === 'event') {
-                    try {
-                        newEntitySnapshot = await this.entityReducer(pendingEvent, newEntitySnapshot);
-                    }
-                    catch (e) {
-                        if (e instanceof common_1.InvalidEventError) {
-                            const globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(this.config);
-                            const error = await globalErrorDispatcher.dispatch(new common_1.EventGlobalError(pendingEvent, e));
-                            if (error)
-                                throw error;
-                            continue;
+        config = tslib_1.__runInitializers(this, _instanceExtraInitializers);
+        constructor(config) {
+            this.config = config;
+        }
+        /**
+         * Will fetch the latest snapshot for an entity by applying a reduction
+         * since the time of creation of the last snapshot or from the origin of time
+         * if no snapshot is found.
+         *
+         * Also, in order to make next calls faster, this method caches the newly calculated
+         * snapshot storing it at the end of the process.
+         */
+        async fetchEntitySnapshot(entityName, entityID) {
+            const logger = (0, common_1.getLogger)(this.config, 'EventStore#fetchEntitySnapshot');
+            logger.debug(`Fetching snapshot for entity ${entityName} with ID ${entityID}`);
+            const latestSnapshotEnvelope = await this.loadLatestSnapshot(entityName, entityID);
+            const lastVisitedTime = latestSnapshotEnvelope?.snapshottedEventCreatedAt ?? originOfTime;
+            const pendingEvents = await this.loadEventStreamSince(entityName, entityID, lastVisitedTime);
+            if (pendingEvents.length <= 0) {
+                return latestSnapshotEnvelope;
+            }
+            else {
+                logger.debug(`Looking for the reducer for entity ${entityName} with ID ${entityID}`);
+                // In this assignment we discard the `createdAt` field because it's not needed in the reduction process
+                let newEntitySnapshot = latestSnapshotEnvelope;
+                for (const pendingEvent of pendingEvents) {
+                    // We double-check that what we are reducing is an event
+                    if (pendingEvent.kind === 'event') {
+                        try {
+                            const reducerResult = await this.entityReducer(pendingEvent, newEntitySnapshot);
+                            // If reducer returns ReducerAction.Skip, keep the current snapshot unchanged
+                            if (reducerResult !== common_1.ReducerAction.Skip) {
+                                newEntitySnapshot = reducerResult;
+                            }
                         }
-                        else if (e instanceof common_1.InvalidReducerError) {
-                            const globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(this.config);
-                            const reducerMetadata = this.config.reducers[pendingEvent.typeName];
-                            const error = await globalErrorDispatcher.dispatch(new common_1.ReducerGlobalError(pendingEvent, e.eventInstance, e.snapshotInstance, reducerMetadata, e));
-                            if (error)
-                                throw error;
-                            continue;
+                        catch (e) {
+                            if (e instanceof common_1.InvalidEventError) {
+                                const globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(this.config);
+                                const error = await globalErrorDispatcher.dispatch(new common_1.EventGlobalError(pendingEvent, e));
+                                if (error)
+                                    throw error;
+                                continue;
+                            }
+                            else if (e instanceof common_1.InvalidReducerError) {
+                                const globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(this.config);
+                                const reducerMetadata = this.config.reducers[pendingEvent.typeName];
+                                const error = await globalErrorDispatcher.dispatch(new common_1.ReducerGlobalError(pendingEvent, e.eventInstance, e.snapshotInstance, reducerMetadata, e));
+                                if (error)
+                                    throw error;
+                                continue;
+                            }
+                            throw e;
                         }
-                        throw e;
                     }
                 }
+                if (!newEntitySnapshot) {
+                    logger.debug('No snapshot was found or reduced, returning');
+                    return newEntitySnapshot;
+                }
+                if (newEntitySnapshot.entityID !== entityID) {
+                    logger.debug(`Migrated entity ${entityName} with previous ID ${entityID} to ${newEntitySnapshot?.typeName} with the new ID ${newEntitySnapshot?.entityID}`, newEntitySnapshot);
+                }
+                else {
+                    logger.debug(`Reduced new snapshot for entity ${entityName} with ID ${entityID}: `, newEntitySnapshot);
+                }
+                return await this.storeSnapshot(newEntitySnapshot);
             }
-            if (!newEntitySnapshot) {
-                logger.debug('No snapshot was found or reduced, returning');
-                return newEntitySnapshot;
-            }
-            if (newEntitySnapshot.entityID !== entityID) {
-                logger.debug(`Migrated entity ${entityName} with previous ID ${entityID} to ${newEntitySnapshot === null || newEntitySnapshot === void 0 ? void 0 : newEntitySnapshot.typeName} with the new ID ${newEntitySnapshot === null || newEntitySnapshot === void 0 ? void 0 : newEntitySnapshot.entityID}`, newEntitySnapshot);
+        }
+        async storeDispatchedEvent(eventEnvelope) {
+            const logger = (0, common_1.getLogger)(this.config, 'EventStore#storeDispatchedEvent');
+            try {
+                logger.debug('Storing event in the dispatched event store:', eventEnvelope);
+                return await this.config.eventStore.storeDispatched(eventEnvelope, this.config);
             }
-            else {
-                logger.debug(`Reduced new snapshot for entity ${entityName} with ID ${entityID}: `, newEntitySnapshot);
+            catch (e) {
+                logger.debug('Could not store dispatched event. Continue its processing.', { error: e, eventEnvelope });
+                return true;
             }
-            return await this.storeSnapshot(newEntitySnapshot);
-        }
-    }
-    async storeDispatchedEvent(eventEnvelope) {
-        const logger = (0, common_1.getLogger)(this.config, 'EventStore#storeDispatchedEvent');
-        try {
-            logger.debug('Storing event in the dispatched event store:', eventEnvelope);
-            return await this.config.eventStore.storeDispatched(eventEnvelope, this.config);
-        }
-        catch (e) {
-            logger.debug('Could not store dispatched event. Continue its processing.', { error: e, eventEnvelope });
-            return true;
         }
-    }
-    async storeSnapshot(snapshot) {
-        const logger = (0, common_1.getLogger)(this.config, 'EventStore#storeSnapshot');
-        try {
-            logger.debug('Storing snapshot in the event store:', snapshot);
-            return await this.config.eventStore.storeSnapshot(snapshot, this.config);
+        async storeSnapshot(snapshot) {
+            const logger = (0, common_1.getLogger)(this.config, 'EventStore#storeSnapshot');
+            try {
+                logger.debug('Storing snapshot in the event store:', snapshot);
+                return await this.config.eventStore.storeSnapshot(snapshot, this.config);
+            }
+            catch (e) {
+                logger.error(`The snapshot for entity ${snapshot.typeName} with ID ${snapshot.entityID} couldn't be stored (Tried on ${new Date()})`, snapshot, '\nError:', e);
+                return;
+            }
         }
-        catch (e) {
-            logger.error(`The snapshot for entity ${snapshot.typeName} with ID ${snapshot.entityID} couldn't be stored (Tried on ${new Date()})`, snapshot, '\nError:', e);
-            return;
+        async loadLatestSnapshot(entityName, entityID) {
+            const logger = (0, common_1.getLogger)(this.config, 'EventStore#loadLatestSnapshot');
+            logger.debug(`Loading latest snapshot for entity ${entityName} and ID ${entityID}`);
+            const latestSnapshot = await this.config.eventStore.latestEntitySnapshot(this.config, entityName, entityID);
+            if (latestSnapshot) {
+                return new schema_migrator_1.SchemaMigrator(this.config).migrate(latestSnapshot);
+            }
+            return undefined;
         }
-    }
-    async loadLatestSnapshot(entityName, entityID) {
-        const logger = (0, common_1.getLogger)(this.config, 'EventStore#loadLatestSnapshot');
-        logger.debug(`Loading latest snapshot for entity ${entityName} and ID ${entityID}`);
-        const latestSnapshot = await this.config.eventStore.latestEntitySnapshot(this.config, entityName, entityID);
-        if (latestSnapshot) {
-            return new schema_migrator_1.SchemaMigrator(this.config).migrate(latestSnapshot);
+        async loadEventStreamSince(entityTypeName, entityID, timestamp) {
+            const logger = (0, common_1.getLogger)(this.config, 'EventStore#loadEventStreamSince');
+            logger.debug(`Loading list of pending events for entity ${entityTypeName} with ID ${entityID} since ${timestamp}`);
+            return this.config.eventStore.forEntitySince(this.config, entityTypeName, entityID, timestamp);
         }
-        return undefined;
-    }
-    async loadEventStreamSince(entityTypeName, entityID, timestamp) {
-        const logger = (0, common_1.getLogger)(this.config, 'EventStore#loadEventStreamSince');
-        logger.debug(`Loading list of pending events for entity ${entityTypeName} with ID ${entityID} since ${timestamp}`);
-        return this.config.eventStore.forEntitySince(this.config, entityTypeName, entityID, timestamp);
-    }
-    async entityReducer(eventEnvelope, latestSnapshot) {
-        const logger = (0, common_1.getLogger)(this.config, 'entityReducer');
-        logger.debug('Calling reducer with event: ', eventEnvelope, ' and entity snapshot ', latestSnapshot);
-        if (this.shouldReduceMagekSuperKind(eventEnvelope)) {
-            return this.reduceSuperKind(eventEnvelope, latestSnapshot);
+        async entityReducer(eventEnvelope, latestSnapshot) {
+            const logger = (0, common_1.getLogger)(this.config, 'entityReducer');
+            logger.debug('Calling reducer with event: ', eventEnvelope, ' and entity snapshot ', latestSnapshot);
+            if (this.shouldReduceMagekSuperKind(eventEnvelope)) {
+                return this.reduceSuperKind(eventEnvelope, latestSnapshot);
+            }
+            const eventMetadata = this.eventMetadataFor(eventEnvelope);
+            const migratedEventEnvelope = await new schema_migrator_1.SchemaMigrator(this.config).migrate(eventEnvelope);
+            const eventInstance = (0, common_1.createInstance)(eventMetadata.class, migratedEventEnvelope.value);
+            const entityMetadata = this.config.entities[migratedEventEnvelope.entityTypeName];
+            const reducerMetadata = this.config.reducers[eventEnvelope.typeName];
+            const snapshotInstance = latestSnapshot ? (0, common_1.createInstance)(entityMetadata.class, latestSnapshot.value) : null;
+            return this.createNewSnapshot(migratedEventEnvelope, eventInstance, snapshotInstance, eventEnvelope, reducerMetadata);
         }
-        const eventMetadata = this.eventMetadataFor(eventEnvelope);
-        const migratedEventEnvelope = await new schema_migrator_1.SchemaMigrator(this.config).migrate(eventEnvelope);
-        const eventInstance = (0, common_1.createInstance)(eventMetadata.class, migratedEventEnvelope.value);
-        const entityMetadata = this.config.entities[migratedEventEnvelope.entityTypeName];
-        const reducerMetadata = this.config.reducers[eventEnvelope.typeName];
-        const snapshotInstance = latestSnapshot ? (0, common_1.createInstance)(entityMetadata.class, latestSnapshot.value) : null;
-        return this.createNewSnapshot(migratedEventEnvelope, eventInstance, snapshotInstance, eventEnvelope, reducerMetadata);
-    }
-    shouldReduceMagekSuperKind(eventEnvelope) {
-        const reducible = reducibleEventsTypesNames.includes(eventEnvelope.typeName);
-        return eventEnvelope.superKind && eventEnvelope.superKind === common_1.MAGEK_SUPER_KIND && reducible;
-    }
-    eventMetadataFor(eventEnvelope) {
-        const logger = (0, common_1.getLogger)(this.config, 'eventMetadataFor');
-        const eventMetadata = this.config.events[eventEnvelope.typeName];
-        if (!eventMetadata) {
-            logger.error(`No event registered for event ${eventEnvelope.typeName}`);
-            throw new common_1.InvalidEventError(`No event registered for event ${eventEnvelope.typeName}`);
+        shouldReduceMagekSuperKind(eventEnvelope) {
+            const reducible = reducibleEventsTypesNames.includes(eventEnvelope.typeName);
+            return eventEnvelope.superKind && eventEnvelope.superKind === common_1.MAGEK_SUPER_KIND && reducible;
         }
-        return eventMetadata;
-    }
-    async createNewSnapshot(migratedEventEnvelope, eventInstance, snapshotInstance, eventEnvelope, reducerMetadata) {
-        const logger = (0, common_1.getLogger)(this.config, 'createNewSnapshot');
-        try {
-            const newEntity = this.reducerForEvent(migratedEventEnvelope.typeName, eventInstance, snapshotInstance)(eventInstance, snapshotInstance);
-            const newSnapshot = {
-                version: this.config.currentVersionFor(eventEnvelope.entityTypeName),
-                kind: 'snapshot',
-                superKind: migratedEventEnvelope.superKind,
-                requestID: migratedEventEnvelope.requestID,
-                entityID: migratedEventEnvelope.entityID,
-                entityTypeName: migratedEventEnvelope.entityTypeName,
-                typeName: migratedEventEnvelope.entityTypeName,
-                value: newEntity,
-                snapshottedEventCreatedAt: migratedEventEnvelope.createdAt,
-            };
-            logger.debug('Reducer result: ', newSnapshot);
-            return newSnapshot;
+        eventMetadataFor(eventEnvelope) {
+            const logger = (0, common_1.getLogger)(this.config, 'eventMetadataFor');
+            const eventMetadata = this.config.events[eventEnvelope.typeName];
+            if (!eventMetadata) {
+                logger.error(`No event registered for event ${eventEnvelope.typeName}`);
+                throw new common_1.InvalidEventError(`No event registered for event ${eventEnvelope.typeName}`);
+            }
+            return eventMetadata;
         }
-        catch (e) {
-            const globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(this.config);
-            throw await globalErrorDispatcher.dispatch(new common_1.ReducerGlobalError(migratedEventEnvelope, eventInstance, snapshotInstance, reducerMetadata, e));
+        async createNewSnapshot(migratedEventEnvelope, eventInstance, snapshotInstance, eventEnvelope, reducerMetadata) {
+            const logger = (0, common_1.getLogger)(this.config, 'createNewSnapshot');
+            try {
+                const reducerResult = this.reducerForEvent(migratedEventEnvelope.typeName, eventInstance, snapshotInstance)(eventInstance, snapshotInstance);
+                if (reducerResult === common_1.ReducerAction.Skip) {
+                    logger.debug('Reducer returned ReducerAction.Skip, skipping snapshot creation');
+                    return common_1.ReducerAction.Skip;
+                }
+                const newSnapshot = {
+                    version: this.config.currentVersionFor(eventEnvelope.entityTypeName),
+                    kind: 'snapshot',
+                    superKind: migratedEventEnvelope.superKind,
+                    requestID: migratedEventEnvelope.requestID,
+                    entityID: migratedEventEnvelope.entityID,
+                    entityTypeName: migratedEventEnvelope.entityTypeName,
+                    typeName: migratedEventEnvelope.entityTypeName,
+                    value: reducerResult,
+                    snapshottedEventCreatedAt: migratedEventEnvelope.createdAt,
+                };
+                logger.debug('Reducer result: ', newSnapshot);
+                return newSnapshot;
+            }
+            catch (e) {
+                const globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(this.config);
+                throw await globalErrorDispatcher.dispatch(new common_1.ReducerGlobalError(migratedEventEnvelope, eventInstance, snapshotInstance, reducerMetadata, e));
+            }
         }
-    }
-    async reduceSuperKind(eventEnvelope, latestSnapshot) {
-        if (eventEnvelope.typeName === entity_touched_1.MagekEntityTouched.name) {
-            return this.reduceEntityTouched(eventEnvelope, latestSnapshot);
+        async reduceSuperKind(eventEnvelope, latestSnapshot) {
+            if (eventEnvelope.typeName === entity_touched_1.MagekEntityTouched.name) {
+                return this.reduceEntityTouched(eventEnvelope, latestSnapshot);
+            }
+            if (eventEnvelope.typeName === entity_migrated_1.MagekEntityMigrated.name) {
+                return this.reduceEntityMigrated(eventEnvelope);
+            }
+            throw new common_1.InvalidParameterError(`Unexpected super kind ${eventEnvelope.superKind} to be reduced`);
         }
-        if (eventEnvelope.typeName === entity_migrated_1.MagekEntityMigrated.name) {
-            return this.reduceEntityMigrated(eventEnvelope);
+        reduceEntityMigrated(eventEnvelope) {
+            const event = eventEnvelope.value;
+            return this.toMagekEntitySnapshot(eventEnvelope, event.newEntity, event.newEntityName);
         }
-        throw new common_1.InvalidParameterError(`Unexpected super kind ${eventEnvelope.superKind} to be reduced`);
-    }
-    reduceEntityMigrated(eventEnvelope) {
-        const event = eventEnvelope.value;
-        return this.toMagekEntitySnapshot(eventEnvelope, event.newEntity, event.newEntityName);
-    }
-    reduceEntityTouched(eventEnvelope, latestSnapshot) {
-        const logger = (0, common_1.getLogger)(this.config, 'EventStore#reduceEntityTouched');
-        logger.debug('Reducing ', eventEnvelope, ' with latestSnapshot');
-        if (!latestSnapshot) {
-            logger.debug('Latest snapshot not found, returning');
-            return;
+        reduceEntityTouched(eventEnvelope, latestSnapshot) {
+            const logger = (0, common_1.getLogger)(this.config, 'EventStore#reduceEntityTouched');
+            logger.debug('Reducing ', eventEnvelope, ' with latestSnapshot');
+            if (!latestSnapshot) {
+                logger.debug('Latest snapshot not found, returning Skip');
+                return common_1.ReducerAction.Skip;
+            }
+            const event = eventEnvelope.value;
+            const entityMetadata = this.config.entities[event.entityName];
+            const snapshotInstance = (0, common_1.createInstance)(entityMetadata.class, latestSnapshot.value);
+            return this.toMagekEntitySnapshot(eventEnvelope, snapshotInstance, event.entityName);
         }
-        const event = eventEnvelope.value;
-        const entityMetadata = this.config.entities[event.entityName];
-        const snapshotInstance = (0, common_1.createInstance)(entityMetadata.class, latestSnapshot.value);
-        return this.toMagekEntitySnapshot(eventEnvelope, snapshotInstance, event.entityName);
-    }
-    toMagekEntitySnapshot(eventEnvelope, entity, className) {
-        const logger = (0, common_1.getLogger)(this.config, 'EventStore#toMagekEntitySnapshot');
-        const migratedSnapshot = {
-            version: this.config.currentVersionFor(className),
-            kind: 'snapshot',
-            superKind: eventEnvelope.superKind,
-            requestID: eventEnvelope.requestID,
-            entityID: entity.id,
-            entityTypeName: className,
-            typeName: className,
-            value: entity,
-            snapshottedEventCreatedAt: eventEnvelope.createdAt,
-        };
-        logger.debug('MagekEntitySnapshot result: ', migratedSnapshot);
-        return migratedSnapshot;
-    }
-    reducerForEvent(eventName, eventInstance, snapshotInstance) {
-        const logger = (0, common_1.getLogger)(this.config, 'EventStore#reducerForEvent');
-        const reducerMetadata = this.config.reducers[eventName];
-        if (!reducerMetadata) {
-            throw new common_1.InvalidReducerError(`No reducer registered for event ${eventName}`, eventInstance, snapshotInstance);
+        toMagekEntitySnapshot(eventEnvelope, entity, className) {
+            const logger = (0, common_1.getLogger)(this.config, 'EventStore#toMagekEntitySnapshot');
+            const migratedSnapshot = {
+                version: this.config.currentVersionFor(className),
+                kind: 'snapshot',
+                superKind: eventEnvelope.superKind,
+                requestID: eventEnvelope.requestID,
+                entityID: entity.id,
+                entityTypeName: className,
+                typeName: className,
+                value: entity,
+                snapshottedEventCreatedAt: eventEnvelope.createdAt,
+            };
+            logger.debug('MagekEntitySnapshot result: ', migratedSnapshot);
+            return migratedSnapshot;
         }
-        else {
-            try {
-                const methodName = reducerMetadata.methodName;
-                const reducer = reducerMetadata.class[methodName];
-                logger.debug(`Found reducer for event ${eventName}: "${reducerMetadata.class.name}.${methodName}"`);
-                return reducer;
+        reducerForEvent(eventName, eventInstance, snapshotInstance) {
+            const logger = (0, common_1.getLogger)(this.config, 'EventStore#reducerForEvent');
+            const reducerMetadata = this.config.reducers[eventName];
+            if (!reducerMetadata) {
+                throw new common_1.InvalidReducerError(`No reducer registered for event ${eventName}`, eventInstance, snapshotInstance);
             }
-            catch {
-                throw new Error(`Couldn't load the Entity class ${reducerMetadata.class.name}`);
+            else {
+                try {
+                    const methodName = reducerMetadata.methodName;
+                    const reducer = reducerMetadata.class[methodName];
+                    logger.debug(`Found reducer for event ${eventName}: "${reducerMetadata.class.name}.${methodName}"`);
+                    return reducer;
+                }
+                catch {
+                    throw new Error(`Couldn't load the Entity class ${reducerMetadata.class.name}`);
+                }
             }
         }
-    }
-}
+    };
+})();
 exports.EventStore = EventStore;
-tslib_1.__decorate([
-    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.FETCH_ENTITY_SNAPSHOT),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", [String, common_1.UUID]),
-    tslib_1.__metadata("design:returntype", Promise)
-], EventStore.prototype, "fetchEntitySnapshot", null);
-tslib_1.__decorate([
-    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.CUSTOM),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", [Object]),
-    tslib_1.__metadata("design:returntype", Promise)
-], EventStore.prototype, "storeDispatchedEvent", null);
-tslib_1.__decorate([
-    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.STORE_SNAPSHOT),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", [Object]),
-    tslib_1.__metadata("design:returntype", Promise)
-], EventStore.prototype, "storeSnapshot", null);
-tslib_1.__decorate([
-    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.LOAD_LATEST_SNAPSHOT),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", [String, common_1.UUID]),
-    tslib_1.__metadata("design:returntype", Promise)
-], EventStore.prototype, "loadLatestSnapshot", null);
-tslib_1.__decorate([
-    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.LOAD_EVENT_STREAM_SINCE),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", [String, common_1.UUID, String]),
-    tslib_1.__metadata("design:returntype", Promise)
-], EventStore.prototype, "loadEventStreamSince", null);
-tslib_1.__decorate([
-    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.ENTITY_REDUCER),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", [Object, Object]),
-    tslib_1.__metadata("design:returntype", Promise)
-], EventStore.prototype, "entityReducer", null);

package/dist/services/graphql/graphql-generator.js

@@ -13,6 +13,11 @@ const graphql_subcriptions_generator_1 = require("./graphql-subcriptions-generat
 const graphql_type_informer_1 = require("./graphql-type-informer");
 const query_dispatcher_1 = require("../../query-dispatcher");
 class GraphQLGenerator {
+    static commandsDispatcher;
+    static queriesDispatcher;
+    static readModelsReader;
+    static eventsReader;
+    static schema;
     static generateSchema(config) {
         const logger = (0, common_1.getLogger)(config, 'GraphQLGenerator#generateSchema');
         if (!this.schema) {
@@ -40,7 +45,7 @@ class GraphQLGenerator {
             let isPaginated = false;
             const fields = this.getFields(info);
             let select = fields.length > 0 ? fields : undefined;
-            if ((info === null || info === void 0 ? void 0 : info.fieldName) === `List${(0, inflected_1.pluralize)(readModelClass.name)}`) {
+            if (info?.fieldName === `List${(0, inflected_1.pluralize)(readModelClass.name)}`) {
                 isPaginated = true;
                 if (select) {
                     // In paginated queries, the `items[].` field needs to be removed from the select fields before querying the database
@@ -72,7 +77,7 @@ class GraphQLGenerator {
             const result = await this.commandsDispatcher.dispatchCommand(commandEnvelope, context);
             // It could be that the command didn't return anything
             // so in that case we return `true`, as GraphQL doesn't have a `null` type
-            return result !== null && result !== void 0 ? result : true;
+            return result ?? true;
         };
     }
     static queriesResolverBuilder(queryClass) {
@@ -228,14 +233,13 @@ class GraphQLGenerator {
 }
 exports.GraphQLGenerator = GraphQLGenerator;
 function toReadModelRequestEnvelope(readModelClass, args, context, paginatedVersion = false, select) {
-    var _a, _b;
     return {
         requestID: context.requestID,
         currentUser: context.user,
         class: readModelClass,
         className: readModelClass.name,
-        filters: (_a = args.filter) !== null && _a !== void 0 ? _a : {},
-        sortBy: (_b = args.sortBy) !== null && _b !== void 0 ? _b : {},
+        filters: args.filter ?? {},
+        sortBy: args.sortBy ?? {},
         limit: args.limit,
         afterCursor: args.afterCursor,
         paginatedVersion,
@@ -251,7 +255,6 @@ function toEventSearchRequest(args, context) {
     };
 }
 function toEnvelope(typeName, value, context) {
-    var _a, _b;
     return {
         requestID: context.requestID,
         currentUser: context.user,
@@ -260,8 +263,8 @@ function toEnvelope(typeName, value, context) {
         version: 1, // TODO: How to pass the version through GraphQL?
         context: {
             request: {
-                body: (_a = context.context) === null || _a === void 0 ? void 0 : _a.request.body,
-                headers: (_b = context.context) === null || _b === void 0 ? void 0 : _b.request.headers,
+                body: context.context?.request.body,
+                headers: context.context?.request.headers,
             },
             rawContext: context,
         },

package/dist/services/graphql/graphql-mutation-generator.js

@@ -4,6 +4,10 @@ exports.GraphQLMutationGenerator = void 0;
 const graphql_1 = require("graphql");
 const graphql_handled_fields_generator_1 = require("./query-helpers/graphql-handled-fields-generator");
 class GraphQLMutationGenerator {
+    targetTypes;
+    typeInformer;
+    mutationResolver;
+    config;
     constructor(targetTypes, typeInformer, mutationResolver, config) {
         this.targetTypes = targetTypes;
         this.typeInformer = typeInformer;

package/dist/services/graphql/graphql-query-generator.js

@@ -8,6 +8,20 @@ const graphql_query_filters_generator_1 = require("./query-generators/graphql-qu
 const graphql_query_listed_generator_1 = require("./query-generators/graphql-query-listed-generator");
 const graphql_query_generator_1 = require("./query-generators/graphql-query-generator");
 class GraphQLQueryGenerator {
+    config;
+    readModels;
+    targetTypes;
+    typeInformer;
+    byIDResolverBuilder;
+    queryResolverBuilder;
+    filterResolverBuilder;
+    eventsResolver;
+    generatedFiltersByTypeName;
+    graphqlQueryByKeysGenerator;
+    graphqlQueryGenerator;
+    graphqlQueryFiltersGenerator;
+    graphqlQueryListedGenerator;
+    graphqlQueryEventsGenerator;
     constructor(config, readModels, targetTypes, typeInformer, byIDResolverBuilder, queryResolverBuilder, filterResolverBuilder, eventsResolver, generatedFiltersByTypeName = {}) {
         this.config = config;
         this.readModels = readModels;

package/dist/services/graphql/graphql-subcriptions-generator.js

@@ -5,6 +5,13 @@ const graphql_1 = require("graphql");
 const inflected = require("inflected");
 const graphql_query_filter_fields_builder_1 = require("./query-helpers/graphql-query-filter-fields-builder");
 class GraphQLSubscriptionGenerator {
+    readModels;
+    typeInformer;
+    byIDResolverBuilder;
+    filterResolverBuilder;
+    generatedFiltersByTypeName;
+    config;
+    graphqlQueryFilterFieldsBuilder;
     constructor(readModels, typeInformer, byIDResolverBuilder, filterResolverBuilder, generatedFiltersByTypeName = {}, config) {
         this.readModels = readModels;
         this.typeInformer = typeInformer;

package/dist/services/graphql/graphql-type-informer.js

@@ -6,9 +6,10 @@ const graphql_1 = require("graphql");
 const graphql_scalars_1 = require("graphql-scalars");
 const common_1 = require("./common");
 class GraphQLTypeInformer {
+    logger;
+    graphQLTypes = {};
     constructor(logger) {
         this.logger = logger;
-        this.graphQLTypes = {};
     }
     generateGraphQLTypeForClass(type, excludeProps, inputType = false) {
         this.logger.debug(`Generate GraphQL ${inputType ? 'input' : 'output'} type for class ${type.name}`);
@@ -123,7 +124,7 @@ class GraphQLTypeInformer {
         if (inputType) {
             return new graphql_1.GraphQLInputObjectType({
                 name: classMetadata.name + 'Input',
-                fields: finalFields === null || finalFields === void 0 ? void 0 : finalFields.reduce((obj, prop) => {
+                fields: finalFields?.reduce((obj, prop) => {
                     this.logger.debug(`Get or create GraphQL input type for property ${prop.name}`);
                     return {
                         ...obj,
@@ -147,7 +148,7 @@ class GraphQLTypeInformer {
         const finalFields = (0, common_1.nonExcludedFields)(classMetadata.fields, excludeProps);
         return new graphql_1.GraphQLObjectType({
             name: classMetadata.name,
-            fields: finalFields === null || finalFields === void 0 ? void 0 : finalFields.reduce((obj, prop) => {
+            fields: finalFields?.reduce((obj, prop) => {
                 this.logger.debug(`Get or create GraphQL output type for property ${prop.name}`);
                 return {
                     ...obj,