@griddo/cx 11.13.0 → 11.13.2

package/build/core/check-env-health.d.ts

@@ -1,3 +1,49 @@
+/**
+ * Check if required environment variables exist with any value.
+ *
+ * @returns An object containing:
+ *   - isValid: boolean indicating if all required environment variables are present.
+ *   - missing: an array of missing environment variable names.
+ */
+declare function checkRequiredEnvVars(): {
+    isValid: boolean;
+    missing: string[];
+};
+/**
+ * Check if environment variables have the expected values.
+ *
+ * @returns An object containing:
+ *   - isValid: boolean indicating if all required environment variables have the expected values.
+ *   - mismatches: an array of mismatched environment variable names and their expected and actual values.
+ */
+declare function checkEnvVarValues(): {
+    isValid: boolean;
+    mismatches: {
+        key: string;
+        expected: string;
+        actual: string;
+    }[];
+};
+/**
+ * Check recommended environment variables and show warnings for missing ones.
+ *
+ * @returns An object containing:
+ *   - isValid: boolean indicating if all recommended environment variables are set.
+ *   - missing: an array of missing recommended environment variable names.
+ */
+declare function checkRecommendedEnvVars(): void;
+/**
+ * Check if set enviroment variables have been deprecated
+ *
+ * @returns An object containing:
+ *   - deprecated: an array of deprecated environment variable names.
+ */
+declare function checkDeprecatedEnvVars(): {
+    deprecated: {
+        key: string;
+        description?: string;
+    }[];
+};
 /**
  * Check if the environment is secure to launch a render.
  * If something fails then log an error message and exit from the process.
@@ -6,4 +52,4 @@
  * @returns A boolean indicating if the environment is secure to launch a render.
  */
 declare function checkEnvironmentHealth(): boolean;
-export { checkEnvironmentHealth };
+export { checkDeprecatedEnvVars, checkEnvVarValues, checkEnvironmentHealth, checkRecommendedEnvVars, checkRequiredEnvVars };

package/build/core/http/create-adapter.d.ts

@@ -0,0 +1,13 @@
+import type { HttpAdapter } from "./types";
+/**
+ * Sync getter del adapter HTTP.
+ *
+ * Composición:
+ *   circuitBreaker → retry(exponential + jitter) → undici(timeout nativo)
+ */
+declare function getHttpAdapter(): HttpAdapter;
+/**
+ * Reset del singleton (para tests).
+ */
+declare function resetHttpAdapter(): void;
+export { getHttpAdapter, resetHttpAdapter };

package/build/core/http/index.d.ts

@@ -0,0 +1,6 @@
+export type { HttpAdapter, HttpRequest, HttpResponse } from "./types";
+export type { CircuitBreakerOptions } from "./with-circuit-breaker";
+export type { RetryOptions } from "./with-retry";
+export { getHttpAdapter, resetHttpAdapter } from "./create-adapter";
+export { CircuitOpenError, withCircuitBreaker } from "./with-circuit-breaker";
+export { withRetry } from "./with-retry";

package/build/core/http/types.d.ts

@@ -0,0 +1,20 @@
+/** Descriptor de request que recibe el adapter. */
+export interface HttpRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+}
+/** Descriptor de response que devuelve el adapter. */
+export interface HttpResponse {
+    status: number;
+    statusText: string;
+    ok: boolean;
+    headers: Record<string, string>;
+    json: <T = unknown>() => Promise<T>;
+    text: () => Promise<string>;
+}
+/** Contrato del adapter. Un solo metodo, sin estado. */
+export interface HttpAdapter {
+    request: (req: HttpRequest) => Promise<HttpResponse>;
+}

package/build/core/http/undici-adapter.d.ts

@@ -0,0 +1,7 @@
+import type { HttpAdapter } from "./types";
+export interface UndiciAdapterOptions {
+    /** Request timeout in milliseconds. Cancels the request if exceeded. */
+    timeoutMs?: number;
+}
+declare function createUndiciAdapter(options?: UndiciAdapterOptions): HttpAdapter;
+export { createUndiciAdapter };

package/build/core/http/with-circuit-breaker.d.ts

@@ -0,0 +1,24 @@
+import type { HttpAdapter } from "./types";
+export interface CircuitBreakerOptions {
+    /** Number of consecutive failures before opening the circuit. */
+    failureThreshold: number;
+    /** Time in ms before switching from open to half-open. */
+    cooldownMs: number;
+    /** Called when the circuit opens. */
+    onOpen?: () => void;
+    /** Called when the circuit closes (recovery). */
+    onClose?: () => void;
+}
+export declare class CircuitOpenError extends Error {
+    constructor(cooldownMs: number);
+}
+/**
+ * Decorator that adds circuit breaker logic to an HttpAdapter.
+ *
+ * States:
+ * - CLOSED:    requests pass through normally, failures are counted
+ * - OPEN:      all requests fail immediately with CircuitOpenError
+ * - HALF-OPEN: one probe request is allowed; success → CLOSED, failure → OPEN
+ */
+declare function withCircuitBreaker(adapter: HttpAdapter, options: CircuitBreakerOptions): HttpAdapter;
+export { withCircuitBreaker };

package/build/core/http/with-retry.d.ts

@@ -0,0 +1,32 @@
+import type { HttpAdapter, HttpRequest, HttpResponse } from "./types";
+export interface RetryOptions {
+    /** Max number of attempts (including the first one). */
+    attempts: number;
+    /** Base delay between retries in milliseconds. */
+    delayMs: number;
+    /** Backoff strategy: "fixed" (same delay) or "exponential" (1x, 2x, 4x...). Default: "fixed". */
+    backoff?: "fixed" | "exponential";
+    /** Add random jitter (±50%) to the delay to avoid thundering herd. Default: false. */
+    jitter?: boolean;
+    /** Decide whether a successful response should be retried (e.g. 5xx). */
+    retryOn?: (response: HttpResponse) => boolean;
+    /** Called before each retry. */
+    onRetry?: (context: {
+        request: HttpRequest;
+        attempt: number;
+        delayMs: number;
+        error?: Error;
+        response?: HttpResponse;
+    }) => void;
+}
+/**
+ * Decorator that adds retry logic to an HttpAdapter.
+ *
+ * Retries on:
+ * - Transport errors (network failures, DNS, connection refused, timeouts)
+ * - Responses matching `retryOn` predicate (e.g. status >= 500)
+ *
+ * Supports fixed and exponential backoff with optional jitter.
+ */
+declare function withRetry(adapter: HttpAdapter, options: RetryOptions): HttpAdapter;
+export { withRetry };