@ductape/sdk 0.0.4-v55 → 0.0.4-v56

package/dist/resilience/quota.service.d.ts

@@ -2,8 +2,11 @@
  * Quota Service
  *
  * Code-first API for defining and managing quotas with weighted distribution.
+ * Uses ProductBuilder for CRUD operations and ProcessorService for execution.
+ * Implements health-aware weighted selection with minimal latency.
  */
 import { IQuotaDefineOptions, IQuotaSchema, IQuotaRunOptions, IQuotaDispatchOptions, IDefinedQuota, IResilienceServiceConfig } from './types';
+import { IProductQuota } from '../types/productsBuilder.types';
 /**
  * Error class for quota operations
  */
@@ -13,75 +16,61 @@ export declare class QuotaError extends Error {
     constructor(message: string, code: string, details?: unknown);
 }
 /**
- * Quota Service
- *
- * Provides code-first API for defining, creating, and managing quotas.
+ * Result of a quota run with provider information
  */
+export interface IQuotaRunResult<T = unknown> {
+    data: T;
+    provider: string;
+    latency: number;
+    wasHealthy: boolean;
+    retriesUsed: number;
+}
 export declare class QuotaService {
-    private apiService;
+    private config;
+    private productBuilders;
+    private processorCache;
     constructor(config: IResilienceServiceConfig);
     /**
-     * Define a quota using code-first API
-     *
-     * @example
-     * ```ts
-     * const quota = await quotaService.define({
-     *   product: 'my-product',
-     *   tag: 'sms-quota',
-     *   name: 'SMS Provider Quota',
-     *   input: {
-     *     phone: { type: 'string', required: true },
-     *     message: { type: 'string', required: true },
-     *   },
-     *   handler: async (ctx) => {
-     *     ctx.provider('twilio')
-     *       .weight(70)
-     *       .healthcheck('twilio-health')
-     *       .app('twilio-app')
-     *       .action('send-sms')
-     *       .mapInput((input) => ({ body: { to: input.phone, body: input.message } }))
-     *       .mapOutput((res) => ({ messageId: res.sid }))
-     *       .retries(2);
-     *
-     *     ctx.provider('nexmo')
-     *       .weight(30)
-     *       .healthcheck('nexmo-health')
-     *       .app('nexmo-app')
-     *       .action('send-sms')
-     *       .mapInput((input) => ({ body: { to: input.phone, text: input.message } }))
-     *       .mapOutput((res) => ({ messageId: res['message-id'] }))
-     *       .retries(2);
-     *   },
-     * });
-     * ```
+     * Gets or creates a cached ProductBuilder
      */
-    define<TInput = Record<string, unknown>>(options: IQuotaDefineOptions<TInput>): Promise<IDefinedQuota>;
+    private getProductBuilder;
     /**
-     * Create a quota from a defined quota or schema
+     * Gets or creates a cached ProcessorService for minimal latency
      */
-    create(product: string, quota: IDefinedQuota | IQuotaSchema): Promise<IQuotaSchema>;
-    /**
-     * Update an existing quota
-     */
-    update<TInput = Record<string, unknown>>(product: string, tag: string, quota: Partial<IQuotaDefineOptions<TInput>> | Partial<IQuotaSchema>): Promise<IQuotaSchema>;
+    private getProcessor;
+    define<TInput = Record<string, unknown>>(options: IQuotaDefineOptions<TInput>): Promise<IDefinedQuota>;
+    create(product: string, quota: IDefinedQuota | IQuotaSchema): Promise<IProductQuota>;
+    fetch(product: string, tag: string): Promise<IProductQuota | null>;
+    fetchAll(product: string): Promise<IProductQuota[]>;
+    update(product: string, tag: string, data: Partial<IProductQuota>): Promise<void>;
+    delete(product: string, tag: string): Promise<void>;
     /**
-     * Fetch a quota by tag
+     * Run a quota with health-aware weighted provider selection
+     *
+     * Optimization strategies:
+     * 1. Parallel health status lookups from Redis (O(1) per provider)
+     * 2. Cached processor instances to avoid re-initialization
+     * 3. Pre-computed weighted selection for O(n) provider selection
+     * 4. Exponential backoff only on failures
      */
-    fetch(product: string, tag: string): Promise<IQuotaSchema>;
+    run<TOutput = unknown>(options: IQuotaRunOptions): Promise<IQuotaRunResult<TOutput>>;
     /**
-     * Fetch all quotas for a product
+     * Parallel health status lookup from Redis - O(n) with parallel I/O
      */
-    fetchAll(product: string): Promise<IQuotaSchema[]>;
+    private getHealthStatusesParallel;
     /**
-     * Delete a quota
+     * Fast weighted selection with health-aware prioritization
      */
-    delete(product: string, tag: string): Promise<void>;
+    private selectHealthyProvider;
     /**
-     * Run a quota
+     * Execute provider action with exponential backoff retries
      */
-    run<TOutput = unknown>(options: IQuotaRunOptions): Promise<TOutput>;
+    private executeWithRetries;
     /**
-     * Dispatch/schedule a quota for later execution
+     * Dispatch quota for deferred execution via job queue
+     *
+     * Note: For immediate execution, use run() instead.
+     * Dispatch schedules the quota for background processing.
      */
     dispatch(options: IQuotaDispatchOptions): Promise<{
         jobId: string;