@magek/common 0.0.1

package/dist/provider/azure-configuration.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CHUNK_SIZE = void 0;
+exports.DEFAULT_CHUNK_SIZE = 100;

package/dist/provider.d.ts

@@ -0,0 +1,83 @@
+import { MagekConfig } from './config';
+import { GraphQLRequestEnvelope, GraphQLRequestEnvelopeError, HealthEnvelope, ScheduledCommandEnvelope } from './envelope';
+export interface ProviderLibrary {
+    graphQL: ProviderGraphQLLibrary;
+    api: ProviderAPIHandling;
+    messaging: ProviderMessagingLibrary;
+    scheduled: ScheduledCommandsLibrary;
+    sensor: ProviderSensorLibrary;
+}
+export interface ProviderMessagingLibrary {
+    /**
+     * Sends a message to a specific connection.
+     *
+     * @param config - The Magek configuration object.
+     * @param connectionID - The ID of the connection.
+     * @param data - The data to be sent to the connection.
+     * @returns A promise that resolves when the message has been sent successfully.
+     */
+    sendMessage(config: MagekConfig, connectionID: string, data: unknown): Promise<void>;
+}
+export interface ProviderSensorLibrary {
+    databaseEventsHealthDetails(config: MagekConfig): Promise<unknown>;
+    databaseReadModelsHealthDetails(config: MagekConfig): Promise<unknown>;
+    isDatabaseEventUp(config: MagekConfig): Promise<boolean>;
+    areDatabaseReadModelsUp(config: MagekConfig): Promise<boolean>;
+    databaseUrls(config: MagekConfig): Promise<Array<string>>;
+    isGraphQLFunctionUp(config: MagekConfig): Promise<boolean>;
+    graphQLFunctionUrl(config: MagekConfig): Promise<string>;
+    rawRequestToHealthEnvelope(rawRequest: unknown): HealthEnvelope;
+}
+export interface ProviderGraphQLLibrary {
+    /**
+     * Converts a raw GraphQL request to a `GraphQLRequestEnvelope` or a `GraphQLRequestEnvelopeError`.
+     *
+     * @param config - The Magek configuration object.
+     * @param rawGraphQLRequest - The raw GraphQL request to be converted.
+     * @returns A promise that resolves to either a `GraphQLRequestEnvelope` or a `GraphQLRequestEnvelopeError` object.
+     */
+    rawToEnvelope(config: MagekConfig, rawGraphQLRequest: unknown): Promise<GraphQLRequestEnvelope | GraphQLRequestEnvelopeError>;
+    /**
+     * Handles the result of a GraphQL request.
+     *
+     * @param result - The result of the GraphQL request (optional).
+     * @param headers - The headers associated with the GraphQL request result (optional).
+     * @returns A promise that resolves to any value.
+     */
+    handleResult(result?: unknown, headers?: Record<string, string>): Promise<unknown>;
+}
+export interface ProviderAPIHandling {
+    /**
+     * Handles a successful API request by returning the response body.
+     *
+     * @param body - The response body of the API request.
+     * @param headers - The headers of the API request.
+     * @returns A promise that resolves with the response body.
+     */
+    requestSucceeded(body?: unknown, headers?: Record<string, number | string | ReadonlyArray<string>>): Promise<unknown>;
+    /**
+     * Handles a failed API request by returning an error.
+     *
+     * @param error - The error that occurred during the API request.
+     * @returns A promise that resolves with the error.
+     */
+    requestFailed(error: Error): Promise<unknown>;
+    /**
+     * Handles a health check response with appropriate status code.
+     *
+     * @param body - The health check results
+     * @param isHealthy - Whether all the components are UP
+     * @returns A promise that resolves with the response
+     */
+    healthRequestResult(body: unknown, isHealthy: boolean): Promise<unknown>;
+}
+export interface ScheduledCommandsLibrary {
+    /**
+     * Converts a raw message into a `ScheduledCommandEnvelope`.
+     *
+     * @param config - The configuration for the application.
+     * @param rawMessage - The raw message to convert.
+     * @returns A promise that resolves with the `ScheduledCommandEnvelope` representation of the raw message.
+     */
+    rawToEnvelope(config: MagekConfig, rawMessage: unknown): Promise<ScheduledCommandEnvelope>;
+}

package/dist/provider.js

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

package/dist/read-model-store-adapter.d.ts

@@ -0,0 +1,84 @@
+import { SequenceKey, UUID } from './concepts';
+import { MagekConfig } from './config';
+import { ReadModelInterface } from './concepts';
+import { FilterFor, ProjectionFor, SortFor } from './searcher';
+import { ReadModelListResult } from './envelope';
+import { ReadOnlyNonEmptyArray } from './typelevel';
+export interface ReadModelStoreEnvelope<T = ReadModelInterface> {
+    typeName: string;
+    value: T;
+    id: UUID;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ReadModelStoreAdapter {
+    /**
+     * Fetches a read model by its ID
+     *
+     * @param config - The Magek configuration object
+     * @param readModelName - The name of the read model type
+     * @param readModelID - The ID of the read model to fetch
+     * @param sequenceKey - The sequence key for sequenced read models (optional)
+     * @returns A promise that resolves to an array of read models, or undefined if not found
+     */
+    fetch<TReadModel extends ReadModelInterface>(config: MagekConfig, readModelName: string, readModelID: UUID, sequenceKey?: SequenceKey): Promise<ReadOnlyNonEmptyArray<TReadModel> | undefined>;
+    /**
+     * Searches for read models based on specific parameters
+     * This method signature matches the original provider library interface
+     *
+     * @param config - The Magek configuration object
+     * @param readModelName - The name of the read model type
+     * @param filters - The filters to be applied during the search
+     * @param sortBy - An object that specifies how the results should be sorted (optional)
+     * @param limit - The maximum number of results to return (optional)
+     * @param afterCursor - A cursor that specifies the position after which results should be returned (optional)
+     * @param paginatedVersion - A boolean value that indicates whether the results should be paginated (optional)
+     * @param select - An object that specifies fields to be returned, including calculated field dependencies (optional)
+     * @returns A promise that resolves to an array of read models or a ReadModelListResult
+     */
+    search<TReadModel extends ReadModelInterface>(config: MagekConfig, readModelName: string, filters: FilterFor<unknown>, sortBy?: SortFor<unknown>, limit?: number, afterCursor?: unknown, paginatedVersion?: boolean, select?: ProjectionFor<TReadModel>): Promise<Array<TReadModel> | ReadModelListResult<TReadModel>>;
+    /**
+     * Stores or updates a read model
+     *
+     * @param config - The Magek configuration object
+     * @param readModelName - The name of the read model type
+     * @param readModel - The read model envelope to store
+     * @returns A promise that resolves to the stored read model envelope
+     */
+    store<TReadModel extends ReadModelInterface>(config: MagekConfig, readModelName: string, readModel: ReadModelStoreEnvelope<TReadModel>): Promise<ReadModelStoreEnvelope<TReadModel>>;
+    /**
+     * Deletes a read model by its ID
+     *
+     * @param config - The Magek configuration object
+     * @param readModelName - The name of the read model type
+     * @param readModelID - The ID of the read model to delete
+     * @returns A promise that resolves when the read model has been deleted
+     */
+    delete(config: MagekConfig, readModelName: string, readModelID: UUID): Promise<void>;
+    /**
+     * Converts raw read model data into ReadModelStoreEnvelope objects
+     *
+     * @param config - The Magek configuration object
+     * @param rawReadModels - The raw read model data to be converted
+     * @returns A promise that resolves to an array of ReadModelStoreEnvelope objects
+     */
+    rawToEnvelopes<TReadModel extends ReadModelInterface>(config: MagekConfig, rawReadModels: unknown): Promise<Array<ReadModelStoreEnvelope<TReadModel>>>;
+    /**
+     * Health check methods for the read model store
+     */
+    healthCheck?: {
+        /**
+         * Check if the read model store is up and running
+         */
+        isUp(config: MagekConfig): Promise<boolean>;
+        /**
+         * Get detailed health information about the read model store
+         */
+        details(config: MagekConfig): Promise<unknown>;
+        /**
+         * Get the URLs/endpoints of the read model store
+         */
+        urls(config: MagekConfig): Promise<Array<string>>;
+    };
+}

package/dist/read-model-store-adapter.js

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

package/dist/retrier.d.ts

@@ -0,0 +1,12 @@
+import { Class } from './typelevel';
+import { Logger } from './logger';
+/**
+ * Retries an async function if it fails with an error that matches the given class.
+ *
+ * @param logicToRetry Async function to retry
+ * @param errorClassThatRetries Error class. If the async function fails with an error that matches this class, it will be retried.
+ * @param logger Logger to use for logging. If not provided, no logging will be performed.
+ * @param maxRetries Maximum number of retries. If not provided, the default is 1000.
+ * @returns The result of the first successful retry.
+ */
+export declare function retryIfError<TReturn>(logicToRetry: (tryNumber?: number) => Promise<TReturn>, errorClassThatRetries: Class<Error>, logger?: Logger, maxRetries?: number): Promise<TReturn>;

package/dist/retrier.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryIfError = retryIfError;
+/**
+ * Retries an async function if it fails with an error that matches the given class.
+ *
+ * @param logicToRetry Async function to retry
+ * @param errorClassThatRetries Error class. If the async function fails with an error that matches this class, it will be retried.
+ * @param logger Logger to use for logging. If not provided, no logging will be performed.
+ * @param maxRetries Maximum number of retries. If not provided, the default is 1000.
+ * @returns The result of the first successful retry.
+ */
+async function retryIfError(logicToRetry, errorClassThatRetries, logger, maxRetries = 1000) {
+    let tryNumber;
+    let errorAfterMaxTries;
+    for (tryNumber = 1; tryNumber <= maxRetries; tryNumber++) {
+        try {
+            logger === null || logger === void 0 ? void 0 : logger.debug(`[retryIfError] Try number ${tryNumber}`);
+            const result = await logicToRetry(tryNumber);
+            logger === null || logger === void 0 ? void 0 : logger.debug(`[retryIfError] Succeeded after ${tryNumber} retries`);
+            return result;
+        }
+        catch (e) {
+            const error = e;
+            checkRetryError(error, errorClassThatRetries, logger);
+            errorAfterMaxTries = error;
+        }
+    }
+    throw new Error(`[retryIfError] Reached the maximum number of retries (${maxRetries}), but still getting the following error: ${errorAfterMaxTries}`);
+}
+function checkRetryError(e, errorClassThatRetries, logger) {
+    if (!(e instanceof errorClassThatRetries)) {
+        logger === null || logger === void 0 ? void 0 : logger.debug('[checkRetryError] Logic failed with an error that must not be retried. Rethrowing');
+        throw e;
+    }
+}

package/dist/rocket-loader.d.ts

@@ -0,0 +1,7 @@
+import { RocketDescriptor } from './rockets';
+export declare class RocketLoader {
+    private static requireRocket;
+    static loadRocket(rocketDescriptor: RocketDescriptor): {
+        mountStack: Function;
+    };
+}

package/dist/rocket-loader.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RocketLoader = void 0;
+class RocketLoader {
+    // Separate function to make it easier to mock in tests
+    static requireRocket(rocketPackageName) {
+        return require(rocketPackageName).default;
+    }
+    static loadRocket(rocketDescriptor) {
+        const rocketBuilder = RocketLoader.requireRocket(rocketDescriptor.packageName);
+        if (!rocketBuilder)
+            throw new Error(`Could not load the rocket infrastructure package ${rocketDescriptor.packageName}. Make sure you installed it in your project devDependencies.`);
+        if (typeof rocketBuilder !== 'function')
+            throw new Error(`Could not initialize rocket infrastructure package ${rocketDescriptor.packageName}. It doesn't seem to implement a rocket builder method as default export.`);
+        const rocket = rocketBuilder(rocketDescriptor.parameters);
+        if (!(rocket === null || rocket === void 0 ? void 0 : rocket.mountStack))
+            throw new Error(`The package ${rocketDescriptor.packageName} doesn't seem to be a rocket.`);
+        return rocket;
+    }
+}
+exports.RocketLoader = RocketLoader;

package/dist/rockets.d.ts

@@ -0,0 +1,10 @@
+import { MagekConfig } from './config';
+export declare const rocketFunctionIDEnvVar = "ROCKET_FUNCTION_ID";
+export type RocketFunction = (config: MagekConfig, request: unknown) => Promise<unknown>;
+export interface RocketDescriptor {
+    packageName: string;
+    parameters: unknown;
+}
+export interface RocketEnvelope {
+    rocketId: string | undefined;
+}

package/dist/rockets.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rocketFunctionIDEnvVar = void 0;
+exports.rocketFunctionIDEnvVar = 'ROCKET_FUNCTION_ID';

package/dist/run-command.d.ts

@@ -0,0 +1,5 @@
+import { ChildProcessWithoutNullStreams } from 'child_process';
+/** Spawn a CLI command and optionally printing the logs and error messages */
+export declare function runCommandAsync(path: string, command: string, ignoreLogs?: boolean): ChildProcessWithoutNullStreams;
+/** Synchronously run a CLI command and return the stdout, optionally printing the logs and error messages */
+export declare function runCommand(path: string, command: string, ignoreLogs?: boolean): Promise<string>;

package/dist/run-command.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommandAsync = runCommandAsync;
+exports.runCommand = runCommand;
+const child_process_1 = require("child_process");
+/** Spawn a CLI command and optionally printing the logs and error messages */
+function runCommandAsync(path, command, ignoreLogs = false) {
+    // Split the command into an array of arguments
+    const args = command.split(' ');
+    // Use the first argument as the command name
+    const subprocess = (0, child_process_1.spawn)(args[0], args.slice(1), {
+        cwd: path,
+        stdio: 'pipe',
+    });
+    if (!ignoreLogs) {
+        subprocess.stdout.on('data', (data) => {
+            console.log(data.toString());
+        });
+        subprocess.stderr.on('data', (data) => {
+            console.error(data.toString());
+        });
+    }
+    return subprocess;
+}
+/** Synchronously run a CLI command and return the stdout, optionally printing the logs and error messages */
+function runCommand(path, command, ignoreLogs = false) {
+    return new Promise((resolve, reject) => {
+        const subprocess = runCommandAsync(path, command, ignoreLogs);
+        let stdout = '';
+        let stderr = '';
+        if (subprocess) {
+            subprocess.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            subprocess.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            subprocess.on('close', (code) => {
+                if (code === 0) {
+                    resolve(stdout);
+                }
+                else {
+                    reject(stderr);
+                }
+            });
+        }
+    });
+}

package/dist/schedule.d.ts

@@ -0,0 +1,8 @@
+export interface ScheduleInterface {
+    readonly minute?: string;
+    readonly hour?: string;
+    readonly day?: string;
+    readonly month?: string;
+    readonly weekDay?: string;
+    readonly year?: string;
+}

package/dist/schedule.js

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

package/dist/searcher.d.ts

@@ -0,0 +1,98 @@
+import { SequenceKey, UUID } from './concepts';
+import { ReadModelListResult } from './envelope';
+import { AnyClass, Class, ReadOnlyNonEmptyArray } from './typelevel';
+export type SearcherFunction<TObject, TResult> = (objectClass: AnyClass, filters: FilterFor<TObject>, sortBy: SortFor<TObject>, limit?: number, afterCursor?: any, paginatedVersion?: boolean, select?: ProjectionFor<TObject>) => Promise<TResult>;
+export type FinderByKeyFunction<TObject> = (objectClass: AnyClass, id: UUID, sequenceKey?: SequenceKey) => Promise<TObject | ReadOnlyNonEmptyArray<TObject>>;
+export type SequenceFinderByKeyFunction<TObject> = (className: string, id: UUID, sequenceKey?: SequenceKey) => Promise<TObject>;
+/**
+ * This class represents a search intended to be run by any search provider. They way you use it
+ * is by setting filters on the properties of the object you want to search and then run it.
+ * Check the documentation on the individual methods to know more about how to do so.
+ */
+export declare class Searcher<TObject, TSingleResult extends SingleResultType<TObject> = TObject, TContainer extends ContainerType = Array<any>> {
+    private readonly objectClass;
+    private readonly searcherFunction;
+    private readonly finderByKeyFunction;
+    private _limit?;
+    private _afterCursor?;
+    private filters;
+    private _sortByList;
+    private _paginatedVersion;
+    private _selectFor?;
+    /**
+     * @param objectClass The class of the object you want to run the search for.
+     * @param searcherFunction The function that will receive all the filters and run the actual search
+     * @param finderByKeyFunction Function that performs a find by Key operation (Either simple or compound keys)
+     */
+    constructor(objectClass: Class<TObject>, searcherFunction: SearcherFunction<TObject, ApplyContainerToType<TContainer, TSingleResult>>, finderByKeyFunction: FinderByKeyFunction<TObject>);
+    /**
+     * Adds a filter for the search. For example: If you want to search for people whose age is greater than 30
+     * and their height is between 1.80m and 2.00m, you would do:
+     * ```
+     * searcher.filter({
+     *  age: { gt: 30 },
+     *  height: { gte: 1.8, lte: 2 }
+     * }).search()
+     * ```
+     * @param filters An object with the property filters
+     */
+    filter(filters: FilterFor<TObject>): this;
+    sortBy(sortBy?: SortFor<TObject>): this;
+    select(select?: ProjectionFor<TObject>): SearchAfterSelect<TObject, TContainer>;
+    limit(limit?: number): this;
+    afterCursor(afterCursor?: unknown): this;
+    paginatedVersion<TPaginated extends boolean>(paginatedVersion?: TPaginated): SearcherAfterPaginatedVersion<TObject, TSingleResult, TPaginated>;
+    findById(id: UUID, sequenceKey?: SequenceKey): Promise<TObject | ReadOnlyNonEmptyArray<TObject>>;
+    searchOne(): Promise<TSingleResult | undefined>;
+    /**
+     * Do the actual search by sending all the configured filters to the provided search function
+     */
+    search(): Promise<ApplyContainerToType<TContainer, TSingleResult>>;
+}
+type SingleResultType<TObject> = TObject | Partial<TObject>;
+type ContainerType = Array<any> | ReadModelListResult<any>;
+type ApplyContainerToType<Container extends ContainerType, Type> = Container extends Array<any> ? Array<Type> : ReadModelListResult<Type>;
+type SearchAfterSelect<TObject, TContainer extends ContainerType> = Searcher<TObject, Partial<TObject>, TContainer>;
+type SearcherAfterPaginatedVersion<TObject, TSingleResult extends SingleResultType<TObject>, Paginated extends boolean> = Searcher<TObject, TSingleResult, Paginated extends true ? ReadModelListResult<any> : Array<any>>;
+type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : never;
+type Paths<T, TLevels extends any[] = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]> = TLevels extends [] ? '' : T extends object ? {
+    [K in keyof T]: `${Exclude<K, symbol>}${'' | `.${Paths<T[K], Tail<TLevels>>}`}`;
+}[keyof T] : never;
+export type ProjectionFor<TType> = Array<Paths<TType>>;
+export type SortFor<TType> = {
+    [TProp in keyof TType]?: SortFor<TType[TProp]> | 'ASC' | 'DESC';
+};
+export type FilterFor<TType> = {
+    [TProp in keyof TType]?: Operation<TType[TProp]>;
+} & FilterCombinators<TType> & IsDefinedOperator;
+interface FilterCombinators<TType> {
+    and?: Array<FilterFor<TType>>;
+    or?: Array<FilterFor<TType>>;
+    not?: FilterFor<TType>;
+}
+export type Operation<TType> = TType extends Array<infer TElementType> ? ArrayOperators<TElementType> : TType extends string | UUID ? StringOperators<TType> : TType extends number ? ScalarOperators<TType> : TType extends boolean ? BooleanOperators<TType> : TType extends Record<string, any> ? FilterFor<TType> : never;
+interface IsDefinedOperator {
+    isDefined?: boolean;
+}
+interface BooleanOperators<TType> extends IsDefinedOperator {
+    eq?: TType | null;
+    ne?: TType | null;
+}
+interface ScalarOperators<TType> extends BooleanOperators<TType> {
+    gt?: TType;
+    gte?: TType;
+    lt?: TType;
+    lte?: TType;
+    in?: Array<TType>;
+}
+interface StringOperators<TType> extends ScalarOperators<TType> {
+    beginsWith?: TType;
+    contains?: TType;
+    regex?: TType;
+    iRegex?: TType;
+}
+interface ArrayOperators<TElementType> {
+    includes?: TElementType;
+    isDefined?: boolean;
+}
+export {};

package/dist/searcher.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Searcher = void 0;
+/**
+ * This class represents a search intended to be run by any search provider. They way you use it
+ * is by setting filters on the properties of the object you want to search and then run it.
+ * Check the documentation on the individual methods to know more about how to do so.
+ */
+class Searcher {
+    /**
+     * @param objectClass The class of the object you want to run the search for.
+     * @param searcherFunction The function that will receive all the filters and run the actual search
+     * @param finderByKeyFunction Function that performs a find by Key operation (Either simple or compound keys)
+     */
+    constructor(objectClass, searcherFunction, finderByKeyFunction) {
+        this.objectClass = objectClass;
+        this.searcherFunction = searcherFunction;
+        this.finderByKeyFunction = finderByKeyFunction;
+        this.filters = {};
+        this._sortByList = {};
+        this._paginatedVersion = false;
+    }
+    /**
+     * Adds a filter for the search. For example: If you want to search for people whose age is greater than 30
+     * and their height is between 1.80m and 2.00m, you would do:
+     * ```
+     * searcher.filter({
+     *  age: { gt: 30 },
+     *  height: { gte: 1.8, lte: 2 }
+     * }).search()
+     * ```
+     * @param filters An object with the property filters
+     */
+    filter(filters) {
+        this.filters = filters;
+        return this;
+    }
+    sortBy(sortBy) {
+        if (sortBy)
+            this._sortByList = sortBy;
+        return this;
+    }
+    select(select) {
+        if (select)
+            this._selectFor = select;
+        return this;
+    }
+    limit(limit) {
+        if (limit)
+            this._limit = limit;
+        return this;
+    }
+    afterCursor(afterCursor) {
+        if (afterCursor)
+            this._afterCursor = afterCursor;
+        return this;
+    }
+    paginatedVersion(paginatedVersion) {
+        if (paginatedVersion)
+            this._paginatedVersion = paginatedVersion;
+        return this;
+    }
+    async findById(id, sequenceKey) {
+        return this.finderByKeyFunction(this.objectClass, id, sequenceKey);
+    }
+    async searchOne() {
+        const searchResult = await this.searcherFunction(this.objectClass, this.filters, this._sortByList, 1, // Forces limit 1
+        this._afterCursor, false, // It doesn't make sense to paginate a single result, as pagination metadata would be discarded
+        this._selectFor);
+        return searchResult[0];
+    }
+    /**
+     * Do the actual search by sending all the configured filters to the provided search function
+     */
+    async search() {
+        return this.searcherFunction(this.objectClass, this.filters, this._sortByList, this._limit, this._afterCursor, this._paginatedVersion, this._selectFor);
+    }
+}
+exports.Searcher = Searcher;

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

@@ -0,0 +1,60 @@
+import { HealthRoleAccess } from '../concepts';
+import { MagekConfig } from '../config';
+import { Class } from '../typelevel';
+export declare enum HealthStatus {
+    UP = "UP",// The component or subsystem is working as expected
+    PARTIALLY_UP = "PARTIALLY_UP",// The component is partially working or has reduced functionality
+    DOWN = "DOWN",// The component is not working
+    OUT_OF_SERVICE = "OUT_OF_SERVICE",// The component is out of service temporarily
+    UNKNOWN = "UNKNOWN"
+}
+export interface HealthIndicatorResult {
+    status: HealthStatus;
+    details?: {
+        [key: string]: unknown;
+    };
+}
+export interface HealthIndicatorsResult extends HealthIndicatorResult {
+    name: string;
+    id: string;
+    components?: Array<HealthIndicatorsResult>;
+}
+export declare enum HEALTH_INDICATORS_IDS {
+    ROOT = "magek",
+    FUNCTION = "magek/function",
+    DATABASE = "magek/database",
+    DATABASE_EVENTS = "magek/database/events",
+    DATABASE_READ_MODELS = "magek/database/readmodels"
+}
+export declare const DEFAULT_HEALTH_CONFIGURATION: SensorMagekHealthConfigurationDetails;
+export declare const DEFAULT_SENSOR_HEALTH_CONFIGURATIONS: Record<HEALTH_INDICATORS_IDS, SensorMagekHealthConfigurationDetails>;
+export type SensorMagekHealthConfigurationDetails = HealthIndicatorConfigurationBase;
+export interface SensorMagekHealthConfiguration {
+    globalAuthorizer: HealthRoleAccess;
+    magek: {
+        [HEALTH_INDICATORS_IDS.ROOT]: SensorMagekHealthConfigurationDetails;
+        [HEALTH_INDICATORS_IDS.FUNCTION]: SensorMagekHealthConfigurationDetails;
+        [HEALTH_INDICATORS_IDS.DATABASE]: SensorMagekHealthConfigurationDetails;
+        [HEALTH_INDICATORS_IDS.DATABASE_EVENTS]: SensorMagekHealthConfigurationDetails;
+        [HEALTH_INDICATORS_IDS.DATABASE_READ_MODELS]: SensorMagekHealthConfigurationDetails;
+    };
+}
+export interface SensorConfiguration {
+    health: SensorMagekHealthConfiguration;
+}
+export interface HealthIndicatorInterface {
+    health: (config: MagekConfig, healthIndicatorMetadata: HealthIndicatorMetadata) => Promise<HealthIndicatorResult>;
+}
+export interface HealthIndicatorConfigurationBase {
+    enabled: boolean;
+    details: boolean;
+    showChildren?: boolean;
+}
+export interface HealthIndicatorConfiguration extends HealthIndicatorConfigurationBase {
+    id: string;
+    name: string;
+}
+export interface HealthIndicatorMetadata {
+    readonly class: Class<HealthIndicatorInterface>;
+    readonly healthIndicatorConfiguration: HealthIndicatorConfiguration;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SENSOR_HEALTH_CONFIGURATIONS = exports.DEFAULT_HEALTH_CONFIGURATION = exports.HEALTH_INDICATORS_IDS = exports.HealthStatus = void 0;
+var HealthStatus;
+(function (HealthStatus) {
+    HealthStatus["UP"] = "UP";
+    HealthStatus["PARTIALLY_UP"] = "PARTIALLY_UP";
+    HealthStatus["DOWN"] = "DOWN";
+    HealthStatus["OUT_OF_SERVICE"] = "OUT_OF_SERVICE";
+    HealthStatus["UNKNOWN"] = "UNKNOWN";
+})(HealthStatus || (exports.HealthStatus = HealthStatus = {}));
+var HEALTH_INDICATORS_IDS;
+(function (HEALTH_INDICATORS_IDS) {
+    HEALTH_INDICATORS_IDS["ROOT"] = "magek";
+    HEALTH_INDICATORS_IDS["FUNCTION"] = "magek/function";
+    HEALTH_INDICATORS_IDS["DATABASE"] = "magek/database";
+    HEALTH_INDICATORS_IDS["DATABASE_EVENTS"] = "magek/database/events";
+    HEALTH_INDICATORS_IDS["DATABASE_READ_MODELS"] = "magek/database/readmodels";
+})(HEALTH_INDICATORS_IDS || (exports.HEALTH_INDICATORS_IDS = HEALTH_INDICATORS_IDS = {}));
+exports.DEFAULT_HEALTH_CONFIGURATION = {
+    enabled: false,
+    details: true,
+    showChildren: true,
+};
+exports.DEFAULT_SENSOR_HEALTH_CONFIGURATIONS = {
+    [HEALTH_INDICATORS_IDS.ROOT]: { ...exports.DEFAULT_HEALTH_CONFIGURATION },
+    [HEALTH_INDICATORS_IDS.FUNCTION]: { ...exports.DEFAULT_HEALTH_CONFIGURATION },
+    [HEALTH_INDICATORS_IDS.DATABASE]: { ...exports.DEFAULT_HEALTH_CONFIGURATION },
+    [HEALTH_INDICATORS_IDS.DATABASE_EVENTS]: { ...exports.DEFAULT_HEALTH_CONFIGURATION },
+    [HEALTH_INDICATORS_IDS.DATABASE_READ_MODELS]: { ...exports.DEFAULT_HEALTH_CONFIGURATION },
+};