Storefront client — createStorefrontClient

import { createStorefrontClient } from "@dscodotco/sdk";
 
const store = createStorefrontClient({
  apiUrl: "https://api.ruo.pro",   // the commerce API origin
  tenant: "ruo-demo",              // pinned into every call's {tenant} segment
  storefrontToken: process.env.FLIGHTDECK_STOREFRONT_TOKEN!, // x-storefront-token
  fetch,                           // optional; defaults to the global fetch
});

store.tenant; // "ruo-demo" — the pinned tenant ref, read-only

site.get(): Promise<{ tenant_ref: string; version: number; manifest: SiteManifest }>

const { tenant_ref, version, manifest } = await store.site.get();
// manifest.template?.sections is the ordered home-page section list

products.list(): Promise<{ products: StorefrontProduct[] }>
products.get(slug: string): Promise<{ product: StorefrontProduct }>

collections.list(): Promise<{ collections: StorefrontCollection[] }>
collections.get(slug: string): Promise<CollectionResponse>

const { collections } = await store.collections.list();
const summer = await store.collections.get("summer-stack");

search(query: {
  q?: string;
  collection?: string;
  price_min_cents?: number | null;
  price_max_cents?: number | null;
  limit?: number;
  offset?: number | null;
}): Promise<{
  query: string;
  result_count: number;
  limit: number;
  offset: number;
  filters: StorefrontSearchFilters;
  facets: StorefrontSearchFacets;
  products: StorefrontProduct[];
}>

const results = await store.search({ q: "peptide", collection: "peptides", limit: 10 });
results.result_count;      // total matches
results.facets.collections; // [{ slug, title, count }, …]
results.facets.price_buckets; // [{ min_cents, max_cents, count }, …]

checkout.submit(body, { idempotencyKey })              // place an order
checkout.orders.cancel(id, { idempotencyKey }, body?)  // cancel a placed order
checkout.orders.edit(id, { idempotencyKey }, body)     // edit a placed order
checkout.orders.refund(id, { idempotencyKey }, body)   // refund a placed order

submit(
  body: StorefrontCheckoutRequest,
  opts: { idempotencyKey: string },
): Promise<CheckoutResponse>

const result = await store.checkout.submit(
  {
    customer_ref: `guest:${email}`,
    items: [{ variant_id: variantId, quantity: 1 }],
    card: { ccnumber, ccexp, cvv },
  },
  { idempotencyKey: `cart-${cartId}:attempt-${attempt}` },
);
 
if (result.outcome === "placed") {
  result.order.order_number;       // e.g. 1042
  result.card_charged_cents;       // the tender split (integer cents)
  result.store_credit_applied_cents;
  result.gift_card_applied_cents;
}

// Full or partial refund. Omit amount_cents for a full refund.
await store.checkout.orders.refund(
  orderId,
  { idempotencyKey: `order-${orderId}:refund-1` },
  { charge_id: chargeId, amount_cents: 1500, reason: "return accepted" },
);
 
// Cancel — body is optional.
await store.checkout.orders.cancel(
  orderId,
  { idempotencyKey: `order-${orderId}:cancel` },
);
 
// Edit line quantities.
await store.checkout.orders.edit(
  orderId,
  { idempotencyKey: `order-${orderId}:edit-1` },
  { edits: [{ order_item_id: itemId, quantity: 2 }] },
);

shopper.orders(query?: { person_id: string }): Promise<{ orders: StorefrontOrder[] }>
shopper.order(id: string): Promise<{ order: StorefrontOrder; items: StorefrontOrderItem[] }>

const { orders } = await store.shopper.orders({ person_id });

storeCredit.balance(query?: { customer_ref: string }): Promise<{
  customer_ref: string;
  balance_cents: number;
  currency: string;
}>

const { balance_cents } = await store.storeCredit.balance({ customer_ref });