@magek/core 0.0.1

package/dist/rocket-dispatcher.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekRocketDispatcher = void 0;
+class MagekRocketDispatcher {
+    constructor(config) {
+        this.config = config;
+    }
+    dispatch(request) {
+        const rawToEnvelopes = this.config.provider.rockets.rawToEnvelopes(this.config, request);
+        const rocketId = rawToEnvelopes.rocketId;
+        if (!rocketId) {
+            throw new Error('Attempt to execute a rocket function but the ID is missing.');
+        }
+        const rocketFunction = this.config.getRegisteredRocketFunction(rocketId);
+        if (!rocketFunction) {
+            throw new Error(`Rocket function with ID "${rocketId}" not found. Did you forget registering the function with "config.registerRocketFunction()"?`);
+        }
+        return rocketFunction(this.config, request);
+    }
+}
+exports.MagekRocketDispatcher = MagekRocketDispatcher;

package/dist/scheduled-command-dispatcher.d.ts

@@ -0,0 +1,12 @@
+import { MagekConfig, ScheduledCommandEnvelope } from '@magek/common';
+export declare class MagekScheduledCommandDispatcher {
+    readonly config: MagekConfig;
+    private readonly globalErrorDispatcher;
+    constructor(config: MagekConfig);
+    dispatchCommand(commandEnvelope: ScheduledCommandEnvelope): Promise<void>;
+    /**
+     * Entry point to dispatch scheduled commands.
+     * @param request The incoming request
+     */
+    dispatch(request: unknown): Promise<void>;
+}

package/dist/scheduled-command-dispatcher.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekScheduledCommandDispatcher = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const register_handler_1 = require("./register-handler");
+const global_error_dispatcher_1 = require("./global-error-dispatcher");
+const instrumentation_1 = require("./instrumentation");
+class MagekScheduledCommandDispatcher {
+    constructor(config) {
+        this.config = config;
+        this.globalErrorDispatcher = new global_error_dispatcher_1.MagekGlobalErrorDispatcher(config);
+    }
+    async dispatchCommand(commandEnvelope) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekScheduledCommandDispatcher#dispatchCommand');
+        logger.debug('Dispatching the following scheduled command envelope: ', commandEnvelope);
+        const commandMetadata = this.config.scheduledCommandHandlers[commandEnvelope.typeName];
+        if (!commandMetadata) {
+            throw new common_1.NotFoundError(`Could not find a proper handler for ${commandEnvelope.typeName}`);
+        }
+        const commandClass = commandMetadata.class;
+        logger.debug('Found the following command:', commandClass.name);
+        const command = commandClass;
+        const register = new common_1.Register(commandEnvelope.requestID, {}, register_handler_1.RegisterHandler.flush, undefined, commandEnvelope.context);
+        try {
+            logger.debug('Calling "handle" method on command: ', command);
+            await command.handle(register);
+        }
+        catch (e) {
+            const error = await this.globalErrorDispatcher.dispatch(new common_1.ScheduleCommandGlobalError(commandEnvelope, commandMetadata, e));
+            if (error)
+                throw error;
+        }
+        logger.debug('Command dispatched with register: ', register);
+        await register_handler_1.RegisterHandler.handle(this.config, register);
+    }
+    /**
+     * Entry point to dispatch scheduled commands.
+     * @param request The incoming request
+     */
+    async dispatch(request) {
+        const logger = (0, common_1.getLogger)(this.config, 'MagekScheduledCommandDispatcher#dispatch');
+        const envelopeOrError = await this.config.provider.scheduled.rawToEnvelope(this.config, request);
+        logger.debug('Received ScheduledCommand envelope...', envelopeOrError);
+        await this.dispatchCommand(envelopeOrError);
+    }
+}
+exports.MagekScheduledCommandDispatcher = MagekScheduledCommandDispatcher;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.SCHEDULED_COMMAND_HANDLER),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MagekScheduledCommandDispatcher.prototype, "dispatchCommand", null);

package/dist/schema-migrator.d.ts

@@ -0,0 +1,12 @@
+import { MagekConfig, CommandEnvelope, EventEnvelope, EntitySnapshotEnvelope } from '@magek/common';
+type SchemaMigrableEnvelope = CommandEnvelope | EventEnvelope | EntitySnapshotEnvelope;
+export declare class SchemaMigrator {
+    private config;
+    constructor(config: MagekConfig);
+    migrate<TMigrableEnvelope extends SchemaMigrableEnvelope>(conceptEnvelope: TMigrableEnvelope): Promise<TMigrableEnvelope>;
+    private checkVersionRange;
+    private needsMigration;
+    private applyAllMigrations;
+    private applyMigration;
+}
+export {};

package/dist/schema-migrator.js

@@ -0,0 +1,71 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaMigrator = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const instrumentation_1 = require("./instrumentation");
+class SchemaMigrator {
+    constructor(config) {
+        this.config = config;
+    }
+    async migrate(conceptEnvelope) {
+        this.checkVersionRange(conceptEnvelope);
+        if (this.needsMigration(conceptEnvelope)) {
+            return await this.applyAllMigrations(conceptEnvelope);
+        }
+        return conceptEnvelope; // The current version is exactly the same as the version of the concept
+    }
+    checkVersionRange(conceptEnvelope) {
+        if (conceptEnvelope.version < 1) {
+            throw new common_1.InvalidVersionError(`Received an invalid schema version value, ${conceptEnvelope.version}, for ${conceptEnvelope.typeName}. ` +
+                'Versions must be greater than 0');
+        }
+        const currentVersion = this.config.currentVersionFor(conceptEnvelope.typeName);
+        if (currentVersion < conceptEnvelope.version) {
+            throw new common_1.InvalidVersionError(`Can not migrate schema an unknown version: The current schema version of ${conceptEnvelope.typeName} is ${currentVersion}, which is ` +
+                `lower than the received version ${conceptEnvelope.version}`);
+        }
+    }
+    needsMigration(conceptEnvelope) {
+        const currentVersion = this.config.currentVersionFor(conceptEnvelope.typeName);
+        return currentVersion > conceptEnvelope.version;
+    }
+    async applyAllMigrations(oldConceptEnvelope) {
+        const logger = (0, common_1.getLogger)(this.config, 'SchemaMigrator#applyAllMigrations');
+        const currentVersion = this.config.currentVersionFor(oldConceptEnvelope.typeName);
+        const oldVersion = oldConceptEnvelope.version;
+        logger.info(`Migrating schema ${oldConceptEnvelope.typeName} from version ${oldVersion} to version ${currentVersion}`);
+        logger.debug('Envelope before schema migration:\n', oldConceptEnvelope);
+        const migrations = this.config.schemaMigrations[oldConceptEnvelope.typeName];
+        let migratedConceptValue = oldConceptEnvelope.value;
+        for (let toVersion = oldVersion + 1; toVersion <= currentVersion; toVersion++) {
+            migratedConceptValue = await this.applyMigration(migratedConceptValue, migrations.get(toVersion));
+        }
+        const newConceptEnvelope = {
+            ...oldConceptEnvelope,
+            value: migratedConceptValue,
+            version: currentVersion,
+        };
+        logger.debug('Envelope after migration:\n', newConceptEnvelope);
+        return newConceptEnvelope;
+    }
+    async applyMigration(oldValue, migration) {
+        const logger = (0, common_1.getLogger)(this.config, 'SchemaMigrator#applyMigration');
+        if (!migration) {
+            throw new common_1.InvalidVersionError('Received an undefined schema migration value. Are there "gaps" between the versions of the schema migrations?');
+        }
+        const oldConcept = Object.assign(new migration.fromSchema(), oldValue);
+        const migrationMethod = new migration.migrationClass()[migration.methodName];
+        const newConcept = await migrationMethod(oldConcept);
+        logger.debug(`Partial migration finished. Migrated from oldValue=${oldConcept} to newValue=${newConcept}`);
+        return newConcept;
+    }
+}
+exports.SchemaMigrator = SchemaMigrator;
+tslib_1.__decorate([
+    (0, instrumentation_1.Trace)(common_1.TraceActionTypes.SCHEMA_MIGRATOR_MIGRATE),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [typeof (_a = typeof TMigrableEnvelope !== "undefined" && TMigrableEnvelope) === "function" ? _a : Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], SchemaMigrator.prototype, "migrate", null);

package/dist/sensor/health/health-indicators/database-events-health-indicator.d.ts

@@ -0,0 +1,5 @@
+import { MagekConfig, HealthIndicatorResult, HealthIndicatorMetadata } from '@magek/common';
+export declare class MagekDatabaseEventsHealthIndicator {
+    health(config: MagekConfig, healthIndicatorMetadata: HealthIndicatorMetadata): Promise<HealthIndicatorResult>;
+    private isUp;
+}

package/dist/sensor/health/health-indicators/database-events-health-indicator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekDatabaseEventsHealthIndicator = void 0;
+const common_1 = require("@magek/common");
+class MagekDatabaseEventsHealthIndicator {
+    async health(config, healthIndicatorMetadata) {
+        try {
+            const result = {
+                status: await this.isUp(config),
+            };
+            if (healthIndicatorMetadata.healthIndicatorConfiguration.details) {
+                const details = await config.provider.sensor.databaseEventsHealthDetails(config);
+                result.details = details;
+            }
+            return result;
+        }
+        catch (e) {
+            return { status: common_1.HealthStatus.DOWN, details: e };
+        }
+    }
+    async isUp(config) {
+        const databaseEvents = await config.provider.sensor.isDatabaseEventUp(config);
+        return databaseEvents ? common_1.HealthStatus.UP : common_1.HealthStatus.DOWN;
+    }
+}
+exports.MagekDatabaseEventsHealthIndicator = MagekDatabaseEventsHealthIndicator;

package/dist/sensor/health/health-indicators/database-health-indicator.d.ts

@@ -0,0 +1,5 @@
+import { MagekConfig, HealthIndicatorResult, HealthIndicatorMetadata } from '@magek/common';
+export declare class MagekDatabaseHealthIndicator {
+    health(config: MagekConfig, healthIndicatorMetadata: HealthIndicatorMetadata): Promise<HealthIndicatorResult>;
+    private isUp;
+}

package/dist/sensor/health/health-indicators/database-health-indicator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekDatabaseHealthIndicator = void 0;
+const common_1 = require("@magek/common");
+class MagekDatabaseHealthIndicator {
+    async health(config, healthIndicatorMetadata) {
+        try {
+            const result = {
+                status: await this.isUp(config),
+            };
+            if (healthIndicatorMetadata.healthIndicatorConfiguration.details) {
+                const details = {
+                    urls: await config.provider.sensor.databaseUrls(config),
+                };
+                result.details = details;
+            }
+            return result;
+        }
+        catch (e) {
+            return { status: common_1.HealthStatus.DOWN, details: e };
+        }
+    }
+    async isUp(config) {
+        const databaseEvents = await config.provider.sensor.isDatabaseEventUp(config);
+        const databaseReadModels = await config.provider.sensor.areDatabaseReadModelsUp(config);
+        return databaseEvents && databaseReadModels ? common_1.HealthStatus.UP : common_1.HealthStatus.DOWN;
+    }
+}
+exports.MagekDatabaseHealthIndicator = MagekDatabaseHealthIndicator;

package/dist/sensor/health/health-indicators/database-read-models-health-indicator.d.ts

@@ -0,0 +1,5 @@
+import { MagekConfig, HealthIndicatorResult, HealthIndicatorMetadata } from '@magek/common';
+export declare class MagekDatabaseReadModelsHealthIndicator {
+    health(config: MagekConfig, healthIndicatorMetadata: HealthIndicatorMetadata): Promise<HealthIndicatorResult>;
+    private isUp;
+}

package/dist/sensor/health/health-indicators/database-read-models-health-indicator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekDatabaseReadModelsHealthIndicator = void 0;
+const common_1 = require("@magek/common");
+class MagekDatabaseReadModelsHealthIndicator {
+    async health(config, healthIndicatorMetadata) {
+        try {
+            const result = {
+                status: await this.isUp(config),
+            };
+            if (healthIndicatorMetadata.healthIndicatorConfiguration.details) {
+                const details = await config.provider.sensor.databaseReadModelsHealthDetails(config);
+                result.details = details;
+            }
+            return result;
+        }
+        catch (e) {
+            return { status: common_1.HealthStatus.DOWN, details: e };
+        }
+    }
+    async isUp(config) {
+        const databaseReadModels = await config.provider.sensor.areDatabaseReadModelsUp(config);
+        return databaseReadModels ? common_1.HealthStatus.UP : common_1.HealthStatus.DOWN;
+    }
+}
+exports.MagekDatabaseReadModelsHealthIndicator = MagekDatabaseReadModelsHealthIndicator;

package/dist/sensor/health/health-indicators/default-health-indicators.d.ts

@@ -0,0 +1,5 @@
+import { MagekConfig, HealthIndicatorMetadata } from '@magek/common';
+/**
+ * Magek configured HealthIndicators
+ */
+export declare function defaultMagekHealthIndicators(config: MagekConfig): Record<string, HealthIndicatorMetadata>;

package/dist/sensor/health/health-indicators/default-health-indicators.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMagekHealthIndicators = defaultMagekHealthIndicators;
+const common_1 = require("@magek/common");
+const health_indicator_1 = require("./health-indicator");
+const database_health_indicator_1 = require("./database-health-indicator");
+const database_events_health_indicator_1 = require("./database-events-health-indicator");
+const function_health_indicator_1 = require("./function-health-indicator");
+const database_read_models_health_indicator_1 = require("./database-read-models-health-indicator");
+function buildMetadata(config, id, name, healthIndicator) {
+    const health = config.sensorConfiguration.health;
+    return {
+        class: healthIndicator,
+        healthIndicatorConfiguration: {
+            id: id,
+            name: name,
+            enabled: health.magek[id].enabled,
+            details: health.magek[id].details,
+            showChildren: health.magek[id].showChildren,
+        },
+    };
+}
+/**
+ * Magek configured HealthIndicators
+ */
+function defaultMagekHealthIndicators(config) {
+    const root = buildMetadata(config, common_1.HEALTH_INDICATORS_IDS.ROOT, 'Magek', health_indicator_1.MagekHealthIndicator);
+    const magekFunction = buildMetadata(config, common_1.HEALTH_INDICATORS_IDS.FUNCTION, 'Magek Function', function_health_indicator_1.MagekFunctionHealthIndicator);
+    const magekDatabase = buildMetadata(config, common_1.HEALTH_INDICATORS_IDS.DATABASE, 'Magek Database', database_health_indicator_1.MagekDatabaseHealthIndicator);
+    const databaseEvents = buildMetadata(config, common_1.HEALTH_INDICATORS_IDS.DATABASE_EVENTS, 'Magek Database Events', database_events_health_indicator_1.MagekDatabaseEventsHealthIndicator);
+    const databaseReadModels = buildMetadata(config, common_1.HEALTH_INDICATORS_IDS.DATABASE_READ_MODELS, 'Magek Database ReadModels', database_read_models_health_indicator_1.MagekDatabaseReadModelsHealthIndicator);
+    return {
+        [root.healthIndicatorConfiguration.id]: root,
+        [magekFunction.healthIndicatorConfiguration.id]: magekFunction,
+        [magekDatabase.healthIndicatorConfiguration.id]: magekDatabase,
+        [databaseEvents.healthIndicatorConfiguration.id]: databaseEvents,
+        [databaseReadModels.healthIndicatorConfiguration.id]: databaseReadModels,
+    };
+}

package/dist/sensor/health/health-indicators/function-health-indicator.d.ts

@@ -0,0 +1,5 @@
+import { MagekConfig, HealthIndicatorMetadata, HealthIndicatorResult } from '@magek/common';
+export declare class MagekFunctionHealthIndicator {
+    health(config: MagekConfig, healthIndicatorMetadata: HealthIndicatorMetadata): Promise<HealthIndicatorResult>;
+    private isUp;
+}

package/dist/sensor/health/health-indicators/function-health-indicator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekFunctionHealthIndicator = void 0;
+const common_1 = require("@magek/common");
+const os_info_1 = require("./os-info");
+class MagekFunctionHealthIndicator {
+    async health(config, healthIndicatorMetadata) {
+        try {
+            const result = {
+                status: await this.isUp(config),
+            };
+            if (healthIndicatorMetadata.healthIndicatorConfiguration.details) {
+                const graphQLUrl = await config.provider.sensor.graphQLFunctionUrl(config);
+                const osInfoResult = await (0, os_info_1.osInfo)();
+                result.details = {
+                    ...osInfoResult,
+                    graphQL_url: graphQLUrl,
+                };
+            }
+            return result;
+        }
+        catch (e) {
+            return { status: common_1.HealthStatus.DOWN, details: e };
+        }
+    }
+    async isUp(config) {
+        return (await config.provider.sensor.isGraphQLFunctionUp(config)) ? common_1.HealthStatus.UP : common_1.HealthStatus.DOWN;
+    }
+}
+exports.MagekFunctionHealthIndicator = MagekFunctionHealthIndicator;

package/dist/sensor/health/health-indicators/health-indicator.d.ts

@@ -0,0 +1,5 @@
+import { MagekConfig, HealthIndicatorResult, HealthIndicatorMetadata } from '@magek/common';
+export declare class MagekHealthIndicator {
+    health(config: MagekConfig, healthIndicatorMetadata: HealthIndicatorMetadata): Promise<HealthIndicatorResult>;
+    private isUp;
+}

package/dist/sensor/health/health-indicators/health-indicator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagekHealthIndicator = void 0;
+const common_1 = require("@magek/common");
+const version_1 = require("./version");
+class MagekHealthIndicator {
+    async health(config, healthIndicatorMetadata) {
+        try {
+            const result = {
+                status: await this.isUp(config),
+            };
+            if (healthIndicatorMetadata.healthIndicatorConfiguration.details) {
+                result.details = {
+                    magekVersion: (0, version_1.magekVersion)(config),
+                };
+            }
+            return result;
+        }
+        catch (e) {
+            return { status: common_1.HealthStatus.DOWN, details: e };
+        }
+    }
+    async isUp(config) {
+        const graphqlUp = await config.provider.sensor.isGraphQLFunctionUp(config);
+        const databaseEvents = await config.provider.sensor.isDatabaseEventUp(config);
+        const databaseReadModels = await config.provider.sensor.areDatabaseReadModelsUp(config);
+        return graphqlUp && databaseEvents && databaseReadModels ? common_1.HealthStatus.UP : common_1.HealthStatus.DOWN;
+    }
+}
+exports.MagekHealthIndicator = MagekHealthIndicator;

package/dist/sensor/health/health-indicators/index.d.ts

@@ -0,0 +1,3 @@
+export * from './health-indicator';
+export * from './default-health-indicators';
+export * from './function-health-indicator';

package/dist/sensor/health/health-indicators/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./health-indicator"), exports);
+tslib_1.__exportStar(require("./default-health-indicators"), exports);
+tslib_1.__exportStar(require("./function-health-indicator"), exports);

package/dist/sensor/health/health-indicators/os-info.d.ts

@@ -0,0 +1,14 @@
+import * as os from 'os';
+export interface OsInfoCpuResult {
+    cpu: os.CpuInfo;
+    timesPercentages: Array<number>;
+}
+export interface OsInfoMemoryResult {
+    totalBytes: number;
+    freeBytes: number;
+}
+export interface OsInfoResult {
+    cpus: Array<OsInfoCpuResult>;
+    memory: OsInfoMemoryResult;
+}
+export declare function osInfo(): Promise<OsInfoResult>;

package/dist/sensor/health/health-indicators/os-info.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.osInfo = osInfo;
+const os = require("os");
+async function osInfo() {
+    const rawCpus = os.cpus();
+    const cpus = rawCpus.length > 0 ? rawCpus : [fallbackCpuInfo()];
+    const cpuResult = cpus.map((cpu) => {
+        // times is an object containing the number of CPU ticks spent in: user, nice, sys, idle, and irq
+        const totalTimes = Object.values(cpu.times).reduce((accumulator, value) => accumulator + value, 0);
+        const safeTotalTimes = totalTimes === 0 ? 1 : totalTimes;
+        const timesPercentages = Object.values(cpu.times).map((time) => Math.round((100 * time) / safeTotalTimes));
+        return {
+            cpu,
+            timesPercentages,
+        };
+    });
+    return {
+        cpus: cpuResult,
+        memory: {
+            totalBytes: os.totalmem(),
+            freeBytes: os.freemem(),
+        },
+    };
+}
+function fallbackCpuInfo() {
+    return {
+        model: 'unknown',
+        speed: 0,
+        times: {
+            user: 0,
+            nice: 0,
+            sys: 0,
+            idle: 0,
+            irq: 0,
+        },
+    };
+}

package/dist/sensor/health/health-indicators/rockets-health-indicator.d.ts

@@ -0,0 +1,5 @@
+import { MagekConfig, HealthIndicatorMetadata, HealthIndicatorsResult } from '@magek/common';
+export declare class RocketsHealthIndicator {
+    health(config: MagekConfig, healthIndicatorMetadata: HealthIndicatorMetadata): Promise<HealthIndicatorsResult>;
+    private getOverAllHealthStatus;
+}

package/dist/sensor/health/health-indicators/rockets-health-indicator.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RocketsHealthIndicator = void 0;
+const common_1 = require("@magek/common");
+class RocketsHealthIndicator {
+    async health(config, healthIndicatorMetadata) {
+        const results = await config.provider.sensor.areRocketFunctionsUp(config);
+        if (Object.keys(results).length === 0) {
+            return {
+                name: 'Rockets',
+                id: common_1.HEALTH_INDICATORS_IDS.ROCKETS,
+                status: common_1.HealthStatus.UNKNOWN,
+                details: {
+                    reason: 'No Rockets found',
+                },
+            };
+        }
+        // Check if we're looking for a specific rocket
+        const componentPath = healthIndicatorMetadata.healthIndicatorConfiguration.id;
+        const rocketName = componentPath.split('/')[1]; // rockets/<rocket-name>
+        if (rocketName) {
+            const rocketStatus = results[rocketName];
+            if (rocketStatus === undefined) {
+                throw new Error(`Rocket "${rocketName}" not found`);
+            }
+            return {
+                name: rocketName,
+                id: `${common_1.HEALTH_INDICATORS_IDS.ROCKETS}/${rocketName}`,
+                status: rocketStatus ? common_1.HealthStatus.UP : common_1.HealthStatus.DOWN,
+            };
+        }
+        // return all rockets status
+        return {
+            name: 'Rockets',
+            id: common_1.HEALTH_INDICATORS_IDS.ROCKETS,
+            status: this.getOverAllHealthStatus(results),
+            components: Object.entries(results).map(([rocketName, status]) => {
+                return {
+                    name: rocketName,
+                    id: `${common_1.HEALTH_INDICATORS_IDS.ROCKETS}/${rocketName}`,
+                    status: status ? common_1.HealthStatus.UP : common_1.HealthStatus.DOWN,
+                };
+            }),
+        };
+    }
+    getOverAllHealthStatus(results) {
+        const statusValues = Object.values(results);
+        if (statusValues.every((status) => status)) {
+            return common_1.HealthStatus.UP;
+        }
+        if (statusValues.every((status) => !status)) {
+            return common_1.HealthStatus.DOWN;
+        }
+        return common_1.HealthStatus.PARTIALLY_UP;
+    }
+}
+exports.RocketsHealthIndicator = RocketsHealthIndicator;

package/dist/sensor/health/health-indicators/version.d.ts

@@ -0,0 +1,2 @@
+import { MagekConfig } from '@magek/common';
+export declare function magekVersion(config: MagekConfig): any;

package/dist/sensor/health/health-indicators/version.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.magekVersion = magekVersion;
+const path = require("path");
+const process = require("process");
+const common_1 = require("@magek/common");
+function magekVersion(config) {
+    const projectAbsolutePath = path.resolve(process.cwd());
+    const logger = (0, common_1.getLogger)(config, 'magekVersion');
+    try {
+        const packageJsonContents = require(path.join(projectAbsolutePath, 'package.json'));
+        const version = packageJsonContents.dependencies['@magek/core'];
+        if (!version) {
+            logger.warn('Could not get Magek Version');
+            return '';
+        }
+        const versionParts = version.replace('workspace:', '').replace('^', '').replace('.tgz', '').split('-');
+        return versionParts[versionParts.length - 1];
+    }
+    catch (e) {
+        logger.warn('There was an error when calculating the magek version the application', e);
+        return '';
+    }
+}

package/dist/sensor/health/health-service.d.ts

@@ -0,0 +1,22 @@
+import { MagekConfig } from '@magek/common';
+/**
+ * This class is in charge of handling the health check requests
+ * and dispatching the health checks to the corresponding health indicators
+ */
+export declare class MagekHealthService {
+    readonly config: MagekConfig;
+    constructor(config: MagekConfig);
+    health(request: unknown): Promise<unknown>;
+    private validate;
+    private healthProviderResolver;
+    private enabledIndicatorHealth;
+    private indicatorHealth;
+    /**
+     * If there is not any indicator configured, then we will use only the Magek indicators.
+     * @private
+     */
+    private getHealthProviders;
+    private parentsHealthProviders;
+    private verify;
+    private isOverallHealthy;
+}