@magek/common 0.0.1

package/dist/concepts/token-verifier.d.ts

@@ -0,0 +1,25 @@
+import { UserEnvelope } from '../envelope';
+export interface DecodedToken {
+    header: {
+        kid: string;
+        [key: string]: any;
+    };
+    payload: {
+        sub: string;
+        email?: string;
+        phone_number?: string;
+        [key: string]: any;
+    };
+}
+export interface TokenVerifier {
+    /**
+     * Verify asd deserialize a stringified token with this token verifier.
+     * @param token The token to verify
+     */
+    verify(token: string): Promise<DecodedToken>;
+    /**
+     * Build a valid `UserEnvelope` from a decoded token.
+     * @param decodedToken The decoded token
+     */
+    toUserEnvelope(decodedToken: DecodedToken): UserEnvelope;
+}

package/dist/concepts/token-verifier.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/uuid.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `UUID` type to work globally as a identifier for Entities,
+ * Commands, Events or any other magek artifact.
+ * New unique identifiers can be created using the
+ * `UUID.generate` method.
+ */
+export declare class UUID extends String {
+    static generate(): UUID;
+}
+/** Time-based unique identifier. It's a string in the form <timestamp>-<random UUID>.  */
+export declare class TimeKey extends String {
+    /**
+     * Time-based unique identifier generator
+     * @param moment Number of milliseconds since epoch for the moment in which the identifier should be generated. It defaults to the current time.
+     * @returns A unique identifier in the form "<moment>-<random UUID>"
+     */
+    static generate(moment?: number): TimeKey;
+}

package/dist/concepts/uuid.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeKey = exports.UUID = void 0;
+const uuid_1 = require("uuid");
+/**
+ * `UUID` type to work globally as a identifier for Entities,
+ * Commands, Events or any other magek artifact.
+ * New unique identifiers can be created using the
+ * `UUID.generate` method.
+ */
+class UUID extends String {
+    static generate() {
+        return (0, uuid_1.v4)();
+    }
+}
+exports.UUID = UUID;
+/** Time-based unique identifier. It's a string in the form <timestamp>-<random UUID>.  */
+class TimeKey extends String {
+    /**
+     * Time-based unique identifier generator
+     * @param moment Number of milliseconds since epoch for the moment in which the identifier should be generated. It defaults to the current time.
+     * @returns A unique identifier in the form "<moment>-<random UUID>"
+     */
+    static generate(moment = Date.now()) {
+        return `${moment}-${(0, uuid_1.v4)()}`;
+    }
+}
+exports.TimeKey = TimeKey;

package/dist/config.d.ts

@@ -0,0 +1,122 @@
+import { CommandMetadata, DataMigrationMetadata, EntityInterface, EntityMetadata, EventHandlerInterface, EventMetadata, EventStreamConfiguration, GlobalErrorHandlerMetadata, NotificationMetadata, ProjectionMetadata, QueryMetadata, ReadModelInterface, ReadModelMetadata, ReducerMetadata, RoleMetadata, ScheduledCommandMetadata, SchemaMigrationMetadata, TokenVerifier } from './concepts';
+import { ProviderLibrary } from './provider';
+import { EventStoreAdapter } from './event-store-adapter';
+import { ReadModelStoreAdapter } from './read-model-store-adapter';
+import { SessionStoreAdapter } from './session-store-adapter';
+import { Level } from './logger';
+import { HealthIndicatorMetadata, Logger, SensorConfiguration } from '.';
+import { TraceConfiguration } from './instrumentation/trace-types';
+/**
+ * Class used by external packages that needs to get a representation of
+ * the Magek config. Used mainly for vendor-specific deployment packages
+ */
+export declare class MagekConfig {
+    readonly environmentName: string;
+    logLevel: Level;
+    logPrefix?: string;
+    logger?: Logger;
+    private _provider?;
+    eventStoreAdapter?: EventStoreAdapter;
+    readModelStoreAdapter?: ReadModelStoreAdapter;
+    sessionStoreAdapter?: SessionStoreAdapter;
+    appName: string;
+    assets?: Array<string>;
+    defaultResponseHeaders: Record<string, string>;
+    injectable?: unknown;
+    readonly subscriptions: {
+        maxConnectionDurationInSeconds: number;
+        maxDurationInSeconds: number;
+    };
+    enableGraphQLIntrospection: boolean;
+    private _userProjectRootPath?;
+    readonly codeRelativePath: string;
+    readonly eventDispatcherHandler: string;
+    readonly eventStreamConsumer: string;
+    readonly eventStreamProducer: string;
+    readonly serveGraphQLHandler: string;
+    readonly sensorHealthHandler: string;
+    readonly scheduledTaskHandler: string;
+    readonly notifySubscribersHandler: string;
+    readonly functionRelativePath: string;
+    readonly events: Record<EventName, EventMetadata>;
+    readonly notifications: Record<EventName, NotificationMetadata>;
+    readonly partitionKeys: Record<EventName, string>;
+    readonly topicToEvent: Record<string, EventName>;
+    readonly eventToTopic: Record<EventName, string>;
+    readonly entities: Record<EntityName, EntityMetadata>;
+    readonly reducers: Record<EventName, ReducerMetadata>;
+    readonly commandHandlers: Record<CommandName, CommandMetadata>;
+    readonly queryHandlers: Record<QueryName, QueryMetadata>;
+    readonly eventHandlers: Record<EventName, Array<EventHandlerInterface>>;
+    readonly readModels: Record<ReadModelName, ReadModelMetadata>;
+    readonly projections: Record<EntityName, Array<ProjectionMetadata<EntityInterface, ReadModelInterface>>>;
+    readonly unProjections: Record<EntityName, Array<ProjectionMetadata<EntityInterface, ReadModelInterface>>>;
+    readonly readModelSequenceKeys: Record<EntityName, string>;
+    readonly roles: Record<RoleName, RoleMetadata>;
+    readonly schemaMigrations: Record<ConceptName, Map<Version, SchemaMigrationMetadata>>;
+    readonly scheduledCommandHandlers: Record<ScheduledCommandName, ScheduledCommandMetadata>;
+    readonly dataMigrationHandlers: Record<DataMigrationName, DataMigrationMetadata>;
+    userHealthIndicators: Record<string, HealthIndicatorMetadata>;
+    readonly sensorConfiguration: SensorConfiguration;
+    globalErrorsHandler: GlobalErrorHandlerMetadata | undefined;
+    enableSubscriptions: boolean;
+    readonly nonExposedGraphQLMetadataKey: Record<string, Array<string>>;
+    dispatchedEventsTtl: number;
+    traceConfiguration: TraceConfiguration;
+    eventStreamConfiguration: EventStreamConfiguration;
+    /** Environment variables to set when running the application */
+    readonly env: Record<string, string>;
+    /**
+     * Add `TokenVerifier` implementations to this array to enable token verification.
+     * When a bearer token arrives in a request 'Authorization' header, it will be checked
+     * against all the verifiers registered here.
+     */
+    tokenVerifiers: Array<TokenVerifier>;
+    constructor(environmentName: string);
+    get resourceNames(): ResourceNames;
+    /**
+     * Returns the name of the ReadModel from the name of its resouce (normally, a table)
+     * @param resourceName
+     */
+    readModelNameFromResourceName(resourceName: string): string;
+    /**
+     * This is a convenience property to easily check if the application has defined any roles.
+     * Only in that case we will create a user pool and an authorization API.
+     * If there are no roles defined, it means that all app endpoints are public and users
+     * won't be registered (they are all anonymous)
+     */
+    get thereAreRoles(): boolean;
+    currentVersionFor(className: string): number;
+    validate(): void;
+    get provider(): ProviderLibrary;
+    set provider(provider: ProviderLibrary);
+    get userProjectRootPath(): string;
+    set userProjectRootPath(path: string);
+    get eventStore(): EventStoreAdapter;
+    get readModelStore(): ReadModelStoreAdapter;
+    get sessionStore(): SessionStoreAdapter;
+    mustGetEnvironmentVar(varName: string): string;
+    private validateAllMigrations;
+    private validateConceptSchemaMigrations;
+}
+interface ResourceNames {
+    applicationStack: string;
+    eventsStore: string;
+    dispatchedEventsStore: string;
+    eventsDedup: string;
+    subscriptionsStore: string;
+    connectionsStore: string;
+    streamTopic: string;
+    forReadModel(entityName: string): string;
+}
+type EntityName = string;
+type EventName = string;
+type CommandName = string;
+type QueryName = string;
+type ReadModelName = string;
+type RoleName = string;
+type ConceptName = string;
+type Version = number;
+type ScheduledCommandName = string;
+type DataMigrationName = string;
+export {};

package/dist/config.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekConfig = void 0;
+const logger_1 = require("./logger");
+const path = require("path");
+const _1 = require(".");
+/**
+ * Class used by external packages that needs to get a representation of
+ * the Magek config. Used mainly for vendor-specific deployment packages
+ */
+class MagekConfig {
+    constructor(environmentName) {
+        this.environmentName = environmentName;
+        this.logLevel = logger_1.Level.debug;
+        this.appName = 'new-magek-app';
+        this.defaultResponseHeaders = {};
+        this.subscriptions = {
+            maxConnectionDurationInSeconds: 7 * 24 * 60 * 60, // 7 days
+            maxDurationInSeconds: 2 * 24 * 60 * 60, // 2 days
+        };
+        this.enableGraphQLIntrospection = true;
+        this.codeRelativePath = 'dist';
+        this.eventDispatcherHandler = path.join(this.codeRelativePath, 'index.eventDispatcher');
+        this.eventStreamConsumer = path.join(this.codeRelativePath, 'index.consumeEventStream');
+        this.eventStreamProducer = path.join(this.codeRelativePath, 'index.produceEventStream');
+        this.serveGraphQLHandler = path.join(this.codeRelativePath, 'index.graphQLDispatcher');
+        this.sensorHealthHandler = path.join(this.codeRelativePath, 'index.health');
+        this.scheduledTaskHandler = path.join(this.codeRelativePath, 'index.triggerScheduledCommands');
+        this.notifySubscribersHandler = path.join(this.codeRelativePath, 'index.notifySubscribers');
+        this.functionRelativePath = path.join('..', this.codeRelativePath, 'index.js');
+        this.events = {};
+        this.notifications = {};
+        this.partitionKeys = {};
+        this.topicToEvent = {};
+        this.eventToTopic = {};
+        this.entities = {};
+        this.reducers = {};
+        this.commandHandlers = {};
+        this.queryHandlers = {};
+        this.eventHandlers = {};
+        this.readModels = {};
+        this.projections = {};
+        this.unProjections = {};
+        this.readModelSequenceKeys = {};
+        this.roles = {};
+        this.schemaMigrations = {};
+        this.scheduledCommandHandlers = {};
+        this.dataMigrationHandlers = {};
+        this.userHealthIndicators = {};
+        this.sensorConfiguration = {
+            health: {
+                globalAuthorizer: {
+                    authorize: 'all',
+                },
+                magek: _1.DEFAULT_SENSOR_HEALTH_CONFIGURATIONS,
+            },
+        };
+        this.enableSubscriptions = true;
+        this.nonExposedGraphQLMetadataKey = {};
+        // TTL for events stored in dispatched events table. Default to 5 minutes (i.e., 300 seconds).
+        this.dispatchedEventsTtl = 300;
+        this.traceConfiguration = {
+            enableTraceNotification: false,
+            includeInternal: false,
+            onStart: async () => { },
+            onEnd: async () => { },
+        };
+        this.eventStreamConfiguration = { enabled: false };
+        /** Environment variables to set when running the application */
+        this.env = {};
+        /**
+         * Add `TokenVerifier` implementations to this array to enable token verification.
+         * When a bearer token arrives in a request 'Authorization' header, it will be checked
+         * against all the verifiers registered here.
+         */
+        this.tokenVerifiers = [];
+    }
+    get resourceNames() {
+        var _a, _b;
+        if (this.appName.length === 0)
+            throw new Error('Application name cannot be empty');
+        const applicationStackName = this.appName + '-app';
+        return {
+            applicationStack: applicationStackName,
+            eventsStore: applicationStackName + '-events-store',
+            dispatchedEventsStore: applicationStackName + '-dispatched-events',
+            eventsDedup: applicationStackName + '-events-dedup',
+            subscriptionsStore: applicationStackName + '-subscriptions-store',
+            connectionsStore: applicationStackName + '-connections-store',
+            streamTopic: (_b = (_a = this.eventStreamConfiguration.parameters) === null || _a === void 0 ? void 0 : _a.streamTopic) !== null && _b !== void 0 ? _b : 'magek_events',
+            forReadModel(readModelName) {
+                return applicationStackName + '-' + readModelName;
+            },
+        };
+    }
+    /**
+     * Returns the name of the ReadModel from the name of its resouce (normally, a table)
+     * @param resourceName
+     */
+    readModelNameFromResourceName(resourceName) {
+        const resourceNamePrefixRegex = new RegExp(`^${this.resourceNames.applicationStack}-`);
+        return resourceName.replace(resourceNamePrefixRegex, '');
+    }
+    /**
+     * This is a convenience property to easily check if the application has defined any roles.
+     * Only in that case we will create a user pool and an authorization API.
+     * If there are no roles defined, it means that all app endpoints are public and users
+     * won't be registered (they are all anonymous)
+     */
+    get thereAreRoles() {
+        return Object.entries(this.roles).length > 0;
+    }
+    currentVersionFor(className) {
+        const migrations = this.schemaMigrations[className];
+        if (!migrations) {
+            return 1;
+        }
+        return Math.max(...migrations.keys());
+    }
+    validate() {
+        this.validateAllMigrations();
+    }
+    get provider() {
+        if (!this._provider)
+            throw new Error('It is required to set a valid provider runtime in your configuration files');
+        return this._provider;
+    }
+    set provider(provider) {
+        this._provider = provider;
+    }
+    get userProjectRootPath() {
+        if (!this._userProjectRootPath)
+            throw new Error('Property "userProjectRootPath" is not set. Ensure you have called "Magek.start"');
+        return this._userProjectRootPath;
+    }
+    set userProjectRootPath(path) {
+        this._userProjectRootPath = path;
+    }
+    get eventStore() {
+        if (!this.eventStoreAdapter) {
+            throw new Error('EventStoreAdapter is not configured. Please set config.eventStoreAdapter.');
+        }
+        return this.eventStoreAdapter;
+    }
+    get readModelStore() {
+        if (!this.readModelStoreAdapter) {
+            throw new Error('ReadModelStoreAdapter is not configured. Please set config.readModelStoreAdapter.');
+        }
+        return this.readModelStoreAdapter;
+    }
+    get sessionStore() {
+        if (this.enableSubscriptions && !this.sessionStoreAdapter) {
+            throw new Error('SessionStoreAdapter is not configured. Please set config.sessionStoreAdapter.');
+        }
+        return this.sessionStoreAdapter;
+    }
+    mustGetEnvironmentVar(varName) {
+        const value = process.env[varName];
+        if (value == undefined) {
+            throw new Error(`Missing environment variable '${varName}'`);
+        }
+        return value;
+    }
+    validateAllMigrations() {
+        for (const conceptName in this.schemaMigrations) {
+            this.validateConceptSchemaMigrations(conceptName, this.schemaMigrations[conceptName]);
+        }
+    }
+    validateConceptSchemaMigrations(conceptName, migrations) {
+        // Check that migrations are defined consecutively. In other words, there are no gaps between the version numbers
+        const currentVersion = this.currentVersionFor(conceptName);
+        for (let toVersion = 2; toVersion <= currentVersion; toVersion++) {
+            if (!migrations.has(toVersion)) {
+                throw new Error(`Schema Migrations for '${conceptName}' are invalid: they are missing a migration with toVersion=${toVersion}. ` +
+                    `There must be a migration for '${conceptName}' for every version in the range [2..${currentVersion}]`);
+            }
+        }
+    }
+}
+exports.MagekConfig = MagekConfig;

package/dist/data-migration-parameters.d.ts

@@ -0,0 +1,3 @@
+export interface DataMigrationParameters {
+    readonly order: number;
+}

package/dist/data-migration-parameters.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/envelope.d.ts

@@ -0,0 +1,188 @@
+import { CommandInput, EntityInterface, EventInterface, NotificationInterface, ReadModelInterface, SequenceKey, UUID } from './concepts';
+import { GraphQLClientMessage } from './graphql-websocket-messages';
+import { FilterFor, ProjectionFor, SortFor } from './searcher';
+import { Class } from './typelevel';
+/**
+ * An `Envelope` carries a command/event body together with the name
+ * of its class. This is important information for the `Distributor` to
+ * work. Each provider has to implement their own `Envelope`.
+ */
+export interface Envelope {
+    currentUser?: UserEnvelope;
+    requestID: UUID;
+    context?: ContextEnvelope;
+}
+export interface TypedEnvelope extends Envelope {
+    typeName: string;
+    version: number;
+}
+export interface CommandEnvelope extends TypedEnvelope {
+    value: CommandInput;
+}
+export type QueryEnvelope = CommandEnvelope;
+export interface HealthEnvelope extends Envelope {
+    componentPath: string;
+    token?: string;
+}
+export interface ScheduledCommandEnvelope extends Envelope {
+    typeName: string;
+}
+export type SuperKindType = 'domain' | 'notification' | 'magek';
+export interface EventStoreEntryEnvelope extends TypedEnvelope {
+    superKind: SuperKindType;
+    entityID: UUID;
+    entityTypeName: string;
+    value: EventInterface | EntityInterface | NotificationInterface;
+}
+export interface NonPersistedEventEnvelope extends EventStoreEntryEnvelope {
+    kind: 'event';
+}
+export interface EventEnvelope extends NonPersistedEventEnvelope {
+    id?: string;
+    createdAt: string;
+    deletedAt?: string;
+}
+export interface NonPersistedEntitySnapshotEnvelope extends EventStoreEntryEnvelope {
+    kind: 'snapshot';
+    snapshottedEventCreatedAt: string;
+}
+export interface EntitySnapshotEnvelope extends NonPersistedEntitySnapshotEnvelope {
+    /** Logic creation date of the snapshot, it always matches the creation date of the latest event included in it. */
+    createdAt: string;
+    /** Time when this snapshot was actually persisted in the database. */
+    persistedAt: string;
+}
+export interface EventSearchRequest extends Envelope {
+    parameters: EventSearchParameters;
+}
+export type EventSearchParameters = EventParametersFilterByEntity | EventParametersFilterByType;
+export interface EventLimitParameter {
+    limit?: number;
+}
+export interface EventTimeParameterFilter extends EventLimitParameter {
+    from?: string;
+    to?: string;
+}
+export interface EventParametersFilterByEntity extends EventTimeParameterFilter {
+    entity: string;
+    entityID?: string;
+}
+export interface EventParametersFilterByType extends EventTimeParameterFilter {
+    type: string;
+}
+export interface EventSearchResponse {
+    type: string;
+    entity: string;
+    entityID: UUID;
+    requestID: UUID;
+    user?: UserEnvelope;
+    createdAt: string;
+    value: EventInterface | NotificationInterface;
+    deletedAt?: string;
+}
+export interface ReadModelEnvelope {
+    typeName: string;
+    value: ReadModelInterface;
+}
+export interface PaginatedEntityIdResult {
+    entityID: UUID;
+}
+export interface PaginatedEntitiesIdsResult {
+    items: Array<PaginatedEntityIdResult>;
+    count?: number;
+    cursor?: Record<string, string>;
+}
+export interface ReadModelListResult<TReadModel> {
+    items: Array<TReadModel>;
+    count?: number;
+    cursor?: Record<string, string>;
+}
+export interface ReadModelRequestEnvelope<TReadModel extends ReadModelInterface> extends Envelope {
+    key?: {
+        id: UUID;
+        sequenceKey?: SequenceKey;
+    };
+    class: Class<TReadModel>;
+    className: string;
+    version: number;
+    filters: ReadModelRequestProperties<TReadModel>;
+    sortBy?: ReadModelSortProperties<TReadModel>;
+    limit?: number;
+    afterCursor?: unknown;
+    paginatedVersion?: boolean;
+    select?: ProjectionFor<TReadModel>;
+}
+export interface ReadModelRequestArgs<TReadModel extends ReadModelInterface> {
+    filter?: ReadModelRequestProperties<TReadModel>;
+    sortBy?: ReadModelSortProperties<TReadModel>;
+    limit?: number;
+    afterCursor?: unknown;
+}
+export interface ReadModelByIdRequestArgs {
+    id: string;
+    [sequenceKey: string]: string | undefined;
+}
+export type ReadModelRequestProperties<TReadModel> = Record<string, FilterFor<TReadModel>>;
+export type ReadModelSortProperties<TReadModel> = Record<string, SortFor<TReadModel>>;
+export type EventType = 'CONNECT' | 'MESSAGE' | 'DISCONNECT';
+export interface GraphQLRequestEnvelope extends Envelope {
+    eventType: EventType;
+    connectionID?: string;
+    value?: GraphQLOperation | GraphQLClientMessage;
+    token?: string;
+}
+export type GraphQLRequestEnvelopeError = Pick<GraphQLRequestEnvelope, 'eventType' | 'connectionID' | 'requestID'> & {
+    error: Error;
+};
+export interface SubscriptionEnvelope extends ReadModelRequestEnvelope<ReadModelInterface> {
+    expirationTime: number;
+    connectionID: string;
+    operation: GraphQLOperation;
+}
+export interface GraphQLOperation {
+    query: string;
+    id?: string;
+    operationName?: string;
+    variables?: Record<string, any>;
+}
+export interface ConnectionDataEnvelope {
+    expirationTime: number;
+    user?: UserEnvelope;
+}
+export interface UserEnvelope {
+    /** An optional identifier of the user */
+    id?: string;
+    /** The unique username of the current user */
+    username: string;
+    /** The list of role names assigned to this user */
+    roles: Array<string>;
+    /** An object containing the claims included in the body of the JWT token */
+    claims: Record<string, unknown>;
+    /** An object containing the headers of the JWT token for further verification */
+    header?: Record<string, unknown>;
+}
+export interface ContextEnvelope {
+    /** Decoded request header and body */
+    request: {
+        headers: unknown;
+        body: unknown;
+    };
+    /** Provider-dependent raw request context object */
+    rawContext: unknown;
+}
+export type EventEnvelopeFromDatabase = EventEnvelope & {
+    id: string;
+};
+export type EntitySnapshotEnvelopeFromDatabase = EntitySnapshotEnvelope & {
+    id: string;
+};
+export interface EventDeleteParameters {
+    entityTypeName: string;
+    entityID: string;
+    createdAt: string;
+}
+export interface SnapshotDeleteParameters {
+    entityID: UUID;
+    entityTypeName: string;
+    createdAt: string;
+}

package/dist/envelope.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/errors/command-handler-global-error.d.ts

@@ -0,0 +1,8 @@
+import { GlobalErrorContainer } from './global-error-container';
+import { CommandEnvelope } from '../envelope';
+import { CommandMetadata } from '../concepts';
+export declare class CommandHandlerGlobalError extends GlobalErrorContainer {
+    readonly commandEnvelope: CommandEnvelope;
+    readonly commandMetadata: CommandMetadata;
+    constructor(commandEnvelope: CommandEnvelope, commandMetadata: CommandMetadata, originalError: Error);
+}

package/dist/errors/command-handler-global-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandHandlerGlobalError = void 0;
+const global_error_container_1 = require("./global-error-container");
+class CommandHandlerGlobalError extends global_error_container_1.GlobalErrorContainer {
+    constructor(commandEnvelope, commandMetadata, originalError) {
+        super(originalError);
+        this.commandEnvelope = commandEnvelope;
+        this.commandMetadata = commandMetadata;
+    }
+}
+exports.CommandHandlerGlobalError = CommandHandlerGlobalError;

package/dist/errors/event-global-error.d.ts

@@ -0,0 +1,6 @@
+import { GlobalErrorContainer } from './global-error-container';
+import { EventEnvelope } from '../envelope';
+export declare class EventGlobalError extends GlobalErrorContainer {
+    readonly eventEnvelope: EventEnvelope;
+    constructor(eventEnvelope: EventEnvelope, originalError: Error);
+}

package/dist/errors/event-global-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventGlobalError = void 0;
+const global_error_container_1 = require("./global-error-container");
+class EventGlobalError extends global_error_container_1.GlobalErrorContainer {
+    constructor(eventEnvelope, originalError) {
+        super(originalError);
+        this.eventEnvelope = eventEnvelope;
+    }
+}
+exports.EventGlobalError = EventGlobalError;

package/dist/errors/event-handler-global-error.d.ts

@@ -0,0 +1,9 @@
+import { GlobalErrorContainer } from './global-error-container';
+import { EventInterface, NotificationInterface } from '../concepts';
+import { EventEnvelope } from '../envelope';
+export declare class EventHandlerGlobalError extends GlobalErrorContainer {
+    readonly eventEnvelope: EventEnvelope | NotificationInterface;
+    readonly eventInstance: EventInterface;
+    readonly eventHandlerMetadata: unknown;
+    constructor(eventEnvelope: EventEnvelope | NotificationInterface, eventInstance: EventInterface, eventHandlerMetadata: unknown, originalError: Error);
+}

package/dist/errors/event-handler-global-error.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandlerGlobalError = void 0;
+const global_error_container_1 = require("./global-error-container");
+class EventHandlerGlobalError extends global_error_container_1.GlobalErrorContainer {
+    constructor(eventEnvelope, eventInstance, eventHandlerMetadata, originalError) {
+        super(originalError);
+        this.eventEnvelope = eventEnvelope;
+        this.eventInstance = eventInstance;
+        this.eventHandlerMetadata = eventHandlerMetadata;
+    }
+}
+exports.EventHandlerGlobalError = EventHandlerGlobalError;

package/dist/errors/global-error-container.d.ts

@@ -0,0 +1,4 @@
+export declare class GlobalErrorContainer {
+    readonly originalError: Error;
+    constructor(originalError: Error);
+}

package/dist/errors/global-error-container.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalErrorContainer = void 0;
+class GlobalErrorContainer {
+    constructor(originalError) {
+        this.originalError = originalError;
+    }
+}
+exports.GlobalErrorContainer = GlobalErrorContainer;