@magek/common 0.0.1

package/dist/errors/index.d.ts

@@ -0,0 +1,9 @@
+export * from './command-handler-global-error';
+export * from './query-handler-global-error';
+export * from './event-handler-global-error';
+export * from './global-error-container';
+export * from './projection-global-error';
+export * from './reducer-global-error';
+export * from './schedule-command-global-error';
+export * from './snapshot-persist-handler-global-error';
+export * from './event-global-error';

package/dist/errors/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./command-handler-global-error"), exports);
+tslib_1.__exportStar(require("./query-handler-global-error"), exports);
+tslib_1.__exportStar(require("./event-handler-global-error"), exports);
+tslib_1.__exportStar(require("./global-error-container"), exports);
+tslib_1.__exportStar(require("./projection-global-error"), exports);
+tslib_1.__exportStar(require("./reducer-global-error"), exports);
+tslib_1.__exportStar(require("./schedule-command-global-error"), exports);
+tslib_1.__exportStar(require("./snapshot-persist-handler-global-error"), exports);
+tslib_1.__exportStar(require("./event-global-error"), exports);

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

@@ -0,0 +1,10 @@
+import { GlobalErrorContainer } from './global-error-container';
+import { EntityInterface, ProjectionMetadata, ReadModelInterface } from '../concepts';
+import { EntitySnapshotEnvelope } from '../envelope';
+export declare class ProjectionGlobalError extends GlobalErrorContainer {
+    readonly entityEnvelope: EntitySnapshotEnvelope;
+    readonly entity: EntityInterface;
+    readonly readModel: ReadModelInterface | undefined;
+    readonly projectionMetadata: ProjectionMetadata<EntityInterface, ReadModelInterface>;
+    constructor(entityEnvelope: EntitySnapshotEnvelope, entity: EntityInterface, readModel: ReadModelInterface | undefined, projectionMetadata: ProjectionMetadata<EntityInterface, ReadModelInterface>, originalError: Error);
+}

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { GlobalErrorContainer } from './global-error-container';
+import { EntityInterface, EventInterface, ReducerMetadata } from '../concepts';
+import { EventEnvelope } from '../envelope';
+export declare class ReducerGlobalError extends GlobalErrorContainer {
+    readonly eventEnvelope: EventEnvelope;
+    readonly eventInstance: EventInterface;
+    readonly snapshotInstance: EntityInterface | null;
+    readonly reducerMetadata: ReducerMetadata;
+    constructor(eventEnvelope: EventEnvelope, eventInstance: EventInterface, snapshotInstance: EntityInterface | null, reducerMetadata: ReducerMetadata, originalError: Error);
+}

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

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

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

@@ -0,0 +1,8 @@
+import { GlobalErrorContainer } from './global-error-container';
+import { ScheduledCommandMetadata } from '../concepts';
+import { ScheduledCommandEnvelope } from '../envelope';
+export declare class ScheduleCommandGlobalError extends GlobalErrorContainer {
+    readonly scheduleCommandEnvelope: ScheduledCommandEnvelope;
+    readonly scheduleCommandMetadata: ScheduledCommandMetadata;
+    constructor(scheduleCommandEnvelope: ScheduledCommandEnvelope, scheduleCommandMetadata: ScheduledCommandMetadata, originalError: Error);
+}

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

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

package/dist/errors/snapshot-persist-handler-global-error.d.ts

@@ -0,0 +1,16 @@
+import { GlobalErrorContainer } from './global-error-container';
+import { NonPersistedEntitySnapshotEnvelope } from '../envelope';
+/**
+ * @deprecated [EOL v3] Errors when persisting snapshots can be safely ignored because
+ * this problem is likely caused by a temporary network error, and the events,
+ * which are the true source of truth are kept in any case.
+ * The next time the entity is fetched, the snapshot will be recalculated and
+ * Magek will try to persist it once again.
+ * If you define custom error handlers for this error, they will still be called,
+ * but errors returned by them will be logged and ignored.
+ * This class is kept for backwards compatibility.
+ */
+export declare class SnapshotPersistHandlerGlobalError extends GlobalErrorContainer {
+    readonly snapshot: NonPersistedEntitySnapshotEnvelope;
+    constructor(snapshot: NonPersistedEntitySnapshotEnvelope, originalError: Error);
+}

package/dist/errors/snapshot-persist-handler-global-error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotPersistHandlerGlobalError = void 0;
+const global_error_container_1 = require("./global-error-container");
+/**
+ * @deprecated [EOL v3] Errors when persisting snapshots can be safely ignored because
+ * this problem is likely caused by a temporary network error, and the events,
+ * which are the true source of truth are kept in any case.
+ * The next time the entity is fetched, the snapshot will be recalculated and
+ * Magek will try to persist it once again.
+ * If you define custom error handlers for this error, they will still be called,
+ * but errors returned by them will be logged and ignored.
+ * This class is kept for backwards compatibility.
+ */
+class SnapshotPersistHandlerGlobalError extends global_error_container_1.GlobalErrorContainer {
+    constructor(snapshot, originalError) {
+        super(originalError);
+        this.snapshot = snapshot;
+    }
+}
+exports.SnapshotPersistHandlerGlobalError = SnapshotPersistHandlerGlobalError;

package/dist/errors.d.ts

@@ -0,0 +1,30 @@
+import { EntityInterface, EventInterface } from './concepts';
+export declare class MagekError extends Error {
+    readonly data?: Record<string, unknown> | undefined;
+    readonly code: string;
+    constructor(message: string, code?: string, data?: Record<string, unknown> | undefined);
+}
+export declare class InvalidParameterError extends MagekError {
+}
+export declare class InvalidProtocolError extends MagekError {
+}
+export declare class NotAuthorizedError extends MagekError {
+}
+export declare class MagekTokenExpiredError extends MagekError {
+}
+export declare class MagekTokenNotBeforeError extends MagekError {
+}
+export declare class NotFoundError extends MagekError {
+}
+export declare class InvalidVersionError extends MagekError {
+}
+export declare class OptimisticConcurrencyUnexpectedVersionError extends MagekError {
+}
+export declare class InvalidEventError extends MagekError {
+}
+export declare class InvalidReducerError extends MagekError {
+    readonly eventInstance: EventInterface;
+    readonly snapshotInstance: EntityInterface | null;
+    constructor(message: string, eventInstance: EventInterface, snapshotInstance: EntityInterface | null);
+}
+export declare function httpStatusCodeFor(error: Error): number;

package/dist/errors.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidReducerError = exports.InvalidEventError = exports.OptimisticConcurrencyUnexpectedVersionError = exports.InvalidVersionError = exports.NotFoundError = exports.MagekTokenNotBeforeError = exports.MagekTokenExpiredError = exports.NotAuthorizedError = exports.InvalidProtocolError = exports.InvalidParameterError = exports.MagekError = void 0;
+exports.httpStatusCodeFor = httpStatusCodeFor;
+class MagekError extends Error {
+    constructor(message, code, data) {
+        super(message);
+        this.data = data;
+        this.code = code !== null && code !== void 0 ? code : this.constructor.name;
+    }
+}
+exports.MagekError = MagekError;
+class InvalidParameterError extends MagekError {
+}
+exports.InvalidParameterError = InvalidParameterError;
+class InvalidProtocolError extends MagekError {
+}
+exports.InvalidProtocolError = InvalidProtocolError;
+class NotAuthorizedError extends MagekError {
+}
+exports.NotAuthorizedError = NotAuthorizedError;
+class MagekTokenExpiredError extends MagekError {
+}
+exports.MagekTokenExpiredError = MagekTokenExpiredError;
+class MagekTokenNotBeforeError extends MagekError {
+}
+exports.MagekTokenNotBeforeError = MagekTokenNotBeforeError;
+class NotFoundError extends MagekError {
+}
+exports.NotFoundError = NotFoundError;
+class InvalidVersionError extends MagekError {
+}
+exports.InvalidVersionError = InvalidVersionError;
+class OptimisticConcurrencyUnexpectedVersionError extends MagekError {
+}
+exports.OptimisticConcurrencyUnexpectedVersionError = OptimisticConcurrencyUnexpectedVersionError;
+class InvalidEventError extends MagekError {
+}
+exports.InvalidEventError = InvalidEventError;
+class InvalidReducerError extends MagekError {
+    constructor(message, eventInstance, snapshotInstance) {
+        super(message);
+        this.eventInstance = eventInstance;
+        this.snapshotInstance = snapshotInstance;
+    }
+}
+exports.InvalidReducerError = InvalidReducerError;
+function httpStatusCodeFor(error) {
+    var _a;
+    const errorToHTTPCode = {
+        [InvalidParameterError.name]: 400,
+        [InvalidProtocolError.name]: 400,
+        [NotAuthorizedError.name]: 401,
+        [MagekTokenExpiredError.name]: 401,
+        [MagekTokenNotBeforeError.name]: 401,
+        [NotFoundError.name]: 404,
+        [InvalidVersionError.name]: 422,
+    };
+    return (_a = errorToHTTPCode[error.constructor.name]) !== null && _a !== void 0 ? _a : 500;
+}

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

@@ -0,0 +1,123 @@
+import { UUID } from './concepts';
+import { MagekConfig } from './config';
+import { EntitySnapshotEnvelope, EntitySnapshotEnvelopeFromDatabase, EventDeleteParameters, EventEnvelope, EventEnvelopeFromDatabase, EventSearchParameters, EventSearchResponse, NonPersistedEntitySnapshotEnvelope, NonPersistedEventEnvelope, PaginatedEntitiesIdsResult, SnapshotDeleteParameters } from './envelope';
+import { EventStream } from './stream-types';
+export interface EventStoreAdapter {
+    /**
+     * Converts raw events data into an array of EventEnvelope objects
+     *
+     * @param rawEvents - The raw events data to be converted
+     * @returns An array of EventEnvelope objects
+     */
+    rawToEnvelopes(rawEvents: unknown): Array<EventEnvelope>;
+    rawStreamToEnvelopes(config: MagekConfig, context: unknown, dedupEventStream: EventStream): Array<EventEnvelope>;
+    dedupEventStream(config: MagekConfig, rawEvents: unknown): Promise<EventStream>;
+    produce(entityName: string, entityID: UUID, eventEnvelopes: Array<EventEnvelope>, config: MagekConfig): Promise<void>;
+    /**
+     * Retrieves events for a specific entity since a given time
+     *
+     * @param config - The Magek configuration object
+     * @param entityTypeName - The type name of the entity
+     * @param entityID - The ID of the entity
+     * @param since - The time to retrieve events since (optional)
+     * @returns A promise that resolves to an array of EventEnvelope objects
+     */
+    forEntitySince(config: MagekConfig, entityTypeName: string, entityID: UUID, since?: string): Promise<Array<EventEnvelope>>;
+    /**
+     * Retrieves the latest snapshot of an entity
+     *
+     * @param config - The Magek configuration object
+     * @param entityTypeName - The type name of the entity
+     * @param entityID - The ID of the entity
+     * @returns A promise that resolves to the latest EventEnvelope for the entity, or null if none exist
+     */
+    latestEntitySnapshot(config: MagekConfig, entityTypeName: string, entityID: UUID): Promise<EntitySnapshotEnvelope | undefined>;
+    /**
+     * Searches for events based on specific parameters
+     *
+     * @param config - The Magek configuration object
+     * @param parameters - The search parameters
+     * @returns A promise that resolves to an array of EventSearchResponse objects
+     */
+    search(config: MagekConfig, parameters: EventSearchParameters): Promise<Array<EventSearchResponse>>;
+    /**
+     * Searches for entities IDs based on a specific entity type and pagination parameters
+     *
+     * @param config - The Magek configuration object
+     * @param limit - The maximum number of entities IDs to retrieve
+     * @param afterCursor - The cursor to retrieve entities IDs after (optional)
+     * @param entityTypeName - The type name of the entities to search for
+     * @returns A promise that resolves to a PaginatedEntitiesIdsResult object
+     */
+    searchEntitiesIDs(config: MagekConfig, limit: number, afterCursor: Record<string, string> | undefined, entityTypeName: string): Promise<PaginatedEntitiesIdsResult>;
+    /**
+     * Streams an event to the corresponding event handler
+     *
+     * @param eventEnvelopes - The array of `NonPersistedEventEnvelope` objects to store
+     * @param config - The Magek configuration object
+     * @returns A promise that resolves with the list of `EventEnvelope`s when the events have been stored
+     */
+    store(eventEnvelopes: Array<NonPersistedEventEnvelope>, config: MagekConfig): Promise<Array<EventEnvelope>>;
+    /**
+     * Stores a snapshot of an entity
+     *
+     * @param snapshotEnvelope - The `NonPersistedEntitySnapshotEnvelope` object to store
+     * @param config - The Magek configuration object
+     * @returns A promise that resolves with the `EntitySnapshotEnvelope` when the snapshot has been stored
+     */
+    storeSnapshot(snapshotEnvelope: NonPersistedEntitySnapshotEnvelope, config: MagekConfig): Promise<EntitySnapshotEnvelope>;
+    /**
+     * Stores an event envelope that has been dispatched in the dispatched events table.
+     *
+     * @param eventEnvelope - The `EventEnvelope` to store.
+     * @param config - The Magek configuration object.
+     * @returns `true` if the dispatched event was stored, `false` if the event already exists in the dispatched events
+     * table, throws an error on any other type of error.
+     */
+    storeDispatched(eventEnvelope: EventEnvelope, config: MagekConfig): Promise<boolean>;
+    /**
+     * Find all events to be removed based on the parameters
+     *
+     * @param config
+     * @param parameters
+     */
+    findDeletableEvent(config: MagekConfig, parameters: EventDeleteParameters): Promise<Array<EventEnvelopeFromDatabase>>;
+    /**
+     * Find all snapshots to be removed based on the parameters
+     *
+     * @param config
+     * @param parameters
+     */
+    findDeletableSnapshot(config: MagekConfig, parameters: SnapshotDeleteParameters): Promise<Array<EntitySnapshotEnvelopeFromDatabase>>;
+    /**
+     * Delete events
+     *
+     * @param config
+     * @param events
+     */
+    deleteEvent(config: MagekConfig, events: Array<EventEnvelopeFromDatabase>): Promise<void>;
+    /**
+     * Delete snapshots
+     *
+     * @param config
+     * @param snapshots
+     */
+    deleteSnapshot(config: MagekConfig, snapshots: Array<EntitySnapshotEnvelopeFromDatabase>): Promise<void>;
+    /**
+     * Health check methods for the event store
+     */
+    healthCheck?: {
+        /**
+         * Check if the event store is up and running
+         */
+        isUp(config: MagekConfig): Promise<boolean>;
+        /**
+         * Get detailed health information about the event store
+         */
+        details(config: MagekConfig): Promise<unknown>;
+        /**
+         * Get the URLs/endpoints of the event store
+         */
+        urls(config: MagekConfig): Promise<Array<string>>;
+    };
+}

package/dist/event-store-adapter.js

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

package/dist/field-decorator.d.ts

@@ -0,0 +1,63 @@
+import 'reflect-metadata';
+/**
+ * Type function for specifying field types
+ * The parameter is optional and not used - it's just for TypeGraphQL-style ergonomics
+ */
+export type TypeFunction = (type?: unknown) => unknown;
+/**
+ * Options for the @Field() decorator
+ */
+export interface FieldOptions {
+    nullable?: boolean;
+    readonly?: boolean;
+}
+/**
+ * Metadata stored for each field
+ */
+export interface FieldMetadata {
+    name: string;
+    typeFunction?: TypeFunction;
+    options: FieldOptions;
+    designType?: unknown;
+}
+/**
+ * Stage 3 decorator context for class fields (TypeScript 5.0+)
+ */
+interface Stage3FieldContext {
+    kind: 'field';
+    name: string | symbol;
+    static: boolean;
+    private: boolean;
+    metadata: Record<string | symbol, unknown>;
+    access?: {
+        get: () => unknown;
+        set: (value: unknown) => void;
+    };
+    addInitializer?: (initializer: () => void) => void;
+}
+/**
+ * Decorator return type that supports both legacy and Stage 3 formats.
+ * This is a function that can be called with either signature.
+ */
+type UniversalFieldDecorator = {
+    (target: object, propertyKey: string | symbol): void;
+    (value: undefined, context: Stage3FieldContext): void;
+};
+/**
+ * @Field() decorator for explicit type declaration
+ *
+ * Supports both legacy decorators (experimentalDecorators) and
+ * Stage 3 TC39 decorators.
+ *
+ * Usage:
+ *   @Field() - Simple type (inferred from design:type in legacy mode)
+ *   @Field(type => String) - Explicit type
+ *   @Field(type => [String]) - Array type
+ *   @Field({ nullable: true }) - With options
+ *   @Field(type => String, { nullable: true }) - Type with options
+ */
+export declare function Field(): UniversalFieldDecorator;
+export declare function Field(options: FieldOptions): UniversalFieldDecorator;
+export declare function Field(typeFunction: TypeFunction): UniversalFieldDecorator;
+export declare function Field(typeFunction: TypeFunction, options: FieldOptions): UniversalFieldDecorator;
+export {};

package/dist/field-decorator.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Field = Field;
+require("reflect-metadata");
+// Symbol for storing fields metadata (for Stage 3 decorators)
+const FIELDS_KEY = Symbol.for('magek:fields');
+/**
+ * Type guard to detect Stage 3 decorator context
+ */
+function isStage3Context(arg) {
+    return (arg !== null &&
+        typeof arg === 'object' &&
+        'kind' in arg &&
+        arg.kind === 'field' &&
+        'name' in arg &&
+        'metadata' in arg);
+}
+/**
+ * Store field metadata on a constructor (works for both legacy and Stage 3)
+ */
+function storeFieldMetadata(constructor, fieldMetadata) {
+    // Get existing fields
+    let existingFields = [];
+    // Try Reflect.getMetadata first
+    try {
+        if (typeof Reflect !== 'undefined' && typeof Reflect.getMetadata === 'function') {
+            existingFields = Reflect.getMetadata('magek:fields', constructor) || [];
+        }
+    }
+    catch {
+        // Ignore
+    }
+    // Also check fallback property
+    const ctorWithFields = constructor;
+    if (existingFields.length === 0 && ctorWithFields.__magek_fields__) {
+        existingFields = ctorWithFields.__magek_fields__;
+    }
+    // Add this field (avoid duplicates by name)
+    const filteredFields = existingFields.filter((f) => f.name !== fieldMetadata.name);
+    filteredFields.push(fieldMetadata);
+    // Store using both mechanisms for reliability
+    try {
+        if (typeof Reflect !== 'undefined' && typeof Reflect.defineMetadata === 'function') {
+            Reflect.defineMetadata('magek:fields', filteredFields, constructor);
+        }
+    }
+    catch {
+        // Ignore
+    }
+    // Also store as a fallback property
+    ctorWithFields.__magek_fields__ = filteredFields;
+}
+/**
+ * Handle legacy decorator format (experimentalDecorators)
+ */
+function handleLegacyDecorator(target, propertyKey, typeFunction, fieldOptions) {
+    // Get design type from TypeScript decorator metadata
+    let designType;
+    try {
+        if (typeof Reflect !== 'undefined' && typeof Reflect.getMetadata === 'function') {
+            designType = Reflect.getMetadata('design:type', target, propertyKey);
+        }
+    }
+    catch {
+        // Ignore - Reflect.getMetadata may fail if called before initialization
+    }
+    const fieldMetadata = {
+        name: propertyKey.toString(),
+        typeFunction,
+        options: fieldOptions,
+        designType,
+    };
+    const constructor = target.constructor;
+    if (constructor) {
+        storeFieldMetadata(constructor, fieldMetadata);
+    }
+}
+/**
+ * Handle Stage 3 decorator format (TC39 decorators)
+ */
+function handleStage3Decorator(context, typeFunction, fieldOptions) {
+    const fieldMetadata = {
+        name: context.name.toString(),
+        typeFunction,
+        options: fieldOptions,
+        designType: undefined, // Stage 3 doesn't have design:type
+    };
+    // Store in context.metadata for later retrieval by class decorators
+    // Class decorators (like @Command, @Entity, etc.) will transfer this to the class constructor
+    if (!context.metadata[FIELDS_KEY]) {
+        context.metadata[FIELDS_KEY] = [];
+    }
+    const fields = context.metadata[FIELDS_KEY];
+    const filteredFields = fields.filter((f) => f.name !== fieldMetadata.name);
+    filteredFields.push(fieldMetadata);
+    context.metadata[FIELDS_KEY] = filteredFields;
+}
+function Field(typeFunctionOrOptions, options) {
+    // Parse arguments
+    let typeFunction;
+    let fieldOptions = {};
+    if (typeof typeFunctionOrOptions === 'function') {
+        typeFunction = typeFunctionOrOptions;
+        fieldOptions = options || {};
+    }
+    else if (typeFunctionOrOptions) {
+        fieldOptions = typeFunctionOrOptions;
+    }
+    // Return decorator that handles both formats
+    return function fieldDecorator(targetOrValue, propertyKeyOrContext) {
+        // Detect Stage 3 vs Legacy based on the second argument
+        if (isStage3Context(propertyKeyOrContext)) {
+            // Stage 3 decorator
+            handleStage3Decorator(propertyKeyOrContext, typeFunction, fieldOptions);
+        }
+        else if (targetOrValue) {
+            // Legacy decorator
+            handleLegacyDecorator(targetOrValue, propertyKeyOrContext, typeFunction, fieldOptions);
+        }
+        // If targetOrValue is undefined and not Stage 3, silently skip
+    };
+}

package/dist/graphql-websocket-messages.d.ts

@@ -0,0 +1,65 @@
+import { GraphQLOperation } from './envelope';
+import { ExecutionResult } from 'graphql';
+export declare enum MessageTypes {
+    GQL_CONNECTION_INIT = "connection_init",
+    GQL_CONNECTION_ACK = "connection_ack",
+    GQL_CONNECTION_ERROR = "connection_error",
+    GQL_CONNECTION_TERMINATE = "connection_terminate",
+    GQL_START = "start",
+    GQL_DATA = "data",
+    GQL_ERROR = "error",
+    GQL_COMPLETE = "complete",
+    GQL_STOP = "stop"
+}
+export type GraphQLClientMessage = GraphQLInit | GraphQLStart | GraphQLStop | GraphQLTerminate;
+export interface GraphQLInit {
+    type: MessageTypes.GQL_CONNECTION_INIT;
+    payload: {
+        Authorization?: string;
+    };
+}
+export interface GraphQLStart {
+    type: MessageTypes.GQL_START;
+    id: string;
+    payload: Omit<GraphQLOperation, 'id'>;
+}
+export interface GraphQLStop {
+    type: MessageTypes.GQL_STOP;
+    id: string;
+}
+export interface GraphQLTerminate {
+    type: MessageTypes.GQL_CONNECTION_TERMINATE;
+}
+export type GraphQLServerMessage = GraphQLInitError | GraphQLInitAck | GraphQLData | GraphQLError | GraphQLComplete;
+export declare class GraphQLInitError {
+    readonly payload: string;
+    readonly type = MessageTypes.GQL_CONNECTION_ERROR;
+    constructor(payload: string);
+}
+export declare class GraphQLInitAck {
+    readonly type = MessageTypes.GQL_CONNECTION_ACK;
+}
+export declare class GraphQLData {
+    readonly id: string;
+    readonly payload: ExecutionResult;
+    readonly type = MessageTypes.GQL_DATA;
+    constructor(id: string, payload: ExecutionResult);
+}
+export declare class GraphQLError {
+    readonly id: string;
+    readonly payload: {
+        errors: Array<Error>;
+    };
+    readonly type = MessageTypes.GQL_ERROR;
+    constructor(id: string, payload: {
+        errors: Array<Error>;
+    });
+}
+export declare class GraphQLComplete {
+    readonly id: string;
+    readonly type = MessageTypes.GQL_COMPLETE;
+    constructor(id: string);
+}
+export declare const graphQLWebsocketSubprotocolHeaders: {
+    'Sec-WebSocket-Protocol': string;
+};