ecomcoder-cli 1.3.1 → 1.3.3

package/dist/commands/discount/service.js

@@ -0,0 +1,684 @@
+/**
+ * Discount Service Layer
+ * Business logic for discount operations
+ */
+import { shopifyGraphQL } from '../../lib/shopify-client.js';
+import { DISCOUNT_CODE_BASIC_CREATE, DISCOUNT_AUTOMATIC_BASIC_CREATE, DISCOUNT_CODE_BXGY_CREATE, DISCOUNT_AUTOMATIC_BXGY_CREATE, DISCOUNT_CODE_FREE_SHIPPING_CREATE, DISCOUNT_AUTOMATIC_FREE_SHIPPING_CREATE, CODE_DISCOUNT_NODES, AUTOMATIC_DISCOUNT_NODES, DISCOUNT_CODE_DELETE, DISCOUNT_AUTOMATIC_DELETE } from './queries.js';
+import { validateDiscountValue, validateDiscountCode, parseDateTimeInput, formatDiscountCode, formatUserErrors, formatDiscountForDisplay, buildDiscountQuery } from './utils.js';
+/**
+ * Create a basic discount (percentage or fixed amount)
+ */
+export async function createBasicDiscount(input, credentials) {
+    // Validate discount value
+    const valueValidation = validateDiscountValue(input.type, input.value);
+    if (!valueValidation.valid) {
+        return { success: false, error: valueValidation.error };
+    }
+    // Validate code (required for code discounts)
+    if (!input.automatic) {
+        if (!input.code) {
+            return { success: false, error: 'Discount code is required for code-based discounts' };
+        }
+        const codeValidation = validateDiscountCode(input.code);
+        if (!codeValidation.valid) {
+            return { success: false, error: codeValidation.error };
+        }
+    }
+    // Validate dates
+    const startsAtValidation = parseDateTimeInput(input.startsAt);
+    if (!startsAtValidation.valid) {
+        return { success: false, error: `Start date: ${startsAtValidation.error}` };
+    }
+    let endsAt;
+    if (input.endsAt) {
+        const endsAtValidation = parseDateTimeInput(input.endsAt);
+        if (!endsAtValidation.valid) {
+            return { success: false, error: `End date: ${endsAtValidation.error}` };
+        }
+        endsAt = endsAtValidation.value;
+    }
+    // Build customerGets input
+    const customerGets = {
+        items: {},
+        value: {}
+    };
+    // Set items based on target
+    if (input.target === 'all') {
+        customerGets.items.all = true;
+    }
+    else if (input.target === 'collections' && input.targetIds) {
+        customerGets.items.collections = {
+            add: input.targetIds
+        };
+    }
+    else if (input.target === 'products' && input.targetIds) {
+        customerGets.items.products = {
+            add: input.targetIds
+        };
+    }
+    else {
+        return {
+            success: false,
+            error: `Invalid target: ${input.target}. Must specify targetIds for collections/products`
+        };
+    }
+    // Set value based on type
+    if (input.type === 'percentage') {
+        customerGets.value.percentage = parseFloat(input.value.toString());
+    }
+    else {
+        customerGets.value.discountAmount = {
+            amount: input.value.toString(),
+            appliesOnEachItem: false
+        };
+    }
+    // Build minimum requirement
+    let minimumRequirement = undefined;
+    if (input.minSubtotal) {
+        minimumRequirement = {
+            subtotal: {
+                greaterThanOrEqualToSubtotal: input.minSubtotal
+            }
+        };
+    }
+    else if (input.minQuantity) {
+        minimumRequirement = {
+            quantity: {
+                greaterThanOrEqualToQuantity: input.minQuantity
+            }
+        };
+    }
+    // Build combinesWith
+    const combinesWith = input.combinesWith || {
+        orderDiscounts: true,
+        productDiscounts: true,
+        shippingDiscounts: true
+    };
+    // Build context (customer targeting)
+    // Context is REQUIRED - must specify all customers or specific segments
+    const context = input.customerSegments && input.customerSegments.length > 0
+        ? {
+            customerSegments: {
+                add: input.customerSegments
+            }
+        }
+        : undefined; // Will be handled separately for code vs automatic
+    // Choose mutation based on automatic flag
+    if (input.automatic) {
+        // Automatic discount (context not needed for automatic)
+        const variables = {
+            automaticBasicDiscount: {
+                title: input.title,
+                startsAt: startsAtValidation.value,
+                endsAt,
+                customerGets,
+                minimumRequirement,
+                combinesWith
+            }
+        };
+        const response = await shopifyGraphQL(credentials, DISCOUNT_AUTOMATIC_BASIC_CREATE, variables);
+        // Check for GraphQL errors
+        if (response.errors) {
+            return {
+                success: false,
+                error: response.errors.map(e => e.message).join('; ')
+            };
+        }
+        if (!response.data) {
+            return { success: false, error: 'No data returned from Shopify API' };
+        }
+        if (response.data.discountAutomaticBasicCreate.userErrors.length > 0) {
+            return {
+                success: false,
+                error: formatUserErrors(response.data.discountAutomaticBasicCreate.userErrors)
+            };
+        }
+        const node = response.data.discountAutomaticBasicCreate.automaticDiscountNode;
+        if (!node) {
+            return { success: false, error: 'Failed to create automatic discount' };
+        }
+        return {
+            success: true,
+            data: {
+                id: node.id,
+                ...node.automaticDiscount
+            }
+        };
+    }
+    else {
+        // Code discount - context is REQUIRED
+        const discountContext = context || {
+            all: "ALL" // Enum value for "all customers"
+        };
+        const variables = {
+            basicCodeDiscount: {
+                title: input.title,
+                code: formatDiscountCode(input.code),
+                startsAt: startsAtValidation.value,
+                endsAt,
+                customerGets,
+                minimumRequirement,
+                combinesWith,
+                context: discountContext,
+                usageLimit: input.usageLimit,
+                appliesOncePerCustomer: input.appliesOncePerCustomer
+            }
+        };
+        const response = await shopifyGraphQL(credentials, DISCOUNT_CODE_BASIC_CREATE, variables);
+        // Check for GraphQL errors
+        if (response.errors) {
+            return {
+                success: false,
+                error: response.errors.map(e => e.message).join('; ')
+            };
+        }
+        if (!response.data) {
+            return { success: false, error: 'No data returned from Shopify API' };
+        }
+        if (response.data.discountCodeBasicCreate.userErrors.length > 0) {
+            return {
+                success: false,
+                error: formatUserErrors(response.data.discountCodeBasicCreate.userErrors)
+            };
+        }
+        const node = response.data.discountCodeBasicCreate.codeDiscountNode;
+        if (!node) {
+            return { success: false, error: 'Failed to create code discount' };
+        }
+        return {
+            success: true,
+            data: {
+                id: node.id,
+                ...node.codeDiscount
+            }
+        };
+    }
+}
+/**
+ * List discounts with filtering
+ */
+export async function listDiscounts(input, credentials) {
+    const limit = input.limit || 50;
+    const query = buildDiscountQuery(input.status, input.query);
+    const results = [];
+    try {
+        // Fetch code discounts
+        if (input.type === 'code' || input.type === 'all' || !input.type) {
+            const variables = {
+                first: limit,
+                query: query || undefined,
+                after: input.after
+            };
+            const response = await shopifyGraphQL(credentials, CODE_DISCOUNT_NODES, variables);
+            if (response.errors) {
+                return {
+                    success: false,
+                    error: response.errors.map(e => e.message).join('; ')
+                };
+            }
+            if (!response.data) {
+                return { success: false, error: 'No data returned from Shopify API' };
+            }
+            const codeDiscounts = response.data.codeDiscountNodes.edges.map((edge) => formatDiscountForDisplay(edge.node, false));
+            results.push(...codeDiscounts);
+        }
+        // Fetch automatic discounts
+        if (input.type === 'automatic' || input.type === 'all' || !input.type) {
+            const variables = {
+                first: limit,
+                query: query || undefined,
+                after: input.after
+            };
+            const response = await shopifyGraphQL(credentials, AUTOMATIC_DISCOUNT_NODES, variables);
+            if (response.errors) {
+                return {
+                    success: false,
+                    error: response.errors.map(e => e.message).join('; ')
+                };
+            }
+            if (!response.data) {
+                return { success: false, error: 'No data returned from Shopify API' };
+            }
+            const automaticDiscounts = response.data.automaticDiscountNodes.edges.map((edge) => formatDiscountForDisplay(edge.node, true));
+            results.push(...automaticDiscounts);
+        }
+        return {
+            success: true,
+            data: {
+                discounts: results,
+                count: results.length
+            }
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Failed to list discounts'
+        };
+    }
+}
+/**
+ * Delete a discount by ID
+ */
+export async function deleteDiscount(discountId, credentials) {
+    // Determine if it's a code or automatic discount based on GID
+    const isCodeDiscount = discountId.includes('DiscountCodeNode');
+    const isAutomaticDiscount = discountId.includes('DiscountAutomaticNode');
+    if (!isCodeDiscount && !isAutomaticDiscount) {
+        return {
+            success: false,
+            error: 'Invalid discount ID: must be a DiscountCodeNode or DiscountAutomaticNode GID'
+        };
+    }
+    try {
+        if (isCodeDiscount) {
+            const response = await shopifyGraphQL(credentials, DISCOUNT_CODE_DELETE, { id: discountId });
+            if (response.errors) {
+                return {
+                    success: false,
+                    error: response.errors.map(e => e.message).join('; ')
+                };
+            }
+            if (!response.data) {
+                return { success: false, error: 'No data returned from Shopify API' };
+            }
+            if (response.data.discountCodeDelete.userErrors.length > 0) {
+                return {
+                    success: false,
+                    error: formatUserErrors(response.data.discountCodeDelete.userErrors)
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    deletedId: response.data.discountCodeDelete.deletedCodeDiscountId
+                }
+            };
+        }
+        else {
+            const response = await shopifyGraphQL(credentials, DISCOUNT_AUTOMATIC_DELETE, { id: discountId });
+            if (response.errors) {
+                return {
+                    success: false,
+                    error: response.errors.map(e => e.message).join('; ')
+                };
+            }
+            if (!response.data) {
+                return { success: false, error: 'No data returned from Shopify API' };
+            }
+            if (response.data.discountAutomaticDelete.userErrors.length > 0) {
+                return {
+                    success: false,
+                    error: formatUserErrors(response.data.discountAutomaticDelete.userErrors)
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    deletedId: response.data.discountAutomaticDelete.deletedAutomaticDiscountId
+                }
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Failed to delete discount'
+        };
+    }
+}
+/**
+ * Create a BXGY (Buy X Get Y) discount
+ * Single Responsibility: Handles BXGY discount creation logic
+ * Dependency Inversion: Depends on ShopifyCredentials abstraction
+ */
+export async function createBxgyDiscount(input, credentials) {
+    // Validate code (required for code discounts)
+    if (!input.automatic) {
+        if (!input.code) {
+            return { success: false, error: 'Discount code is required for code-based BXGY discounts' };
+        }
+        const codeValidation = validateDiscountCode(input.code);
+        if (!codeValidation.valid) {
+            return { success: false, error: codeValidation.error };
+        }
+    }
+    else if (input.code) {
+        return { success: false, error: 'Automatic discounts cannot have codes' };
+    }
+    // Validate dates
+    const startsAtValidation = parseDateTimeInput(input.startsAt);
+    if (!startsAtValidation.valid) {
+        return { success: false, error: `Start date: ${startsAtValidation.error}` };
+    }
+    let endsAt;
+    if (input.endsAt) {
+        const endsAtValidation = parseDateTimeInput(input.endsAt);
+        if (!endsAtValidation.valid) {
+            return { success: false, error: `End date: ${endsAtValidation.error}` };
+        }
+        endsAt = endsAtValidation.value;
+    }
+    // Validate customerBuys has either quantity or amount
+    const hasQuantity = input.customerBuys.value.quantity !== undefined;
+    const hasAmount = input.customerBuys.value.amount !== undefined;
+    if (!hasQuantity && !hasAmount) {
+        return {
+            success: false,
+            error: 'customerBuys must specify either quantity or amount requirement'
+        };
+    }
+    if (hasQuantity && hasAmount) {
+        return {
+            success: false,
+            error: 'customerBuys cannot specify both quantity and amount - choose one'
+        };
+    }
+    // Validate customerGets has discountOnQuantity
+    if (!input.customerGets.value.discountOnQuantity) {
+        return {
+            success: false,
+            error: 'customerGets must specify discountOnQuantity with quantity and effect'
+        };
+    }
+    try {
+        if (!input.automatic) {
+            // Code-based BXGY discount
+            const discountContext = {
+                all: "ALL" // Apply to all customers
+            };
+            const variables = {
+                bxgyCodeDiscount: {
+                    title: input.title,
+                    code: formatDiscountCode(input.code),
+                    startsAt: startsAtValidation.value,
+                    endsAt,
+                    customerBuys: input.customerBuys,
+                    customerGets: input.customerGets,
+                    usesPerOrderLimit: input.usesPerOrderLimit,
+                    combinesWith: input.combinesWith || {
+                        orderDiscounts: false,
+                        productDiscounts: false,
+                        shippingDiscounts: false
+                    },
+                    context: discountContext
+                }
+            };
+            const response = await shopifyGraphQL(credentials, DISCOUNT_CODE_BXGY_CREATE, variables);
+            // Check for GraphQL errors
+            if (response.errors) {
+                return {
+                    success: false,
+                    error: response.errors.map(e => e.message).join('; ')
+                };
+            }
+            if (!response.data) {
+                return { success: false, error: 'No data returned from Shopify API' };
+            }
+            if (response.data.discountCodeBxgyCreate.userErrors.length > 0) {
+                return {
+                    success: false,
+                    error: formatUserErrors(response.data.discountCodeBxgyCreate.userErrors)
+                };
+            }
+            const node = response.data.discountCodeBxgyCreate.codeDiscountNode;
+            if (!node) {
+                return { success: false, error: 'Failed to create BXGY code discount' };
+            }
+            return {
+                success: true,
+                data: {
+                    id: node.id,
+                    title: node.codeDiscount.title,
+                    code: node.codeDiscount.codes?.edges?.[0]?.node.code,
+                    type: 'bxgy',
+                    automatic: false,
+                    status: node.codeDiscount.status,
+                    startsAt: node.codeDiscount.startsAt,
+                    endsAt: node.codeDiscount.endsAt,
+                    summary: node.codeDiscount.summary
+                }
+            };
+        }
+        else {
+            // Automatic BXGY discount
+            const variables = {
+                automaticBxgyDiscount: {
+                    title: input.title,
+                    startsAt: startsAtValidation.value,
+                    endsAt,
+                    customerBuys: input.customerBuys,
+                    customerGets: input.customerGets,
+                    usesPerOrderLimit: input.usesPerOrderLimit,
+                    combinesWith: input.combinesWith || {
+                        orderDiscounts: false,
+                        productDiscounts: false,
+                        shippingDiscounts: false
+                    }
+                }
+            };
+            const response = await shopifyGraphQL(credentials, DISCOUNT_AUTOMATIC_BXGY_CREATE, variables);
+            // Check for GraphQL errors
+            if (response.errors) {
+                return {
+                    success: false,
+                    error: response.errors.map(e => e.message).join('; ')
+                };
+            }
+            if (!response.data) {
+                return { success: false, error: 'No data returned from Shopify API' };
+            }
+            if (response.data.discountAutomaticBxgyCreate.userErrors.length > 0) {
+                return {
+                    success: false,
+                    error: formatUserErrors(response.data.discountAutomaticBxgyCreate.userErrors)
+                };
+            }
+            const node = response.data.discountAutomaticBxgyCreate.automaticDiscountNode;
+            if (!node) {
+                return { success: false, error: 'Failed to create automatic BXGY discount' };
+            }
+            return {
+                success: true,
+                data: {
+                    id: node.id,
+                    title: node.automaticDiscount.title,
+                    type: 'bxgy',
+                    automatic: true,
+                    status: node.automaticDiscount.status,
+                    startsAt: node.automaticDiscount.startsAt,
+                    endsAt: node.automaticDiscount.endsAt,
+                    summary: node.automaticDiscount.summary
+                }
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Failed to create BXGY discount'
+        };
+    }
+}
+/**
+ * Create a free shipping discount
+ * Single Responsibility: Handles free shipping discount creation logic
+ * Dependency Inversion: Depends on ShopifyCredentials abstraction
+ */
+export async function createFreeShippingDiscount(input, credentials) {
+    // Validate code (required for code discounts)
+    if (!input.automatic) {
+        if (!input.code) {
+            return { success: false, error: 'Discount code is required for code-based free shipping discounts' };
+        }
+        const codeValidation = validateDiscountCode(input.code);
+        if (!codeValidation.valid) {
+            return { success: false, error: codeValidation.error };
+        }
+    }
+    else if (input.code) {
+        return { success: false, error: 'Automatic discounts cannot have codes' };
+    }
+    // Validate dates
+    const startsAtValidation = parseDateTimeInput(input.startsAt);
+    if (!startsAtValidation.valid) {
+        return { success: false, error: `Start date: ${startsAtValidation.error}` };
+    }
+    let endsAt;
+    if (input.endsAt) {
+        const endsAtValidation = parseDateTimeInput(input.endsAt);
+        if (!endsAtValidation.valid) {
+            return { success: false, error: `End date: ${endsAtValidation.error}` };
+        }
+        endsAt = endsAtValidation.value;
+    }
+    // Build minimum requirement (optional)
+    let minimumRequirement = undefined;
+    if (input.minimumRequirement) {
+        if (input.minimumRequirement.subtotal) {
+            minimumRequirement = {
+                subtotal: {
+                    greaterThanOrEqualToSubtotal: input.minimumRequirement.subtotal
+                }
+            };
+        }
+        else if (input.minimumRequirement.quantity) {
+            minimumRequirement = {
+                quantity: {
+                    greaterThanOrEqualToQuantity: input.minimumRequirement.quantity
+                }
+            };
+        }
+    }
+    // Build destination (default to all countries)
+    let destination = { all: true };
+    if (input.destinationSelection) {
+        if (input.destinationSelection.countries && input.destinationSelection.countries.length > 0) {
+            destination = {
+                countries: {
+                    add: input.destinationSelection.countries
+                }
+            };
+        }
+        else if (input.destinationSelection.all) {
+            destination = { all: true };
+        }
+    }
+    try {
+        if (!input.automatic) {
+            // Code-based free shipping discount
+            const discountContext = {
+                all: "ALL" // Apply to all customers
+            };
+            const variables = {
+                freeShippingCodeDiscount: {
+                    title: input.title,
+                    code: formatDiscountCode(input.code),
+                    startsAt: startsAtValidation.value,
+                    endsAt,
+                    minimumRequirement,
+                    destination,
+                    combinesWith: input.combinesWith || {
+                        orderDiscounts: false,
+                        productDiscounts: false,
+                        shippingDiscounts: false
+                    },
+                    context: discountContext
+                }
+            };
+            const response = await shopifyGraphQL(credentials, DISCOUNT_CODE_FREE_SHIPPING_CREATE, variables);
+            // Check for GraphQL errors
+            if (response.errors) {
+                return {
+                    success: false,
+                    error: response.errors.map(e => e.message).join('; ')
+                };
+            }
+            if (!response.data) {
+                return { success: false, error: 'No data returned from Shopify API' };
+            }
+            if (response.data.discountCodeFreeShippingCreate.userErrors.length > 0) {
+                return {
+                    success: false,
+                    error: formatUserErrors(response.data.discountCodeFreeShippingCreate.userErrors)
+                };
+            }
+            const node = response.data.discountCodeFreeShippingCreate.codeDiscountNode;
+            if (!node) {
+                return { success: false, error: 'Failed to create free shipping code discount' };
+            }
+            return {
+                success: true,
+                data: {
+                    id: node.id,
+                    title: node.codeDiscount.title,
+                    code: node.codeDiscount.codes?.edges?.[0]?.node.code,
+                    type: 'free_shipping',
+                    automatic: false,
+                    status: node.codeDiscount.status,
+                    startsAt: node.codeDiscount.startsAt,
+                    endsAt: node.codeDiscount.endsAt,
+                    summary: node.codeDiscount.summary
+                }
+            };
+        }
+        else {
+            // Automatic free shipping discount
+            const variables = {
+                freeShippingAutomaticDiscount: {
+                    title: input.title,
+                    startsAt: startsAtValidation.value,
+                    endsAt,
+                    minimumRequirement,
+                    destination,
+                    combinesWith: input.combinesWith || {
+                        orderDiscounts: false,
+                        productDiscounts: false,
+                        shippingDiscounts: false
+                    }
+                }
+            };
+            const response = await shopifyGraphQL(credentials, DISCOUNT_AUTOMATIC_FREE_SHIPPING_CREATE, variables);
+            // Check for GraphQL errors
+            if (response.errors) {
+                return {
+                    success: false,
+                    error: response.errors.map(e => e.message).join('; ')
+                };
+            }
+            if (!response.data) {
+                return { success: false, error: 'No data returned from Shopify API' };
+            }
+            if (response.data.discountAutomaticFreeShippingCreate.userErrors.length > 0) {
+                return {
+                    success: false,
+                    error: formatUserErrors(response.data.discountAutomaticFreeShippingCreate.userErrors)
+                };
+            }
+            const node = response.data.discountAutomaticFreeShippingCreate.automaticDiscountNode;
+            if (!node) {
+                return { success: false, error: 'Failed to create automatic free shipping discount' };
+            }
+            return {
+                success: true,
+                data: {
+                    id: node.id,
+                    title: node.automaticDiscount.title,
+                    type: 'free_shipping',
+                    automatic: true,
+                    status: node.automaticDiscount.status,
+                    startsAt: node.automaticDiscount.startsAt,
+                    endsAt: node.automaticDiscount.endsAt,
+                    summary: node.automaticDiscount.summary
+                }
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Failed to create free shipping discount'
+        };
+    }
+}
+//# sourceMappingURL=service.js.map