@ductape/sdk 0.0.4-v55 → 0.0.4-v57

package/dist/resilience/quota.service.js

@@ -3,11 +3,17 @@
  * 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.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QuotaService = exports.QuotaError = void 0;
 const types_1 = require("./types");
-const resilienceApi_service_1 = require("../api/services/resilienceApi.service");
+const products_service_1 = __importDefault(require("../products/services/products.service"));
+const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
 /**
  * Error class for quota operations
  */
@@ -20,6 +26,97 @@ class QuotaError extends Error {
     }
 }
 exports.QuotaError = QuotaError;
+// ============================================================================
+// Recording Builders (for code-first API)
+// ============================================================================
+class RecordingAppProviderBuilder {
+    constructor(parent, appTag) {
+        this.parent = parent;
+        this.appTag = appTag;
+    }
+    action(event) {
+        this.parent.setAppAction(this.appTag, event);
+        return this.parent;
+    }
+    weight(value) { return this.parent.weight(value); }
+    healthcheck(tag) { return this.parent.healthcheck(tag); }
+    app(tag) { return this.parent.app(tag); }
+    feature(tag) { return this.parent.feature(tag); }
+    database(tag) { return this.parent.database(tag); }
+    workflow(tag) { return this.parent.workflow(tag); }
+    notification(tag) { return this.parent.notification(tag); }
+    mapInput(mapper) { return this.parent.mapInput(mapper); }
+    mapOutput(mapper) { return this.parent.mapOutput(mapper); }
+    retries(count) { return this.parent.retries(count); }
+    checkInterval(ms) { return this.parent.checkInterval(ms); }
+}
+class RecordingDatabaseProviderBuilder {
+    constructor(parent, databaseTag) {
+        this.parent = parent;
+        this.databaseTag = databaseTag;
+    }
+    action(event) {
+        this.parent.setDatabaseAction(this.databaseTag, event);
+        return this.parent;
+    }
+    weight(value) { return this.parent.weight(value); }
+    healthcheck(tag) { return this.parent.healthcheck(tag); }
+    app(tag) { return this.parent.app(tag); }
+    feature(tag) { return this.parent.feature(tag); }
+    database(tag) { return this.parent.database(tag); }
+    workflow(tag) { return this.parent.workflow(tag); }
+    notification(tag) { return this.parent.notification(tag); }
+    mapInput(mapper) { return this.parent.mapInput(mapper); }
+    mapOutput(mapper) { return this.parent.mapOutput(mapper); }
+    retries(count) { return this.parent.retries(count); }
+    checkInterval(ms) { return this.parent.checkInterval(ms); }
+}
+class RecordingWorkflowProviderBuilder {
+    constructor(parent, workflowTag) {
+        this.parent = parent;
+        this.parent.setWorkflow(workflowTag);
+    }
+    input(data) {
+        this.parent.setWorkflowInput(data);
+        return this.parent;
+    }
+    weight(value) { return this.parent.weight(value); }
+    healthcheck(tag) { return this.parent.healthcheck(tag); }
+    app(tag) { return this.parent.app(tag); }
+    feature(tag) { return this.parent.feature(tag); }
+    database(tag) { return this.parent.database(tag); }
+    workflow(tag) { return this.parent.workflow(tag); }
+    notification(tag) { return this.parent.notification(tag); }
+    mapInput(mapper) { return this.parent.mapInput(mapper); }
+    mapOutput(mapper) { return this.parent.mapOutput(mapper); }
+    retries(count) { return this.parent.retries(count); }
+    checkInterval(ms) { return this.parent.checkInterval(ms); }
+}
+class RecordingNotificationProviderBuilder {
+    constructor(parent, notificationTag) {
+        this.parent = parent;
+        this.parent.setNotification(notificationTag);
+    }
+    message(messageTag) {
+        this.parent.setNotificationMessage(messageTag);
+        return this.parent;
+    }
+    event(eventTag) {
+        this.parent.setNotificationEvent(eventTag);
+        return this.parent;
+    }
+    weight(value) { return this.parent.weight(value); }
+    healthcheck(tag) { return this.parent.healthcheck(tag); }
+    app(tag) { return this.parent.app(tag); }
+    feature(tag) { return this.parent.feature(tag); }
+    database(tag) { return this.parent.database(tag); }
+    workflow(tag) { return this.parent.workflow(tag); }
+    notification(tag) { return this.parent.notification(tag); }
+    mapInput(mapper) { return this.parent.mapInput(mapper); }
+    mapOutput(mapper) { return this.parent.mapOutput(mapper); }
+    retries(count) { return this.parent.retries(count); }
+    checkInterval(ms) { return this.parent.checkInterval(ms); }
+}
 /**
  * Provider builder that records provider configuration
  */
@@ -39,310 +136,75 @@ class RecordingProviderBuilder {
         return this;
     }
     app(tag) {
-        this._type = types_1.FeatureEventTypes.ACTION;
         this._app = tag;
-        return new RecordingAppProviderBuilder(this, this._app);
+        return new RecordingAppProviderBuilder(this, tag);
     }
-    /**
-     * @deprecated Features are deprecated - use workflow() instead
-     */
     feature(tag) {
         console.warn('feature() is deprecated. Use workflow() instead.');
-        this._type = types_1.FeatureEventTypes.ACTION;
         this._event = tag;
         this.finalize();
         return this;
     }
     database(tag) {
-        this._type = types_1.FeatureEventTypes.ACTION;
-        this._database = tag;
-        return new RecordingDatabaseProviderBuilder(this, this._database);
+        return new RecordingDatabaseProviderBuilder(this, tag);
     }
     workflow(tag) {
-        this._type = types_1.FeatureEventTypes.ACTION;
-        this._workflow = tag;
-        return new RecordingWorkflowProviderBuilder(this, this._workflow);
+        return new RecordingWorkflowProviderBuilder(this, tag);
     }
     notification(tag) {
-        this._type = types_1.FeatureEventTypes.ACTION;
-        this._notification = tag;
-        return new RecordingNotificationProviderBuilder(this, this._notification);
+        return new RecordingNotificationProviderBuilder(this, tag);
     }
-    mapInput(mapper) {
-        this._inputMapper = mapper;
+    mapInput(_mapper) {
         return this;
     }
-    mapOutput(mapper) {
-        this._outputMapper = mapper;
+    mapOutput(_mapper) {
         return this;
     }
     retries(count) {
         this._retries = count;
+        this.finalize();
         return this;
     }
     checkInterval(ms) {
         this._checkInterval = ms;
         return this;
     }
-    /**
-     * Set event/action name (used by sub-builders)
-     */
-    setEvent(event) {
+    setAppAction(app, event) {
+        this._app = app;
         this._event = event;
-        this.finalize();
     }
-    /**
-     * Set workflow input (used by workflow builder)
-     */
-    setWorkflowInput(input) {
-        this._workflowInput = input;
-        this.finalize();
+    setDatabaseAction(_database, event) {
+        this._event = event;
+    }
+    setWorkflow(workflow) {
+        this._event = workflow;
+    }
+    setWorkflowInput(_input) { }
+    setNotification(_notification) { }
+    setNotificationMessage(_message) { }
+    setNotificationEvent(event) {
+        this._event = event;
     }
-    /**
-     * Finalize and add provider to options
-     */
     finalize() {
-        // Generate input mapping from function
-        const inputSchema = this.generateInputSchema();
-        const outputSchema = this.generateOutputSchema();
         const option = {
             provider: this.providerName,
             quota: this._weight,
-            healthcheck: this._healthcheck,
-            type: this._type || types_1.FeatureEventTypes.ACTION,
-            app: this._app,
+            type: types_1.FeatureEventTypes.ACTION,
             event: this._event || '',
-            input: this._workflowInput || inputSchema,
-            output: outputSchema,
+            input: {},
+            output: {},
             retries: this._retries,
+            healthcheck: this._healthcheck,
             check_interval: this._checkInterval,
         };
-        this.options.push(option);
-    }
-    /**
-     * Generate input schema from mapper function
-     */
-    generateInputSchema() {
-        if (!this._inputMapper) {
-            return {};
+        if (this._app) {
+            option.app = this._app;
         }
-        // Create a proxy to capture property access patterns
-        const proxyHandler = {
-            get: (_target, prop) => {
-                if (typeof prop === 'string') {
-                    return `$Input{${prop}}`;
-                }
-                return undefined;
-            },
-        };
-        try {
-            const proxy = new Proxy({}, proxyHandler);
-            return this._inputMapper(proxy);
-        }
-        catch (_a) {
-            // If proxy fails, return empty schema
-            return {};
-        }
-    }
-    /**
-     * Generate output schema from mapper function
-     */
-    generateOutputSchema() {
-        if (!this._outputMapper) {
-            return {};
-        }
-        // Create a proxy to capture property access patterns
-        const proxyHandler = {
-            get: (_target, prop) => {
-                if (typeof prop === 'string') {
-                    return `$Response{${prop}}`;
-                }
-                return undefined;
-            },
-        };
-        try {
-            const proxy = new Proxy({}, proxyHandler);
-            return this._outputMapper(proxy);
-        }
-        catch (_a) {
-            return {};
-        }
-    }
-}
-class RecordingAppProviderBuilder {
-    constructor(parent, appTag) {
-        this.parent = parent;
-        this.appTag = appTag;
-    }
-    action(event) {
-        this.parent.setEvent(event);
-        return this.parent;
-    }
-    weight(value) {
-        return this.parent.weight(value);
-    }
-    healthcheck(tag) {
-        return this.parent.healthcheck(tag);
-    }
-    app(tag) {
-        return this.parent.app(tag);
-    }
-    feature(tag) {
-        return this.parent.feature(tag);
-    }
-    database(tag) {
-        return this.parent.database(tag);
-    }
-    workflow(tag) {
-        return this.parent.workflow(tag);
-    }
-    notification(tag) {
-        return this.parent.notification(tag);
-    }
-    mapInput(mapper) {
-        return this.parent.mapInput(mapper);
-    }
-    mapOutput(mapper) {
-        return this.parent.mapOutput(mapper);
-    }
-    retries(count) {
-        return this.parent.retries(count);
-    }
-    checkInterval(ms) {
-        return this.parent.checkInterval(ms);
-    }
-}
-class RecordingDatabaseProviderBuilder {
-    constructor(parent, dbTag) {
-        this.parent = parent;
-        this.dbTag = dbTag;
-    }
-    action(event) {
-        this.parent.setEvent(event);
-        return this.parent;
-    }
-    weight(value) {
-        return this.parent.weight(value);
-    }
-    healthcheck(tag) {
-        return this.parent.healthcheck(tag);
-    }
-    app(tag) {
-        return this.parent.app(tag);
-    }
-    feature(tag) {
-        return this.parent.feature(tag);
-    }
-    database(tag) {
-        return this.parent.database(tag);
-    }
-    workflow(tag) {
-        return this.parent.workflow(tag);
-    }
-    notification(tag) {
-        return this.parent.notification(tag);
-    }
-    mapInput(mapper) {
-        return this.parent.mapInput(mapper);
-    }
-    mapOutput(mapper) {
-        return this.parent.mapOutput(mapper);
-    }
-    retries(count) {
-        return this.parent.retries(count);
-    }
-    checkInterval(ms) {
-        return this.parent.checkInterval(ms);
-    }
-}
-class RecordingWorkflowProviderBuilder {
-    constructor(parent, workflowTag) {
-        this.parent = parent;
-        this.workflowTag = workflowTag;
-    }
-    input(data) {
-        this.parent.setWorkflowInput(data);
-        return this.parent;
-    }
-    weight(value) {
-        return this.parent.weight(value);
-    }
-    healthcheck(tag) {
-        return this.parent.healthcheck(tag);
-    }
-    app(tag) {
-        return this.parent.app(tag);
-    }
-    feature(tag) {
-        return this.parent.feature(tag);
-    }
-    database(tag) {
-        return this.parent.database(tag);
-    }
-    workflow(tag) {
-        return this.parent.workflow(tag);
-    }
-    notification(tag) {
-        return this.parent.notification(tag);
-    }
-    mapInput(mapper) {
-        return this.parent.mapInput(mapper);
-    }
-    mapOutput(mapper) {
-        return this.parent.mapOutput(mapper);
-    }
-    retries(count) {
-        return this.parent.retries(count);
-    }
-    checkInterval(ms) {
-        return this.parent.checkInterval(ms);
-    }
-}
-class RecordingNotificationProviderBuilder {
-    constructor(parent, notificationTag) {
-        this.parent = parent;
-        this.notificationTag = notificationTag;
-    }
-    event(event) {
-        this.parent.setEvent(event);
-        return this.parent;
-    }
-    weight(value) {
-        return this.parent.weight(value);
-    }
-    healthcheck(tag) {
-        return this.parent.healthcheck(tag);
-    }
-    app(tag) {
-        return this.parent.app(tag);
-    }
-    feature(tag) {
-        return this.parent.feature(tag);
-    }
-    database(tag) {
-        return this.parent.database(tag);
-    }
-    workflow(tag) {
-        return this.parent.workflow(tag);
-    }
-    notification(tag) {
-        return this.parent.notification(tag);
-    }
-    mapInput(mapper) {
-        return this.parent.mapInput(mapper);
-    }
-    mapOutput(mapper) {
-        return this.parent.mapOutput(mapper);
-    }
-    retries(count) {
-        return this.parent.retries(count);
-    }
-    checkInterval(ms) {
-        return this.parent.checkInterval(ms);
+        this.options.push(option);
     }
 }
 /**
- * Recording context that captures quota configuration during handler execution
+ * Recording context for quota configuration
  */
 class RecordingQuotaContext {
     constructor(inputSchema) {
@@ -350,106 +212,84 @@ class RecordingQuotaContext {
         this._input = inputSchema;
     }
     get input() {
-        // Create a proxy that returns data references
-        const proxyHandler = {
-            get: (target, prop) => {
-                if (typeof prop === 'string') {
-                    return `$Input{${prop}}`;
-                }
-                return undefined;
-            },
-        };
-        return new Proxy({}, proxyHandler);
+        return new Proxy({}, {
+            get: (_, prop) => typeof prop === 'string' ? `$Input{${prop}}` : undefined,
+        });
     }
     provider(name) {
         return new RecordingProviderBuilder(name, this._options);
     }
-    auth(field) {
-        return `$Auth{${field}}`;
-    }
-    token(key) {
-        return `$Secret{${key}}`;
-    }
-    variable(app, key) {
-        return `$Variable{${app}}{${key}}`;
-    }
-    constant(app, key) {
-        return `$Constant{${app}}{${key}}`;
-    }
-    /**
-     * Build the quota schema from recorded configuration
-     */
+    auth(field) { return `$Auth{${field}}`; }
+    token(key) { return `$Secret{${key}}`; }
+    variable(app, key) { return `$Variable{${app}}{${key}}`; }
+    constant(app, key) { return `$Constant{${app}}{${key}}`; }
     build(tag, name, description) {
         if (this._options.length === 0) {
             throw new QuotaError('At least one provider must be configured', 'NO_PROVIDERS_CONFIGURED');
         }
-        const total_quota = this._options.reduce((sum, opt) => sum + opt.quota, 0);
         return {
             tag,
             name,
             description,
             input: this._input,
-            total_quota,
+            total_quota: this._options.reduce((sum, opt) => sum + opt.quota, 0),
             options: this._options,
         };
     }
-    get options() {
-        return this._options;
-    }
+    get options() { return this._options; }
 }
-/**
- * Quota Service
- *
- * Provides code-first API for defining, creating, and managing quotas.
- */
+// ============================================================================
+// Quota Service - Optimized for Minimal Latency
+// ============================================================================
 class QuotaService {
     constructor(config) {
-        this.apiService = new resilienceApi_service_1.ResilienceApiService({
-            token: config.token,
-            env_type: config.env_type,
-            base_url: config.base_url,
-        });
+        this.productBuilders = new Map();
+        this.processorCache = new Map();
+        this.config = config;
     }
     /**
-     * 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
+     */
+    async getProductBuilder(productTag) {
+        let builder = this.productBuilders.get(productTag);
+        if (!builder) {
+            builder = new products_service_1.default({
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                redis_client: this.config.redis_client,
+                queues: this.config.queues,
+            });
+            await builder.initializeProductByTag(productTag);
+            this.productBuilders.set(productTag, builder);
+        }
+        return builder;
+    }
+    /**
+     * Gets or creates a cached ProcessorService for minimal latency
      */
+    getProcessor(productTag) {
+        let processor = this.processorCache.get(productTag);
+        if (!processor) {
+            processor = new processor_service_1.default({
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                redis_client: this.config.redis_client,
+                queues: this.config.queues,
+            });
+            this.processorCache.set(productTag, processor);
+        }
+        return processor;
+    }
+    // ==================== Code-First API ====================
     async define(options) {
         const ctx = new RecordingQuotaContext(options.input);
-        // Execute the handler to record the configuration
         await options.handler(ctx);
-        // Build the schema
         const schema = ctx.build(options.tag, options.name, options.description);
         const definedQuota = {
             tag: options.tag,
@@ -458,60 +298,215 @@ class QuotaService {
             input: options.input,
             compile: () => schema,
         };
-        // If product is specified, register immediately
         if (options.product) {
             await this.create(options.product, definedQuota);
         }
         return definedQuota;
     }
-    /**
-     * Create a quota from a defined quota or schema
-     */
+    // ==================== CRUD via ProductBuilder ====================
     async create(product, quota) {
         const schema = 'compile' in quota ? quota.compile() : quota;
-        return await this.apiService.createQuota(product, schema);
+        const builder = await this.getProductBuilder(product);
+        const productQuota = {
+            tag: schema.tag,
+            name: schema.name || schema.tag,
+            description: schema.description || '',
+            input: schema.input,
+            total_quota: schema.total_quota,
+            options: schema.options.map(opt => ({
+                app: opt.app,
+                type: types_1.FeatureEventTypes.ACTION,
+                event: opt.event,
+                input: opt.input || {},
+                output: opt.output || {},
+                retries: opt.retries || 2,
+                quota: opt.quota,
+                healthcheck: opt.healthcheck,
+                check_interval: opt.check_interval,
+            })),
+        };
+        await builder.createQuota(productQuota);
+        return await builder.fetchQuota(schema.tag);
     }
-    /**
-     * Update an existing quota
-     */
-    async update(product, tag, quota) {
-        if ('handler' in quota && quota.handler && quota.input) {
-            const ctx = new RecordingQuotaContext(quota.input);
-            await quota.handler(ctx);
-            const schema = ctx.build(tag, quota.name, quota.description);
-            return await this.apiService.updateQuota(product, tag, schema);
-        }
-        return await this.apiService.updateQuota(product, tag, quota);
+    async fetch(product, tag) {
+        const builder = await this.getProductBuilder(product);
+        return builder.fetchQuota(tag);
+    }
+    async fetchAll(product) {
+        const builder = await this.getProductBuilder(product);
+        return builder.fetchQuotas();
     }
+    async update(product, tag, data) {
+        const builder = await this.getProductBuilder(product);
+        await builder.updateQuota(tag, data);
+    }
+    async delete(product, tag) {
+        const builder = await this.getProductBuilder(product);
+        await builder.deleteQuota(tag);
+    }
+    // ==================== Execution - Optimized for Minimal Latency ====================
     /**
-     * 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
      */
-    async fetch(product, tag) {
-        return await this.apiService.getQuota(product, tag);
+    async run(options) {
+        var _a;
+        const { product, env, tag, input } = options;
+        const startTime = Date.now();
+        // Fetch quota config
+        const quota = await this.fetch(product, tag);
+        if (!quota) {
+            throw new QuotaError(`Quota '${tag}' not found in product '${product}'`, 'QUOTA_NOT_FOUND');
+        }
+        if (!((_a = quota.options) === null || _a === void 0 ? void 0 : _a.length)) {
+            throw new QuotaError(`Quota '${tag}' has no providers configured`, 'NO_PROVIDERS');
+        }
+        const processor = this.getProcessor(product);
+        // Parallel health status lookup - minimal latency
+        const healthStatuses = await this.getHealthStatusesParallel(processor, product, env, quota.options);
+        // Fast weighted selection with health awareness
+        const { provider, wasHealthy } = this.selectHealthyProvider(quota.options, healthStatuses);
+        // Execute with retries
+        const result = await this.executeWithRetries(processor, provider, env, product, input);
+        return {
+            data: result.data,
+            provider: provider.app || provider.event,
+            latency: Date.now() - startTime,
+            wasHealthy,
+            retriesUsed: result.retriesUsed,
+        };
     }
     /**
-     * Fetch all quotas for a product
+     * Parallel health status lookup from Redis - O(n) with parallel I/O
      */
-    async fetchAll(product) {
-        return await this.apiService.listQuotas(product);
+    async getHealthStatusesParallel(processor, product, env, options) {
+        const statuses = new Map();
+        // Collect healthcheck tags
+        const healthcheckTags = options
+            .filter(opt => opt.healthcheck)
+            .map(opt => opt.healthcheck);
+        if (healthcheckTags.length === 0) {
+            return statuses;
+        }
+        // Parallel Redis lookups
+        const results = await Promise.allSettled(healthcheckTags.map(async (tag) => {
+            try {
+                const cached = await processor.getHealthcheckStatusFromCache(product, `${tag}:${env}`);
+                return { tag, status: (cached === null || cached === void 0 ? void 0 : cached.status) || 'unknown', latency: cached === null || cached === void 0 ? void 0 : cached.latency };
+            }
+            catch (_a) {
+                return { tag, status: 'unknown' };
+            }
+        }));
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                statuses.set(result.value.tag, {
+                    status: result.value.status,
+                    lastLatency: result.value.latency,
+                });
+            }
+        }
+        return statuses;
     }
     /**
-     * Delete a quota
+     * Fast weighted selection with health-aware prioritization
      */
-    async delete(product, tag) {
-        await this.apiService.deleteQuota(product, tag);
+    selectHealthyProvider(options, healthStatuses) {
+        // Categorize by health in single pass
+        const healthy = [];
+        const unknown = [];
+        const unhealthy = [];
+        for (const opt of options) {
+            if (!opt.healthcheck) {
+                healthy.push(opt); // No healthcheck = assume healthy
+            }
+            else {
+                const status = healthStatuses.get(opt.healthcheck);
+                if (!status || status.status === 'unknown') {
+                    unknown.push(opt);
+                }
+                else if (status.status === 'available') {
+                    healthy.push(opt);
+                }
+                else {
+                    unhealthy.push(opt);
+                }
+            }
+        }
+        // Priority: healthy > unknown > unhealthy
+        let candidates = healthy.length > 0 ? healthy : unknown.length > 0 ? unknown : unhealthy;
+        const wasHealthy = healthy.length > 0;
+        if (candidates.length === 0) {
+            throw new QuotaError('No providers available', 'NO_PROVIDERS_AVAILABLE');
+        }
+        // Weighted random selection - O(n)
+        const totalWeight = candidates.reduce((sum, opt) => sum + (opt.quota || 1), 0);
+        const random = Math.random() * totalWeight;
+        let cumulative = 0;
+        for (const opt of candidates) {
+            cumulative += opt.quota || 1;
+            if (random <= cumulative) {
+                return { provider: opt, wasHealthy };
+            }
+        }
+        return { provider: candidates[candidates.length - 1], wasHealthy };
     }
     /**
-     * Run a quota
+     * Execute provider action with exponential backoff retries
      */
-    async run(options) {
-        return await this.apiService.runQuota(options);
+    async executeWithRetries(processor, provider, env, product, input) {
+        const maxRetries = provider.retries || 2;
+        let lastError = null;
+        let retriesUsed = 0;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                // Execute app action via processor
+                const result = await processor.processAction({
+                    env,
+                    product,
+                    app: provider.app,
+                    action: provider.event,
+                    input,
+                    retries: 0, // We handle retries
+                });
+                return { data: result, retriesUsed };
+            }
+            catch (error) {
+                lastError = error;
+                retriesUsed++;
+                if (attempt < maxRetries) {
+                    // Exponential backoff: 50ms, 100ms, 200ms (capped at 2s for low latency)
+                    await new Promise(r => setTimeout(r, Math.min(50 * Math.pow(2, attempt), 2000)));
+                }
+            }
+        }
+        throw new QuotaError(`All ${maxRetries + 1} attempts failed. Last error: ${lastError === null || lastError === void 0 ? void 0 : lastError.message}`, 'ALL_RETRIES_FAILED', { lastError, retriesUsed });
     }
     /**
-     * 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.
      */
     async dispatch(options) {
-        return await this.apiService.dispatchQuota(options);
+        const { product, tag } = options;
+        const jobId = `quota_${tag}_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        // For deferred execution, we run the quota asynchronously
+        // The job queue integration would be implemented based on your queue system
+        setImmediate(async () => {
+            try {
+                await this.run(options);
+            }
+            catch (error) {
+                console.error(`Deferred quota execution failed for ${product}:${tag}:`, error);
+            }
+        });
+        return { jobId };
     }
 }
 exports.QuotaService = QuotaService;