@magek/core 0.0.1

package/dist/graphql-dispatcher.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekGraphQLDispatcher = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const graphql_1 = require("graphql");
+const graphql = require("graphql");
+const graphql_generator_1 = require("./services/graphql/graphql-generator");
+const read_models_reader_1 = require("./read-models-reader");
+const noop_read_model_pub_sub_1 = require("./services/pub-sub/noop-read-model-pub-sub");
+const graphql_websocket_protocol_1 = require("./services/graphql/websocket-protocol/graphql-websocket-protocol");
+const token_verifier_1 = require("./token-verifier");
+const instrumentation_1 = require("./instrumentation");
+class MagekGraphQLDispatcher {
+    constructor(config) {
+        this.config = config;
+        this.readModelDispatcher = new read_models_reader_1.MagekReadModelsReader(config);
+        this.graphQLSchema = graphql_generator_1.GraphQLGenerator.generateSchema(config);
+        this.tokenVerifier = new token_verifier_1.MagekTokenVerifier(config);
+        this.websocketHandler = new graphql_websocket_protocol_1.GraphQLWebsocketHandler(config, {
+            onStartOperation: this.runGraphQLOperation.bind(this),
+            onStopOperation: this.readModelDispatcher.unsubscribe.bind(this.readModelDispatcher),
+            onTerminate: this.handleDisconnect.bind(this),
+        }, this.tokenVerifier);
+    }
+    async dispatch(request) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekGraphQLDispatcher#dispatch');
+        const envelopeOrError = await this.config.provider.graphQL.rawToEnvelope(this.config, request);
+        logger.debug('Received the following GraphQL envelope: ', envelopeOrError);
+        switch (envelopeOrError.eventType) {
+            case 'CONNECT':
+                return this.config.provider.graphQL.handleResult(null, common_1.graphQLWebsocketSubprotocolHeaders);
+            case 'MESSAGE':
+                const responseHeaders = { ...this.config.defaultResponseHeaders };
+                const result = await this.handleMessage(envelopeOrError, responseHeaders);
+                return this.config.provider.graphQL.handleResult(result, responseHeaders);
+            case 'DISCONNECT':
+                return this.config.provider.graphQL.handleResult(await this.handleDisconnect(envelopeOrError.connectionID));
+            default:
+                return this.config.provider.graphQL.handleResult({
+                    errors: [new Error(`Unknown message type ${envelopeOrError.eventType}`)],
+                });
+        }
+    }
+    async verifyTokenFromEnvelope(envelope) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekGraphQLDispatcher#verifyTokenFromEnvelop');
+        if (envelope.token) {
+            try {
+                logger.debug(`Decoding current user from auth token: ${envelope.token}`);
+                envelope.currentUser = await this.tokenVerifier.verify(envelope.token);
+            }
+            catch (e) {
+                envelope = {
+                    ...envelope,
+                    error: e,
+                };
+                logger.debug('Unable to decode auth token');
+            }
+        }
+        return envelope;
+    }
+    async handleMessage(envelope, responseHeaders) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekGraphQLDispatcher#handleMessage');
+        logger.debug('Starting GraphQL operation:', envelope);
+        const envelopeOrError = await this.verifyTokenFromEnvelope(envelope);
+        if (cameThroughSocket(envelopeOrError)) {
+            return this.websocketHandler.handle(envelopeOrError);
+        }
+        return this.runGraphQLOperation(envelopeOrError, responseHeaders);
+    }
+    async runGraphQLOperation(envelope, responseHeaders = {}) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekGraphQLDispatcher#runGraphQLOperation');
+        try {
+            if ('error' in envelope) {
+                throw envelope.error;
+            }
+            if (!envelope.value) {
+                throw new common_1.InvalidParameterError('Received an empty GraphQL body');
+            }
+            const operation = envelope.value;
+            if (!operation.query) {
+                throw new common_1.InvalidParameterError('Received an empty GraphQL query');
+            }
+            const queryDocument = graphql.parse(operation.query);
+            const errors = graphql.validate(this.graphQLSchema, queryDocument);
+            if (errors.length > 0) {
+                throw errors;
+            }
+            const operationData = graphql.getOperationAST(queryDocument, operation.operationName);
+            const isIntrospectionQuery = operation.operationName === 'IntrospectionQuery' || operation.query.includes('__schema');
+            if (isIntrospectionQuery && !this.config.enableGraphQLIntrospection) {
+                throw new common_1.InvalidProtocolError('Instrospection queries are disabled. Check the configuration if you want to enable them.');
+            }
+            if (!operationData) {
+                throw new common_1.InvalidParameterError('Could not extract GraphQL operation. ' +
+                    'Be sure to either send only one query, mutation, or subscription, or, in case you send several operations, ' +
+                    'include the "operationName" field');
+            }
+            const resolverContext = {
+                connectionID: envelope.connectionID,
+                responseHeaders: responseHeaders,
+                requestID: envelope.requestID,
+                user: envelope.currentUser,
+                operation: {
+                    ...operation,
+                },
+                pubSub: new noop_read_model_pub_sub_1.NoopReadModelPubSub(),
+                storeSubscriptions: true,
+                context: envelope.context,
+            };
+            switch (operationData.operation) {
+                case graphql_1.OperationTypeNode.QUERY:
+                case graphql_1.OperationTypeNode.MUTATION:
+                    return await this.handleQueryOrMutation(queryDocument, resolverContext);
+                case graphql_1.OperationTypeNode.SUBSCRIPTION:
+                    return await this.handleSubscription(queryDocument, resolverContext);
+            }
+        }
+        catch (e) {
+            const error = e;
+            logger.error(e);
+            const errors = Array.isArray(e) ? e.map(toGraphQLErrorWithExtensions) : [toGraphQLErrorWithExtensions(error)];
+            return { errors };
+        }
+    }
+    async handleQueryOrMutation(queryDocument, resolverContext) {
+        var _a;
+        const logger = (0, common_1.getLogger)(this.config, 'MagekGraphQLDispatcher#handleQueryOrMutation');
+        const result = await graphql.execute({
+            schema: this.graphQLSchema,
+            document: queryDocument,
+            contextValue: resolverContext,
+            variableValues: resolverContext.operation.variables,
+            operationName: resolverContext.operation.operationName,
+        });
+        result.errors = (_a = result.errors) === null || _a === void 0 ? void 0 : _a.map(toGraphQLErrorWithExtensions);
+        logger.debug('GraphQL result: ', result);
+        return result;
+    }
+    async handleSubscription(queryDocument, resolverContext) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekGraphQLDispatcher#handleSubscription');
+        if (!cameThroughSocket(resolverContext)) {
+            throw new common_1.InvalidProtocolError('This API and protocol does not support "subscription" operations, only "query" and "mutation". Use the socket API for "subscription"');
+        }
+        const result = await graphql.subscribe({
+            schema: this.graphQLSchema,
+            document: queryDocument,
+            contextValue: resolverContext,
+            variableValues: resolverContext.operation.variables,
+            operationName: resolverContext.operation.operationName,
+        });
+        logger.debug('GraphQL subscription finished');
+        return result;
+    }
+    async handleDisconnect(connectionID) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekGraphQLDispatcher#handleDisconnect');
+        if (!connectionID) {
+            // This should be impossible, but just in case
+            logger.info("Received a DISCONNECT message but field 'connectionID' is missing. Doing nothing");
+            return;
+        }
+        logger.debug('Deleting all subscriptions and connection data');
+        await this.config.sessionStore.deleteConnection(this.config, connectionID);
+        await this.readModelDispatcher.unsubscribeAll(connectionID);
+    }
+}
+exports.MagekGraphQLDispatcher = MagekGraphQLDispatcher;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.GRAPHQL_DISPATCH),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekGraphQLDispatcher.prototype, "dispatch", null);
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.GRAPHQL_RUN_OPERATION),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekGraphQLDispatcher.prototype, "runGraphQLOperation", null);
+function cameThroughSocket(withConnectionID) {
+    return withConnectionID.connectionID != undefined;
+}
+function toGraphQLErrorWithExtensions(e) {
+    if (e instanceof graphql_1.GraphQLError) {
+        const originalError = e.originalError;
+        return new graphql_1.GraphQLError(e.message, e.nodes, e.source, e.positions, e.path, originalError, {
+            code: originalError === null || originalError === void 0 ? void 0 : originalError.code,
+            data: originalError === null || originalError === void 0 ? void 0 : originalError.data,
+        });
+    }
+    return new graphql_1.GraphQLError(e.message, undefined, undefined, undefined, undefined, e, {
+        code: e.code,
+        data: e.data,
+    });
+}

package/dist/importer.d.ts

@@ -0,0 +1,14 @@
+export declare class Importer {
+    static importUserProjectFiles(codeRootPath: string): void;
+    private static importWithoutExtension;
+    private static getImportFiles;
+    private static walkDir;
+    /**
+     * Returns true if the file is a JavaScript file.
+     */
+    private static isJavaScriptFile;
+    private static isNotIndexJs;
+    private static removeDevExtension;
+    private static listDirectory;
+    private static isDirectory;
+}

package/dist/importer.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Importer = void 0;
+const fs = require("fs");
+const path = require("path");
+class Importer {
+    static importUserProjectFiles(codeRootPath) {
+        Importer.getImportFiles(codeRootPath).forEach(Importer.importWithoutExtension);
+    }
+    static importWithoutExtension(file) {
+        require(Importer.removeDevExtension(file));
+    }
+    static getImportFiles(codeRootPath) {
+        return Importer.walkDir(codeRootPath).filter(Importer.isJavaScriptFile).filter(Importer.isNotIndexJs);
+    }
+    static walkDir(dir) {
+        const files = [];
+        Importer.listDirectory(dir).forEach((file) => {
+            const fileName = path.join(dir, file);
+            if (Importer.isDirectory(fileName)) {
+                const filesInDirectory = Importer.walkDir(fileName);
+                files.push(...filesInDirectory);
+            }
+            else {
+                files.push(fileName);
+            }
+        });
+        return files;
+    }
+    /**
+     * Returns true if the file is a JavaScript file.
+     */
+    static isJavaScriptFile(file) {
+        return file.match(/.*\.js$/) != null;
+    }
+    static isNotIndexJs(file) {
+        return file.match(/index.js$/) == null;
+    }
+    static removeDevExtension(file) {
+        return path.join(file.replace(/(\.d)?(\.ts|\.js)/, ''));
+    }
+    static listDirectory(dir) {
+        return fs.readdirSync(dir);
+    }
+    static isDirectory(fileName) {
+        return fs.statSync(fileName).isDirectory();
+    }
+}
+exports.Importer = Importer;

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+export { Magek } from './magek';
+export { RegisterHandler } from './register-handler';
+export * from './decorators';
+export { MagekDataMigrations } from './data-migrations';
+export { MagekDataMigrationFinished } from './core-concepts/data-migration/events/data-migration-finished';
+export { MagekDataMigrationEntity } from './core-concepts/data-migration/entities/data-migration-entity';
+export { MagekTouchEntityHandler } from './touch-entity-handler';
+export * from './services/token-verifiers';
+export * from './instrumentation/index';
+export * from './decorators/health-sensor';
+export * as Injectable from './injectable';
+/**
+ * Pushes a page of events to be processed by the event dispatcher.
+ *
+ * @param rawEvents A provider-specific representation of the events to be processed
+ * @returns A promise that resolves when the events are processed
+ */
+export declare function eventDispatcher(rawEvents: unknown): Promise<void>;
+/**
+ * Serves a GraphQL request. GraphQL resolvers can send response objects back to the client.
+ *
+ * @param rawRequest A provider-specific representation of the GraphQL request.
+ * @returns A promise that resolves to the GraphQL response.
+ */
+export declare function graphQLDispatcher(rawRequest: unknown): Promise<unknown>;
+/**
+ * Triggers pending scheduled commands. This function is meant to be called by a scheduler.
+ *
+ * @param rawRequest A provider-specific representation of the request to trigger scheduled commands
+ * @returns A promise that resolves when the scheduled commands are triggered
+ */
+export declare function triggerScheduledCommands(rawRequest: unknown): Promise<void>;
+/**
+ * Notifies subscribers of a new update on a read model
+ *
+ * @param rawRequest A provider-specific representation of the request to notify subscribers.
+ * @returns A promise that resolves when the subscribers are notified
+ */
+export declare function notifySubscribers(rawRequest: unknown): Promise<void>;
+/**
+ * Consumes events from the event stream and dispatches them to the event handlers
+ *
+ * @param rawEvent A provider-specific representation of the event to be processed
+ * @returns A promise that resolves when the event is processed
+ */
+export declare function consumeEventStream(rawEvent: unknown): Promise<unknown>;
+/**
+ * Produces events to the event stream
+ *
+ * @param rawEvent A provider-specific representation of the event to be produced
+ * @returns A promise that resolves when the event is produced
+ */
+export declare function produceEventStream(rawEvent: unknown): Promise<unknown>;
+/**
+ * Returns the health of the application
+ *
+ * @param request A provider-specific representation of the request to check the health
+ * @returns A promise that resolves to the health of the application
+ */
+export declare function health(request: unknown): Promise<unknown>;

package/dist/index.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injectable = exports.MagekTouchEntityHandler = exports.MagekDataMigrationEntity = exports.MagekDataMigrationFinished = exports.MagekDataMigrations = exports.RegisterHandler = exports.Magek = void 0;
+exports.eventDispatcher = eventDispatcher;
+exports.graphQLDispatcher = graphQLDispatcher;
+exports.triggerScheduledCommands = triggerScheduledCommands;
+exports.notifySubscribers = notifySubscribers;
+exports.consumeEventStream = consumeEventStream;
+exports.produceEventStream = produceEventStream;
+exports.health = health;
+const tslib_1 = require("tslib");
+const magek_1 = require("./magek");
+const event_dispatcher_1 = require("./event-dispatcher");
+const graphql_dispatcher_1 = require("./graphql-dispatcher");
+const scheduled_command_dispatcher_1 = require("./scheduled-command-dispatcher");
+const subscribers_notifier_1 = require("./subscribers-notifier");
+const event_stream_consumer_1 = require("./event-stream-consumer");
+const event_stream_producer_1 = require("./event-stream-producer");
+const sensor_1 = require("./sensor");
+// Exports
+var magek_2 = require("./magek");
+Object.defineProperty(exports, "Magek", { enumerable: true, get: function () { return magek_2.Magek; } });
+var register_handler_1 = require("./register-handler");
+Object.defineProperty(exports, "RegisterHandler", { enumerable: true, get: function () { return register_handler_1.RegisterHandler; } });
+tslib_1.__exportStar(require("./decorators"), exports);
+var data_migrations_1 = require("./data-migrations");
+Object.defineProperty(exports, "MagekDataMigrations", { enumerable: true, get: function () { return data_migrations_1.MagekDataMigrations; } });
+var data_migration_finished_1 = require("./core-concepts/data-migration/events/data-migration-finished");
+Object.defineProperty(exports, "MagekDataMigrationFinished", { enumerable: true, get: function () { return data_migration_finished_1.MagekDataMigrationFinished; } });
+var data_migration_entity_1 = require("./core-concepts/data-migration/entities/data-migration-entity");
+Object.defineProperty(exports, "MagekDataMigrationEntity", { enumerable: true, get: function () { return data_migration_entity_1.MagekDataMigrationEntity; } });
+var touch_entity_handler_1 = require("./touch-entity-handler");
+Object.defineProperty(exports, "MagekTouchEntityHandler", { enumerable: true, get: function () { return touch_entity_handler_1.MagekTouchEntityHandler; } });
+tslib_1.__exportStar(require("./services/token-verifiers"), exports);
+tslib_1.__exportStar(require("./instrumentation/index"), exports);
+tslib_1.__exportStar(require("./decorators/health-sensor"), exports);
+exports.Injectable = require("./injectable");
+/**
+ * Pushes a page of events to be processed by the event dispatcher.
+ *
+ * @param rawEvents A provider-specific representation of the events to be processed
+ * @returns A promise that resolves when the events are processed
+ */
+async function eventDispatcher(rawEvents) {
+    return event_dispatcher_1.MagekEventDispatcher.dispatch(rawEvents, magek_1.Magek.config);
+}
+/**
+ * Serves a GraphQL request. GraphQL resolvers can send response objects back to the client.
+ *
+ * @param rawRequest A provider-specific representation of the GraphQL request.
+ * @returns A promise that resolves to the GraphQL response.
+ */
+async function graphQLDispatcher(rawRequest) {
+    return new graphql_dispatcher_1.MagekGraphQLDispatcher(magek_1.Magek.config).dispatch(rawRequest);
+}
+/**
+ * Triggers pending scheduled commands. This function is meant to be called by a scheduler.
+ *
+ * @param rawRequest A provider-specific representation of the request to trigger scheduled commands
+ * @returns A promise that resolves when the scheduled commands are triggered
+ */
+async function triggerScheduledCommands(rawRequest) {
+    return new scheduled_command_dispatcher_1.MagekScheduledCommandDispatcher(magek_1.Magek.config).dispatch(rawRequest);
+}
+/**
+ * Notifies subscribers of a new update on a read model
+ *
+ * @param rawRequest A provider-specific representation of the request to notify subscribers.
+ * @returns A promise that resolves when the subscribers are notified
+ */
+async function notifySubscribers(rawRequest) {
+    return new subscribers_notifier_1.MagekSubscribersNotifier(magek_1.Magek.config).dispatch(rawRequest);
+}
+/**
+ * Consumes events from the event stream and dispatches them to the event handlers
+ *
+ * @param rawEvent A provider-specific representation of the event to be processed
+ * @returns A promise that resolves when the event is processed
+ */
+async function consumeEventStream(rawEvent) {
+    return event_stream_consumer_1.MagekEventStreamConsumer.consume(rawEvent, magek_1.Magek.config);
+}
+/**
+ * Produces events to the event stream
+ *
+ * @param rawEvent A provider-specific representation of the event to be produced
+ * @returns A promise that resolves when the event is produced
+ */
+async function produceEventStream(rawEvent) {
+    return event_stream_producer_1.MagekEventStreamProducer.produce(rawEvent, magek_1.Magek.config);
+}
+/**
+ * Returns the health of the application
+ *
+ * @param request A provider-specific representation of the request to check the health
+ * @returns A promise that resolves to the health of the application
+ */
+async function health(request) {
+    return new sensor_1.MagekHealthService(magek_1.Magek.config).health(request);
+}

package/dist/injectable/index.d.ts

@@ -0,0 +1,21 @@
+import type { Command as OclifCommand, Config } from '@oclif/core';
+/**
+ * Type for a concrete oclif Command class (non-abstract).
+ * This represents a class constructor that creates Command instances.
+ */
+export type ConcreteCommand = new (argv: string[], config: Config) => OclifCommand;
+/**
+ * Injectable interface for registering custom CLI commands with Magek.
+ * Commands should be oclif Command classes (concrete implementations, not abstract).
+ */
+export interface Injectable {
+    /**
+     * Map of command names to oclif Command classes.
+     * The command name will be used as the subcommand name.
+     */
+    commands: Record<string, ConcreteCommand>;
+}
+/**
+ * Type for an oclif Command class.
+ */
+export type Command = ConcreteCommand;

package/dist/injectable/index.js

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

package/dist/instrumentation/decorator/trace.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Stage 3 method decorator context
+ */
+interface Stage3MethodContext {
+    kind: 'method';
+    name: string | symbol;
+    static: boolean;
+    private: boolean;
+    metadata: Record<string | symbol, unknown>;
+    addInitializer?: (initializer: () => void) => void;
+}
+export declare function Trace(actionType?: string, description?: string): (targetOrMethod: unknown, memberOrContext: string | Stage3MethodContext, descriptor?: TypedPropertyDescriptor<(...params: any[]) => Promise<any>>) => any;
+export {};

package/dist/instrumentation/decorator/trace.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trace = Trace;
+const common_1 = require("@magek/common");
+const trace_notifier_1 = require("../trace-notifier");
+const magek_1 = require("../../magek");
+/**
+ * Type guard for Stage 3 method context
+ */
+function isStage3MethodContext(arg) {
+    return (arg !== null &&
+        typeof arg === 'object' &&
+        'kind' in arg &&
+        arg.kind === 'method' &&
+        'name' in arg);
+}
+function Trace(actionType = common_1.TraceActionTypes.CUSTOM, description) {
+    // Return type is 'any' to support both legacy (returns PropertyDescriptor) and Stage 3 (returns Function) decorators
+    return (targetOrMethod, memberOrContext, descriptor) => {
+        // Detect Stage 3 decorator
+        if (isStage3MethodContext(memberOrContext)) {
+            // Stage 3: targetOrMethod is the actual method function
+            const originalMethod = targetOrMethod;
+            const methodName = String(memberOrContext.name);
+            // Return a new function that wraps the original
+            return async function (...args) {
+                const config = magek_1.Magek.config;
+                const tracerConfigured = (0, trace_notifier_1.isTraceEnabled)(actionType, config);
+                if (!tracerConfigured) {
+                    return await originalMethod.apply(this, args);
+                }
+                const parameters = buildParametersStage3(this, methodName, args, description, config);
+                const startTime = new Date().getTime();
+                await (0, trace_notifier_1.notifyTrace)(common_1.TraceTypes.START, actionType, parameters, config);
+                try {
+                    return await originalMethod.apply(this, args);
+                }
+                finally {
+                    parameters.elapsedInvocationMillis = new Date().getTime() - startTime;
+                    await (0, trace_notifier_1.notifyTrace)(common_1.TraceTypes.END, actionType, parameters, config);
+                }
+            };
+        }
+        // Legacy decorator
+        const target = targetOrMethod;
+        const member = memberOrContext;
+        // Handle case where descriptor is undefined (can happen with certain TypeScript/ESM configurations)
+        if (!descriptor) {
+            return;
+        }
+        const originalMethod = descriptor.value;
+        if (!originalMethod) {
+            return descriptor;
+        }
+        descriptor.value = async function (...args) {
+            const config = magek_1.Magek.config;
+            const tracerConfigured = (0, trace_notifier_1.isTraceEnabled)(actionType, config);
+            if (!tracerConfigured) {
+                return await originalMethod.apply(this, args);
+            }
+            const parameters = buildParameters(target, member, args, description, descriptor, config);
+            const startTime = new Date().getTime();
+            await (0, trace_notifier_1.notifyTrace)(common_1.TraceTypes.START, actionType, parameters, config);
+            try {
+                return await originalMethod.apply(this, args);
+            }
+            finally {
+                parameters.elapsedInvocationMillis = new Date().getTime() - startTime;
+                await (0, trace_notifier_1.notifyTrace)(common_1.TraceTypes.END, actionType, parameters, config);
+            }
+        };
+        return descriptor;
+    };
+}
+function buildParameters(target, member, args, description, descriptor, config) {
+    let internal = undefined;
+    if (config && config.traceConfiguration.includeInternal) {
+        internal = {
+            target: target,
+            descriptor: descriptor,
+        };
+    }
+    const parameters = {
+        className: getClassName(target),
+        methodName: member,
+        args: args,
+        description: description,
+        traceId: common_1.UUID.generate(),
+        internal: internal,
+    };
+    return parameters;
+}
+function buildParametersStage3(instance, methodName, args, description, config) {
+    let internal = undefined;
+    if (config && config.traceConfiguration.includeInternal) {
+        internal = {
+            target: instance,
+            descriptor: {}, // Stage 3 decorators don't have access to property descriptors
+        };
+    }
+    const parameters = {
+        className: getClassName(instance),
+        methodName: methodName,
+        args: args,
+        description: description,
+        traceId: common_1.UUID.generate(),
+        internal: internal,
+    };
+    return parameters;
+}
+// Get class name for instances and static methods
+function getClassName(target) {
+    var _a, _b, _c, _d, _e;
+    // @ts-ignore
+    return (_e = (_c = (_b = (_a = target === null || target === void 0 ? void 0 : target.prototype) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : (_d = target === null || target === void 0 ? void 0 : target.constructor) === null || _d === void 0 ? void 0 : _d.name) !== null && _e !== void 0 ? _e : '';
+}

package/dist/instrumentation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './trace-notifier';
+export * from './decorator/trace';

package/dist/instrumentation/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./trace-notifier"), exports);
+tslib_1.__exportStar(require("./decorator/trace"), exports);

package/dist/instrumentation/trace-notifier.d.ts

@@ -0,0 +1,3 @@
+import { MagekConfig, TraceInfo, TraceTypes } from '@magek/common';
+export declare function notifyTrace(type: TraceTypes, actionType: string, parameters: TraceInfo, config: MagekConfig): Promise<void>;
+export declare function isTraceEnabled(actionType: string, config: MagekConfig): boolean;

package/dist/instrumentation/trace-notifier.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyTrace = notifyTrace;
+exports.isTraceEnabled = isTraceEnabled;
+const common_1 = require("@magek/common");
+async function notifyTrace(type, actionType, parameters, config) {
+    const handler = type === common_1.TraceTypes.START ? config.traceConfiguration.onStart : config.traceConfiguration.onEnd;
+    return handler.call(handler, config, actionType, parameters);
+}
+function isTraceEnabled(actionType, config) {
+    if (!config) {
+        return false;
+    }
+    const invocations = config.traceConfiguration;
+    if (!invocations) {
+        return false;
+    }
+    const enableNotificationsInvocations = invocations.enableTraceNotification;
+    if (!enableNotificationsInvocations) {
+        return false;
+    }
+    if (Array.isArray(enableNotificationsInvocations) && !enableNotificationsInvocations.includes(actionType)) {
+        return false;
+    }
+    return true;
+}

package/dist/magek.d.ts

@@ -0,0 +1,42 @@
+import { MagekConfig, Class, EntityInterface, EventDeleteParameters, EventSearchParameters, EventSearchResponse, PaginatedEntitiesIdsResult, ReadModelInterface, Searcher, UUID } from '@magek/common';
+/**
+ * Main class to interact with Magek and configure it.
+ * Sensible defaults are used whenever possible:
+ * - `appName`: `new-magek-app`
+ *
+ */
+export declare class Magek {
+    static readonly configuredEnvironments: Set<string>;
+    static readonly config: MagekConfig;
+    static configureCurrentEnv(configurator: (config: MagekConfig) => void): void;
+    /**
+     * Allows to configure the Magek project.
+     *
+     * @param environment The name of the environment you want to configure
+     * @param configurator A function that receives the configuration object to set the values
+     */
+    static configure(environment: string, configurator: (config: MagekConfig) => void): void;
+    /**
+     * Initializes the Magek project
+     */
+    static start(codeRootPath: string): void;
+    private static runInjectableCommands;
+    /**
+     * This function returns a "Searcher" configured to search instances of the read model class passed as param.
+     * For more information, check the Searcher class.
+     * @param readModelClass The class of the read model you what to run searches for
+     */
+    static readModel<TReadModel extends ReadModelInterface>(readModelClass: Class<TReadModel>): Searcher<TReadModel>;
+    static events(request: EventSearchParameters): Promise<Array<EventSearchResponse>>;
+    static entitiesIDs(entityTypeName: string, limit: number, afterCursor?: Record<string, string>): Promise<PaginatedEntitiesIdsResult>;
+    static deleteEvent(parameters: EventDeleteParameters): Promise<boolean>;
+    /**
+     * Fetches the last known version of an entity
+     * @param entityClass Name of the entity class
+     * @param entityID
+     */
+    static entity<TEntity extends EntityInterface>(entityClass: Class<TEntity>, entityID: UUID): Promise<TEntity | undefined>;
+    private static configureMagekConcepts;
+    private static configureDataMigrations;
+    private static configureTouchEntities;
+}