@magek/common 0.0.6 → 0.0.8

package/dist/index.js

@@ -1,33 +1,43 @@
 "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);
+// =============================================================================
+// PUBLIC API - Core Framework Types
+// These are the primary exports for framework users building Magek applications
+// =============================================================================
 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("./envelope"), 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("./logger"), 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("./runtime"), exports);
+// =============================================================================
+// ADAPTER DEVELOPMENT
+// Types and utilities for building custom adapters (event stores, read models, etc.)
+// =============================================================================
 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("./retrier"), exports);
+tslib_1.__exportStar(require("./timestamp-generator"), exports);
+tslib_1.__exportStar(require("./instances"), exports);
+tslib_1.__exportStar(require("./groups"), exports);
+tslib_1.__exportStar(require("./stream-types"), exports);
+// =============================================================================
+// FRAMEWORK INTERNALS
+// Used by @magek/core, @magek/server, and other framework packages
+// These may change between versions - use with caution in user code
+// =============================================================================
+tslib_1.__exportStar(require("./typelevel"), exports);
+tslib_1.__exportStar(require("./runtime"), exports);
+tslib_1.__exportStar(require("./user-app"), exports);
 tslib_1.__exportStar(require("./metadata-types"), exports);
+tslib_1.__exportStar(require("./super-kind"), exports);
+tslib_1.__exportStar(require("./schedule"), exports);
+tslib_1.__exportStar(require("./data-migration-parameters"), exports);
+tslib_1.__exportStar(require("./graphql-websocket-messages"), exports);
+tslib_1.__exportStar(require("./http-service"), exports);
+tslib_1.__exportStar(require("./instrumentation/trace-types"), exports);
+tslib_1.__exportStar(require("./sensor/health-indicator-configuration"), exports);

package/dist/instances.d.ts

@@ -37,6 +37,26 @@ export declare function createInstance<T>(instanceClass: Class<T>, rawObject: Re
  * @see {@link createInstance}
  */
 export declare function createInstances<T>(instanceClass: Class<T>, rawObjects: Array<Record<string, any>>): T[];
+/**
+ * Applies partial changes to an entity, optionally using defaults when creating a new instance.
+ * Designed for plain objects (entity state); use `createInstance` for class instances.
+ *
+ * @remarks
+ * This function always returns a shallow copy, ensuring immutability.
+ *
+ * @example
+ * ```typescript
+ * // Update existing entity
+ * const updated = evolve(current, { balance: current.balance + event.amount })
+ * // Create new entity with defaults
+ * const created = evolve(undefined, { id: event.entityId, name: event.name }, { status: 'active' })
+ * // Create new entity without defaults (changes must be complete)
+ * const created = evolve(undefined, { id: event.entityId, name: event.name, status: 'active' })
+ * ```
+ */
+export declare function evolve<T extends object>(current: T, changes: Partial<T>): T;
+export declare function evolve<C extends object, D extends object>(current: undefined, changes: C, defaults: D): C & D;
+export declare function evolve<T extends object>(current: undefined, changes: T): T;
 /**
  * Creates an instance of the read model class with the calculated properties included
  * @param instanceClass The read model class

package/dist/instances.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInstance = createInstance;
 exports.createInstances = createInstances;
+exports.evolve = evolve;
 exports.createInstanceWithCalculatedProperties = createInstanceWithCalculatedProperties;
 /**
  * Creates an instance of the given class from the given raw object.
@@ -44,6 +45,15 @@ function createInstance(instanceClass, rawObject) {
 function createInstances(instanceClass, rawObjects) {
     return rawObjects.map((rawObject) => createInstance(instanceClass, rawObject));
 }
+function evolve(current, changes, defaults) {
+    if (current !== undefined) {
+        return { ...current, ...changes };
+    }
+    if (defaults !== undefined) {
+        return { ...defaults, ...changes };
+    }
+    return { ...changes };
+}
 /**
  * Creates an instance of the read model class with the calculated properties included
  * @param instanceClass The read model class

package/dist/logger.js

@@ -11,12 +11,11 @@ var Level;
 })(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 debug = config.logger?.debug ?? console.debug;
+    const info = config.logger?.info ?? console.info;
+    const warn = config.logger?.warn ?? console.warn;
+    const error = config.logger?.error ?? console.error;
+    const logPrefix = overridenLogPrefix ?? config?.logPrefix ?? defaultLogPrefix;
     const locationStr = location ? `|${location}: ` : ': ';
     const prefix = `[${logPrefix}]${locationStr}`;
     const prefixedDebugFunction = debug.bind(null, prefix);

package/dist/metadata-types.d.ts

@@ -2,6 +2,26 @@ import 'reflect-metadata';
 export type ClassType = {
     new (...args: unknown[]): unknown;
 };
+/**
+ * Type function for specifying field types
+ * The parameter is optional and not used - it's just for TypeGraphQL-style ergonomics
+ */
+export type TypeFunction = (type?: unknown) => unknown;
+/**
+ * Options for the @field() decorator
+ */
+export interface FieldOptions {
+    nullable?: boolean;
+    readonly?: boolean;
+}
+/**
+ * Metadata stored for each field
+ */
+export interface FieldMetadata {
+    name: string;
+    typeFunction?: TypeFunction;
+    options: FieldOptions;
+}
 export type TypeGroup = 'String' | 'Number' | 'Boolean' | 'Enum' | 'Union' | 'Intersection' | 'Function' | 'Class' | 'Interface' | 'Type' | 'Array' | 'Object' | 'ReadonlyArray' | 'Other';
 export interface TypeMetadata {
     name: string;

package/dist/retrier.js

@@ -15,9 +15,9 @@ async function retryIfError(logicToRetry, errorClassThatRetries, logger, maxRetr
     let errorAfterMaxTries;
     for (tryNumber = 1; tryNumber <= maxRetries; tryNumber++) {
         try {
-            logger === null || logger === void 0 ? void 0 : logger.debug(`[retryIfError] Try number ${tryNumber}`);
+            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`);
+            logger?.debug(`[retryIfError] Succeeded after ${tryNumber} retries`);
             return result;
         }
         catch (e) {
@@ -30,7 +30,7 @@ async function retryIfError(logicToRetry, errorClassThatRetries, logger, maxRetr
 }
 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');
+        logger?.debug('[checkRetryError] Logic failed with an error that must not be retried. Rethrowing');
         throw e;
     }
 }

package/dist/searcher.js

@@ -7,6 +7,16 @@ exports.Searcher = void 0;
  * Check the documentation on the individual methods to know more about how to do so.
  */
 class Searcher {
+    objectClass;
+    searcherFunction;
+    finderByKeyFunction;
+    // private offset?: number
+    _limit;
+    _afterCursor;
+    filters = {};
+    _sortByList = {};
+    _paginatedVersion = false;
+    _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
@@ -16,9 +26,6 @@ class Searcher {
         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

package/dist/timestamp-generator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Generates unique, monotonically increasing ISO 8601 timestamps with sub-millisecond precision.
+ *
+ * Format: 2024-01-28T12:34:56.12345678Z where:
+ * - Digits 1-3 (123): actual milliseconds from Date.now()
+ * - Digits 4-7 (4567): monotonic counter (0000-9999)
+ * - Digit 8 (8): random seed for distributed uniqueness (0-9)
+ *
+ * This provides:
+ * - 10,000 unique orderable timestamps per millisecond per instance
+ * - 100,000 total combinations across distributed instances (10,000 counter values × 10 seeds)
+ * - Standard ISO 8601 format parseable by any Date library
+ * - Deterministic ordering via string comparison
+ * - Random component for distributed uniqueness
+ */
+export declare class TimestampGenerator {
+    private lastMs;
+    private counter;
+    private readonly randomSeed;
+    constructor();
+    /**
+     * Generates the next unique timestamp with microsecond precision.
+     *
+     * @returns ISO 8601 timestamp string with 8 fractional digits
+     */
+    next(): string;
+}
+/**
+ * Returns the singleton TimestampGenerator instance.
+ * Creates it if it doesn't exist yet.
+ *
+ * @returns The global TimestampGenerator instance
+ */
+export declare function getTimestampGenerator(): TimestampGenerator;
+/**
+ * Resets the singleton instance. Primarily for testing purposes.
+ */
+export declare function resetTimestampGenerator(): void;

package/dist/timestamp-generator.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampGenerator = void 0;
+exports.getTimestampGenerator = getTimestampGenerator;
+exports.resetTimestampGenerator = resetTimestampGenerator;
+/**
+ * Generates unique, monotonically increasing ISO 8601 timestamps with sub-millisecond precision.
+ *
+ * Format: 2024-01-28T12:34:56.12345678Z where:
+ * - Digits 1-3 (123): actual milliseconds from Date.now()
+ * - Digits 4-7 (4567): monotonic counter (0000-9999)
+ * - Digit 8 (8): random seed for distributed uniqueness (0-9)
+ *
+ * This provides:
+ * - 10,000 unique orderable timestamps per millisecond per instance
+ * - 100,000 total combinations across distributed instances (10,000 counter values × 10 seeds)
+ * - Standard ISO 8601 format parseable by any Date library
+ * - Deterministic ordering via string comparison
+ * - Random component for distributed uniqueness
+ */
+class TimestampGenerator {
+    lastMs = 0;
+    counter = 0;
+    randomSeed;
+    constructor() {
+        // Generate random seed 0-9 for distributed uniqueness
+        this.randomSeed = Math.floor(Math.random() * 10);
+    }
+    /**
+     * Generates the next unique timestamp with microsecond precision.
+     *
+     * @returns ISO 8601 timestamp string with 8 fractional digits
+     */
+    next() {
+        const nowMs = Date.now();
+        // Reset counter only if we've moved forward to a new millisecond
+        // When nowMs <= lastMs (clock skew), continue using lastMs and incrementing counter
+        if (nowMs > this.lastMs) {
+            this.lastMs = nowMs;
+            this.counter = 0;
+        }
+        // If counter exceeds 9999, advance lastMs to maintain monotonicity
+        if (this.counter > 9999) {
+            this.lastMs++;
+            this.counter = 0;
+        }
+        // Format: milliseconds (3 digits) + counter (4 digits) + seed (1 digit)
+        const microPart = String(this.counter).padStart(4, '0') + String(this.randomSeed);
+        this.counter++;
+        // Build ISO 8601 timestamp with microsecond precision
+        // Use lastMs (which may be clamped due to clock skew) instead of nowMs
+        const date = new Date(this.lastMs);
+        const isoString = date.toISOString();
+        // Replace milliseconds with our extended precision
+        // ISO format: 2024-01-28T12:34:56.123Z
+        //                                    ^^^
+        // We extend to: 2024-01-28T12:34:56.12345678Z
+        const withMicros = isoString.slice(0, -1) + microPart + 'Z';
+        return withMicros;
+    }
+}
+exports.TimestampGenerator = TimestampGenerator;
+/**
+ * Global singleton instance of TimestampGenerator.
+ */
+let timestampGeneratorInstance;
+/**
+ * Returns the singleton TimestampGenerator instance.
+ * Creates it if it doesn't exist yet.
+ *
+ * @returns The global TimestampGenerator instance
+ */
+function getTimestampGenerator() {
+    if (!timestampGeneratorInstance) {
+        timestampGeneratorInstance = new TimestampGenerator();
+    }
+    return timestampGeneratorInstance;
+}
+/**
+ * Resets the singleton instance. Primarily for testing purposes.
+ */
+function resetTimestampGenerator() {
+    timestampGeneratorInstance = undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magek/common",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Contains Magek common helpers used by the core and provider packages",
   "keywords": [
     "framework-common-helpers"
@@ -33,7 +33,7 @@
     "uuid": "^13.0.0"
   },
   "devDependencies": {
-    "@magek/eslint-config": "^0.0.6",
+    "@magek/eslint-config": "^0.0.8",
     "@types/chai": "5.2.3",
     "@types/chai-as-promised": "8.0.2",
     "@types/mocha": "10.0.10",

package/dist/field-decorator.d.ts

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

package/dist/field-decorator.js

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

package/dist/internal-info.d.ts

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

package/dist/internal-info.js

@@ -1,6 +0,0 @@
-"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/promises.d.ts

@@ -1,25 +0,0 @@
-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

@@ -1,42 +0,0 @@
-"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/run-command.d.ts

@@ -1,5 +0,0 @@
-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>;