emittableevent/lib/domain/events/EmittableEvent.js

EmittableEvent is an opinionated abstraction class for generating rich EventBridge events.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EmittableEvent = void 0;
const crypto_1 = require("crypto");
class EmittableEvent {
    constructor(eventInput, awsRequestContext) {
        if (!eventInput.eventName ||
            !eventInput.eventBusName ||
            !eventInput.data ||
            !eventInput.metadataConfig ||
            !awsRequestContext)
            throw new MissingRequiredInputsError();
        const { eventName, eventBusName, data, metadataConfig } = eventInput;
        this.eventBusName = eventBusName;
        this.metadataConfig = metadataConfig;
        this.awsRequestContext = awsRequestContext;
        this.event = this.produceEvent({
            eventName,
            data
        });
    }
    produceEvent(input) {
        const { eventName, data } = input;
        const detailType = eventName;
        const metadata = this.produceMetadata(eventName);
        const source = `${metadata.domain.toLowerCase()}.${metadata.system.toLowerCase()}.${detailType.toLowerCase()}`;
        const detail = {
            metadata,
            data
        };
        return {
            EventBusName: this.eventBusName,
            Source: source,
            DetailType: detailType,
            Detail: JSON.stringify(detail)
        };
    }
    produceMetadata(eventName) {
        const metadata = this.metadataConfig;
        const requestContext = this.awsRequestContext;
        this.validateMetadata(metadata);
        this.validateRequestContext(requestContext);
        const timeNow = Date.now();
        return {
            ...this.metadataConfig,
            eventName,
            eventType: metadata.eventType,
            timestamp: `${timeNow}`,
            timestampHuman: new Date(timeNow).toISOString(),
            requestTimeEpoch: requestContext.requestTimeEpoch,
            version: metadata.version,
            id: (0, crypto_1.randomUUID)().toString(),
            correlationId: requestContext.requestId,
            resource: requestContext.resourcePath,
            accountId: requestContext.accountId,
            runtime: process.env.AWS_EXECUTION_ENV || '',
            functionName: process.env.AWS_LAMBDA_FUNCTION_NAME || '',
            functionMemorySize: process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE || '',
            functionVersion: process.env.AWS_LAMBDA_FUNCTION_VERSION || '',
            lifecycleStage: requestContext.stage,
            domain: metadata.domain,
            system: metadata.system,
            service: metadata.service,
            team: metadata.team,
            hostPlatform: metadata.hostPlatform,
            owner: metadata.owner,
            region: process.env.AWS_REGION || '',
            jurisdiction: metadata.jurisdiction,
            tags: metadata.tags,
            dataSensitivity: metadata.dataSensitivity
        };
    }
    validateMetadata(metadata) {
        if (!metadata.version ||
            !metadata.domain ||
            !metadata.system ||
            !metadata.service ||
            !metadata.team)
            throw new MissingMetadataFieldsError();
    }
    validateRequestContext(requestContext) {
        if (!requestContext.accountId ||
            !requestContext.resourcePath ||
            !requestContext.requestId ||
            !requestContext.requestTimeEpoch ||
            !requestContext.stage)
            throw new MissingRequestContextFieldsError();
    }
    get() {
        return this.event;
    }
}
exports.EmittableEvent = EmittableEvent;
class MissingRequiredInputsError extends Error {
    constructor() {
        super();
        this.name = 'MissingRequiredInputsError';
        const message = `Missing required fields to create the event!`;
        this.message = message;
        console.error(message);
    }
}
class MissingMetadataFieldsError extends Error {
    constructor() {
        super();
        this.name = 'MissingMetadataFieldsError';
        const message = `Missing required fields to produce metadata!`;
        this.message = message;
        console.error(message);
    }
}
class MissingRequestContextFieldsError extends Error {
    constructor() {
        super();
        this.name = 'MissingRequestContextFieldsError';
        const message = `Missing required AWS request context fields to produce metadata!`;
        this.message = message;
        console.error(message);
    }
}
//# sourceMappingURL=EmittableEvent.js.map