Carts and Orders

// Ensure all necessary imports are included and the API client is instantiated as demonstrated in the first example.

/**
 * Updates the min and max quantity for a specific SKU.
 */
async function setMinMaxQuantityForSku(
  sku: string,
  min: number,
  max: number
): Promise<any> {
  const response = await apiRoot
    .inventory()
    .get({ queryArgs: { where: `sku="${sku}" and supplyChannel is not defined` } })
    .execute();

  const entry = response.body.results[0];

  return apiRoot
    .inventory()
    .withId({ ID: entry.id })
    .post({
      body: {
        version: entry.version,
        actions: [
          {
            action: "setInventoryLimits",
            minCartQuantity: min,
            maxCartQuantity: max,
          },
        ],
      },
    })
    .execute();
}

/**
 * Creates a Cart with the specified SKU.
 */
async function createCart(sku: string, quantity: number): Promise<any> {
  return apiRoot
    .carts()
    .post({
      body: {
        currency: "EUR",
        country: "DE",
        lineItems: [{ sku, quantity }],
      },
    })
    .execute();
}

// Execute the logic
async function run() {
  const targetSku = "SPC-01";

  try {
    // 1. Set Limits
    await setMinMaxQuantityForSku(targetSku, 4, 20);
    console.log(`Limits updated! Min: 4, Max: 20`);

    // 2. Create Cart with quantity (this will fail as 2 < 4)
    const cartResponse = await createCart(targetSku, 2);
    console.log(
      "Cart created successfully!",
      JSON.stringify(cartResponse.body.lineItems, null, 2)
    );
  } catch (error: any) {
    // --- READABLE ERROR HANDLING ---
    console.error("\nREQUEST FAILED");
    if (error.body && error.body.errors) {
      console.error(`Status Code: ${error.statusCode}`);
      error.body.errors.forEach((err: any) => {
        console.error(`Field: ${err.code} | Message: ${err.message}`);
      });
    } else {
      console.error("System Error:", error.message);
    }
  }
}

run();

// Ensure all necessary imports are included and the API client is instantiated as demonstrated in the first example.

const SKUS = ["EC-0993", "WOP-09", "WTP-09", "BUCK-023"];
const CURRENCY = "EUR";
const COUNTRY = "DE";

type RoundingMode = "HalfEven" | "HalfUp" | "HalfDown";

/**
 * Creates a Cart with the given rounding mode and predefined SKUs.
 */
async function createCart(roundingMode: RoundingMode): Promise<any> {
  return apiRoot
    .carts()
    .post({
      body: {
        currency: CURRENCY,
        country: COUNTRY,
        priceRoundingMode: roundingMode,
        lineItems: SKUS.map((sku) => ({ sku })),
      },
    })
    .execute();
}

function formatMoney(centAmount: number): string {
  return `${(centAmount / 100).toFixed(2)} ${CURRENCY}`;
}

// Execute the demo
async function run(): Promise<void> {
  const modes: RoundingMode[] = ["HalfEven", "HalfUp", "HalfDown"];

  console.log("=== Price Rounding Modes Demo ===\n");

  try {
    for (const mode of modes) {
      console.log(`Creating cart with rounding mode: ${mode} ...`);
      const response = await createCart(mode);
      const cart = response.body;
      console.log(
        `✓ Cart created | Mode: ${mode} | ID: ${cart.id} | Total: ${formatMoney(
          cart.totalPrice.centAmount
        )}`
      );
    }
  } catch (error: any) {
    console.error("\nCART CREATION FAILED");
    if (error.body && error.body.errors) {
      console.error(`Status Code: ${error.statusCode}`);
      error.body.errors.forEach((err: any) => {
        console.error(`Field: ${err.code} | Message: ${err.message}`);
      });
    } else {
      console.error("System Error:", error.message);
    }
  }
}

run();

// Ensure all necessary imports are included and the API client is instantiated as demonstrated in the first example.

// ID of a customer belonging to our project
const CUSTOMER_ID = "46fbc1a6-fd3c-424c-bbf5-096ab5da0f21";

/**
 * Creates a customer Cart with a single Line Item.
 */
async function createCustomerCart(sku: string, quantity: number): Promise<any> {
  return apiRoot
    .carts()
    .post({
      body: {
        currency: "EUR",
        country: "DE",
        customerId: CUSTOMER_ID,
        lineItems: [{ sku, quantity }],
      },
    })
    .execute();
}

/**
 * Creates an anonymous Cart with a single Line Item.
 */
async function createAnonymousCart(
  sku: string,
  quantity: number
): Promise<any> {
  return apiRoot
    .carts()
    .post({
      body: {
        currency: "EUR",
        country: "DE",
        lineItems: [{ sku, quantity }],
      },
    })
    .execute();
}

/**
 * Merges an anonymous Cart into a customer Cart.
 */
async function mergeCartsForCustomer(anonymousCartId: string): Promise<any> {
  return apiRoot
    .carts()
    .customerIdWithCustomerIdValueMerge({ customerId: CUSTOMER_ID })
    .post({
      body: {
        anonymousCart: { typeId: "cart", id: anonymousCartId },
        mergeMode: "MergeWithExistingCustomerCart",
        updateProductData: false,
      },
    })
    .execute();
}

/**
 * Prints a formatted summary of the Cart merge operation.
 */
function printMergeSummary(
  customerCartId: string,
  anonymousCartId: string,
  mergedCart: any
): void {
  console.log("=== Final Result ===");
  console.log(`Customer Cart ID: ${customerCartId}`);
  console.log(`Anonymous Cart ID: ${anonymousCartId}`);
  console.log(`\nMerged Cart ID: ${mergedCart.id}`);
  console.log(`Total Quantity: ${mergedCart.totalLineItemQuantity}`);
  console.log("\nLine Items in Merged Cart:");
  mergedCart.lineItems.forEach((item: any, index: number) => {
    console.log(
      `  ${index + 1}. Product: ${item.productKey}, Quantity: ${
        item.quantity
      }, SKU: ${item.variant.sku || "N/A"}`
    );
  });
}

// Execute the logic
async function run() {
  try {
    console.log("=== Cart Merge Demo ===\n");

    // Step 1: Create customer Cart
    console.log("Step 1: Creating customer cart...");
    const customerCartResponse = await createCustomerCart("CST-01", 2);
    const customerCartId = customerCartResponse.body.id;
    console.log(`✓ Customer cart created with ID: ${customerCartId}\n`);

    // Step 2: Create anonymous Cart
    console.log("Step 2: Creating anonymous cart...");
    const anonymousCartResponse = await createAnonymousCart("CDG-09", 1);
    const anonymousCartId = anonymousCartResponse.body.id;
    console.log(`✓ Anonymous cart created with ID: ${anonymousCartId}\n`);

    // Step 3: Merge Carts
    console.log("Step 3: Merging anonymous cart into customer cart...");
    const mergedCartResponse = await mergeCartsForCustomer(anonymousCartId);
    console.log(`✓ Carts merged successfully!\n`);

    // Step 4: Print summary
    printMergeSummary(customerCartId, anonymousCartId, mergedCartResponse.body);
  } catch (error: any) {
    // --- READABLE ERROR HANDLING ---
    console.error("\nCART MERGE FAILED");
    if (error.body && error.body.errors) {
      console.error(`Status Code: ${error.statusCode}`);
      error.body.errors.forEach((err: any) => {
        console.error(`Field: ${err.code} | Message: ${err.message}`);
      });
    } else {
      console.error("System Error:", error.message);
    }
  }
}

run();

// Ensure all necessary imports are included and the API client is instantiated as demonstrated in the first example.

const CUSTOMER_ID = "46fbc1a6-fd3c-424c-bbf5-096ab5da0f21";
const SKU = "WTP-09";
const CURRENCY = "EUR";
const COUNTRY = "DE";
const PRICE_AMOUNT = 599; // in cents
const RECURRENCE_POLICY_KEY = "daily-subscription";

const expiryInDays = (days: number): string =>
  new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString();

const formatMoney = (centAmount: number): string =>
  `${(centAmount / 100).toFixed(2)} ${CURRENCY}`;

/**
 * Creates a daily Recurrence Policy.
 */
async function createRecurrencePolicy(): Promise<any> {
  return apiRoot
    .recurrencePolicies()
    .post({
      body: {
        key: RECURRENCE_POLICY_KEY,
        schedule: {
          type: "standard",
          intervalUnit: "Days",
          value: 1,
        },
      },
    })
    .execute();
}

/**
 * Adds an embedded price to a Product Variant and ties it to the Recurrence Policy.
 */
async function addPriceToVariant(
  productId: string,
  productVersion: number,
  recurrencePolicyId: string
): Promise<any> {
  return apiRoot
    .products()
    .withId({ ID: productId })
    .post({
      body: {
        version: productVersion,
        actions: [
          {
            action: "addPrice",
            sku: SKU,
            price: {
              value: {
                type: "centPrecision",
                currencyCode: CURRENCY,
                centAmount: PRICE_AMOUNT,
              },
              country: COUNTRY,
              recurrencePolicy: {
                typeId: "recurrence-policy",
                id: recurrencePolicyId,
              },
            },
          },
          { action: "publish" },
        ],
      },
    })
    .execute();
}

/**
 * Fetches a product by SKU to get its ID and variant details.
 */
async function getProductBySku(sku: string): Promise<any> {
  const response = await apiRoot
    .productProjections()
    .get({
      queryArgs: {
        where: `masterVariant(sku="${sku}")`,
      },
    })
    .execute();

  if (response.body.results.length === 0) {
    throw new Error(`Product with SKU "${sku}" not found`);
  }

  return response.body.results[0];
}

/**
 * Creates a customer Cart with a specific SKU and selects "subscription price".
 */
async function createCustomerCart(
  sku: string,
  recurrencePolicyId: string
): Promise<any> {
  return apiRoot
    .carts()
    .post({
      body: {
        currency: CURRENCY,
        country: COUNTRY,
        customerId: CUSTOMER_ID,
        lineItems: [
          {
            sku,
            recurrenceInfo: {
              recurrencePolicy: {
                typeId: "recurrence-policy",
                id: recurrencePolicyId,
              },
              priceSelectionMode: "Fixed", // or "Dynamic"
            },
          },
        ],
        shippingAddress: {
          country: COUNTRY,
        },
      },
    })
    .execute();
}

/**
 * Creates a Recurring Order from a Cart.
 */
async function createRecurringOrder(
  cartId: string,
  cartVersion: number
): Promise<any> {
  return apiRoot
    .recurringOrders()
    .post({
      body: {
        cart: {
          typeId: "cart",
          id: cartId,
        },
        cartVersion: cartVersion,
        expiresAt: expiryInDays(5),
      },
    })
    .execute();
}

// Execute the demo
async function run(): Promise<void> {
  console.log("=== Recurring Orders Demo ===\n");

  try {
    // Step 1: Create Recurrence Policy
    console.log("Step 1: Creating daily recurrence policy...");
    const recurrencePolicyResponse = await createRecurrencePolicy();
    const recurrencePolicy = recurrencePolicyResponse.body;
    const recurrencePolicyId = recurrencePolicy.id;
    console.log(`✓ Recurrence Policy created | ID: ${recurrencePolicyId}\n`);

    // Step 2: Get Product by SKU and add price
    console.log("Step 2: Fetching product and adding price...");
    const product = await getProductBySku(SKU);
    const { id: productId, version: productVersion } = product;

    await addPriceToVariant(productId, productVersion, recurrencePolicyId);
    console.log(
      `✓ Price added to variant | Product ID: ${productId} | Variant SKU: ${SKU}\n`
    );

    // Step 3: Create customer Cart
    console.log("Step 3: Creating customer cart...");
    const cartResponse = await createCustomerCart(SKU, recurrencePolicyId);
    const cart = cartResponse.body;
    const cartId = cart.id;
    const cartVersion = cart.version;
    console.log(
      `✓ Customer cart created | ID: ${cartId} | Total: ${formatMoney(
        cart.totalPrice.centAmount
      )}\n`
    );

    // Step 4: Create Recurring Order
    console.log("Step 4: Creating recurring order...");
    const recurringOrderResponse = await createRecurringOrder(
      cartId,
      cartVersion
    );
    const recurringOrder = recurringOrderResponse.body;
    console.log(`✓ Recurring order created | ID: ${recurringOrder.id}\n`);
  } catch (error: any) {
    console.error("\nRECURRING ORDER CREATION FAILED");
    if (error.body && error.body.errors) {
      console.error(`Status Code: ${error.statusCode}`);
      error.body.errors.forEach((err: any) => {
        console.error(`Field: ${err.code} | Message: ${err.message}`);
      });
    } else {
      console.error("System Error:", error.message);
    }
  }
}

run();