@magek/core 0.0.1

package/dist/services/graphql/query-helpers/graphql-query-sort-builder.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlQuerySortBuilder = void 0;
+const graphql_1 = require("graphql");
+const metadata_1 = require("../../../decorators/metadata");
+const common_1 = require("../common");
+class GraphqlQuerySortBuilder {
+    constructor(typeInformer, config) {
+        this.typeInformer = typeInformer;
+        this.config = config;
+        this.generatedSortByByTypeName = {};
+        this.orderType = (0, common_1.buildGraphqlSimpleEnumFor)('orderProperty', ['ASC', 'DESC']);
+    }
+    generateSortArguments(type, excludeProps) {
+        const metadata = (0, metadata_1.getClassMetadata)(type);
+        const args = {};
+        const finalFields = (0, common_1.nonExcludedFields)(metadata.fields, excludeProps);
+        finalFields
+            .filter((field) => !field.typeInfo.isGetAccessor)
+            .forEach((prop) => {
+            args[prop.name] = {
+                type: this.generateSortFor(prop),
+            };
+        });
+        return args;
+    }
+    generateSortFor(prop) {
+        let sortByName = `${prop.typeInfo.name}PropertySortBy`;
+        sortByName = sortByName.charAt(0).toUpperCase() + sortByName.substring(1).replace(/\[]/g, '');
+        if (this.generatedSortByByTypeName[sortByName])
+            return this.generatedSortByByTypeName[sortByName];
+        if (!prop.typeInfo.type || typeof prop.typeInfo.type === 'object')
+            return this.orderType;
+        if (prop.typeInfo.typeGroup === 'Array')
+            return this.orderType;
+        if (prop.typeInfo.name === 'UUID' || prop.typeInfo.name === 'Date')
+            return this.orderType;
+        let fields = {};
+        if (prop.typeInfo.type && prop.typeInfo.typeGroup === 'Class') {
+            if ((0, common_1.isExternalType)(prop.typeInfo))
+                return this.orderType;
+            let nestedProperties = {};
+            const metadata = (0, metadata_1.getClassMetadata)(prop.typeInfo.type);
+            if (metadata.fields.length === 0)
+                return this.orderType;
+            const excludeProps = this.config.nonExposedGraphQLMetadataKey[prop.name];
+            this.typeInformer.generateGraphQLTypeForClass(prop.typeInfo.type, excludeProps, true);
+            for (const prop of metadata.fields) {
+                const property = { [prop.name]: { type: this.generateSortFor(prop) } };
+                nestedProperties = { ...nestedProperties, ...property };
+            }
+            fields = () => ({
+                ...nestedProperties,
+            });
+            this.generatedSortByByTypeName[sortByName] = new graphql_1.GraphQLInputObjectType({ name: sortByName, fields });
+            return this.generatedSortByByTypeName[sortByName];
+        }
+        return this.orderType;
+    }
+}
+exports.GraphqlQuerySortBuilder = GraphqlQuerySortBuilder;

package/dist/services/graphql/websocket-protocol/graphql-websocket-protocol.d.ts

@@ -0,0 +1,20 @@
+import { ExecutionResult } from 'graphql';
+import { MagekConfig, GraphQLRequestEnvelope, GraphQLRequestEnvelopeError } from '@magek/common';
+import { MagekTokenVerifier } from '../../../token-verifier';
+export interface GraphQLWebsocketHandlerCallbacks {
+    onStartOperation: (envelope: GraphQLRequestEnvelope) => Promise<AsyncIterableIterator<ExecutionResult> | ExecutionResult>;
+    onStopOperation: (connectionID: string, messageID: string) => Promise<void>;
+    onTerminate: (connectionID: string) => Promise<void>;
+}
+export declare class GraphQLWebsocketHandler {
+    private readonly config;
+    private readonly callbacks;
+    private readonly tokenVerifier;
+    constructor(config: MagekConfig, callbacks: GraphQLWebsocketHandlerCallbacks, tokenVerifier: MagekTokenVerifier);
+    handle(envelope: GraphQLRequestEnvelope | GraphQLRequestEnvelopeError): Promise<void>;
+    private handleInit;
+    private handleStart;
+    private augmentEnvelope;
+    private handleStop;
+    private handleTerminate;
+}

package/dist/services/graphql/websocket-protocol/graphql-websocket-protocol.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLWebsocketHandler = void 0;
+const common_1 = require("@magek/common");
+class GraphQLWebsocketHandler {
+    constructor(config, callbacks, tokenVerifier) {
+        this.config = config;
+        this.callbacks = callbacks;
+        this.tokenVerifier = tokenVerifier;
+    }
+    async handle(envelope) {
+        const logger = (0, common_1.getLogger)(this.config, 'GraphQLWebsocketHandler#handle');
+        if (!envelope.connectionID) {
+            // Impossible case, but just to be sure. The only thing we can do here is to log, as we don't have the connection
+            // to send the message to
+            logger.error('Missing websocket connectionID');
+            return;
+        }
+        try {
+            logger.debug('Handling websocket message');
+            if ('error' in envelope) {
+                throw envelope.error;
+            }
+            if (!envelope.value) {
+                throw new Error('Received an empty GraphQL body');
+            }
+            const clientMessage = envelope.value;
+            logger.debug('Received client message: ', clientMessage);
+            switch (clientMessage.type) {
+                case common_1.MessageTypes.GQL_CONNECTION_INIT:
+                    return await this.handleInit(envelope.connectionID, clientMessage);
+                case common_1.MessageTypes.GQL_START:
+                    return await this.handleStart(envelope.connectionID, envelope, clientMessage);
+                case common_1.MessageTypes.GQL_STOP:
+                    return await this.handleStop(envelope.connectionID, clientMessage);
+                case common_1.MessageTypes.GQL_CONNECTION_TERMINATE:
+                    return await this.handleTerminate(envelope.connectionID);
+                default:
+                    // This branch should be impossible, but just in case
+                    throw new Error(`Unknown message type. Message=${clientMessage}`);
+            }
+        }
+        catch (e) {
+            const error = e;
+            logger.error(e);
+            await this.config.provider.messaging.sendMessage(this.config, envelope.connectionID, new common_1.GraphQLInitError(error.message));
+        }
+    }
+    async handleInit(connectionID, clientMessage) {
+        var _a;
+        const logger = (0, common_1.getLogger)(this.config, 'GraphQLWebsocketHandler#handleInit');
+        let userEnvelope;
+        if ((_a = clientMessage.payload) === null || _a === void 0 ? void 0 : _a.Authorization) {
+            userEnvelope = await this.tokenVerifier.verify(clientMessage.payload.Authorization);
+        }
+        const nowEpoch = Math.floor(new Date().getTime() / 1000);
+        const connectionData = {
+            expirationTime: nowEpoch + this.config.subscriptions.maxConnectionDurationInSeconds,
+            user: userEnvelope,
+        };
+        logger.debug('Storing connection data: ', connectionData);
+        await this.config.sessionStore.storeConnection(this.config, connectionID, connectionData);
+        logger.debug('Sending ACK');
+        await this.config.provider.messaging.sendMessage(this.config, connectionID, new common_1.GraphQLInitAck());
+    }
+    async handleStart(connectionID, envelope, message) {
+        const logger = (0, common_1.getLogger)(this.config, 'GraphQLWebsocketHandler#handleStart');
+        if (!message.id) {
+            throw new Error(`Missing "id" in ${message.type} message`);
+        }
+        if (!message.payload || !message.payload.query) {
+            await this.config.provider.messaging.sendMessage(this.config, connectionID, new common_1.GraphQLError(message.id, {
+                errors: [new Error('Message payload is invalid it must contain at least the "query" property')],
+            }));
+            return;
+        }
+        const augmentedEnvelope = await this.augmentEnvelope(connectionID, envelope, message);
+        logger.debug('Executing operation. Envelope: ', augmentedEnvelope);
+        const result = await this.callbacks.onStartOperation(augmentedEnvelope);
+        if ('next' in result) {
+            logger.debug('Subscription finished.');
+            return; // It was a subscription. We don't need to send any data
+        }
+        logger.debug('Operation finished. Sending DATA:', result);
+        // It was a query or mutation. We send data and complete the operation
+        await this.config.provider.messaging.sendMessage(this.config, connectionID, new common_1.GraphQLData(message.id, result));
+        await this.config.provider.messaging.sendMessage(this.config, connectionID, new common_1.GraphQLComplete(message.id));
+    }
+    async augmentEnvelope(connectionID, envelope, message) {
+        const logger = (0, common_1.getLogger)(this.config, 'GraphQLWebsocketHandler#augmentEnvelope');
+        const connectionData = await this.config.sessionStore.fetchConnection(this.config, connectionID);
+        logger.debug('Found connection data: ', connectionData);
+        return {
+            ...envelope,
+            currentUser: connectionData === null || connectionData === void 0 ? void 0 : connectionData.user,
+            value: {
+                ...message.payload,
+                id: message.id,
+            },
+        };
+    }
+    async handleStop(connectionID, message) {
+        const logger = (0, common_1.getLogger)(this.config, 'GraphQLWebsocketHandler#handleStop');
+        if (!message.id) {
+            throw new Error(`Missing "id" in ${message.type} message`);
+        }
+        logger.debug('Executing stop operation');
+        await this.callbacks.onStopOperation(connectionID, message.id);
+        logger.debug('Stop operation finished');
+        try {
+            await this.config.provider.messaging.sendMessage(this.config, connectionID, new common_1.GraphQLComplete(message.id));
+        }
+        catch (e) {
+            // It could be the case that the client already closed the connection without waiting for stop operation to finish
+            // Log this but ignore it
+            logger.info(`Received an exception while sending the "complete" message after stopping the GraphQL operation with id ${message.id}.` +
+                'The client probably closed the connection. Ignoring. ', e);
+        }
+    }
+    async handleTerminate(connectionID) {
+        const logger = (0, common_1.getLogger)(this.config, 'GraphQLWebsocketHandler#handleTerminate');
+        logger.debug('Executing terminate operation');
+        await this.callbacks.onTerminate(connectionID);
+        logger.debug('Terminate operation finished');
+    }
+}
+exports.GraphQLWebsocketHandler = GraphQLWebsocketHandler;

package/dist/services/pub-sub/noop-read-model-pub-sub.d.ts

@@ -0,0 +1,5 @@
+import { ReadModelRequestEnvelope, ReadModelInterface } from '@magek/common';
+import { ReadModelPubSub } from './read-model-pub-sub';
+export declare class NoopReadModelPubSub implements ReadModelPubSub<ReadModelInterface> {
+    asyncIterator(_: ReadModelRequestEnvelope<ReadModelInterface>): Promise<AsyncIterator<ReadModelInterface>>;
+}

package/dist/services/pub-sub/noop-read-model-pub-sub.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopReadModelPubSub = void 0;
+const iterall_1 = require("iterall");
+class NoopReadModelPubSub {
+    async asyncIterator(_) {
+        return (0, iterall_1.createAsyncIterator)([]);
+    }
+}
+exports.NoopReadModelPubSub = NoopReadModelPubSub;

package/dist/services/pub-sub/read-model-pub-sub.d.ts

@@ -0,0 +1,9 @@
+import { ReadModelRequestEnvelope, ReadModelInterface, Instance, MagekConfig } from '@magek/common';
+export interface ReadModelPubSub<TReadModel extends ReadModelInterface> {
+    asyncIterator(readModelRequestEnvelope: ReadModelRequestEnvelope<TReadModel>, config: MagekConfig): Promise<AsyncIterator<ReadModelInterface>>;
+}
+export declare class FilteredReadModelPubSub<TReadModel extends ReadModelInterface> implements ReadModelPubSub<TReadModel> {
+    private readModels;
+    constructor(readModels: Array<ReadModelInterface & Instance>);
+    asyncIterator(readModelRequestEnvelope: ReadModelRequestEnvelope<TReadModel>, config: MagekConfig): Promise<AsyncIterator<ReadModelInterface>>;
+}

package/dist/services/pub-sub/read-model-pub-sub.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilteredReadModelPubSub = void 0;
+const iterall_1 = require("iterall");
+const filter_helpers_1 = require("../filter-helpers");
+class FilteredReadModelPubSub {
+    constructor(readModels) {
+        this.readModels = readModels;
+    }
+    async asyncIterator(readModelRequestEnvelope, config) {
+        const readModelMetadata = config.readModels[readModelRequestEnvelope.class.name];
+        const newReadModelRequestEnvelope = await (0, filter_helpers_1.applyReadModelRequestBeforeFunctions)(readModelRequestEnvelope, readModelMetadata.before, readModelRequestEnvelope.currentUser);
+        return (0, iterall_1.createAsyncIterator)(this.readModels
+            .filter((readModel) => newReadModelRequestEnvelope.class.name == readModel.constructor.name)
+            .filter((readModel) => filterReadModel(readModel, newReadModelRequestEnvelope.filters)));
+    }
+}
+exports.FilteredReadModelPubSub = FilteredReadModelPubSub;
+function filterReadModel(readModel, filters) {
+    for (const filteredProp in filters) {
+        const readModelPropValue = readModel[filteredProp];
+        return filterByOperation(filters[filteredProp], readModelPropValue);
+    }
+    return true;
+}
+function filterByOperation(filter, readModelPropValue) {
+    for (const [operation, value] of Object.entries(filter)) {
+        switch (operation) {
+            case 'eq':
+                if (readModelPropValue !== value)
+                    return false;
+                break;
+            case 'ne':
+                if (readModelPropValue === value)
+                    return false;
+                break;
+            case 'lt':
+                if (readModelPropValue >= value)
+                    return false;
+                break;
+            case 'gt':
+                if (readModelPropValue <= value)
+                    return false;
+                break;
+            case 'gte':
+                if (readModelPropValue < value)
+                    return false;
+                break;
+            case 'lte':
+                if (readModelPropValue > value)
+                    return false;
+                break;
+            case 'in':
+                if (!value.includes(readModelPropValue))
+                    return false;
+                break;
+            case 'contains':
+                if (!contains(readModelPropValue, value))
+                    return false;
+                break;
+            case 'beginsWith':
+                if (!beginWith(readModelPropValue, value))
+                    return false;
+                break;
+            case 'includes':
+                return includes(readModelPropValue, value);
+            case 'regex':
+                if (!regex(readModelPropValue, value))
+                    return false;
+                break;
+            case 'iRegex':
+                if (!regex(readModelPropValue, value, 'i'))
+                    return false;
+                break;
+            default:
+                if (typeof value === 'object') {
+                    return filterByOperation(value, readModelPropValue[operation]);
+                }
+        }
+    }
+    return true;
+}
+function regex(readModelPropValue, element, flags) {
+    if (!Array.isArray(readModelPropValue) && typeof readModelPropValue === 'string') {
+        const expression = new RegExp(element, flags);
+        return expression.test(readModelPropValue);
+    }
+    return false;
+}
+function contains(readModelPropValue, element) {
+    if (Array.isArray(readModelPropValue) || typeof readModelPropValue === 'string') {
+        return readModelPropValue.includes(element);
+    }
+    return false;
+}
+function beginWith(readModelPropValue, element) {
+    if (typeof readModelPropValue === 'string') {
+        return readModelPropValue.startsWith(element);
+    }
+    return false;
+}
+function includes(readModelPropValue, element) {
+    if (Array.isArray(readModelPropValue)) {
+        // Check that array includes an object
+        if (typeof element === 'object') {
+            return readModelPropValue.some((item) => Object.keys(element).every((key) => item[key] === element[key]));
+        }
+        // If not, do a regular includes
+        return readModelPropValue.includes(element);
+    }
+    return false;
+}

package/dist/services/raw-events-parser.d.ts

@@ -0,0 +1,5 @@
+import { MagekConfig, EventEnvelope, UUID } from '@magek/common';
+export type EventsStreamingCallback = (entityName: string, entityID: UUID, eventEnvelopes: Array<EventEnvelope>, config: MagekConfig) => Promise<void>;
+export declare class RawEventsParser {
+    static streamPerEntityEvents(config: MagekConfig, eventEnvelopes: Array<EventEnvelope>, callbackFn: EventsStreamingCallback): Promise<void>;
+}

package/dist/services/raw-events-parser.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawEventsParser = void 0;
+const common_1 = require("@magek/common");
+class RawEventsParser {
+    static async streamPerEntityEvents(config, eventEnvelopes, callbackFn) {
+        const logger = (0, common_1.getLogger)(config, 'RawEventsParser#streamPerEntityEvents');
+        const eventEnvelopesPerEntity = eventEnvelopes
+            .filter(isEventKind)
+            .filter(isNotDeleted)
+            .reduce(groupByEntity, {});
+        const processes = Object.values(eventEnvelopesPerEntity).map(async (entityEnvelopes) => {
+            // All envelopes are for the same entity type/ID, so we get the first one to get those values
+            if (!entityEnvelopes[0]) {
+                throw new Error('The impossible happened: Attempted to process a non existent event');
+            }
+            const { entityTypeName, entityID } = entityEnvelopes[0];
+            logger.debug(`Streaming the following events for entity '${entityTypeName}' and ID '${entityID}':`, entityEnvelopes);
+            try {
+                await callbackFn(entityTypeName, entityID, entityEnvelopes, config);
+            }
+            catch (e) {
+                logger.error(`An error occurred while processing events for entity ${entityTypeName} with ID ${entityID}`, e);
+            }
+        });
+        // We use allSettled because we don't care if some of the processes fail
+        await Promise.allSettled(processes);
+    }
+}
+exports.RawEventsParser = RawEventsParser;
+function isEventKind(envelope) {
+    return envelope.kind == 'event';
+}
+function isNotDeleted(envelope) {
+    return !(envelope === null || envelope === void 0 ? void 0 : envelope.deletedAt);
+}
+function groupByEntity(envelopesPerEntity, envelope) {
+    const entityKey = `${envelope.entityTypeName}-${envelope.entityID}`;
+    if (!envelopesPerEntity[entityKey]) {
+        envelopesPerEntity[entityKey] = [];
+    }
+    envelopesPerEntity[entityKey].push(envelope);
+    return envelopesPerEntity;
+}

package/dist/services/read-model-searcher.d.ts

@@ -0,0 +1,2 @@
+import { MagekConfig, Class, ReadModelInterface, Searcher } from '@magek/common';
+export declare function readModelSearcher<TReadModel extends ReadModelInterface>(config: MagekConfig, readModelClass: Class<TReadModel>): Searcher<TReadModel>;

package/dist/services/read-model-searcher.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readModelSearcher = readModelSearcher;
+const common_1 = require("@magek/common");
+const read_models_reader_1 = require("../read-models-reader");
+function readModelSearcher(config, readModelClass) {
+    const readModelsReader = new read_models_reader_1.MagekReadModelsReader(config);
+    const searcherFunction = readModelsReader.readModelSearch.bind(readModelsReader);
+    const finderByIdFunction = readModelsReader.finderByIdFunction.bind(readModelsReader);
+    return new common_1.Searcher(readModelClass, searcherFunction, finderByIdFunction);
+}

package/dist/services/read-model-store.d.ts

@@ -0,0 +1,41 @@
+import { MagekConfig, EntityInterface, EntityMetadata, EntitySnapshotEnvelope, ProjectionMetadata, ReadModelInterface, SequenceKey, UUID } from '@magek/common';
+export declare class ReadModelStore {
+    readonly config: MagekConfig;
+    constructor(config: MagekConfig);
+    project(entitySnapshotEnvelope: EntitySnapshotEnvelope, deleteEvent?: boolean): Promise<void>;
+    /**
+     * Gets the read models for a given entity instance using the projection metadata
+     * @param {EntityInterface} entityInstance The entity instance to get the read models for
+     * @param {ProjectionMetadata<EntityInterface, ReadModelInterface>} projectionMetadata The projection metadata to use to get the read models
+     * @param {EntityMetadata} entityMetadata The entity metadata for the entity instance
+     * @returns {Promise<Array<ReadModelInterface>>} The read models for the entity instance
+     */
+    getReadModels(entityInstance: EntityInterface, projectionMetadata: ProjectionMetadata<EntityInterface, ReadModelInterface>, entityMetadata: EntityMetadata): Promise<Array<ReadModelInterface>>;
+    /**
+     * Gets a specific read model instance referencing it by ID when it's a regular read model
+     * or by ID + sequenceKey when it's a sequenced read model
+     * @param {string} readModelName The name of the read model class
+     * @param {UUID | undefined} readModelID The ID of the read model instance
+     * @param {SequenceKey} sequenceKey The sequence key of the read model instance
+     * @returns {Promise<ReadModelInterface | undefined>} The read model instance or undefined if it doesn't exist
+     */
+    fetchReadModel(readModelName: string, readModelID: UUID | undefined, sequenceKey?: SequenceKey): Promise<ReadModelInterface | undefined>;
+    getProjectionFunction(projectionMetadata: ProjectionMetadata<EntityInterface, ReadModelInterface>): Function;
+    private getUnProjections;
+    private entityProjections;
+    private entityUnProjections;
+    private findFirstMissingProjection;
+    private someProjection;
+    private sequenceKeyForProjection;
+    private projectEntity;
+    private projectionsForReadModels;
+    private projectAndStoreReadModelWithRetry;
+    private instanceReadModels;
+    private applyProjectionToReadModel;
+    private store;
+    private callProjectionFunction;
+    private filterForProjection;
+    private filterForEntityProjection;
+    private filterForReadModelProjection;
+    private isJoinKeyByEntity;
+}