@pvh-afl/core 1.1.6 → 1.1.8

package/dist/integrations/commerce/shopify-admin.service.js

@@ -9,359 +9,373 @@ const logger_1 = require("../../common/logger");
  * Shopify Admin API Service
  *
  * Handles Shopify Admin API operations for discount code management.
- * Uses REST Admin API for price rules and discount codes.
+ * Uses GraphQL Admin API for discount operations with tags support.
+ *
+ * Migration from REST to GraphQL (2024):
+ * - REST: price_rules + discount_codes endpoints
+ * - GraphQL: discountCodeBasic mutations with tags support
+ *
+ * All Capillary-synced discounts are tagged with "CAPILLARY" for easy identification.
  */
 let ShopifyAdminService = class ShopifyAdminService {
     configService;
-    API_VERSION = '2024-01';
+    GRAPHQL_API_VERSION = '2026-04';
+    CAPILLARY_TAG = 'CAPILLARY';
     constructor(configService) {
         this.configService = configService;
     }
     /**
      * Create a Shopify discount code from a validated Capillary coupon.
      *
-     * New behavior (no CAP_ prefix):
+     * Behavior:
      * - Uses original Capillary code directly (e.g., "SUMMER20")
-     * - If code exists: adds customer to prerequisite_customer_ids array
-     * - If code doesn't exist: creates with customer in prerequisite_customer_ids
-     * - Uses once_per_customer: true for per-customer usage limit
+     * - If code exists: updates properties from Capillary and adds customer to eligibility
+     * - If code doesn't exist: creates with customer-specific eligibility
+     * - Tags discount with "CAPILLARY" for identification
+     * - Uses appliesOncePerCustomer: true for per-customer usage limit
      */
     async createDiscountFromCapillaryCoupon(brand, capillaryValidation, shopifyCustomerId) {
-        // Use original code directly - no prefix, no suffix
         const shopifyCode = capillaryValidation.couponCode;
         // Check if discount code already exists
         const existing = await this.getDiscountCodeByCode(brand, shopifyCode);
         if (existing) {
-            // Discount code exists - add customer to the price rule's prerequisite_customer_ids
-            logger_1.logger.info('Shopify discount code exists, adding customer to eligibility', {
+            // Discount code exists - update properties and add customer to eligibility
+            logger_1.logger.info('Shopify discount code exists, updating properties and adding customer', {
                 brand,
                 shopifyCode,
                 shopifyCustomerId,
+                discountId: existing.discountId,
             });
-            const addResult = await this.addCustomerToPriceRule(brand, existing.priceRuleId, shopifyCustomerId);
-            if (!addResult.success) {
+            const updateResult = await this.updateDiscountWithCapillaryData(brand, existing.discountId, capillaryValidation, shopifyCustomerId);
+            if (!updateResult.success) {
                 return {
                     success: false,
                     discountCode: shopifyCode,
-                    priceRuleId: existing.priceRuleId,
-                    error: addResult.error,
+                    discountId: existing.discountId,
+                    error: updateResult.error,
                 };
             }
             return {
                 success: true,
                 discountCode: shopifyCode,
-                priceRuleId: existing.priceRuleId,
-                discountCodeId: existing.discountCodeId,
+                discountId: existing.discountId,
                 alreadyExists: true,
             };
         }
-        // Discount code doesn't exist - create new price rule and discount code
-        logger_1.logger.info('Creating new Shopify discount code', {
+        // Discount code doesn't exist - create new discount
+        logger_1.logger.info('Creating new Shopify discount code via GraphQL', {
             brand,
             shopifyCode,
             shopifyCustomerId,
         });
-        // Extract numeric customer ID if it's a GID
-        const numericCustomerId = this.extractNumericCustomerId(shopifyCustomerId);
-        const priceRuleConfig = {
-            title: shopifyCode,
-            valueType: capillaryValidation.discountType === 'PERC' ? 'percentage' : 'fixed_amount',
-            value: -capillaryValidation.discountValue,
-            usageLimit: capillaryValidation.redemptionsLeft ?? 1,
-            oncePerCustomer: true,
-            startsAt: capillaryValidation.validFrom
-                ? new Date(capillaryValidation.validFrom).toISOString()
-                : new Date().toISOString(),
-            endsAt: capillaryValidation.validTill,
-            allocationMethod: 'across',
-            targetType: 'line_item',
-            targetSelection: 'all',
-            customerSelection: 'prerequisite',
-            prerequisiteCustomerIds: [numericCustomerId],
-        };
-        const priceRule = await this.createPriceRule(brand, priceRuleConfig);
-        if (!priceRule.success) {
-            return {
-                success: false,
-                discountCode: shopifyCode,
-                error: priceRule.error,
-            };
-        }
-        const discountCode = await this.createDiscountCode(brand, priceRule.priceRuleId, shopifyCode);
-        if (!discountCode.success) {
+        // Format customer ID as GID if needed
+        const customerGid = this.formatCustomerGid(shopifyCustomerId);
+        const createResult = await this.createDiscountViaGraphQL(brand, shopifyCode, capillaryValidation, customerGid);
+        if (!createResult.success) {
             return {
                 success: false,
                 discountCode: shopifyCode,
-                priceRuleId: priceRule.priceRuleId,
-                error: discountCode.error,
+                error: createResult.error,
             };
         }
-        logger_1.logger.info('Shopify discount code created', {
+        logger_1.logger.info('Shopify discount code created via GraphQL', {
             brand,
             shopifyCode,
-            priceRuleId: priceRule.priceRuleId,
-            discountCodeId: discountCode.discountCodeId,
+            discountId: createResult.discountId,
         });
         return {
             success: true,
             discountCode: shopifyCode,
-            priceRuleId: priceRule.priceRuleId,
-            discountCodeId: discountCode.discountCodeId,
+            discountId: createResult.discountId,
         };
     }
     /**
-     * Add a customer to an existing price rule's prerequisite_customer_ids.
-     * Used when multiple customers share the same Capillary coupon code.
+     * Create a new discount via GraphQL Admin API.
      */
-    async addCustomerToPriceRule(brand, priceRuleId, shopifyCustomerId) {
+    async createDiscountViaGraphQL(brand, code, capillaryValidation, customerGid) {
         const config = this.getAdminConfig(brand);
-        const priceRuleUrl = `${config.baseUrl}/price_rules/${priceRuleId}.json`;
+        const mutation = `
+      mutation discountCodeBasicCreate($basicCodeDiscount: DiscountCodeBasicInput!) {
+        discountCodeBasicCreate(basicCodeDiscount: $basicCodeDiscount) {
+          codeDiscountNode {
+            id
+          }
+          userErrors {
+            field
+            message
+          }
+        }
+      }
+    `;
+        // Build discount value based on type
+        const discountValue = this.buildDiscountValue(capillaryValidation);
+        const variables = {
+            basicCodeDiscount: {
+                title: code,
+                code: code,
+                startsAt: capillaryValidation.validFrom
+                    ? new Date(capillaryValidation.validFrom).toISOString()
+                    : new Date().toISOString(),
+                endsAt: capillaryValidation.validTill
+                    ? new Date(capillaryValidation.validTill).toISOString()
+                    : null,
+                usageLimit: capillaryValidation.redemptionsLeft ?? 1,
+                appliesOncePerCustomer: true,
+                tags: [this.CAPILLARY_TAG],
+                customerGets: {
+                    value: discountValue,
+                    items: { all: true },
+                },
+                context: {
+                    customers: {
+                        add: [customerGid],
+                    },
+                },
+            },
+        };
         try {
-            // Get current price rule
-            const getResponse = await fetch(priceRuleUrl, {
-                method: 'GET',
-                headers: this.getHeaders(config),
-            });
-            if (!getResponse.ok) {
-                const errorText = await getResponse.text();
-                logger_1.logger.error('Failed to get price rule for customer addition', {
-                    brand,
-                    priceRuleId,
-                    error: errorText,
-                });
-                return { success: false, error: `Failed to get price rule: ${getResponse.status}` };
-            }
-            const priceRuleData = (await getResponse.json());
-            // Extract numeric customer ID
-            const numericCustomerId = parseInt(this.extractNumericCustomerId(shopifyCustomerId), 10);
-            // Get existing customer IDs
-            const existingCustomerIds = priceRuleData.price_rule.prerequisite_customer_ids ?? [];
-            // Check if customer already exists
-            if (existingCustomerIds.includes(numericCustomerId)) {
-                logger_1.logger.info('Customer already in price rule prerequisite_customer_ids', {
-                    brand,
-                    priceRuleId,
-                    shopifyCustomerId,
-                });
-                return { success: true };
+            const response = await this.executeGraphQL(config, mutation, variables);
+            if (response.errors && response.errors.length > 0) {
+                const errorMsg = response.errors.map((e) => e.message).join(', ');
+                logger_1.logger.error('GraphQL errors creating discount', { brand, code, errors: response.errors });
+                return { success: false, error: errorMsg };
             }
-            // Add customer to the array (never remove)
-            const updatedCustomerIds = [...existingCustomerIds, numericCustomerId];
-            // Update price rule
-            const updateResponse = await fetch(priceRuleUrl, {
-                method: 'PUT',
-                headers: this.getHeaders(config),
-                body: JSON.stringify({
-                    price_rule: {
-                        prerequisite_customer_ids: updatedCustomerIds,
-                        customer_selection: 'prerequisite',
-                    },
-                }),
-            });
-            if (!updateResponse.ok) {
-                const errorText = await updateResponse.text();
-                logger_1.logger.error('Failed to update price rule with new customer', {
-                    brand,
-                    priceRuleId,
-                    shopifyCustomerId,
-                    numericCustomerId,
-                    status: updateResponse.status,
-                    error: errorText,
-                });
-                // Include actual error details in response
-                let errorDetail = `Failed to update price rule: ${updateResponse.status}`;
-                try {
-                    const errorJson = JSON.parse(errorText);
-                    if (errorJson.errors) {
-                        errorDetail = `Shopify error: ${JSON.stringify(errorJson.errors)}`;
-                    }
-                }
-                catch {
-                    // errorText is not JSON
-                }
-                return { success: false, error: errorDetail };
+            const result = response.data?.discountCodeBasicCreate;
+            if (result?.userErrors && result.userErrors.length > 0) {
+                const errorMsg = result.userErrors.map((e) => e.message).join(', ');
+                logger_1.logger.error('User errors creating discount', { brand, code, userErrors: result.userErrors });
+                return { success: false, error: errorMsg };
             }
-            logger_1.logger.info('Customer added to price rule prerequisite_customer_ids', {
-                brand,
-                priceRuleId,
-                shopifyCustomerId,
-                totalCustomers: updatedCustomerIds.length,
-            });
-            return { success: true };
+            return {
+                success: true,
+                discountId: result?.codeDiscountNode?.id,
+            };
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-            logger_1.logger.error('Error adding customer to price rule', {
-                brand,
-                priceRuleId,
-                shopifyCustomerId,
-                error: errorMsg,
-            });
+            logger_1.logger.error('Failed to create discount via GraphQL', { brand, code, error: errorMsg });
             return { success: false, error: errorMsg };
         }
     }
     /**
-     * Extract numeric customer ID from Shopify GID or return as-is if already numeric.
+     * Update an existing discount with fresh Capillary data and add customer.
+     * This resolves the stale data issue by always syncing latest properties.
      */
-    extractNumericCustomerId(shopifyCustomerId) {
-        if (shopifyCustomerId.startsWith('gid://shopify/Customer/')) {
-            const match = shopifyCustomerId.match(/\/(\d+)$/);
-            return match ? match[1] : shopifyCustomerId;
-        }
-        return shopifyCustomerId;
-    }
-    async createPriceRule(brand, params) {
+    async updateDiscountWithCapillaryData(brand, discountId, capillaryValidation, shopifyCustomerId) {
         const config = this.getAdminConfig(brand);
-        const url = `${config.baseUrl}/price_rules.json`;
-        const body = {
-            price_rule: {
-                title: params.title,
-                target_type: params.targetType,
-                target_selection: params.targetSelection,
-                allocation_method: params.allocationMethod,
-                value_type: params.valueType,
-                value: params.value.toString(),
-                customer_selection: params.customerSelection,
-                prerequisite_customer_ids: params.prerequisiteCustomerIds,
-                usage_limit: params.usageLimit,
-                once_per_customer: params.oncePerCustomer ?? true,
-                starts_at: params.startsAt,
-                ends_at: params.endsAt,
+        const customerGid = this.formatCustomerGid(shopifyCustomerId);
+        const mutation = `
+      mutation discountCodeBasicUpdate($id: ID!, $basicCodeDiscount: DiscountCodeBasicInput!) {
+        discountCodeBasicUpdate(id: $id, basicCodeDiscount: $basicCodeDiscount) {
+          codeDiscountNode {
+            id
+          }
+          userErrors {
+            field
+            message
+          }
+        }
+      }
+    `;
+        // Build discount value based on type
+        const discountValue = this.buildDiscountValue(capillaryValidation);
+        const variables = {
+            id: discountId,
+            basicCodeDiscount: {
+                // Update properties from fresh Capillary validation
+                endsAt: capillaryValidation.validTill
+                    ? new Date(capillaryValidation.validTill).toISOString()
+                    : null,
+                usageLimit: capillaryValidation.redemptionsLeft ?? 1,
+                customerGets: {
+                    value: discountValue,
+                    items: { all: true },
+                },
+                // Add customer to eligibility
+                context: {
+                    customers: {
+                        add: [customerGid],
+                    },
+                },
             },
         };
         try {
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: this.getHeaders(config),
-                body: JSON.stringify(body),
-            });
-            if (!response.ok) {
-                const errorData = (await response.json());
-                const errorMsg = errorData.errors
-                    ? JSON.stringify(errorData.errors)
-                    : `HTTP ${response.status}`;
-                if (response.status === 422 && errorMsg.includes('title')) {
-                    logger_1.logger.warn('Price rule naming collision, looking up existing', { brand, title: params.title });
-                    const existing = await this.findPriceRuleByTitle(brand, params.title);
-                    if (existing) {
-                        return { success: true, priceRuleId: existing };
-                    }
-                }
-                logger_1.logger.error('Failed to create Shopify price rule', { brand, error: errorMsg });
+            const response = await this.executeGraphQL(config, mutation, variables);
+            if (response.errors && response.errors.length > 0) {
+                const errorMsg = response.errors.map((e) => e.message).join(', ');
+                logger_1.logger.error('GraphQL errors updating discount', { brand, discountId, errors: response.errors });
                 return { success: false, error: errorMsg };
             }
-            const data = (await response.json());
-            return {
-                success: true,
-                priceRuleId: data.price_rule.id.toString(),
-            };
+            const result = response.data?.discountCodeBasicUpdate;
+            if (result?.userErrors && result.userErrors.length > 0) {
+                const errorMsg = result.userErrors.map((e) => e.message).join(', ');
+                logger_1.logger.error('User errors updating discount', { brand, discountId, userErrors: result.userErrors });
+                return { success: false, error: errorMsg };
+            }
+            logger_1.logger.info('Discount updated with fresh Capillary data', {
+                brand,
+                discountId,
+                shopifyCustomerId,
+                endsAt: capillaryValidation.validTill,
+                discountValue: capillaryValidation.discountValue,
+            });
+            return { success: true };
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-            logger_1.logger.error('Shopify price rule creation failed', { brand, error: errorMsg });
+            logger_1.logger.error('Failed to update discount via GraphQL', { brand, discountId, error: errorMsg });
             return { success: false, error: errorMsg };
         }
     }
-    async createDiscountCode(brand, priceRuleId, code) {
+    /**
+     * Build discount value object based on Capillary discount type.
+     */
+    buildDiscountValue(capillaryValidation) {
+        if (capillaryValidation.discountType === 'PERC') {
+            // GraphQL expects percentage as decimal (0.10 for 10%)
+            return { percentage: (capillaryValidation.discountValue ?? 0) / 100 };
+        }
+        else {
+            // Fixed amount discount
+            return {
+                discountAmount: {
+                    amount: capillaryValidation.discountValue ?? 0,
+                    appliesOnEachItem: false,
+                },
+            };
+        }
+    }
+    /**
+     * Add a customer to an existing discount's eligibility.
+     * Used when multiple customers share the same Capillary coupon code.
+     *
+     * @deprecated Use updateDiscountWithCapillaryData instead which also updates properties
+     */
+    async addCustomerToPriceRule(brand, priceRuleId, shopifyCustomerId) {
+        // For backwards compatibility, map priceRuleId to discountId
+        // In the new GraphQL model, we use discount GIDs
+        const discountId = priceRuleId.startsWith('gid://')
+            ? priceRuleId
+            : `gid://shopify/DiscountCodeNode/${priceRuleId}`;
+        return this.addCustomerToDiscount(brand, discountId, shopifyCustomerId);
+    }
+    /**
+     * Add a customer to an existing discount's eligibility.
+     */
+    async addCustomerToDiscount(brand, discountId, shopifyCustomerId) {
         const config = this.getAdminConfig(brand);
-        const url = `${config.baseUrl}/price_rules/${priceRuleId}/discount_codes.json`;
-        const body = {
-            discount_code: {
-                code,
+        const customerGid = this.formatCustomerGid(shopifyCustomerId);
+        const mutation = `
+      mutation discountCodeBasicUpdate($id: ID!, $basicCodeDiscount: DiscountCodeBasicInput!) {
+        discountCodeBasicUpdate(id: $id, basicCodeDiscount: $basicCodeDiscount) {
+          codeDiscountNode {
+            id
+          }
+          userErrors {
+            field
+            message
+          }
+        }
+      }
+    `;
+        const variables = {
+            id: discountId,
+            basicCodeDiscount: {
+                context: {
+                    customers: {
+                        add: [customerGid],
+                    },
+                },
             },
         };
         try {
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: this.getHeaders(config),
-                body: JSON.stringify(body),
-            });
-            if (!response.ok) {
-                const errorData = (await response.json());
-                const errorMsg = errorData.errors
-                    ? JSON.stringify(errorData.errors)
-                    : `HTTP ${response.status}`;
-                if (response.status === 422 && errorMsg.includes('code')) {
-                    logger_1.logger.warn('Discount code already exists', { brand, code, priceRuleId });
-                    const existing = await this.findDiscountCodeByCode(brand, priceRuleId, code);
-                    if (existing) {
-                        return { success: true, discountCodeId: existing };
-                    }
-                }
-                logger_1.logger.error('Failed to create Shopify discount code', { brand, error: errorMsg });
+            const response = await this.executeGraphQL(config, mutation, variables);
+            if (response.errors && response.errors.length > 0) {
+                const errorMsg = response.errors.map((e) => e.message).join(', ');
+                logger_1.logger.error('GraphQL errors adding customer to discount', { brand, discountId, errors: response.errors });
                 return { success: false, error: errorMsg };
             }
-            const data = (await response.json());
-            return {
-                success: true,
-                discountCodeId: data.discount_code.id.toString(),
-            };
+            const result = response.data?.discountCodeBasicUpdate;
+            if (result?.userErrors && result.userErrors.length > 0) {
+                const errorMsg = result.userErrors.map((e) => e.message).join(', ');
+                logger_1.logger.error('User errors adding customer to discount', { brand, discountId, userErrors: result.userErrors });
+                return { success: false, error: errorMsg };
+            }
+            logger_1.logger.info('Customer added to discount eligibility', {
+                brand,
+                discountId,
+                shopifyCustomerId,
+            });
+            return { success: true };
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-            logger_1.logger.error('Shopify discount code creation failed', { brand, error: errorMsg });
+            logger_1.logger.error('Failed to add customer to discount', { brand, discountId, error: errorMsg });
             return { success: false, error: errorMsg };
         }
     }
-    async getDiscountCodeByCode(brand, code) {
-        const config = this.getAdminConfig(brand);
-        const url = `${config.baseUrl}/discount_codes/lookup.json?code=${encodeURIComponent(code)}`;
-        try {
-            const response = await fetch(url, {
-                method: 'GET',
-                headers: this.getHeaders(config),
-            });
-            if (!response.ok) {
-                return null;
-            }
-            const data = (await response.json());
-            if (data.discount_code) {
-                return {
-                    priceRuleId: data.discount_code.price_rule_id.toString(),
-                    discountCodeId: data.discount_code.id.toString(),
-                };
-            }
-            return null;
+    /**
+     * Format customer ID as Shopify GID.
+     */
+    formatCustomerGid(shopifyCustomerId) {
+        if (shopifyCustomerId.startsWith('gid://shopify/Customer/')) {
+            return shopifyCustomerId;
         }
-        catch {
-            return null;
+        // Extract numeric ID if needed
+        const numericId = shopifyCustomerId.replace(/\D/g, '');
+        return `gid://shopify/Customer/${numericId}`;
+    }
+    /**
+     * Extract numeric ID from Shopify GID or return as-is if already numeric.
+     *
+     * @deprecated Use formatCustomerGid instead for GID format
+     */
+    extractNumericCustomerId(shopifyCustomerId) {
+        if (shopifyCustomerId.startsWith('gid://shopify/Customer/')) {
+            const match = shopifyCustomerId.match(/\/(\d+)$/);
+            return match ? match[1] : shopifyCustomerId;
         }
+        return shopifyCustomerId;
     }
-    async findPriceRuleByTitle(brand, title) {
+    /**
+     * Lookup discount code by code string.
+     * Returns discount ID if found, null otherwise.
+     */
+    async getDiscountCodeByCode(brand, code) {
         const config = this.getAdminConfig(brand);
-        const url = `${config.baseUrl}/price_rules.json?limit=250`;
-        try {
-            const response = await fetch(url, {
-                method: 'GET',
-                headers: this.getHeaders(config),
-            });
-            if (!response.ok) {
-                return null;
+        const query = `
+      query codeDiscountNodeByCode($code: String!) {
+        codeDiscountNodeByCode(code: $code) {
+          id
+          codeDiscount {
+            ... on DiscountCodeBasic {
+              title
+              tags
             }
-            const data = (await response.json());
-            const rule = data.price_rules?.find((r) => r.title === title);
-            return rule ? rule.id.toString() : null;
+          }
         }
-        catch {
-            return null;
-        }
-    }
-    async findDiscountCodeByCode(brand, priceRuleId, code) {
-        const config = this.getAdminConfig(brand);
-        const url = `${config.baseUrl}/price_rules/${priceRuleId}/discount_codes.json`;
+      }
+    `;
         try {
-            const response = await fetch(url, {
-                method: 'GET',
-                headers: this.getHeaders(config),
-            });
-            if (!response.ok) {
+            const response = await this.executeGraphQL(config, query, { code });
+            if (response.errors && response.errors.length > 0) {
+                logger_1.logger.warn('GraphQL errors looking up discount', { brand, code, errors: response.errors });
                 return null;
             }
-            const data = (await response.json());
-            const dc = data.discount_codes?.find((d) => d.code === code);
-            return dc ? dc.id.toString() : null;
+            const node = response.data?.codeDiscountNodeByCode;
+            if (node?.id) {
+                // For backwards compatibility, extract numeric ID for priceRuleId/discountCodeId
+                const numericId = node.id.match(/\/(\d+)$/)?.[1] ?? node.id;
+                return {
+                    discountId: node.id,
+                    priceRuleId: numericId, // Legacy field for backwards compatibility
+                    discountCodeId: numericId, // Legacy field for backwards compatibility
+                };
+            }
+            return null;
         }
-        catch {
+        catch (error) {
+            logger_1.logger.warn('Failed to lookup discount code', { brand, code, error });
             return null;
         }
     }
@@ -371,18 +385,47 @@ let ShopifyAdminService = class ShopifyAdminService {
         if (!adminConfig) {
             throw new Error(`Shopify Admin API not configured for brand: ${brand}`);
         }
+        // Build GraphQL URL from base URL
+        // baseUrl format: https://store.myshopify.com/admin/api/VERSION
+        // graphqlUrl format: https://store.myshopify.com/admin/api/VERSION/graphql.json
+        let graphqlUrl = adminConfig.baseUrl;
+        // Replace version in URL with GraphQL version
+        graphqlUrl = graphqlUrl.replace(/\/api\/[^/]+/, `/api/${this.GRAPHQL_API_VERSION}`);
+        // Ensure it ends with graphql.json
+        if (!graphqlUrl.endsWith('/graphql.json')) {
+            graphqlUrl = graphqlUrl.replace(/\/?$/, '/graphql.json');
+        }
         return {
-            baseUrl: `${adminConfig.baseUrl}`,
+            baseUrl: adminConfig.baseUrl,
+            graphqlUrl,
             apiKey: adminConfig.apiKey,
             webhookSecret: adminConfig.options?.webhookSecret,
         };
     }
+    /**
+     * Execute a GraphQL query/mutation against Shopify Admin API.
+     */
+    async executeGraphQL(config, query, variables) {
+        const response = await fetch(config.graphqlUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Shopify-Access-Token': config.apiKey,
+            },
+            body: JSON.stringify({ query, variables }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`GraphQL request failed: ${response.status} - ${errorText}`);
+        }
+        return response.json();
+    }
     getWebhookSecret(brand) {
         const config = this.getAdminConfig(brand);
         return config.webhookSecret;
     }
     /**
-     * Reactivate a Shopify discount code by resetting its usage count.
+     * Reactivate a Shopify discount code by extending its end date and usage limit.
      * Used when a redeemed coupon needs to be returned to the user (refund/cancellation).
      */
     async reactivateDiscountCode(brand, discountCode) {
@@ -395,77 +438,86 @@ let ShopifyAdminService = class ShopifyAdminService {
             };
         }
         const config = this.getAdminConfig(brand);
-        // Update the price rule to reset usage and ensure it's enabled
-        const priceRuleUrl = `${config.baseUrl}/price_rules/${existing.priceRuleId}.json`;
+        // First, get current discount state
+        const getQuery = `
+      query getDiscount($id: ID!) {
+        discountNode(id: $id) {
+          ... on DiscountCodeNode {
+            codeDiscount {
+              ... on DiscountCodeBasic {
+                usageLimit
+                endsAt
+              }
+            }
+          }
+        }
+      }
+    `;
         try {
-            // First, get current price rule to check its state
-            const getResponse = await fetch(priceRuleUrl, {
-                method: 'GET',
-                headers: this.getHeaders(config),
-            });
-            if (!getResponse.ok) {
-                logger_1.logger.error('Failed to get price rule for reactivation', {
-                    brand,
-                    discountCode,
-                    priceRuleId: existing.priceRuleId,
-                });
+            const getResponse = await this.executeGraphQL(config, getQuery, { id: existing.discountId });
+            if (getResponse.errors && getResponse.errors.length > 0) {
+                logger_1.logger.error('Failed to get discount for reactivation', { brand, discountCode, errors: getResponse.errors });
                 return {
                     success: false,
                     discountCode,
-                    error: `Failed to get price rule: ${getResponse.status}`,
+                    error: `Failed to get discount: ${getResponse.errors[0].message}`,
                 };
             }
-            const priceRuleData = (await getResponse.json());
-            // Update price rule: increment usage_limit by 1 to allow one more use
-            // and extend end date if it has passed
-            const currentUsageLimit = priceRuleData.price_rule.usage_limit || 1;
-            const newEndDate = this.getExtendedEndDate(priceRuleData.price_rule.ends_at);
-            const updateResponse = await fetch(priceRuleUrl, {
-                method: 'PUT',
-                headers: this.getHeaders(config),
-                body: JSON.stringify({
-                    price_rule: {
-                        usage_limit: currentUsageLimit + 1,
-                        ...(newEndDate && { ends_at: newEndDate }),
-                    },
-                }),
-            });
-            if (!updateResponse.ok) {
-                const errorText = await updateResponse.text();
-                logger_1.logger.error('Failed to update price rule for reactivation', {
-                    brand,
-                    discountCode,
-                    error: errorText,
-                });
-                return {
-                    success: false,
-                    discountCode,
-                    error: `Failed to update price rule: ${updateResponse.status}`,
-                };
+            const currentDiscount = getResponse.data?.discountNode?.codeDiscount;
+            const currentUsageLimit = currentDiscount?.usageLimit ?? 1;
+            const currentEndsAt = currentDiscount?.endsAt;
+            // Calculate new values
+            const newUsageLimit = currentUsageLimit + 1;
+            const newEndsAt = this.getExtendedEndDate(currentEndsAt);
+            // Update discount
+            const updateMutation = `
+        mutation discountCodeBasicUpdate($id: ID!, $basicCodeDiscount: DiscountCodeBasicInput!) {
+          discountCodeBasicUpdate(id: $id, basicCodeDiscount: $basicCodeDiscount) {
+            codeDiscountNode {
+              id
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `;
+            const updateVariables = {
+                id: existing.discountId,
+                basicCodeDiscount: {
+                    usageLimit: newUsageLimit,
+                    ...(newEndsAt && { endsAt: newEndsAt }),
+                },
+            };
+            const updateResponse = await this.executeGraphQL(config, updateMutation, updateVariables);
+            if (updateResponse.errors && updateResponse.errors.length > 0) {
+                const errorMsg = updateResponse.errors.map((e) => e.message).join(', ');
+                logger_1.logger.error('Failed to reactivate discount', { brand, discountCode, errors: updateResponse.errors });
+                return { success: false, discountCode, error: errorMsg };
+            }
+            const result = updateResponse.data?.discountCodeBasicUpdate;
+            if (result?.userErrors && result.userErrors.length > 0) {
+                const errorMsg = result.userErrors.map((e) => e.message).join(', ');
+                logger_1.logger.error('User errors reactivating discount', { brand, discountCode, userErrors: result.userErrors });
+                return { success: false, discountCode, error: errorMsg };
             }
             logger_1.logger.info('Shopify discount code reactivated', {
                 brand,
                 discountCode,
-                priceRuleId: existing.priceRuleId,
-                newUsageLimit: currentUsageLimit + 1,
+                discountId: existing.discountId,
+                newUsageLimit,
             });
-            return {
-                success: true,
-                discountCode,
-            };
+            return { success: true, discountCode };
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : 'Unknown error';
             logger_1.logger.error('Discount code reactivation failed', { brand, discountCode, error: errorMsg });
-            return {
-                success: false,
-                discountCode,
-                error: errorMsg,
-            };
+            return { success: false, discountCode, error: errorMsg };
         }
     }
     /**
-     * Disable or delete a Shopify discount code.
+     * Disable/delete a Shopify discount code.
      * Used when an earned coupon needs to be revoked (refund/cancellation).
      */
     async disableDiscountCode(brand, discountCode) {
@@ -481,43 +533,34 @@ let ShopifyAdminService = class ShopifyAdminService {
             };
         }
         const config = this.getAdminConfig(brand);
+        const mutation = `
+      mutation discountCodeDelete($id: ID!) {
+        discountCodeDelete(id: $id) {
+          deletedCodeDiscountId
+          userErrors {
+            field
+            message
+          }
+        }
+      }
+    `;
         try {
-            // Delete the discount code
-            const deleteCodeUrl = `${config.baseUrl}/price_rules/${existing.priceRuleId}/discount_codes/${existing.discountCodeId}.json`;
-            const deleteCodeResponse = await fetch(deleteCodeUrl, {
-                method: 'DELETE',
-                headers: this.getHeaders(config),
-            });
-            if (!deleteCodeResponse.ok && deleteCodeResponse.status !== 404) {
-                logger_1.logger.error('Failed to delete discount code', {
-                    brand,
-                    discountCode,
-                    status: deleteCodeResponse.status,
-                });
-                return {
-                    success: false,
-                    discountCode,
-                    error: `Failed to delete discount code: ${deleteCodeResponse.status}`,
-                };
+            const response = await this.executeGraphQL(config, mutation, { id: existing.discountId });
+            if (response.errors && response.errors.length > 0) {
+                const errorMsg = response.errors.map((e) => e.message).join(', ');
+                logger_1.logger.error('Failed to delete discount', { brand, discountCode, errors: response.errors });
+                return { success: false, discountCode, error: errorMsg };
             }
-            // Also delete the price rule since it's customer-specific and no longer needed
-            const deletePriceRuleUrl = `${config.baseUrl}/price_rules/${existing.priceRuleId}.json`;
-            const deletePriceRuleResponse = await fetch(deletePriceRuleUrl, {
-                method: 'DELETE',
-                headers: this.getHeaders(config),
-            });
-            if (!deletePriceRuleResponse.ok && deletePriceRuleResponse.status !== 404) {
-                logger_1.logger.warn('Failed to delete price rule (discount code was deleted)', {
-                    brand,
-                    discountCode,
-                    priceRuleId: existing.priceRuleId,
-                });
+            const result = response.data?.discountCodeDelete;
+            if (result?.userErrors && result.userErrors.length > 0) {
+                const errorMsg = result.userErrors.map((e) => e.message).join(', ');
+                logger_1.logger.error('User errors deleting discount', { brand, discountCode, userErrors: result.userErrors });
+                return { success: false, discountCode, error: errorMsg };
             }
-            logger_1.logger.info('Shopify discount code disabled/deleted', {
+            logger_1.logger.info('Shopify discount code deleted', {
                 brand,
                 discountCode,
-                priceRuleId: existing.priceRuleId,
-                discountCodeId: existing.discountCodeId,
+                discountId: existing.discountId,
             });
             return {
                 success: true,
@@ -527,23 +570,148 @@ let ShopifyAdminService = class ShopifyAdminService {
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-            logger_1.logger.error('Discount code disable failed', { brand, discountCode, error: errorMsg });
-            return {
-                success: false,
-                discountCode,
-                error: errorMsg,
-            };
+            logger_1.logger.error('Discount code delete failed', { brand, discountCode, error: errorMsg });
+            return { success: false, discountCode, error: errorMsg };
+        }
+    }
+    /**
+     * Get active Shopify discount codes filtered by tag.
+     * Returns discounts with code, title, discount type/value, validity dates, and tags.
+     */
+    async getDiscountsByTag(brand, tag, limit = 50) {
+        const config = this.getAdminConfig(brand);
+        const query = `
+      query discountNodes($query: String!, $first: Int!) {
+        discountNodes(first: $first, query: $query) {
+          nodes {
+            id
+            discount {
+              ... on DiscountCodeBasic {
+                title
+                startsAt
+                endsAt
+                usageLimit
+                minimumRequirement {
+                  ... on DiscountMinimumSubtotal {
+                    greaterThanOrEqualToSubtotal {
+                      amount
+                    }
+                  }
+                }
+                customerGets {
+                  value {
+                    ... on DiscountPercentage {
+                      percentage
+                    }
+                    ... on DiscountAmount {
+                      amount {
+                        amount
+                      }
+                    }
+                  }
+                  appliesOnOneTimePurchase
+                }
+                codes(first: 1) {
+                  nodes {
+                    code
+                  }
+                }
+              }
+            }
+            metafield(namespace: "custom", key: "discount_upto") {
+              value
+            }
+          }
+        }
+      }
+    `;
+        const searchQuery = `tag:${tag} AND status:ACTIVE`;
+        try {
+            const response = await this.executeGraphQL(config, query, {
+                query: searchQuery,
+                first: limit,
+            });
+            if (response.errors && response.errors.length > 0) {
+                logger_1.logger.error('GraphQL errors fetching discounts by tag', { brand, tag, errors: response.errors });
+                return [];
+            }
+            const nodes = response.data?.discountNodes?.nodes ?? [];
+            const discounts = [];
+            for (const node of nodes) {
+                const discount = node.discount;
+                if (!discount)
+                    continue;
+                // Extract code from codes array
+                const code = discount.codes?.nodes?.[0]?.code;
+                if (!code)
+                    continue;
+                // Determine discount type and value
+                let discountType = 'ABS';
+                let discountValue = 0;
+                const customerGetsValue = discount.customerGets?.value;
+                if (customerGetsValue) {
+                    if ('percentage' in customerGetsValue && customerGetsValue.percentage !== undefined) {
+                        discountType = 'PERC';
+                        // Shopify stores percentage as decimal (0.10 for 10%)
+                        discountValue = customerGetsValue.percentage * 100;
+                    }
+                    else if ('amount' in customerGetsValue && customerGetsValue.amount?.amount !== undefined) {
+                        discountType = 'ABS';
+                        discountValue = parseFloat(customerGetsValue.amount.amount);
+                    }
+                }
+                // Extract minimum order value
+                let minOrderValue;
+                const minReq = discount.minimumRequirement;
+                if (minReq && 'greaterThanOrEqualToSubtotal' in minReq) {
+                    const subtotal = minReq.greaterThanOrEqualToSubtotal?.amount;
+                    if (subtotal) {
+                        minOrderValue = parseFloat(subtotal);
+                    }
+                }
+                // Extract discount upto from metafield
+                let discountUpto;
+                if (node.metafield?.value) {
+                    discountUpto = parseFloat(node.metafield.value);
+                }
+                // Extract tags from the node ID to get full tag list
+                // Note: We know this discount has the requested tag since we filtered by it
+                const tags = [tag]; // At minimum, it has the tag we queried for
+                discounts.push({
+                    id: node.id,
+                    code,
+                    title: discount.title ?? code,
+                    discountType,
+                    discountValue,
+                    discountUpto,
+                    minOrderValue,
+                    startsAt: discount.startsAt,
+                    endsAt: discount.endsAt ?? undefined,
+                    usageLimit: discount.usageLimit ?? undefined,
+                    tags,
+                });
+            }
+            logger_1.logger.info('Fetched discounts by tag', {
+                brand,
+                tag,
+                count: discounts.length,
+            });
+            return discounts;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            logger_1.logger.error('Failed to fetch discounts by tag', { brand, tag, error: errorMsg });
+            return [];
         }
     }
     /**
      * Sync a used Capillary coupon to Shopify for refund tracking.
-     * Creates a price rule and discount code marked as already used.
+     * Creates a discount code marked as already used (ended).
      * This is needed when GoKwik applies a coupon that doesn't exist in Shopify.
      *
      * Uses original code directly (no prefix).
      */
     async syncUsedCouponToShopify(brand, couponCode, discountType, discountValue, shopifyCustomerId, orderId) {
-        // Use original code directly - no prefix
         const shopifyCode = couponCode;
         // Check if already exists
         const existing = await this.getDiscountCodeByCode(brand, shopifyCode);
@@ -552,57 +720,80 @@ let ShopifyAdminService = class ShopifyAdminService {
             return {
                 success: true,
                 discountCode: shopifyCode,
-                priceRuleId: existing.priceRuleId,
-                discountCodeId: existing.discountCodeId,
+                discountId: existing.discountId,
                 alreadyExists: true,
             };
         }
-        // Extract numeric customer ID
-        const numericCustomerId = this.extractNumericCustomerId(shopifyCustomerId);
-        // Create price rule with usage_limit=1 and mark as already used
-        const priceRuleConfig = {
-            title: `${shopifyCode}_USED_${orderId}`,
-            valueType: discountType === 'PERC' ? 'percentage' : 'fixed_amount',
-            value: -discountValue,
-            usageLimit: 1, // Already used once
-            oncePerCustomer: true,
-            startsAt: new Date(Date.now() - 86400000).toISOString(), // Started yesterday
-            endsAt: new Date(Date.now() - 1000).toISOString(), // Already ended (prevents reuse)
-            allocationMethod: 'across',
-            targetType: 'line_item',
-            targetSelection: 'all',
-            customerSelection: 'prerequisite',
-            prerequisiteCustomerIds: [numericCustomerId],
+        const config = this.getAdminConfig(brand);
+        const customerGid = this.formatCustomerGid(shopifyCustomerId);
+        const mutation = `
+      mutation discountCodeBasicCreate($basicCodeDiscount: DiscountCodeBasicInput!) {
+        discountCodeBasicCreate(basicCodeDiscount: $basicCodeDiscount) {
+          codeDiscountNode {
+            id
+          }
+          userErrors {
+            field
+            message
+          }
+        }
+      }
+    `;
+        // Build discount value
+        const discountValueObj = discountType === 'PERC'
+            ? { percentage: discountValue / 100 }
+            : { discountAmount: { amount: discountValue, appliesOnEachItem: false } };
+        const variables = {
+            basicCodeDiscount: {
+                title: `${shopifyCode}_USED_${orderId}`,
+                code: shopifyCode,
+                startsAt: new Date(Date.now() - 86400000).toISOString(), // Started yesterday
+                endsAt: new Date(Date.now() - 1000).toISOString(), // Already ended
+                usageLimit: 1,
+                appliesOncePerCustomer: true,
+                tags: [this.CAPILLARY_TAG, 'USED'],
+                customerGets: {
+                    value: discountValueObj,
+                    items: { all: true },
+                },
+                context: {
+                    customers: {
+                        add: [customerGid],
+                    },
+                },
+            },
         };
-        const priceRule = await this.createPriceRule(brand, priceRuleConfig);
-        if (!priceRule.success) {
+        try {
+            const response = await this.executeGraphQL(config, mutation, variables);
+            if (response.errors && response.errors.length > 0) {
+                const errorMsg = response.errors.map((e) => e.message).join(', ');
+                logger_1.logger.error('Failed to sync used coupon', { brand, shopifyCode, errors: response.errors });
+                return { success: false, discountCode: shopifyCode, error: errorMsg };
+            }
+            const result = response.data?.discountCodeBasicCreate;
+            if (result?.userErrors && result.userErrors.length > 0) {
+                const errorMsg = result.userErrors.map((e) => e.message).join(', ');
+                logger_1.logger.error('User errors syncing used coupon', { brand, shopifyCode, userErrors: result.userErrors });
+                return { success: false, discountCode: shopifyCode, error: errorMsg };
+            }
+            const discountId = result?.codeDiscountNode?.id;
+            logger_1.logger.info('Synced used coupon to Shopify for refund tracking', {
+                brand,
+                shopifyCode,
+                orderId,
+                discountId,
+            });
             return {
-                success: false,
+                success: true,
                 discountCode: shopifyCode,
-                error: priceRule.error,
+                discountId,
             };
         }
-        const discountCodeResult = await this.createDiscountCode(brand, priceRule.priceRuleId, shopifyCode);
-        if (!discountCodeResult.success) {
-            return {
-                success: false,
-                discountCode: shopifyCode,
-                priceRuleId: priceRule.priceRuleId,
-                error: discountCodeResult.error,
-            };
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            logger_1.logger.error('Failed to sync used coupon', { brand, shopifyCode, error: errorMsg });
+            return { success: false, discountCode: shopifyCode, error: errorMsg };
         }
-        logger_1.logger.info('Synced used coupon to Shopify for refund tracking', {
-            brand,
-            shopifyCode,
-            orderId,
-            priceRuleId: priceRule.priceRuleId,
-        });
-        return {
-            success: true,
-            discountCode: shopifyCode,
-            priceRuleId: priceRule.priceRuleId,
-            discountCodeId: discountCodeResult.discountCodeId,
-        };
     }
     /**
      * Get extended end date for reactivating an expired discount.
@@ -621,12 +812,6 @@ let ShopifyAdminService = class ShopifyAdminService {
         }
         return null; // No need to extend
     }
-    getHeaders(config) {
-        return {
-            'Content-Type': 'application/json',
-            'X-Shopify-Access-Token': config.apiKey,
-        };
-    }
 };
 exports.ShopifyAdminService = ShopifyAdminService;
 exports.ShopifyAdminService = ShopifyAdminService = tslib_1.__decorate([