@magek/common 0.0.1

package/dist/graphql-websocket-messages.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphQLWebsocketSubprotocolHeaders = exports.GraphQLComplete = exports.GraphQLError = exports.GraphQLData = exports.GraphQLInitAck = exports.GraphQLInitError = exports.MessageTypes = void 0;
+var MessageTypes;
+(function (MessageTypes) {
+    MessageTypes["GQL_CONNECTION_INIT"] = "connection_init";
+    MessageTypes["GQL_CONNECTION_ACK"] = "connection_ack";
+    MessageTypes["GQL_CONNECTION_ERROR"] = "connection_error";
+    // GQL_CONNECTION_KEEP_ALIVE = 'ka', // Not used on server side. Socket remains open until client decides to close it
+    MessageTypes["GQL_CONNECTION_TERMINATE"] = "connection_terminate";
+    MessageTypes["GQL_START"] = "start";
+    MessageTypes["GQL_DATA"] = "data";
+    MessageTypes["GQL_ERROR"] = "error";
+    MessageTypes["GQL_COMPLETE"] = "complete";
+    MessageTypes["GQL_STOP"] = "stop";
+})(MessageTypes || (exports.MessageTypes = MessageTypes = {}));
+class GraphQLInitError {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = MessageTypes.GQL_CONNECTION_ERROR;
+    }
+}
+exports.GraphQLInitError = GraphQLInitError;
+class GraphQLInitAck {
+    constructor() {
+        this.type = MessageTypes.GQL_CONNECTION_ACK;
+    }
+}
+exports.GraphQLInitAck = GraphQLInitAck;
+class GraphQLData {
+    constructor(id, payload) {
+        this.id = id;
+        this.payload = payload;
+        this.type = MessageTypes.GQL_DATA;
+    }
+}
+exports.GraphQLData = GraphQLData;
+class GraphQLError {
+    constructor(id, payload) {
+        this.id = id;
+        this.payload = payload;
+        this.type = MessageTypes.GQL_ERROR;
+    }
+}
+exports.GraphQLError = GraphQLError;
+class GraphQLComplete {
+    constructor(id) {
+        this.id = id;
+        this.type = MessageTypes.GQL_COMPLETE;
+    }
+}
+exports.GraphQLComplete = GraphQLComplete;
+exports.graphQLWebsocketSubprotocolHeaders = {
+    'Sec-WebSocket-Protocol': 'graphql-ws',
+};

package/dist/groups.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Removes duplicates from an array.
+ */
+export declare function unique<T>(items: Array<T>): Array<T>;

package/dist/groups.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = unique;
+/**
+ * Removes duplicates from an array.
+ */
+function unique(items) {
+    return Array.from(new Set(items));
+}

package/dist/http-service.d.ts

@@ -0,0 +1,10 @@
+export interface PostConfiguration {
+    contentType?: string;
+    timeout?: number;
+    acceptedStatusCodes?: number[];
+}
+export interface PostResult {
+    status: number;
+    body: unknown;
+}
+export declare function request(url: string, method?: 'GET' | 'POST', data?: string, config?: PostConfiguration): Promise<PostResult>;

package/dist/http-service.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = request;
+const https = require("https");
+const http = require("http");
+async function request(url, method = 'GET', data = '', config = {}) {
+    const { contentType = 'application/json', timeout = 10000, acceptedStatusCodes = [] } = config;
+    const options = {
+        method: method,
+        headers: {
+            'Content-Type': contentType,
+            // Content-Length will be added below if needed
+        },
+        timeout: timeout,
+    };
+    if (data) {
+        ;
+        options.headers['Content-Length'] = data.length;
+    }
+    return new Promise((resolve, reject) => {
+        const method = url.startsWith('https') ? https.request : http.request;
+        const request = method(url, options, (res) => {
+            const body = [];
+            res.on('data', (chunk) => body.push(chunk));
+            res.on('end', () => {
+                if (!(res === null || res === void 0 ? void 0 : res.statusCode)) {
+                    return reject(new Error('Unknown HTTP status code'));
+                }
+                // Accept 2xx codes or any explicitly accepted status codes
+                if ((res.statusCode < 200 || res.statusCode > 299) && !acceptedStatusCodes.includes(res.statusCode)) {
+                    return reject(new Error(`HTTP status code ${res.statusCode}`));
+                }
+                const buffer = Buffer.concat(body).toString();
+                resolve({
+                    status: res === null || res === void 0 ? void 0 : res.statusCode,
+                    body: buffer,
+                });
+            });
+        });
+        request.on('error', (err) => {
+            reject(err);
+        });
+        request.on('timeout', () => {
+            request.destroy();
+            reject(new Error('Request time out'));
+        });
+        request.write(data);
+        request.end();
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+export * from './groups';
+export * from './promises';
+export * from './retrier';
+export * from './instances';
+export * from './run-command';
+export * from './logger';
+export * from './http-service';
+export * from './app';
+export * from './envelope';
+export * from './config';
+export * from './concepts';
+export * from './typelevel';
+export * from './errors';
+export * from './errors/index';
+export * from './user-app';
+export * from './searcher';
+export * from './graphql-websocket-messages';
+export * from './schedule';
+export * from './data-migration-parameters';
+export * from './super-kind';
+export * from './instrumentation/trace-types';
+export * from './sensor/health-indicator-configuration';
+export * from './internal-info';
+export * from './stream-types';
+export * from './provider';
+export * from './event-store-adapter';
+export * from './read-model-store-adapter';
+export * from './session-store-adapter';
+export * from './field-decorator';
+export * from './metadata-types';

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./groups"), exports);
+tslib_1.__exportStar(require("./promises"), exports);
+tslib_1.__exportStar(require("./retrier"), exports);
+tslib_1.__exportStar(require("./instances"), exports);
+tslib_1.__exportStar(require("./run-command"), exports);
+tslib_1.__exportStar(require("./logger"), exports);
+tslib_1.__exportStar(require("./http-service"), exports);
+tslib_1.__exportStar(require("./app"), exports);
+tslib_1.__exportStar(require("./envelope"), exports);
+tslib_1.__exportStar(require("./config"), exports);
+tslib_1.__exportStar(require("./concepts"), exports);
+tslib_1.__exportStar(require("./typelevel"), exports);
+tslib_1.__exportStar(require("./errors"), exports);
+tslib_1.__exportStar(require("./errors/index"), exports);
+tslib_1.__exportStar(require("./user-app"), exports);
+tslib_1.__exportStar(require("./searcher"), exports);
+tslib_1.__exportStar(require("./graphql-websocket-messages"), exports);
+tslib_1.__exportStar(require("./schedule"), exports);
+tslib_1.__exportStar(require("./data-migration-parameters"), exports);
+tslib_1.__exportStar(require("./super-kind"), exports);
+tslib_1.__exportStar(require("./instrumentation/trace-types"), exports);
+tslib_1.__exportStar(require("./sensor/health-indicator-configuration"), exports);
+tslib_1.__exportStar(require("./internal-info"), exports);
+tslib_1.__exportStar(require("./stream-types"), exports);
+tslib_1.__exportStar(require("./provider"), exports);
+tslib_1.__exportStar(require("./event-store-adapter"), exports);
+tslib_1.__exportStar(require("./read-model-store-adapter"), exports);
+tslib_1.__exportStar(require("./session-store-adapter"), exports);
+tslib_1.__exportStar(require("./field-decorator"), exports);
+tslib_1.__exportStar(require("./metadata-types"), exports);

package/dist/instances.d.ts

@@ -0,0 +1,47 @@
+import { Class } from './typelevel';
+import { ProjectionFor } from './searcher';
+import { ReadModelInterface } from './concepts';
+/**
+ * Creates an instance of the given class from the given raw object.
+ *
+ * @param instanceClass The class of the instance to create
+ * @param rawObject The raw object to use as source
+ *
+ * @returns An instance of the given class
+ *
+ * @example
+ * ```typescript
+ * import { createInstance } from '@magek/common'
+ * import { User } from './entities/user'
+ *
+ * const rawUser = {
+ *   id: '123',
+ *   name: 'John Doe',
+ * }
+ *
+ * const user = createInstance(User, rawUser)
+ *
+ * console.log(user.id) // Prints '123'
+ * console.log(user.name) // Prints 'John Doe'
+ * ```
+ */
+export declare function createInstance<T>(instanceClass: Class<T>, rawObject: Record<string, any>): T;
+/**
+ * Creates an array of instances of the given class from the given array of raw objects.
+ *
+ * @param instanceClass The class of the instances to create
+ * @param rawObjects The array of raw objects to use as source
+ *
+ * @returns An array of instances of the given class
+ *
+ * @see {@link createInstance}
+ */
+export declare function createInstances<T>(instanceClass: Class<T>, rawObjects: Array<Record<string, any>>): T[];
+/**
+ * Creates an instance of the read model class with the calculated properties included
+ * @param instanceClass The read model class
+ * @param raw The raw read model data
+ * @param propertiesToInclude The properties to include in the response
+ * @private
+ */
+export declare function createInstanceWithCalculatedProperties<T extends ReadModelInterface>(instanceClass: Class<T>, raw: Partial<T>, propertiesToInclude: ProjectionFor<T>): Promise<T>;

package/dist/instances.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstance = createInstance;
+exports.createInstances = createInstances;
+exports.createInstanceWithCalculatedProperties = createInstanceWithCalculatedProperties;
+/**
+ * Creates an instance of the given class from the given raw object.
+ *
+ * @param instanceClass The class of the instance to create
+ * @param rawObject The raw object to use as source
+ *
+ * @returns An instance of the given class
+ *
+ * @example
+ * ```typescript
+ * import { createInstance } from '@magek/common'
+ * import { User } from './entities/user'
+ *
+ * const rawUser = {
+ *   id: '123',
+ *   name: 'John Doe',
+ * }
+ *
+ * const user = createInstance(User, rawUser)
+ *
+ * console.log(user.id) // Prints '123'
+ * console.log(user.name) // Prints 'John Doe'
+ * ```
+ */
+function createInstance(instanceClass, rawObject) {
+    const instance = new instanceClass();
+    return Object.assign(instance, rawObject);
+}
+/**
+ * Creates an array of instances of the given class from the given array of raw objects.
+ *
+ * @param instanceClass The class of the instances to create
+ * @param rawObjects The array of raw objects to use as source
+ *
+ * @returns An array of instances of the given class
+ *
+ * @see {@link createInstance}
+ */
+function createInstances(instanceClass, rawObjects) {
+    return rawObjects.map((rawObject) => createInstance(instanceClass, rawObject));
+}
+/**
+ * Creates an instance of the read model class with the calculated properties included
+ * @param instanceClass The read model class
+ * @param raw The raw read model data
+ * @param propertiesToInclude The properties to include in the response
+ * @private
+ */
+async function createInstanceWithCalculatedProperties(instanceClass, raw, propertiesToInclude) {
+    const instance = new instanceClass();
+    Object.assign(instance, raw);
+    const result = {};
+    const propertiesMap = buildPropertiesMap(propertiesToInclude);
+    await processProperties(instance, result, propertiesMap);
+    return result;
+}
+/**
+ * Builds a map of properties to include in the response
+ * @param properties The properties to include in the response
+ * @private
+ */
+function buildPropertiesMap(properties) {
+    const map = {};
+    properties.forEach((property) => {
+        const parts = property.split('.');
+        let current = map;
+        parts.forEach((part) => {
+            const isArray = part.endsWith('[]');
+            const key = isArray ? part.slice(0, -2) : part;
+            if (!Object.prototype.hasOwnProperty.call(current, key)) {
+                current[key] = isArray ? { __isArray: true, __children: {} } : {};
+            }
+            current = isArray ? current[key].__children : current[key];
+        });
+    });
+    return map;
+}
+/**
+ * Processes the properties of the source object and adds them to the result object
+ * @param source The source object
+ * @param result The result object
+ * @param propertiesMap The map of properties to include in the response
+ * @private
+ */
+async function processProperties(source, result, propertiesMap) {
+    for (const key of Object.keys(propertiesMap)) {
+        if (key === '__isArray' || key === '__children')
+            continue;
+        if (source[key] !== undefined) {
+            if (propertiesMap[key].__isArray) {
+                result[key] = [];
+                const value = source[key];
+                const resolvedValue = isPromise(value) ? await value : value;
+                for (const item of resolvedValue) {
+                    const newItem = {};
+                    await processProperties(item, newItem, propertiesMap[key].__children);
+                    if (Object.keys(newItem).length > 0) {
+                        result[key].push(newItem);
+                    }
+                }
+            }
+            else if (typeof propertiesMap[key] === 'object' && Object.keys(propertiesMap[key]).length > 0) {
+                const value = source[key];
+                const resolvedValue = isPromise(value) ? await value : value;
+                if (resolvedValue === undefined || resolvedValue === null) {
+                    result[key] = null;
+                }
+                else {
+                    result[key] = {};
+                    await processProperties(resolvedValue, result[key], propertiesMap[key]);
+                    if (Object.keys(result[key]).length === 0) {
+                        result[key] = null;
+                    }
+                }
+            }
+            else {
+                const value = source[key];
+                result[key] = isPromise(value) ? await value : value;
+            }
+        }
+        else {
+            // Handle the case when the source property is undefined
+            if (typeof propertiesMap[key] === 'object' && Object.keys(propertiesMap[key]).length > 0) {
+                result[key] = null;
+            }
+        }
+    }
+}
+function isPromise(obj) {
+    return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+}

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

@@ -0,0 +1,52 @@
+import { UUID } from '../concepts';
+import { MagekConfig } from '../config';
+export declare enum TraceTypes {
+    START = 0,
+    END = 1
+}
+export declare enum TraceActionTypes {
+    CUSTOM = "CUSTOM",
+    EVENT_HANDLERS_PROCESS = "EVENT_HANDLERS_PROCESS",
+    HANDLE_EVENT = "HANDLE_EVENT",
+    DISPATCH_ENTITY_TO_EVENT_HANDLERS = "DISPATCH_ENTITY_TO_EVENT_HANDLERS",
+    DISPATCH_EVENTS = "DISPATCH_EVENTS",
+    CONSUME_STREAM_EVENTS = "CONSUME_STREAM_EVENTS",
+    PRODUCE_STREAM_EVENTS = "PRODUCE_STREAM_EVENTS",
+    FETCH_ENTITY_SNAPSHOT = "FETCH_ENTITY_SNAPSHOT",
+    STORE_SNAPSHOT = "STORE_SNAPSHOT",
+    LOAD_LATEST_SNAPSHOT = "LOAD_LATEST_SNAPSHOT",
+    LOAD_EVENT_STREAM_SINCE = "LOAD_EVENT_STREAM_SINCE",
+    ENTITY_REDUCER = "ENTITY_REDUCER",
+    READ_MODEL_FIND_BY_ID = "READ_MODEL_FIND_BY_ID",
+    GRAPHQL_READ_MODEL_SEARCH = "GRAPHQL_READ_MODEL_SEARCH",
+    READ_MODEL_SEARCH = "READ_MODEL_SEARCH",
+    COMMAND_HANDLER = "COMMAND_HANDLER",
+    MIGRATION_RUN = "MIGRATION_RUN",
+    GRAPHQL_DISPATCH = "GRAPHQL_DISPATCH",
+    GRAPHQL_RUN_OPERATION = "GRAPHQL_RUN_OPERATION",
+    SCHEDULED_COMMAND_HANDLER = "SCHEDULED_COMMAND_HANDLER",
+    DISPATCH_SUBSCRIBER_NOTIFIER = "DISPATCH_SUBSCRIBER_NOTIFIER",
+    READ_MODEL_SCHEMA_MIGRATOR_MIGRATE = "READ_MODEL_SCHEMA_MIGRATOR_MIGRATE",
+    SCHEMA_MIGRATOR_MIGRATE = "SCHEMA_MIGRATOR_MIGRATE"
+}
+export interface TraceInfo {
+    className: string;
+    methodName: string;
+    args: Array<unknown>;
+    traceId: UUID;
+    elapsedInvocationMillis?: number;
+    internal?: {
+        target: unknown;
+        descriptor: PropertyDescriptor;
+    };
+    description?: string;
+}
+export interface TraceHandler {
+    (config: MagekConfig, actionType: string, traceInfo: TraceInfo): Promise<void>;
+}
+export interface TraceConfiguration {
+    enableTraceNotification: boolean | Array<string>;
+    includeInternal?: boolean;
+    onStart: TraceHandler;
+    onEnd: TraceHandler;
+}

package/dist/instrumentation/trace-types.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceActionTypes = exports.TraceTypes = void 0;
+var TraceTypes;
+(function (TraceTypes) {
+    TraceTypes[TraceTypes["START"] = 0] = "START";
+    TraceTypes[TraceTypes["END"] = 1] = "END";
+})(TraceTypes || (exports.TraceTypes = TraceTypes = {}));
+var TraceActionTypes;
+(function (TraceActionTypes) {
+    TraceActionTypes["CUSTOM"] = "CUSTOM";
+    TraceActionTypes["EVENT_HANDLERS_PROCESS"] = "EVENT_HANDLERS_PROCESS";
+    TraceActionTypes["HANDLE_EVENT"] = "HANDLE_EVENT";
+    TraceActionTypes["DISPATCH_ENTITY_TO_EVENT_HANDLERS"] = "DISPATCH_ENTITY_TO_EVENT_HANDLERS";
+    TraceActionTypes["DISPATCH_EVENTS"] = "DISPATCH_EVENTS";
+    TraceActionTypes["CONSUME_STREAM_EVENTS"] = "CONSUME_STREAM_EVENTS";
+    TraceActionTypes["PRODUCE_STREAM_EVENTS"] = "PRODUCE_STREAM_EVENTS";
+    TraceActionTypes["FETCH_ENTITY_SNAPSHOT"] = "FETCH_ENTITY_SNAPSHOT";
+    TraceActionTypes["STORE_SNAPSHOT"] = "STORE_SNAPSHOT";
+    TraceActionTypes["LOAD_LATEST_SNAPSHOT"] = "LOAD_LATEST_SNAPSHOT";
+    TraceActionTypes["LOAD_EVENT_STREAM_SINCE"] = "LOAD_EVENT_STREAM_SINCE";
+    TraceActionTypes["ENTITY_REDUCER"] = "ENTITY_REDUCER";
+    TraceActionTypes["READ_MODEL_FIND_BY_ID"] = "READ_MODEL_FIND_BY_ID";
+    TraceActionTypes["GRAPHQL_READ_MODEL_SEARCH"] = "GRAPHQL_READ_MODEL_SEARCH";
+    TraceActionTypes["READ_MODEL_SEARCH"] = "READ_MODEL_SEARCH";
+    TraceActionTypes["COMMAND_HANDLER"] = "COMMAND_HANDLER";
+    TraceActionTypes["MIGRATION_RUN"] = "MIGRATION_RUN";
+    TraceActionTypes["GRAPHQL_DISPATCH"] = "GRAPHQL_DISPATCH";
+    TraceActionTypes["GRAPHQL_RUN_OPERATION"] = "GRAPHQL_RUN_OPERATION";
+    TraceActionTypes["SCHEDULED_COMMAND_HANDLER"] = "SCHEDULED_COMMAND_HANDLER";
+    TraceActionTypes["DISPATCH_SUBSCRIBER_NOTIFIER"] = "DISPATCH_SUBSCRIBER_NOTIFIER";
+    TraceActionTypes["READ_MODEL_SCHEMA_MIGRATOR_MIGRATE"] = "READ_MODEL_SCHEMA_MIGRATOR_MIGRATE";
+    TraceActionTypes["SCHEMA_MIGRATOR_MIGRATE"] = "SCHEMA_MIGRATOR_MIGRATE";
+})(TraceActionTypes || (exports.TraceActionTypes = TraceActionTypes = {}));

package/dist/internal-info.d.ts

@@ -0,0 +1,2 @@
+export declare const MAGEK_LOCAL_PORT = "INTERNAL_LOCAL_PORT";
+export declare const localPort: () => string;

package/dist/internal-info.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localPort = exports.MAGEK_LOCAL_PORT = void 0;
+exports.MAGEK_LOCAL_PORT = 'INTERNAL_LOCAL_PORT';
+const localPort = () => process.env[exports.MAGEK_LOCAL_PORT] || '3000';
+exports.localPort = localPort;

package/dist/logger.d.ts

@@ -0,0 +1,14 @@
+import { MagekConfig } from './config';
+export declare enum Level {
+    debug = 0,
+    info = 1,
+    warn = 2,
+    error = 3
+}
+export interface Logger {
+    debug(message?: any, ...optionalParams: any[]): void;
+    info(message?: any, ...optionalParams: any[]): void;
+    warn(message?: any, ...optionalParams: any[]): void;
+    error(message?: any, ...optionalParams: any[]): void;
+}
+export declare function getLogger(config: MagekConfig, location?: string, overridenLogPrefix?: string): Logger;

package/dist/logger.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Level = void 0;
+exports.getLogger = getLogger;
+var Level;
+(function (Level) {
+    Level[Level["debug"] = 0] = "debug";
+    Level[Level["info"] = 1] = "info";
+    Level[Level["warn"] = 2] = "warn";
+    Level[Level["error"] = 3] = "error";
+})(Level || (exports.Level = Level = {}));
+const defaultLogPrefix = 'Magek';
+function getLogger(config, location, overridenLogPrefix) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const debug = (_b = (_a = config.logger) === null || _a === void 0 ? void 0 : _a.debug) !== null && _b !== void 0 ? _b : console.debug;
+    const info = (_d = (_c = config.logger) === null || _c === void 0 ? void 0 : _c.info) !== null && _d !== void 0 ? _d : console.info;
+    const warn = (_f = (_e = config.logger) === null || _e === void 0 ? void 0 : _e.warn) !== null && _f !== void 0 ? _f : console.warn;
+    const error = (_h = (_g = config.logger) === null || _g === void 0 ? void 0 : _g.error) !== null && _h !== void 0 ? _h : console.error;
+    const logPrefix = (_j = overridenLogPrefix !== null && overridenLogPrefix !== void 0 ? overridenLogPrefix : config === null || config === void 0 ? void 0 : config.logPrefix) !== null && _j !== void 0 ? _j : defaultLogPrefix;
+    const locationStr = location ? `|${location}: ` : ': ';
+    const prefix = `[${logPrefix}]${locationStr}`;
+    const prefixedDebugFunction = debug.bind(null, prefix);
+    const prefixedInfoFunction = info.bind(null, prefix);
+    const prefixedWarnFunction = warn.bind(null, prefix);
+    const prefixedErrFunction = error.bind(null, prefix);
+    return {
+        debug: config.logLevel <= Level.debug ? prefixedDebugFunction : noopLog,
+        info: config.logLevel <= Level.info ? prefixedInfoFunction : noopLog,
+        warn: config.logLevel <= Level.warn ? prefixedWarnFunction : noopLog,
+        error: prefixedErrFunction,
+    };
+}
+function noopLog() { }

package/dist/metadata-types.d.ts

@@ -0,0 +1,28 @@
+import 'reflect-metadata';
+export type ClassType = {
+    new (...args: unknown[]): unknown;
+};
+export type TypeGroup = 'String' | 'Number' | 'Boolean' | 'Enum' | 'Union' | 'Intersection' | 'Function' | 'Class' | 'Interface' | 'Type' | 'Array' | 'Object' | 'ReadonlyArray' | 'Other';
+export interface TypeMetadata {
+    name: string;
+    typeGroup: TypeGroup;
+    parameters: Array<TypeMetadata>;
+    isNullable: boolean;
+    isGetAccessor: boolean;
+    typeName?: string;
+    importPath?: string;
+    type?: ClassType;
+}
+export interface PropertyMetadata {
+    name: string;
+    typeInfo: TypeMetadata;
+    dependencies: Array<string>;
+}
+export interface ClassMetadata {
+    name: string;
+    type: ClassType;
+    fields: Array<PropertyMetadata>;
+    methods: Array<PropertyMetadata>;
+}
+export declare function defineMetadata(metadataKey: string | symbol, metadataValue: unknown, target: object): void;
+export declare function getMetadata<T>(metadataKey: string | symbol, target: object): T | undefined;

package/dist/metadata-types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineMetadata = defineMetadata;
+exports.getMetadata = getMetadata;
+require("reflect-metadata");
+// Metadata helper functions
+function defineMetadata(metadataKey, metadataValue, target) {
+    Reflect.defineMetadata(metadataKey, metadataValue, target);
+}
+function getMetadata(metadataKey, target) {
+    return Reflect.getMetadata(metadataKey, target);
+}

package/dist/promises.d.ts

@@ -0,0 +1,25 @@
+export declare class Promises {
+    /**
+     * Waits until all the passed promise-like values are settled, no matter if they were fulfilled or rejected.
+     * If some rejected were found, an array with all the rejected promises is thrown.
+     * If all were fulfilled, an array of PromiseFulfilledResult is returned
+     * @param values Array of promise-like values to be wait for
+     * @throws an array of PromiseRejectedResult with all the rejected promises, if any
+     *
+     * Comparison with other similar Promise methods:
+     * - `Promise.all`: This has an "all-or-nothing" behavior. As long as one of the promises is rejected, the result is
+     * rejected. More importantly, **it does not wait for al the promises to finish**, which could lead to undesired behaviors
+     * - `Promise.allSettled`: This method waits for all the promises to finish and then returns an array of results. Some
+     * of them will be fulfilled and some rejected. More importantly, **it never throws an error**, which could lead to
+     * unexpected consequences. For example if you do "await Promise.allSettle(...)" expecting it to throw if some of them
+     * failed, you won't get that.
+     *
+     * In brief, `Promises.allSettledAndFulfilled` behaves exactly the same way as `Promise.allSettle` but it throws with
+     * an array of the failed promises, only if there are any.
+     */
+    static allSettledAndFulfilled<TValue>(values: Iterable<TValue>): ReturnType<PromiseConstructor['allSettled']>;
+}
+export declare class PromisesError extends Error {
+    readonly failedReasons: Array<unknown>;
+    constructor(rejectedResults: Array<PromiseRejectedResult>);
+}

package/dist/promises.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromisesError = exports.Promises = void 0;
+class Promises {
+    /**
+     * Waits until all the passed promise-like values are settled, no matter if they were fulfilled or rejected.
+     * If some rejected were found, an array with all the rejected promises is thrown.
+     * If all were fulfilled, an array of PromiseFulfilledResult is returned
+     * @param values Array of promise-like values to be wait for
+     * @throws an array of PromiseRejectedResult with all the rejected promises, if any
+     *
+     * Comparison with other similar Promise methods:
+     * - `Promise.all`: This has an "all-or-nothing" behavior. As long as one of the promises is rejected, the result is
+     * rejected. More importantly, **it does not wait for al the promises to finish**, which could lead to undesired behaviors
+     * - `Promise.allSettled`: This method waits for all the promises to finish and then returns an array of results. Some
+     * of them will be fulfilled and some rejected. More importantly, **it never throws an error**, which could lead to
+     * unexpected consequences. For example if you do "await Promise.allSettle(...)" expecting it to throw if some of them
+     * failed, you won't get that.
+     *
+     * In brief, `Promises.allSettledAndFulfilled` behaves exactly the same way as `Promise.allSettle` but it throws with
+     * an array of the failed promises, only if there are any.
+     */
+    static async allSettledAndFulfilled(values) {
+        const results = await Promise.allSettled(values); // Promise.allSettled never throws
+        // Get all the failed promises
+        const failed = results.filter((result) => result.status === 'rejected');
+        // Throw if we found any failed ones
+        if (failed.length > 0) {
+            throw new PromisesError(failed);
+        }
+        return results;
+    }
+}
+exports.Promises = Promises;
+class PromisesError extends Error {
+    constructor(rejectedResults) {
+        const reasons = rejectedResults.map((res) => res.reason);
+        super(reasons.join('. '));
+        this.failedReasons = reasons;
+    }
+}
+exports.PromisesError = PromisesError;

package/dist/provider/azure-configuration.d.ts

@@ -0,0 +1,12 @@
+export declare const DEFAULT_CHUNK_SIZE = 100;
+export interface AzureConfiguration {
+    enableEventBatching: boolean;
+    cosmos: {
+        batchSize: number;
+        requestOptions?: {
+            consistencyLevel?: 'Strong' | 'BoundedStaleness' | 'Session' | 'Eventual' | 'ConsistentPrefix';
+            disableRUPerMinuteUsage?: boolean;
+            indexingDirective?: 'Include' | 'Exclude';
+        };
+    };
+}