@magek/core 0.0.1

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

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadModelStore = void 0;
+const common_1 = require("@magek/common");
+const global_error_dispatcher_1 = require("../global-error-dispatcher");
+const read_model_searcher_1 = require("./read-model-searcher");
+const read_model_schema_migrator_1 = require("../read-model-schema-migrator");
+class ReadModelStore {
+    constructor(config) {
+        this.config = config;
+    }
+    async project(entitySnapshotEnvelope, deleteEvent = false) {
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelStore#project');
+        const projections = deleteEvent
+            ? this.getUnProjections(entitySnapshotEnvelope)
+            : this.entityProjections(entitySnapshotEnvelope);
+        if (!projections) {
+            logger.debug(`No projections found for entity ${entitySnapshotEnvelope.entityTypeName}. Skipping...`);
+            return;
+        }
+        logger.debug(`Projections found for entity ${entitySnapshotEnvelope.entityTypeName}: ${JSON.stringify(projections)}`);
+        const entityMetadata = this.config.entities[entitySnapshotEnvelope.entityTypeName];
+        const entityInstance = (0, common_1.createInstance)(entityMetadata.class, entitySnapshotEnvelope.value);
+        const projectReadModelPromises = projections.flatMap((projectionMetadata) => {
+            logger.debug(`Projecting entity snapshot ${entitySnapshotEnvelope} to build new state of read model with projectionMetadata ${JSON.stringify(projectionMetadata)}`);
+            const readModelName = projectionMetadata.class.name;
+            const sequenceKey = this.sequenceKeyForProjection(entityInstance, projectionMetadata);
+            return this.projectEntity(entityInstance, projectionMetadata, entityMetadata, entitySnapshotEnvelope, readModelName, deleteEvent, sequenceKey);
+        });
+        await common_1.Promises.allSettledAndFulfilled(projectReadModelPromises);
+    }
+    /**
+     * 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
+     */
+    async getReadModels(entityInstance, projectionMetadata, entityMetadata) {
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelStore#getReadModels');
+        logger.debug(`Looking for ReadModels for entity ${JSON.stringify(entityInstance)} using Filter ${projectionMetadata.joinKey}`);
+        const readModelName = projectionMetadata.class.name;
+        const readModelMetadata = this.config.readModels[readModelName];
+        const filter = this.filterForProjection(entityInstance, projectionMetadata, entityMetadata);
+        if (!filter) {
+            return [];
+        }
+        logger.debug(`Calling ReadModelSearcher searching for ReadModels for entity ${readModelMetadata.class.name} using Filter ${filter}`);
+        const rawReadModels = (await (0, read_model_searcher_1.readModelSearcher)(this.config, readModelMetadata.class)
+            .filter(filter)
+            .paginatedVersion(false)
+            .search());
+        return this.instanceReadModels(readModelName, rawReadModels);
+    }
+    /**
+     * 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
+     */
+    async fetchReadModel(readModelName, readModelID, sequenceKey) {
+        if (!readModelID) {
+            return undefined;
+        }
+        const result = await this.config.readModelStore.fetch(this.config, readModelName, readModelID, sequenceKey);
+        if (result && result.length > 0) {
+            const readModelMetadata = this.config.readModels[readModelName];
+            return (0, common_1.createInstance)(readModelMetadata.class, result[0]);
+        }
+        return undefined;
+    }
+    getProjectionFunction(projectionMetadata) {
+        try {
+            return projectionMetadata.class[projectionMetadata.methodName];
+        }
+        catch {
+            throw new Error(`Couldn't load the ReadModel class ${projectionMetadata.class.name}`);
+        }
+    }
+    getUnProjections(entitySnapshotEnvelope) {
+        const unProjections = this.entityUnProjections(entitySnapshotEnvelope);
+        const projections = this.entityProjections(entitySnapshotEnvelope);
+        if ((projections === null || projections === void 0 ? void 0 : projections.length) > 0) {
+            if (!unProjections) {
+                throw new Error(`Missing UnProjections for entity ${entitySnapshotEnvelope.entityTypeName}`);
+            }
+            const missingProjection = this.findFirstMissingProjection(projections, unProjections);
+            if (missingProjection) {
+                throw new Error(`Missing UnProjection for ReadModel ${missingProjection.class.name} with joinKey ${missingProjection.joinKey} for entity ${entitySnapshotEnvelope.entityTypeName}`);
+            }
+        }
+        return unProjections;
+    }
+    entityProjections(entitySnapshotEnvelope) {
+        return this.config.projections[entitySnapshotEnvelope.entityTypeName];
+    }
+    entityUnProjections(entitySnapshotEnvelope) {
+        return this.config.unProjections[entitySnapshotEnvelope.entityTypeName];
+    }
+    findFirstMissingProjection(sources, to) {
+        return sources.find((source) => !this.someProjection(to, source));
+    }
+    someProjection(sources, to) {
+        const contains = (source) => source.class.name === to.class.name && source.joinKey.toString() === to.joinKey.toString();
+        return sources.some(contains);
+    }
+    sequenceKeyForProjection(entity, projectionMetadata) {
+        const sequenceKeyName = this.config.readModelSequenceKeys[projectionMetadata.class.name];
+        const sequenceKeyValue = entity[sequenceKeyName];
+        if (sequenceKeyName && sequenceKeyValue) {
+            return { name: sequenceKeyName, value: sequenceKeyValue };
+        }
+        return undefined;
+    }
+    async projectEntity(entityInstance, projectionMetadata, entityMetadata, entitySnapshotEnvelope, readModelName, deleteEvent, sequenceKey) {
+        const currentReadModels = await this.getReadModels(entityInstance, projectionMetadata, entityMetadata);
+        if (currentReadModels && currentReadModels.length > 0) {
+            const existingReadModelsProjections = [];
+            for (const currentReadModel of currentReadModels) {
+                const newProjections = await this.projectionsForReadModels(entitySnapshotEnvelope, readModelName, sequenceKey, projectionMetadata, entityInstance, entityMetadata, deleteEvent, currentReadModel);
+                existingReadModelsProjections.push(...newProjections);
+            }
+            return common_1.Promises.allSettledAndFulfilled(existingReadModelsProjections);
+        }
+        const newProjections = await this.projectionsForReadModels(entitySnapshotEnvelope, readModelName, sequenceKey, projectionMetadata, entityInstance, entityMetadata, deleteEvent);
+        return common_1.Promises.allSettledAndFulfilled(newProjections);
+    }
+    async projectionsForReadModels(entitySnapshotEnvelope, readModelName, sequenceKey, projectionMetadata, entityInstance, entityMetadata, deleteEvent, currentReadModel) {
+        const projections = [];
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelStore#projectionsForReadModels');
+        if (this.isJoinKeyByEntity(projectionMetadata.joinKey)) {
+            const entityJoinKey = entityInstance[projectionMetadata.joinKey];
+            if (!entityJoinKey) {
+                logger.warn(`Couldn't find the joinKey named ${projectionMetadata} in entity snapshot of ${entityMetadata.class.name}. Skipping...`);
+                return [];
+            }
+            const entitiesJoinKeys = Array.isArray(entityJoinKey) ? entityJoinKey : [entityJoinKey];
+            // A new Read Model with JoinKey by entity needs to be projected using a JoinKey with an entity query. We don't have a previous read model, but we have the new id from the entity
+            for (const readModelId of entitiesJoinKeys) {
+                const readModel = (currentReadModel === null || currentReadModel === void 0 ? void 0 : currentReadModel.id) === readModelId ? currentReadModel : undefined;
+                projections.push(this.projectAndStoreReadModelWithRetry(entitySnapshotEnvelope, readModelName, sequenceKey, entityInstance, projectionMetadata, deleteEvent, readModelId, readModel));
+            }
+        }
+        else {
+            // A new Read Model with JoinKey by ReadModel needs to be projected using a JoinKey with a read model query. We don't have a previous read model nor the new id as we don't have an entity field
+            projections.push(this.projectAndStoreReadModelWithRetry(entitySnapshotEnvelope, readModelName, sequenceKey, entityInstance, projectionMetadata, deleteEvent, currentReadModel === null || currentReadModel === void 0 ? void 0 : currentReadModel.id, currentReadModel));
+        }
+        return projections;
+    }
+    async projectAndStoreReadModelWithRetry(entitySnapshotEnvelope, readModelName, sequenceKey, entityInstance, projectionMetadata, deleteEvent, readModelId, currentReadModel) {
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelStore#projectAndStoreReadModelWithRetry');
+        logger.debug('Projecting entity snapshot ', entitySnapshotEnvelope, ` to build new state of read model ${readModelName} with ID ${(currentReadModel === null || currentReadModel === void 0 ? void 0 : currentReadModel.id) || readModelId}`, sequenceKey ? ` sequencing by ${sequenceKey.name} with value ${sequenceKey.value}` : '');
+        return (0, common_1.retryIfError)((tryNumber) => this.applyProjectionToReadModel(entitySnapshotEnvelope, entityInstance, projectionMetadata, deleteEvent, currentReadModel, entitySnapshotEnvelope, readModelId, sequenceKey, tryNumber), common_1.OptimisticConcurrencyUnexpectedVersionError, logger);
+    }
+    instanceReadModels(readModelName, rawReadModels) {
+        if (!(rawReadModels === null || rawReadModels === void 0 ? void 0 : rawReadModels.length)) {
+            return [];
+        }
+        const readModelMetadata = this.config.readModels[readModelName];
+        return rawReadModels.map((rawReadModel) => (0, common_1.createInstance)(readModelMetadata.class, rawReadModel));
+    }
+    async applyProjectionToReadModel(entitySnapshotEnvelope, entity, projectionMetadata, deleteEvent, currentReadModel, lastProjectedEntity, currentReadModelID, sequenceKey, tryNumber) {
+        var _a, _b, _c, _d, _e, _f;
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelStore#applyProjectionToReadModel');
+        const readModelName = projectionMetadata.class.name;
+        const readModelID = currentReadModelID !== null && currentReadModelID !== void 0 ? currentReadModelID : currentReadModel === null || currentReadModel === void 0 ? void 0 : currentReadModel.id;
+        if (tryNumber && tryNumber > 1) {
+            // In case of optimistic concurrency error, we need to fetch the current read model version and retry
+            logger.debug(`OptimisticConcurrencyUnexpectedVersionError (version=${(_a = currentReadModel === null || currentReadModel === void 0 ? void 0 : currentReadModel.magekMetadata) === null || _a === void 0 ? void 0 : _a.version} and expectedDatabaseVersion=${(_c = (_b = currentReadModel === null || currentReadModel === void 0 ? void 0 : currentReadModel.magekMetadata) === null || _b === void 0 ? void 0 : _b.version) !== null && _c !== void 0 ? _c : 0}). Looking for an updated version of read model ${readModelName} with ID = ${readModelID}` +
+                (sequenceKey ? ` and sequence key ${sequenceKey.name} = ${sequenceKey.value}` : ''));
+            currentReadModel = await this.fetchReadModel(readModelName, readModelID, sequenceKey);
+            logger.debug(`Current read model ${readModelName} with ID ${readModelID} updated with version = ${(_d = currentReadModel === null || currentReadModel === void 0 ? void 0 : currentReadModel.magekMetadata) === null || _d === void 0 ? void 0 : _d.version}` +
+                (sequenceKey ? ` and sequence key ${sequenceKey.name} = ${sequenceKey.value}` : ''));
+        }
+        let migratedReadModel;
+        if (currentReadModel) {
+            migratedReadModel = await new read_model_schema_migrator_1.ReadModelSchemaMigrator(this.config).migrate(currentReadModel, readModelName);
+        }
+        const currentDatabaseVersion = (_f = (_e = migratedReadModel === null || migratedReadModel === void 0 ? void 0 : migratedReadModel.magekMetadata) === null || _e === void 0 ? void 0 : _e.version) !== null && _f !== void 0 ? _f : 0;
+        let newReadModel;
+        const projectionInfo = {
+            reason: deleteEvent ? common_1.ProjectionInfoReason.ENTITY_DELETED : common_1.ProjectionInfoReason.ENTITY_PROJECTED,
+        };
+        try {
+            newReadModel = await this.callProjectionFunction(entitySnapshotEnvelope, projectionMetadata, entity, migratedReadModel, readModelID, projectionInfo);
+        }
+        catch (e) {
+            const globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(this.config);
+            const error = await globalErrorDispatcher.dispatch(new common_1.ProjectionGlobalError(entitySnapshotEnvelope, entity, migratedReadModel, projectionMetadata, e));
+            if (error)
+                throw error;
+        }
+        if (newReadModel === common_1.ReadModelAction.Delete) {
+            logger.debug(`Deleting read model ${readModelName} with ID ${readModelID}:`, migratedReadModel);
+            return this.config.readModelStore.delete(this.config, readModelName, readModelID);
+        }
+        else if (newReadModel === common_1.ReadModelAction.Nothing) {
+            logger.debug(`Skipping actions for ${readModelName} with ID ${readModelID}:`, newReadModel);
+            return;
+        }
+        return await this.store(entity, projectionMetadata, readModelID, readModelName, migratedReadModel, newReadModel, currentDatabaseVersion, lastProjectedEntity);
+    }
+    async store(entity, projectionMetadata, readModelID, readModelName, migratedReadModel, newReadModel, expectedCurrentDatabaseVersion, lastProjectedEntity) {
+        var _a, _b;
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelStore#store');
+        const schemaVersion = (_b = (_a = migratedReadModel === null || migratedReadModel === void 0 ? void 0 : migratedReadModel.magekMetadata) === null || _a === void 0 ? void 0 : _a.schemaVersion) !== null && _b !== void 0 ? _b : this.config.currentVersionFor(readModelName);
+        // Increment the read model version in 1 before storing
+        const newReadModelVersion = expectedCurrentDatabaseVersion + 1;
+        newReadModel.magekMetadata = {
+            ...migratedReadModel === null || migratedReadModel === void 0 ? void 0 : migratedReadModel.magekMetadata,
+            version: newReadModelVersion,
+            schemaVersion: schemaVersion,
+            lastUpdateAt: new Date().toISOString(),
+            lastProjectionInfo: {
+                entityId: entity.id,
+                entityName: lastProjectedEntity === null || lastProjectedEntity === void 0 ? void 0 : lastProjectedEntity.entityTypeName,
+                entityUpdatedAt: lastProjectedEntity === null || lastProjectedEntity === void 0 ? void 0 : lastProjectedEntity.createdAt,
+                projectionMethod: `${projectionMetadata.class.name}.${projectionMetadata.methodName}`,
+            },
+        };
+        logger.debug(`Storing new version of read model ${readModelName} with ID ${readModelID}, version ${newReadModel.magekMetadata.version} and expected database version ${expectedCurrentDatabaseVersion}:`, newReadModel);
+        const envelope = {
+            typeName: readModelName,
+            value: newReadModel,
+            id: readModelID,
+            version: newReadModel.magekMetadata.version,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        return await this.config.readModelStore.store(this.config, readModelName, envelope);
+    }
+    async callProjectionFunction(entitySnapshotEnvelope, projectionMetadata, entity, migratedReadModel, readModelID, projectionInfo) {
+        try {
+            const projectionMetadataJoinKey = projectionMetadata.joinKey;
+            const projectionFunction = this.getProjectionFunction(projectionMetadata);
+            if (this.isJoinKeyByEntity(projectionMetadataJoinKey)) {
+                return Array.isArray(entity[projectionMetadataJoinKey])
+                    ? projectionFunction(entity, readModelID, migratedReadModel || null, projectionInfo)
+                    : projectionFunction(entity, migratedReadModel || null, projectionInfo);
+            }
+            return projectionFunction(entity, readModelID, migratedReadModel || null);
+        }
+        catch (e) {
+            const globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(this.config);
+            const error = await globalErrorDispatcher.dispatch(new common_1.ProjectionGlobalError(entitySnapshotEnvelope, entity, migratedReadModel, projectionMetadata, e));
+            if (error)
+                throw error;
+        }
+        return undefined;
+    }
+    filterForProjection(entity, projectionMetadata, entityMetadata) {
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelStore#filterForProjection');
+        const projectionMetadataJoinKey = projectionMetadata.joinKey;
+        logger.debug(`Calculating filter for projection for ReadModels using Filter ${projectionMetadataJoinKey}`);
+        if (this.isJoinKeyByEntity(projectionMetadataJoinKey)) {
+            return this.filterForEntityProjection(entity, projectionMetadata, entityMetadata);
+        }
+        return this.filterForReadModelProjection(entity, projectionMetadata, entityMetadata);
+    }
+    filterForEntityProjection(entity, projectionMetadata, entityMetadata) {
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelStore#filterForEntityProjection');
+        const projectionMetadataJoinKey = projectionMetadata.joinKey;
+        const entityJoinKey = entity[projectionMetadataJoinKey];
+        if (!entityJoinKey) {
+            logger.warn(`Couldn't find the joinKey ${projectionMetadata.joinKey} in entity snapshot of ${entityMetadata.class.name}. Skipping...`);
+            return;
+        }
+        const ids = Array.isArray(entityJoinKey) ? entityJoinKey : [entityJoinKey];
+        if (!ids || ids.length === 0) {
+            logger.debug('No ids found for entity projection. Skipping...');
+            return undefined;
+        }
+        logger.debug(`Filtering for entity projection with ids ${ids}`);
+        return {
+            id: {
+                in: ids,
+            },
+        };
+    }
+    filterForReadModelProjection(entity, projectionMetadata, entityMetadata) {
+        const logger = (0, common_1.getLogger)(this.config, 'ReadModelStore#filterForReadModelProjection');
+        const joinKeyForProjection = projectionMetadata.joinKey;
+        if (!joinKeyForProjection) {
+            logger.warn(`Couldn't find the joinKey ${projectionMetadata.joinKey} in entity snapshot of ${entityMetadata.class.name}. Skipping...`);
+            return;
+        }
+        return joinKeyForProjection(entity);
+    }
+    isJoinKeyByEntity(projectionMetadataJoinKey) {
+        return typeof projectionMetadataJoinKey === 'string';
+    }
+}
+exports.ReadModelStore = ReadModelStore;

package/dist/services/token-verifiers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './utilities';
+export * from './jwks-uri-token-verifier';
+export * from './public-key-token-verifier';
+export * from './role-based-token-verifier';

package/dist/services/token-verifiers/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./utilities"), exports);
+tslib_1.__exportStar(require("./jwks-uri-token-verifier"), exports);
+tslib_1.__exportStar(require("./public-key-token-verifier"), exports);
+tslib_1.__exportStar(require("./role-based-token-verifier"), exports);

package/dist/services/token-verifiers/jwks-uri-token-verifier.d.ts

@@ -0,0 +1,21 @@
+import { DecodedToken } from '@magek/common';
+import type { GetPublicKeyOrSecret } from 'jsonwebtoken';
+import type { JwksClient } from 'jwks-rsa';
+import { RoleBasedTokenVerifier } from './role-based-token-verifier';
+type JwksClientFactory = (jwksUri: string) => JwksClient;
+type KeyResolverBuilder = (client: JwksClient) => GetPublicKeyOrSecret;
+type JwtVerifier = (token: string, issuer: string, key: GetPublicKeyOrSecret) => Promise<DecodedToken>;
+export declare class JwksUriTokenVerifier extends RoleBasedTokenVerifier {
+    readonly issuer: string;
+    readonly jwksUri: string;
+    private readonly buildClient;
+    private readonly buildKeyResolver;
+    private readonly verifyToken;
+    constructor(issuer: string, jwksUri: string, rolesClaim?: string, dependencies?: {
+        jwksClientFactory?: JwksClientFactory;
+        keyResolverBuilder?: KeyResolverBuilder;
+        jwtVerifier?: JwtVerifier;
+    });
+    verify(token: string): Promise<DecodedToken>;
+}
+export {};

package/dist/services/token-verifiers/jwks-uri-token-verifier.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwksUriTokenVerifier = void 0;
+const utilities_1 = require("./utilities");
+const role_based_token_verifier_1 = require("./role-based-token-verifier");
+class JwksUriTokenVerifier extends role_based_token_verifier_1.RoleBasedTokenVerifier {
+    constructor(issuer, jwksUri, rolesClaim, dependencies) {
+        var _a, _b, _c;
+        super(rolesClaim);
+        this.issuer = issuer;
+        this.jwksUri = jwksUri;
+        this.buildClient = (_a = dependencies === null || dependencies === void 0 ? void 0 : dependencies.jwksClientFactory) !== null && _a !== void 0 ? _a : utilities_1.getJwksClient;
+        this.buildKeyResolver =
+            (_b = dependencies === null || dependencies === void 0 ? void 0 : dependencies.keyResolverBuilder) !== null && _b !== void 0 ? _b : ((client) => utilities_1.getKeyWithClient.bind(this, client));
+        this.verifyToken = (_c = dependencies === null || dependencies === void 0 ? void 0 : dependencies.jwtVerifier) !== null && _c !== void 0 ? _c : utilities_1.verifyJWT;
+    }
+    async verify(token) {
+        const client = this.buildClient(this.jwksUri);
+        const keyResolver = this.buildKeyResolver(client);
+        return this.verifyToken(token, this.issuer, keyResolver);
+    }
+}
+exports.JwksUriTokenVerifier = JwksUriTokenVerifier;

package/dist/services/token-verifiers/public-key-token-verifier.d.ts

@@ -0,0 +1,13 @@
+import { DecodedToken } from '@magek/common';
+import { RoleBasedTokenVerifier } from './role-based-token-verifier';
+type JwtVerifier = (token: string, issuer: string, key: string) => Promise<DecodedToken>;
+export declare class PublicKeyTokenVerifier extends RoleBasedTokenVerifier {
+    readonly issuer: string;
+    readonly publicKeyResolver: Promise<string>;
+    private readonly verifyToken;
+    constructor(issuer: string, publicKeyResolver: Promise<string>, rolesClaim?: string, dependencies?: {
+        jwtVerifier?: JwtVerifier;
+    });
+    verify(token: string): Promise<DecodedToken>;
+}
+export {};

package/dist/services/token-verifiers/public-key-token-verifier.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicKeyTokenVerifier = void 0;
+const utilities_1 = require("./utilities");
+const role_based_token_verifier_1 = require("./role-based-token-verifier");
+class PublicKeyTokenVerifier extends role_based_token_verifier_1.RoleBasedTokenVerifier {
+    constructor(issuer, publicKeyResolver, rolesClaim, dependencies) {
+        var _a;
+        super(rolesClaim);
+        this.issuer = issuer;
+        this.publicKeyResolver = publicKeyResolver;
+        this.verifyToken = (_a = dependencies === null || dependencies === void 0 ? void 0 : dependencies.jwtVerifier) !== null && _a !== void 0 ? _a : utilities_1.verifyJWT;
+    }
+    async verify(token) {
+        const key = await this.publicKeyResolver;
+        return this.verifyToken(token, this.issuer, key);
+    }
+}
+exports.PublicKeyTokenVerifier = PublicKeyTokenVerifier;

package/dist/services/token-verifiers/role-based-token-verifier.d.ts

@@ -0,0 +1,8 @@
+import { DecodedToken, TokenVerifier, UserEnvelope } from '@magek/common';
+export declare const DEFAULT_ROLES_CLAIM = "custom:role";
+export declare abstract class RoleBasedTokenVerifier implements TokenVerifier {
+    readonly rolesClaim: string;
+    constructor(rolesClaim?: string);
+    abstract verify(token: string): Promise<DecodedToken>;
+    toUserEnvelope(decodedToken: DecodedToken): UserEnvelope;
+}

package/dist/services/token-verifiers/role-based-token-verifier.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleBasedTokenVerifier = exports.DEFAULT_ROLES_CLAIM = void 0;
+exports.DEFAULT_ROLES_CLAIM = 'custom:role';
+function rolesFromTokenRole(rolesClaim) {
+    if (!rolesClaim) {
+        return [];
+    }
+    const roles = Array.isArray(rolesClaim) ? rolesClaim : [rolesClaim];
+    return roles.map((role) => {
+        if (typeof role !== 'string') {
+            throw new Error(`Invalid role format ${role}. Valid format are Array<string> or string`);
+        }
+        return role;
+    });
+}
+class RoleBasedTokenVerifier {
+    constructor(rolesClaim = exports.DEFAULT_ROLES_CLAIM) {
+        this.rolesClaim = rolesClaim;
+    }
+    toUserEnvelope(decodedToken) {
+        const payload = decodedToken.payload;
+        const username = (payload === null || payload === void 0 ? void 0 : payload.email) || (payload === null || payload === void 0 ? void 0 : payload.phone_number) || payload.sub;
+        const id = payload.sub;
+        const roles = rolesFromTokenRole(payload[this.rolesClaim]);
+        return {
+            id,
+            username,
+            roles,
+            claims: decodedToken.payload,
+            header: decodedToken.header,
+        };
+    }
+}
+exports.RoleBasedTokenVerifier = RoleBasedTokenVerifier;

package/dist/services/token-verifiers/utilities.d.ts

@@ -0,0 +1,31 @@
+import { DecodedToken } from '@magek/common';
+import * as jwt from 'jsonwebtoken';
+import { JwksClient } from 'jwks-rsa';
+/**
+ * Initializes a jwksRSA client that can be used to get the public key of a JWKS URI using the
+ * `getKeyWithClient` function.
+ *
+ * @param jwksUri The JWKS URI
+ * @returns A JwksRSA client
+ */
+export declare function getJwksClient(jwksUri: string): JwksClient;
+/**
+ * Initializes a function that can be used to get the public key from a JWKS URI with the signature
+ * required by the `verifyJWT` function. You can create a client using the `getJwksClient` function.
+ *
+ * @param client A JwksClient instance
+ * @param header The JWT header
+ * @param callback The callback function that will be called when the public key is ready
+ * @returns A function that can be used to get the public key
+ */
+export declare function getKeyWithClient(client: JwksClient, header: jwt.JwtHeader, callback: jwt.SigningKeyCallback): void;
+/**
+ * Verifies a JWT token using a key or key resolver function and returns a Magek UserEnvelope.
+ *
+ * @param token The token to verify
+ * @param issuer The issuer of the token
+ * @param key The public key to use to verify the token or a function that will resolve a jwksUri to get the public key. The function can be generated using the `getKeyWithClient` function.
+ * @param verifier Optional custom JWT verify function (defaults to jsonwebtoken's verify)
+ * @returns A promise that resolves to the DecodedToken object
+ */
+export declare function verifyJWT(token: string, issuer: string, key: jwt.Secret | jwt.GetPublicKeyOrSecret, verifier?: typeof jwt.verify): Promise<DecodedToken>;

package/dist/services/token-verifiers/utilities.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJwksClient = getJwksClient;
+exports.getKeyWithClient = getKeyWithClient;
+exports.verifyJWT = verifyJWT;
+const jwt = require("jsonwebtoken");
+/**
+ * Initializes a jwksRSA client that can be used to get the public key of a JWKS URI using the
+ * `getKeyWithClient` function.
+ *
+ * @param jwksUri The JWKS URI
+ * @returns A JwksRSA client
+ */
+function getJwksClient(jwksUri) {
+    const jwksRSA = require('jwks-rsa'); // Manually loading the default export here to be able to stub it
+    return jwksRSA({
+        jwksUri,
+        cache: true,
+        cacheMaxAge: 15 * 60 * 1000, // 15 Minutes cache
+    });
+}
+/**
+ * Initializes a function that can be used to get the public key from a JWKS URI with the signature
+ * required by the `verifyJWT` function. You can create a client using the `getJwksClient` function.
+ *
+ * @param client A JwksClient instance
+ * @param header The JWT header
+ * @param callback The callback function that will be called when the public key is ready
+ * @returns A function that can be used to get the public key
+ */
+function getKeyWithClient(client, header, callback) {
+    if (!header.kid) {
+        callback(new Error('JWT kid not found'));
+        return;
+    }
+    client.getSigningKey(header.kid, function (err, key) {
+        if (err) {
+            callback(err);
+            return;
+        }
+        callback(null, key === null || key === void 0 ? void 0 : key.getPublicKey());
+    });
+}
+/**
+ * Verifies a JWT token using a key or key resolver function and returns a Magek UserEnvelope.
+ *
+ * @param token The token to verify
+ * @param issuer The issuer of the token
+ * @param key The public key to use to verify the token or a function that will resolve a jwksUri to get the public key. The function can be generated using the `getKeyWithClient` function.
+ * @param verifier Optional custom JWT verify function (defaults to jsonwebtoken's verify)
+ * @returns A promise that resolves to the DecodedToken object
+ */
+async function verifyJWT(token, issuer, key, verifier = jwt.verify) {
+    const sanitizedToken = token.replace('Bearer ', ''); // Remove the 'Bearer' prefix from the token
+    return await new Promise((resolve, reject) => {
+        verifier(sanitizedToken, key, {
+            algorithms: ['RS256'],
+            issuer,
+            complete: true, // To return headers, payload and other useful token information
+        }, (err, decoded) => {
+            if (err) {
+                return reject(err);
+            }
+            if (!decoded) {
+                return reject(new Error('The token could not be decoded'));
+            }
+            return resolve(decoded);
+        });
+    });
+}

package/dist/subscribers-notifier.d.ts

@@ -0,0 +1,14 @@
+import { MagekConfig } from '@magek/common';
+export declare class MagekSubscribersNotifier {
+    private config;
+    private readonly graphQLSchema;
+    constructor(config: MagekConfig);
+    dispatch(request: unknown): Promise<void>;
+    private getReadModelInstance;
+    private getSubscriptions;
+    private getPubSub;
+    private runSubscriptionAndNotify;
+    private parseSubscriptionQuery;
+    private processSubscriptionsIterator;
+    private notifyWithGraphQLResult;
+}