Orders

import crypto from 'crypto';

// 1. Define Signing Helper
function generateHmacSignature(payload: string, secret: string): string {
  return crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('base64');
}

// 2. Prepare Data & Sign
const timestamp = Math.floor(Date.now() / 1000);
const body = JSON.stringify(orderData);
const payload = `${timestamp}.${body}`;
const signature = generateHmacSignature(payload, hmacSecret);

// 3. Execute request with headers
const order = await client.orders.createOrder({
  idempotencyKey: `order-${timestamp}`,
  xTimestamp: timestamp,
  xSignature: signature,
  requestBody: orderData
});

const client = new Tybrite({ apiKey: process.env.TYBRITE_SECRET_KEY });

// First page — most recent 20 paid orders
const page = await client.orders.listOrders({
  limit: 20,
  paymentStatus: 'paid',
});

console.log(page.orders);            // array of order summaries
console.log(page.pagination.has_more); // true if more pages exist

let cursor: string | undefined = undefined;

do {
  const page = await client.orders.listOrders({ limit: 50, cursor });
  for (const order of page.orders ?? []) {
    // process each order
  }
  cursor = page.pagination?.next_cursor ?? undefined;
} while (cursor);

{
  orders: [
    {
      id: 'order-uuid',
      order_number: 'ORD-1771523999910',
      customer_name: 'John Doe',
      payment_status: 'paid',
      order_status: 'processing',
      total_amount: 2520,
      environment: 'production',
      created_at: '2026-02-19T10:30:00Z'
      // ...other order header fields (no `items`)
    }
  ],
  pagination: {
    limit: 50,
    next_cursor: 'eyJ...' | null, // pass this back as `cursor` for the next page
    has_more: false
  }
}

const { reservation_ids, expires_in_seconds } = await client.orders.reserveStock({
  requestBody: {
    items: [
      { variant_id: 'variant-uuid', quantity: 2 }
    ],
    // optional: ttl_seconds, customer_id, session_id (for checkout recovery)
  }
});

// ...customer completes payment...

// Convert the hold into the sale by passing reservation_ids to createOrder:
const result = await client.orders.createOrder({
  idempotencyKey: `order-${Date.now()}`,
  xTimestamp: Math.floor(Date.now() / 1000),
  xSignature: hmacSignature,
  requestBody: {
    total_amount: 5000,
    payment_method: 'card',
    payment_status: 'paid',
    items: [{ product_id: 'product-uuid', variant_id: 'variant-uuid', quantity: 2, unit_price: 2500 }],
    reservation_ids, // converts the hold into the actual stock deduction
  }
});
// → { order: { id, order_number, payment_status: 'paid', total_amount, … }, post_processing_warnings? }

const result = await client.orders.createOrder({
  idempotencyKey: `order-${Date.now()}-abc123`,
  xTimestamp: Math.floor(Date.now() / 1000),
  xSignature: hmacSignature, // base64 HMAC-SHA256 of `${timestamp}.${body}`
  requestBody: {
    customer_email: '[email protected]',
    customer_name: 'Jane Doe',
    billing_address: { street: '123 Main St', city: 'New York', state: 'NY', zip: '10001', country: 'US' },
    shipping_address: { street: '123 Main St', city: 'New York', state: 'NY', zip: '10001', country: 'US' },
    subtotal: 5000,
    total_amount: 5000,
    payment_method: 'card',
    customer_id: 'optional-customer-uuid', // optional; omit for guest checkout
    items: [
      // Prefer variant_id — the exact SKU the shopper chose (e.g. straight from the cart).
      { variant_id: 'variant-uuid', quantity: 2, unit_price: 2500, total_price: 5000 }
      // …or send product_id alone to use the product's default variant.
    ],
    payment_status: 'paid' // triggers inventory + accounting + metrics
  }
});
const order = result.order;
// order.id is the new order UUID
// result.post_processing_warnings is undefined OR present with details

{
  order: {
    id: 'order-uuid',
    // ... full order fields
  },
  post_processing_warnings: [
    {
      stage: 'gift_card_redemption',
      message: 'Gift card redemption failed: insufficient balance. The order was created but no gift card credit was applied. Please contact support.'
    }
    // OR
    {
      stage: 'stock_reduction',
      message: 'Some inventory updates failed. Order is recorded; an operator will reconcile stock manually.'
    }
  ]
}

const result = await client.orders.createOrder({ /* ... */ });
const order = result.order;

if (result.post_processing_warnings?.length) {
  for (const warning of result.post_processing_warnings) {
    if (warning.stage === 'gift_card_redemption') {
      // Alert the customer + create a support ticket
      // The customer paid full price but the gift card credit was not applied
      await flagForRetry(order.id, warning);
    }
    if (warning.stage === 'stock_reduction') {
      // Notify ops; inventory needs manual review
      console.warn('Stock review needed for order', order.id);
    }
  }
}

const client = new Tybrite({ apiKey: process.env.TYBRITE_SECRET_KEY });
const order = await client.orders.getOrder({ id: 'order-uuid' });

const updated = await client.orders.updateOrder({
  id: 'order-uuid-here',
  idempotencyKey: `update-status-${orderId}-${Date.now()}`,
  xTimestamp: Math.floor(Date.now() / 1000),
  xSignature: '...',
  requestBody: {
    payment_status: 'paid', // Triggers auto-accounting & inventory reduction
    order_status: 'shipped',
    tracking_number: 'CARGO-123-ABC'
  }
});