@magek/core 0.0.1

package/dist/sensor/health/health-service.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekHealthService = void 0;
+const common_1 = require("@magek/common");
+const health_utils_1 = require("./health-utils");
+const health_indicators_1 = require("./health-indicators");
+const token_verifier_1 = require("../../token-verifier");
+const authorizer_1 = require("../../authorizer");
+/**
+ * This class is in charge of handling the health check requests
+ * and dispatching the health checks to the corresponding health indicators
+ */
+class MagekHealthService {
+    constructor(config) {
+        this.config = config;
+    }
+    async health(request) {
+        try {
+            const healthEnvelope = this.config.provider.sensor.rawRequestToHealthEnvelope(request);
+            await this.validate(healthEnvelope);
+            const healthProviders = this.getHealthProviders();
+            const parents = this.parentsHealthProviders(healthEnvelope, healthProviders);
+            const healthIndicatorResults = await this.healthProviderResolver(parents, healthProviders);
+            // Check if all components are healthy
+            const isHealthy = this.isOverallHealthy(healthIndicatorResults);
+            // Use the new health specific response handler
+            return await this.config.provider.api.healthRequestResult(healthIndicatorResults, isHealthy);
+        }
+        catch (e) {
+            return await this.config.provider.api.requestFailed(e);
+        }
+    }
+    async validate(healthEnvelope) {
+        const userEnvelope = await this.verify(healthEnvelope);
+        const authorizer = authorizer_1.MagekAuthorizer.build(this.config.sensorConfiguration.health.globalAuthorizer);
+        await authorizer(userEnvelope, healthEnvelope);
+    }
+    async healthProviderResolver(healthIndicatorsMetadata, healthProviders) {
+        const result = [];
+        for (const current of healthIndicatorsMetadata) {
+            const indicatorResult = await this.enabledIndicatorHealth(current, healthProviders);
+            if (!indicatorResult) {
+                continue;
+            }
+            const children = (0, health_utils_1.childHealthProviders)(current, healthProviders);
+            // Check if the result is already a HealthIndicatorsResult (has name and id)
+            const isHealthIndicatorsResult = 'name' in indicatorResult && 'id' in indicatorResult;
+            const newResult = {
+                ...indicatorResult,
+                name: isHealthIndicatorsResult
+                    ? indicatorResult.name
+                    : current.healthIndicatorConfiguration.name,
+                id: current.healthIndicatorConfiguration.id,
+            };
+            if (children && (children === null || children === void 0 ? void 0 : children.length) > 0) {
+                newResult.components = await this.healthProviderResolver(children, healthProviders);
+            }
+            result.push(newResult);
+        }
+        return result;
+    }
+    async enabledIndicatorHealth(current, healthProviders) {
+        if ((0, health_utils_1.isEnabled)(current, healthProviders)) {
+            return await this.indicatorHealth(current);
+        }
+        return;
+    }
+    async indicatorHealth(metadata) {
+        const rootClass = metadata.class;
+        const instance = (0, common_1.createInstance)(rootClass, {});
+        const healthIndicatorResult = await instance.health(this.config, metadata);
+        if (!metadata.healthIndicatorConfiguration.details) {
+            healthIndicatorResult.details = undefined;
+        }
+        return healthIndicatorResult;
+    }
+    /**
+     * If there is not any indicator configured, then we will use only the Magek indicators.
+     * @private
+     */
+    getHealthProviders() {
+        return Object.keys(this.config.userHealthIndicators).length !== 0
+            ? this.config.userHealthIndicators
+            : (0, health_indicators_1.defaultMagekHealthIndicators)(this.config);
+    }
+    parentsHealthProviders(envelope, healthProviders) {
+        const componentPath = envelope.componentPath;
+        if (!componentPath || componentPath.length === 0) {
+            return (0, health_utils_1.rootHealthProviders)(healthProviders);
+        }
+        return [(0, health_utils_1.metadataFromId)(healthProviders, componentPath)];
+    }
+    async verify(envelope) {
+        const tokenVerifier = new token_verifier_1.MagekTokenVerifier(this.config);
+        const token = envelope.token;
+        if (!token) {
+            return;
+        }
+        return await tokenVerifier.verify(token);
+    }
+    isOverallHealthy(results) {
+        for (const result of results) {
+            // Check current component's status
+            if (result.status !== common_1.HealthStatus.UP) {
+                return false;
+            }
+            // Recursively check child components if they exist
+            if (result.components && result.components.length > 0) {
+                if (!this.isOverallHealthy(result.components)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+exports.MagekHealthService = MagekHealthService;

package/dist/sensor/health/health-utils.d.ts

@@ -0,0 +1,7 @@
+import { HealthIndicatorMetadata } from '@magek/common';
+export declare function metadataFromId(healthProviders: Record<string, HealthIndicatorMetadata>, id: string): HealthIndicatorMetadata;
+export declare function parentId(healthProvider: HealthIndicatorMetadata): string;
+export declare function rootHealthProviders(healthProviders: Record<string, HealthIndicatorMetadata>): Array<HealthIndicatorMetadata>;
+export declare function childHealthProviders(healthIndicatorMetadata: HealthIndicatorMetadata, healthProviders: Record<string, HealthIndicatorMetadata>): Array<HealthIndicatorMetadata>;
+export declare function isEnabled(mainIndicatorMetadata: HealthIndicatorMetadata, healthProviders: Record<string, HealthIndicatorMetadata>): boolean;
+export declare function showChildren(mainIndicatorMetadata: HealthIndicatorMetadata, healthProviders: Record<string, HealthIndicatorMetadata>): boolean;

package/dist/sensor/health/health-utils.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metadataFromId = metadataFromId;
+exports.parentId = parentId;
+exports.rootHealthProviders = rootHealthProviders;
+exports.childHealthProviders = childHealthProviders;
+exports.isEnabled = isEnabled;
+exports.showChildren = showChildren;
+const PATH_SEPARATOR = '/';
+function metadataFromId(healthProviders, id) {
+    const healthProvider = healthProviders[id];
+    if (!healthProvider) {
+        throw new Error(`Unexpected HealthProvider id ${id}`);
+    }
+    return healthProvider;
+}
+function parentId(healthProvider) {
+    const childId = healthProvider.healthIndicatorConfiguration.id;
+    const childPath = childId.split(PATH_SEPARATOR);
+    return childPath.slice(0, -1).join(PATH_SEPARATOR);
+}
+function rootHealthProviders(healthProviders) {
+    return Object.values(healthProviders).filter((healthProvider) => healthProvider.healthIndicatorConfiguration.id.split(PATH_SEPARATOR).length === 1);
+}
+function childHealthProviders(healthIndicatorMetadata, healthProviders) {
+    if (!showChildren(healthIndicatorMetadata, healthProviders)) {
+        return [];
+    }
+    const currentParentId = healthIndicatorMetadata.healthIndicatorConfiguration.id;
+    return Object.values(healthProviders).filter((healthProvider) => {
+        return parentId(healthProvider) === currentParentId;
+    });
+}
+function isEnabled(mainIndicatorMetadata, healthProviders) {
+    if (!mainIndicatorMetadata.healthIndicatorConfiguration.enabled) {
+        return false;
+    }
+    const parent = healthProviders[parentId(mainIndicatorMetadata)];
+    if (!parent) {
+        return true;
+    }
+    return isEnabled(parent, healthProviders);
+}
+function showChildren(mainIndicatorMetadata, healthProviders) {
+    if (!mainIndicatorMetadata.healthIndicatorConfiguration.showChildren) {
+        return false;
+    }
+    const parent = healthProviders[parentId(mainIndicatorMetadata)];
+    if (!parent) {
+        return true;
+    }
+    return showChildren(parent, healthProviders);
+}

package/dist/sensor/health/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../../decorators/health-sensor';
+export * from './health-indicators/index';
+export * from './health-service';

package/dist/sensor/health/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../../decorators/health-sensor"), exports);
+tslib_1.__exportStar(require("./health-indicators/index"), exports);
+tslib_1.__exportStar(require("./health-service"), exports);

package/dist/sensor/index.d.ts

@@ -0,0 +1 @@
+export * from './health/index';

package/dist/sensor/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./health/index"), exports);

package/dist/services/event-store.d.ts

@@ -0,0 +1,27 @@
+import { MagekConfig, EntitySnapshotEnvelope, EventEnvelope, UUID } from '@magek/common';
+export declare class EventStore {
+    readonly config: MagekConfig;
+    constructor(config: MagekConfig);
+    /**
+     * 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.
+     */
+    fetchEntitySnapshot(entityName: string, entityID: UUID): Promise<EntitySnapshotEnvelope | undefined>;
+    storeDispatchedEvent(eventEnvelope: EventEnvelope): Promise<boolean | undefined>;
+    private storeSnapshot;
+    private loadLatestSnapshot;
+    private loadEventStreamSince;
+    private entityReducer;
+    private shouldReduceMagekSuperKind;
+    private eventMetadataFor;
+    private createNewSnapshot;
+    private reduceSuperKind;
+    private reduceEntityMigrated;
+    private reduceEntityTouched;
+    private toMagekEntitySnapshot;
+    private reducerForEvent;
+}

package/dist/services/event-store.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventStore = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const global_error_dispatcher_1 = require("../global-error-dispatcher");
+const schema_migrator_1 = require("../schema-migrator");
+const entity_migrated_1 = require("../core-concepts/data-migration/events/entity-migrated");
+const entity_touched_1 = require("../core-concepts/touch-entity/events/entity-touched");
+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;
+        }
+        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;
+                        }
+                        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;
+                    }
+                }
+            }
+            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);
+            }
+            else {
+                logger.debug(`Reduced new snapshot for entity ${entityName} with ID ${entityID}: `, newEntitySnapshot);
+            }
+            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);
+        }
+        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 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);
+        }
+        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}`);
+        }
+        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;
+        }
+        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);
+        }
+        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`);
+    }
+    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;
+        }
+        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);
+        }
+        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/filter-helpers.d.ts

@@ -0,0 +1,3 @@
+import { ReadModelBeforeFunction, CommandBeforeFunction, CommandInput, UserEnvelope, ReadModelRequestEnvelope, ReadModelInterface, QueryInput, QueryBeforeFunction } from '@magek/common';
+export declare const applyReadModelRequestBeforeFunctions: (readModelRequestEnvelope: ReadModelRequestEnvelope<ReadModelInterface>, beforeHooks: Array<ReadModelBeforeFunction>, currentUser?: UserEnvelope) => Promise<ReadModelRequestEnvelope<ReadModelInterface>>;
+export declare const applyBeforeFunctions: (commandInput: CommandInput | QueryInput, beforeHooks: Array<CommandBeforeFunction | QueryBeforeFunction>, currentUser?: UserEnvelope) => Promise<CommandInput | QueryInput>;

package/dist/services/filter-helpers.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyBeforeFunctions = exports.applyReadModelRequestBeforeFunctions = void 0;
+const applyReadModelRequestBeforeFunctions = async (readModelRequestEnvelope, beforeHooks, currentUser) => {
+    let result = readModelRequestEnvelope;
+    for (const beforeHook of beforeHooks) {
+        result = await beforeHook(result, currentUser);
+    }
+    return result;
+};
+exports.applyReadModelRequestBeforeFunctions = applyReadModelRequestBeforeFunctions;
+const applyBeforeFunctions = async (commandInput, beforeHooks, currentUser) => {
+    let result = commandInput;
+    for (const beforeHook of beforeHooks) {
+        result = await beforeHook(result, currentUser);
+    }
+    return result;
+};
+exports.applyBeforeFunctions = applyBeforeFunctions;

package/dist/services/graphql/common.d.ts

@@ -0,0 +1,26 @@
+import { GraphQLScalarType } from 'graphql/type/definition';
+import { AnyClass, UserEnvelope, UUID, GraphQLOperation, ReadModelInterface, ContextEnvelope, PropertyMetadata, TypeMetadata } from '@magek/common';
+import { GraphQLEnumType, GraphQLFieldResolver, GraphQLList, GraphQLObjectType, GraphQLType } from 'graphql';
+import { ReadModelPubSub } from '../pub-sub/read-model-pub-sub';
+export type TargetTypesMap = Record<string, TargetTypeMetadata>;
+export interface TargetTypeMetadata {
+    class: AnyClass;
+    properties: Array<PropertyMetadata>;
+    methods: Array<PropertyMetadata>;
+}
+export type GraphQLNonInputType = GraphQLObjectType | GraphQLScalarType | GraphQLList<GraphQLType>;
+export type ResolverBuilder = (objectClass: AnyClass) => GraphQLFieldResolver<unknown, GraphQLResolverContext, any>;
+export interface GraphQLResolverContext {
+    connectionID?: string;
+    responseHeaders: Record<string, string>;
+    operation: GraphQLOperation;
+    requestID: UUID;
+    user?: UserEnvelope;
+    storeSubscriptions: boolean;
+    pubSub: ReadModelPubSub<ReadModelInterface>;
+    context?: ContextEnvelope;
+}
+export declare const DateScalar: GraphQLScalarType<Date, string>;
+export declare function isExternalType(typeMetadata: Pick<TypeMetadata, 'importPath'>): boolean;
+export declare const buildGraphqlSimpleEnumFor: (enumName: string, values: Array<string>) => GraphQLEnumType;
+export declare function nonExcludedFields(fields: Array<PropertyMetadata>, excludeProps?: Array<string>): Array<PropertyMetadata>;

package/dist/services/graphql/common.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraphqlSimpleEnumFor = exports.DateScalar = void 0;
+exports.isExternalType = isExternalType;
+exports.nonExcludedFields = nonExcludedFields;
+const definition_1 = require("graphql/type/definition");
+const graphql_1 = require("graphql");
+function parseDate(inputValue) {
+    const result = safeParse();
+    switch (result.type) {
+        case 'success':
+            return result.date;
+        case 'error':
+            throw new Error(result.message);
+    }
+    function safeParse() {
+        if (typeof inputValue !== 'string')
+            return { type: 'error', message: `Invalid date, not a string: ${inputValue}` };
+        const date = new Date(inputValue); // Verified that it's a string, so it's safe to cast.
+        return isNaN(date.getTime()) ? { type: 'error', message: `Invalid date: ${inputValue}` } : { type: 'success', date };
+    }
+}
+exports.DateScalar = new definition_1.GraphQLScalarType({
+    name: 'Date',
+    description: 'Date custom scalar type',
+    serialize(value) {
+        return value.toJSON();
+    },
+    parseValue: parseDate,
+    parseLiteral(ast) {
+        if (ast.kind === graphql_1.Kind.STRING) {
+            return parseDate(ast.value);
+        }
+        // This should never happen, it's not safe, but the safeguards at the edges should guarantee this.
+        return null;
+    },
+});
+function isExternalType(typeMetadata) {
+    return !!typeMetadata.importPath && !typeMetadata.importPath.startsWith('.');
+}
+const buildGraphqlSimpleEnumFor = (enumName, values) => {
+    return new graphql_1.GraphQLEnumType({
+        name: enumName,
+        values: values.reduce((valuesRecord, value) => {
+            valuesRecord[value] = { value };
+            return valuesRecord;
+        }, {}),
+    });
+};
+exports.buildGraphqlSimpleEnumFor = buildGraphqlSimpleEnumFor;
+function nonExcludedFields(fields, excludeProps) {
+    return excludeProps ? fields.filter((field) => !excludeProps.includes(field.name)) : fields;
+}

package/dist/services/graphql/graphql-generator.d.ts

@@ -0,0 +1,46 @@
+import { AnyClass, MagekConfig, EventSearchParameters, EventSearchResponse, ReadModelByIdRequestArgs, ReadModelInterface, ReadModelRequestArgs, ReadModelRequestProperties } from '@magek/common';
+import { GraphQLFieldResolver, GraphQLSchema } from 'graphql';
+import { GraphQLResolverContext } from './common';
+export declare class GraphQLGenerator {
+    private static commandsDispatcher;
+    private static queriesDispatcher;
+    private static readModelsReader;
+    private static eventsReader;
+    private static schema;
+    static generateSchema(config: MagekConfig): GraphQLSchema;
+    static readModelResolverBuilder(readModelClass: AnyClass): GraphQLFieldResolver<unknown, GraphQLResolverContext, ReadModelRequestArgs<ReadModelInterface>>;
+    static readModelByIDResolverBuilder(config: MagekConfig, readModelClass: AnyClass): GraphQLFieldResolver<unknown, GraphQLResolverContext, ReadModelByIdRequestArgs>;
+    static eventResolver(parent: unknown, args: EventSearchParameters, context: GraphQLResolverContext): Promise<Array<EventSearchResponse>>;
+    static commandResolverBuilder(commandClass: AnyClass): GraphQLFieldResolver<unknown, GraphQLResolverContext, {
+        input: unknown;
+    }>;
+    static queriesResolverBuilder(queryClass: AnyClass): GraphQLFieldResolver<unknown, GraphQLResolverContext, {
+        input: unknown;
+    }>;
+    static subscriptionByIDResolverBuilder(config: MagekConfig, readModelClass: AnyClass): GraphQLFieldResolver<unknown, GraphQLResolverContext, ReadModelRequestProperties<ReadModelInterface>>;
+    static subscriptionResolverBuilder(config: MagekConfig, readModelClass: AnyClass): GraphQLFieldResolver<unknown, GraphQLResolverContext, ReadModelRequestArgs<ReadModelInterface>>;
+    private static toReadModelByIdRequestEnvelope;
+    /**
+     * Extracts the fields from a GraphQLResolveInfo object. This object is part of a GraphQL request and the goal is to
+     * identify the fields in the request. For example, for the following GraphQL query request:
+     *
+     * ```graphql
+     * query {
+     *   CartReadModel {
+     *     id
+     *     cartItems {
+     *       id
+     *       quantity
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * it will return the following list of fields: `['id', 'cartItems[].id', 'cartItems[].quantity']`
+     *
+     * @param {GraphQLResolveInfo} info - The GraphQLResolveInfo object.
+     * @returns {string[]} - The extracted fields.
+     * @private
+     */
+    private static getFields;
+}