Store Setup and Admin Basics

// Generates the 18 Pocket Coffee bean variants and writes the product CSV.
import { writeFileSync } from 'node:fs';

const origins = [
  { name: 'Ethiopia Yirgacheffe', code: 'ETH', surchargePer250g: 1.0 },
  { name: 'Colombia Huila', code: 'COL', surchargePer250g: 0 },
  { name: 'Brazil Cerrado', code: 'BRA', surchargePer250g: 0 },
];
const grinds = [
  { name: 'Whole bean', code: 'WHL' },
  { name: 'Espresso', code: 'ESP' },
  { name: 'Filter', code: 'FIL' },
];
const sizes = [
  { name: '250 g', code: '250', grams: 250, base: 8.9, units: 1 },
  { name: '1 kg', code: '1KG', grams: 1000, base: 29.9, units: 4 },
];

const variants = [];
for (const o of origins)
  for (const g of grinds)
    for (const s of sizes)
      variants.push({
        origin: o.name,
        grind: g.name,
        size: s.name,
        sku: `PC-${o.code}-${g.code}-${s.code}`,
        grams: s.grams,
        price: (s.base + o.surchargePer250g * s.units).toFixed(2),
      });

const header = [
  'URL handle', 'Title', 'Description', 'Vendor', 'Product category', 'Type', 'Tags',
  'Published on online store', 'Status', 'SKU', 'Option1 name', 'Option1 value',
  'Option2 name', 'Option2 value', 'Option3 name', 'Option3 value', 'Price',
  'Charge tax', 'Inventory tracker', 'Inventory quantity',
  'Continue selling when out of stock', 'Weight value (grams)', 'Weight unit for display',
  'Requires shipping', 'Fulfillment service', 'SEO title', 'SEO description',
];
const q = (v) => (/[",\n]/.test(String(v)) ? `"${String(v).replace(/"/g, '""')}"` : String(v));
const row = (o) => header.map((h) => q(o[h] ?? '')).join(',');

const rows = [];
variants.forEach((v, i) => {
  const first = i === 0;
  rows.push({
    'URL handle': 'single-origin-beans',
    ...(first && {
      Title: 'Single-origin beans',
      Description: '<p>Specialty coffee beans roasted in small batches.</p>',
      Vendor: 'Pocket Coffee',
      'Product category': 'Food, Beverages & Tobacco > Beverages > Coffee > Coffee Beans & Ground Coffee',
      Type: 'Beans',
      Tags: 'beans, single-origin, origin-filter',
      'Published on online store': 'true',
      Status: 'active',
      'SEO title': 'Single-origin coffee beans | Pocket Coffee',
      'SEO description': 'Ethiopia, Colombia and Brazil beans in three grinds and two sizes.',
    }),
    SKU: v.sku,
    'Option1 name': 'Origin', 'Option1 value': v.origin,
    'Option2 name': 'Grind', 'Option2 value': v.grind,
    'Option3 name': 'Size', 'Option3 value': v.size,
    Price: v.price,
    'Charge tax': 'true',
    'Inventory tracker': 'shopify',
    'Inventory quantity': 40,
    'Continue selling when out of stock': 'deny',
    'Weight value (grams)': v.grams,
    'Weight unit for display': 'kg',
    'Requires shipping': 'true',
    'Fulfillment service': 'manual',
  });
});
rows.push({
  'URL handle': 'starter-kit', Title: 'Starter kit',
  Description: '<p>Hand grinder and 250 g of beans.</p>', Vendor: 'Pocket Coffee',
  Type: 'Equipment', Tags: 'equipment, kit', 'Published on online store': 'true', Status: 'active',
  SKU: 'PC-KIT-001', 'Option1 name': 'Title', 'Option1 value': 'Default Title', Price: '24.00',
  'Charge tax': 'true', 'Inventory tracker': 'shopify', 'Inventory quantity': 15,
  'Continue selling when out of stock': 'deny', 'Weight value (grams)': 900,
  'Weight unit for display': 'kg', 'Requires shipping': 'true', 'Fulfillment service': 'manual',
});

const csv = [header.join(','), ...rows.map(row)].join('\n') + '\n';
writeFileSync('pocket-coffee-products.csv', csv);
writeFileSync('variants.json', JSON.stringify(variants, null, 2));
console.log(`${variants.length} variants, ${rows.length} product rows, ${csv.split('\n').length - 1} CSV lines`);

// Checks the generated product CSV against the column names and limits in the product CSV documentation.
import { readFileSync } from 'node:fs';

const documented = new Set([
  'Title', 'URL handle', 'Description', 'Vendor', 'Product category', 'Type', 'Tags',
  'Published on online store', 'Status', 'SKU', 'Barcodes', 'Option1 name', 'Option1 value',
  'Option1 LinkedTo', 'Option2 name', 'Option2 value', 'Option2 LinkedTo', 'Option3 name',
  'Option3 value', 'Option3 LinkedTo', 'Price', 'Compare-at price', 'Cost per item',
  'Charge tax', 'Inventory tracker', 'Inventory quantity', 'Continue selling when out of stock',
  'Weight value (grams)', 'Weight unit for display', 'Requires shipping', 'Fulfillment service',
  'SEO title', 'SEO description',
]);

function parse(text) {
  const rows = [];
  let row = [];
  let cell = '';
  let inQ = false;
  for (let i = 0; i < text.length; i++) {
    const c = text[i];
    if (inQ) {
      if (c === '"') {
        if (text[i + 1] === '"') { cell += '"'; i++; } else inQ = false;
      } else cell += c;
    } else if (c === '"') inQ = true;
    else if (c === ',') { row.push(cell); cell = ''; }
    else if (c === '\n') { row.push(cell); rows.push(row); row = []; cell = ''; }
    else cell += c;
  }
  return rows;
}

const file = process.argv[2] ?? 'pocket-coffee-products.csv';
const [header, ...body] = parse(readFileSync(file, 'utf8'));
const errors = [];
for (const h of header) if (!documented.has(h)) errors.push(`undocumented column: ${h}`);
const col = Object.fromEntries(header.map((h, i) => [h, i]));
for (const need of ['Title', 'URL handle']) if (!(need in col)) errors.push(`missing required column ${need}`);
const skus = new Set();
const combos = new Set();
let beans = 0;
for (const r of body) {
  if (r.length !== header.length) errors.push(`row has ${r.length} cells instead of ${header.length}`);
  const handle = r[col['URL handle']];
  if (!/^[a-z0-9-]+$/.test(handle)) errors.push(`bad handle ${handle}`);
  const sku = r[col['SKU']];
  if (skus.has(sku)) errors.push(`duplicate SKU ${sku}`);
  skus.add(sku);
  if (handle === 'single-origin-beans') {
    beans++;
    if (!/^PC-(ETH|COL|BRA)-(WHL|ESP|FIL)-(250|1KG)$/.test(sku)) errors.push(`SKU pattern ${sku}`);
    const key = [1, 2, 3].map((n) => r[col[`Option${n} value`]]).join('/');
    if (combos.has(key)) errors.push(`duplicate option combination ${key}`);
    combos.add(key);
  }
  if (!/^\d+\.\d{2}$/.test(r[col['Price']])) errors.push(`price format ${sku}`);
  const tags = (r[col['Tags']] ?? '').split(',').map((t) => t.trim()).filter(Boolean);
  if (tags.length > 250 || tags.some((t) => t.length > 255)) errors.push(`tag limits ${sku}`);
}
if (beans !== 18) errors.push(`expected 18 bean variants, got ${beans}`);
console.log(`columns=${header.length} rows=${body.length} skus=${skus.size} bean variants=${beans}`);
console.log(errors.length ? errors.join('\n') : 'CSV OK');
process.exit(errors.length ? 1 : 0);

$ node pocket-coffee-variants.mjs
18 variants, 19 product rows, 20 CSV lines
$ node check-csv.mjs
columns=27 rows=19 skus=19 bean variants=18
CSV OK
$ node check-csv.mjs bad.csv
undocumented column: Option1 nme

URL handle,Title,Description,Vendor,Product category,Type,Tags,Published on online store,Status,SKU,Option1 name,Option1 value,Option2 name,Option2 value,Option3 name,Option3 value,Price,Charge tax,Inventory tracker,Inventory quantity,Continue selling when out of stock,Weight value (grams),Weight unit for display,Requires shipping,Fulfillment service,SEO title,SEO description
single-origin-beans,Single-origin beans,<p>Specialty coffee beans roasted in small batches.</p>,Pocket Coffee,"Food, Beverages & Tobacco > Beverages > Coffee > Coffee Beans & Ground Coffee",Beans,"beans, single-origin, origin-filter",true,active,PC-ETH-WHL-250,Origin,Ethiopia Yirgacheffe,Grind,Whole bean,Size,250 g,9.90,true,shopify,40,deny,250,kg,true,manual,Single-origin coffee beans | Pocket Coffee,"Ethiopia, Colombia and Brazil beans in three grinds and two sizes."
single-origin-beans,,,,,,,,,PC-ETH-WHL-1KG,Origin,Ethiopia Yirgacheffe,Grind,Whole bean,Size,1 kg,33.90,true,shopify,40,deny,1000,kg,true,manual,,

mutation SetBeans($input: ProductSetInput!) {
  productSet(input: $input, synchronous: true) {
    product {
      id
      handle
      status
      variantsCount {
        count
      }
      options {
        name
        optionValues {
          name
        }
      }
    }
    userErrors {
      field
      message
      code
    }
  }
}

// Builds the productSet input for "Single-origin beans" from the generated variant list.
import { readFileSync, writeFileSync } from 'node:fs';

const variants = JSON.parse(readFileSync('variants.json', 'utf8'));
const uniq = (key) => [...new Set(variants.map((v) => v[key]))];
const roastery = 'gid://shopify/Location/1000000001';

const input = {
  title: 'Single-origin beans',
  handle: 'single-origin-beans',
  descriptionHtml: '<p>Specialty coffee beans roasted in small batches.</p>',
  vendor: 'Pocket Coffee',
  productType: 'Beans',
  tags: ['beans', 'single-origin'],
  status: 'DRAFT',
  seo: {
    title: 'Single-origin coffee beans | Pocket Coffee',
    description: 'Ethiopia, Colombia and Brazil beans in three grinds and two sizes.',
  },
  productOptions: [
    { name: 'Origin', position: 1, values: uniq('origin').map((name) => ({ name })) },
    { name: 'Grind', position: 2, values: uniq('grind').map((name) => ({ name })) },
    { name: 'Size', position: 3, values: uniq('size').map((name) => ({ name })) },
  ],
  variants: variants.map((v) => ({
    optionValues: [
      { optionName: 'Origin', name: v.origin },
      { optionName: 'Grind', name: v.grind },
      { optionName: 'Size', name: v.size },
    ],
    price: v.price,
    inventoryPolicy: 'DENY',
    inventoryItem: {
      sku: v.sku,
      tracked: true,
      requiresShipping: true,
      measurement: { weight: { value: v.grams / 1000, unit: 'KILOGRAMS' } },
    },
    inventoryQuantities: [{ locationId: roastery, name: 'available', quantity: 40 }],
  })),
};
writeFileSync('01-product-set.SetBeans.vars.json', JSON.stringify({ input }, null, 2));
console.log(`${input.variants.length} variants in ${input.productOptions.length} options`);

{
  "input": {
    "title": "Single-origin beans",
    "handle": "single-origin-beans",
    "descriptionHtml": "<p>Specialty coffee beans roasted in small batches.</p>",
    "vendor": "Pocket Coffee",
    "productType": "Beans",
    "tags": [
      "beans",
      "single-origin"
    ],
    "status": "DRAFT",
    "seo": {
      "title": "Single-origin coffee beans | Pocket Coffee",
      "description": "Ethiopia, Colombia and Brazil beans in three grinds and two sizes."
    },
    "productOptions": [
      {
        "name": "Origin",
        "position": 1,
        "values": [
          {
            "name": "Ethiopia Yirgacheffe"
          },
          {
            "name": "Colombia Huila"
          },
          {
            "name": "Brazil Cerrado"
          }
        ]
      },
      {
        "name": "Grind",
        "position": 2,
        "values": [
          {
            "name": "Whole bean"
          },
          {
            "name": "Espresso"
          },
          {
            "name": "Filter"
          }
        ]
      },
      {
        "name": "Size",
        "position": 3,
        "values": [
          {
            "name": "250 g"
          },
          {
            "name": "1 kg"
          }
        ]
      }
    ],
    "variants": [
      {
        "optionValues": [
          {
            "optionName": "Origin",
            "name": "Ethiopia Yirgacheffe"
          },
          {
            "optionName": "Grind",
            "name": "Whole bean"
          },
          {
            "optionName": "Size",
            "name": "250 g"
          }
        ],
        "price": "9.90",
        "inventoryPolicy": "DENY",
        "inventoryItem": {
          "sku": "PC-ETH-WHL-250",
          "tracked": true,
          "requiresShipping": true,
          "measurement": {
            "weight": {
              "value": 0.25,
              "unit": "KILOGRAMS"
            }
          }
        },
        "inventoryQuantities": [
          {
            "locationId": "gid://shopify/Location/1000000001",
            "name": "available",
            "quantity": 40
          }
        ]
      },
      {
        "optionValues": [
          {
            "optionName": "Origin",
            "name": "Ethiopia Yirgacheffe"
          },
          {
            "optionName": "Grind",
            "name": "Whole bean"
          },
          {
            "optionName": "Size",
            "name": "1 kg"
          }
        ],
        "price": "33.90",
        "inventoryPolicy": "DENY",
        "inventoryItem": {
          "sku": "PC-ETH-WHL-1KG",
          "tracked": true,
          "requiresShipping": true,
          "measurement": {
            "weight": {
              "value": 1,
              "unit": "KILOGRAMS"
            }
          }
        },
        "inventoryQuantities": [
          {
            "locationId": "gid://shopify/Location/1000000001",
            "name": "available",
            "quantity": 40
          }
        ]
      }
    ]
  }
}

mutation CreateStarterKit($product: ProductCreateInput!) {
  productCreate(product: $product) {
    product {
      id
      handle
      variants(first: 1) {
        nodes {
          id
          title
          inventoryItem {
            id
          }
        }
      }
    }
    userErrors {
      field
      message
    }
  }
}

mutation PriceStarterKit($productId: ID!, $variants: [ProductVariantsBulkInput!]!) {
  productVariantsBulkUpdate(productId: $productId, variants: $variants) {
    productVariants {
      id
      price
      sku
    }
    userErrors {
      field
      message
      code
    }
  }
}

{
  "product": {
    "title": "Starter kit",
    "handle": "starter-kit",
    "descriptionHtml": "<p>Hand grinder and 250 g of beans.</p>",
    "vendor": "Pocket Coffee",
    "productType": "Equipment",
    "tags": ["equipment", "kit"],
    "status": "DRAFT"
  }
}

{
  "productId": "gid://shopify/Product/2000000002",
  "variants": [
    {
      "id": "gid://shopify/ProductVariant/3000000001",
      "price": "24.00",
      "inventoryItem": {
        "sku": "PC-KIT-001",
        "tracked": true,
        "requiresShipping": true,
        "measurement": { "weight": { "value": 0.9, "unit": "KILOGRAMS" } }
      }
    }
  ]
}

mutation CreateCollection($collection: CollectionCreateInput!) {
  collectionCreate(collection: $collection) {
    collection {
      id
      handle
      sortOrder
    }
    userErrors {
      field
      message
    }
  }
}

query Publications {
  publications(first: 10) {
    nodes {
      id
      name
    }
  }
}

mutation PublishCollection($id: ID!, $input: [PublicationInput!]!) {
  publishablePublish(id: $id, input: $input) {
    userErrors {
      field
      message
    }
  }
}

{
  "collection": {
    "title": "Beans",
    "handle": "beans",
    "descriptionHtml": "<p>Single-origin coffee beans.</p>",
    "sortOrder": "BEST_SELLING",
    "sources": [
      {
        "source": {
          "title": "Tagged beans",
          "targetType": "PRODUCTS",
          "inclusion": {
            "matchType": "ALL",
            "conditions": [
              { "productTag": { "relation": "TAGGED_WITH", "values": ["beans"], "matchType": "ANY" } }
            ]
          }
        }
      }
    ]
  }
}

{
  "collection": {
    "title": "Equipment",
    "handle": "equipment",
    "sortOrder": "MANUAL",
    "sources": [
      {
        "source": {
          "title": "Hand-picked equipment",
          "targetType": "PRODUCTS",
          "inclusion": {
            "selections": [{ "productId": "gid://shopify/Product/2000000002" }]
          }
        }
      }
    ]
  }
}

{
  "id": "gid://shopify/Collection/4000000001",
  "input": [{ "publicationId": "gid://shopify/Publication/5000000001" }]
}

query Locations {
  locations(first: 10) {
    nodes {
      id
      name
      isActive
      fulfillsOnlineOrders
    }
  }
}

mutation AddLocation($input: LocationAddInput!) {
  locationAdd(input: $input) {
    location {
      id
      name
    }
    userErrors {
      field
      message
    }
  }
}

query StockOfSku($query: String!, $locationId: ID!) {
  inventoryItems(first: 1, query: $query) {
    nodes {
      id
      sku
      tracked
      inventoryLevel(locationId: $locationId) {
        quantities(names: ["available", "committed", "on_hand"]) {
          name
          quantity
        }
      }
    }
  }
}

mutation CountBeans($input: InventorySetQuantitiesInput!, $idempotencyKey: String!) {
  inventorySetQuantities(input: $input) @idempotent(key: $idempotencyKey) {
    inventoryAdjustmentGroup {
      reason
      changes {
        name
        delta
        quantityAfterChange
        item {
          sku
        }
      }
    }
    userErrors {
      field
      message
      code
    }
  }
}

mutation StockAtBerlin(
  $inventoryItemId: ID!
  $locationId: ID!
  $available: Int
  $idempotencyKey: String!
) {
  inventoryActivate(
    inventoryItemId: $inventoryItemId
    locationId: $locationId
    available: $available
  ) @idempotent(key: $idempotencyKey) {
    inventoryLevel {
      id
      quantities(names: ["available"]) {
        name
        quantity
      }
    }
    userErrors {
      field
      message
    }
  }
}

mutation ReceiveBeans($input: InventoryAdjustQuantitiesInput!, $idempotencyKey: String!) {
  inventoryAdjustQuantities(input: $input) @idempotent(key: $idempotencyKey) {
    inventoryAdjustmentGroup {
      reason
      changes {
        name
        delta
        quantityAfterChange
      }
    }
    userErrors {
      field
      message
    }
  }
}

{
  "input": {
    "name": "Berlin partner warehouse",
    "fulfillsOnlineOrders": true,
    "address": {
      "address1": "Beispielstrasse 1",
      "city": "Berlin",
      "zip": "10115",
      "countryCode": "DE"
    }
  }
}

{
  "query": "sku:PC-ETH-WHL-250",
  "locationId": "gid://shopify/Location/1000000001"
}

{
  "input": {
    "name": "available",
    "reason": "cycle_count_available",
    "referenceDocumentUri": "logistics://pocket-coffee/stocktake/2026-10-27",
    "quantities": [
      {
        "inventoryItemId": "gid://shopify/InventoryItem/6000000001",
        "locationId": "gid://shopify/Location/1000000001",
        "quantity": 36,
        "changeFromQuantity": 40
      }
    ]
  },
  "idempotencyKey": "4a6f1b2e-8d3c-4f57-9a10-2c7e5b9d0f31"
}

{
  "inventoryItemId": "gid://shopify/InventoryItem/6000000001",
  "locationId": "gid://shopify/Location/1000000002",
  "available": 0,
  "idempotencyKey": "c93e5a17-2b64-4f08-a1d9-6e0b7f4c8d25"
}

{
  "input": {
    "name": "available",
    "reason": "received",
    "referenceDocumentUri": "logistics://pocket-coffee/shipment/SHIP-0001",
    "changes": [
      {
        "inventoryItemId": "gid://shopify/InventoryItem/6000000001",
        "locationId": "gid://shopify/Location/1000000002",
        "delta": 24,
        "changeFromQuantity": 0
      }
    ]
  },
  "idempotencyKey": "b21f7c04-5e9a-4d36-8c11-7a3d2e6f9b48"
}

{% doc %}
  Renders a short availability message for one variant.

  - Inventory not tracked: no message.
  - Tracked, none available and overselling denied: "Sold out".
  - Tracked, none available and overselling allowed: "Roasting soon".
  - Tracked and at or below the threshold: "Only N left".

  @param {variant} variant - The variant to describe
  @param {number} [threshold] - Show the low-stock message at or below this quantity (default 5)

  @example
  {% render 'stock-badge', variant: product.selected_or_first_available_variant %}
{% enddoc %}

{%- liquid
  assign low_stock_at = threshold | default: 5
  assign quantity = variant.inventory_quantity
-%}

{%- if variant.inventory_management == blank -%}
  {%- # Inventory is not tracked: the quantity property would count items sold. -%}
{%- elsif quantity <= 0 and variant.inventory_policy == 'continue' -%}
  <span class="stock-badge stock-badge--backorder">Roasting soon</span>
{%- elsif quantity <= 0 -%}
  <span class="stock-badge stock-badge--sold-out">Sold out</span>
{%- elsif quantity <= low_stock_at -%}
  <span class="stock-badge stock-badge--low">Only {{ quantity }} left</span>
{%- endif -%}

{% assign current_variant = product.selected_or_first_available_variant %}

{% render 'stock-badge', variant: current_variant %}

$ shopify theme check
41 files inspected with no offenses found.
$ node render-badge.mjs
not tracked        -> (nothing)
sold out           -> <span class="stock-badge stock-badge--sold-out">Sold out</span>
oversell allowed   -> <span class="stock-badge stock-badge--backorder">Roasting soon</span>
low stock (4)      -> <span class="stock-badge stock-badge--low">Only 4 left</span>
plenty (40)        -> (nothing)

mutation PhoneOrder($input: DraftOrderInput!) {
  draftOrderCreate(input: $input) {
    draftOrder {
      id
      name
      status
      invoiceUrl
      subtotalPriceSet {
        shopMoney {
          amount
          currencyCode
        }
      }
      totalPriceSet {
        shopMoney {
          amount
          currencyCode
        }
      }
    }
    userErrors {
      field
      message
    }
  }
}

mutation CompleteDraft($id: ID!) {
  draftOrderComplete(id: $id) {
    draftOrder {
      id
      order {
        id
        name
        displayFinancialStatus
        displayFulfillmentStatus
      }
    }
    userErrors {
      field
      message
    }
  }
}

query OpenOrders($query: String!) {
  orders(first: 25, sortKey: CREATED_AT, reverse: true, query: $query) {
    nodes {
      id
      name
      createdAt
      displayFinancialStatus
      displayFulfillmentStatus
      customer {
        displayName
      }
      totalPriceSet {
        shopMoney {
          amount
          currencyCode
        }
      }
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

mutation CancelOrder(
  $orderId: ID!
  $reason: OrderCancelReason!
  $refundMethod: OrderCancelRefundMethodInput
) {
  orderCancel(
    orderId: $orderId
    reason: $reason
    refundMethod: $refundMethod
    restock: true
    notifyCustomer: false
    staffNote: "Duplicate order"
  ) {
    job {
      id
      done
    }
    orderCancelUserErrors {
      field
      message
      code
    }
  }
}

{
  "input": {
    "email": "ada@example.test",
    "tags": ["phone-order", "Coffee Club"],
    "note": "Phone order, pay by invoice",
    "lineItems": [
      { "variantId": "gid://shopify/ProductVariant/3000000011", "quantity": 2 },
      { "variantId": "gid://shopify/ProductVariant/3000000001", "quantity": 1 }
    ],
    "shippingAddress": {
      "firstName": "Ada",
      "lastName": "Example",
      "address1": "Calle Ejemplo 1",
      "city": "Madrid",
      "zip": "28001",
      "countryCode": "ES"
    },
    "shippingLine": {
      "title": "Spain flat rate",
      "priceWithCurrency": { "amount": "4.90", "currencyCode": "EUR" }
    }
  }
}

{ "id": "gid://shopify/DraftOrder/8000000001" }

{ "query": "fulfillment_status:unfulfilled financial_status:paid" }

{
  "orderId": "gid://shopify/Order/9000000001",
  "reason": "OTHER",
  "refundMethod": { "originalPaymentMethodsRefund": true }
}

mutation CreateCustomer($input: CustomerInput!) {
  customerCreate(input: $input) {
    customer {
      id
      displayName
      tags
      emailMarketingConsent {
        marketingState
      }
    }
    userErrors {
      field
      message
    }
  }
}

mutation CreateSegment($name: String!, $query: String!) {
  segmentCreate(name: $name, query: $query) {
    segment {
      id
      name
      query
    }
    userErrors {
      field
      message
    }
  }
}

{
  "input": {
    "firstName": "Ada",
    "lastName": "Example",
    "email": "ada@example.test",
    "locale": "es",
    "tags": ["Coffee Club"],
    "note": "Founding Coffee Club member",
    "emailMarketingConsent": {
      "marketingState": "SUBSCRIBED",
      "marketingOptInLevel": "SINGLE_OPT_IN"
    }
  }
}

{
  "name": "Coffee Club",
  "query": "customer_tags CONTAINS 'Coffee Club'"
}

mutation CoffeeClubAutomatic($input: DiscountAutomaticBasicInput!) {
  discountAutomaticBasicCreate(automaticBasicDiscount: $input) {
    automaticDiscountNode {
      id
      automaticDiscount {
        ... on DiscountAutomaticBasic {
          title
          status
        }
      }
    }
    userErrors {
      field
      message
      code
    }
  }
}

mutation CoffeeClubBeans($input: DiscountCodeBasicInput!) {
  discountCodeBasicCreate(basicCodeDiscount: $input) {
    codeDiscountNode {
      id
      codeDiscount {
        ... on DiscountCodeBasic {
          title
          status
          codes(first: 1) {
            nodes {
              code
            }
          }
        }
      }
    }
    userErrors {
      field
      message
      code
    }
  }
}

mutation CoffeeClubShipping($input: DiscountAutomaticFreeShippingInput!) {
  discountAutomaticFreeShippingCreate(freeShippingAutomaticDiscount: $input) {
    automaticDiscountNode {
      id
    }
    userErrors {
      field
      message
      code
    }
  }
}

{
  "input": {
    "title": "Coffee Club 10% off beans",
    "startsAt": "2026-11-01T00:00:00Z",
    "context": {
      "customerSegments": { "add": ["gid://shopify/Segment/7000000001"] }
    },
    "customerGets": {
      "value": { "percentage": 0.1 },
      "items": {
        "collections": { "add": ["gid://shopify/Collection/4000000001"] }
      }
    },
    "combinesWith": {
      "productDiscounts": false,
      "orderDiscounts": false,
      "shippingDiscounts": true
    }
  }
}

{
  "input": {
    "title": "Coffee Club 10% off beans",
    "code": "COFFEECLUB10",
    "startsAt": "2026-11-01T00:00:00Z",
    "appliesOncePerCustomer": false,
    "context": {
      "customerSegments": { "add": ["gid://shopify/Segment/7000000001"] }
    },
    "customerGets": {
      "value": { "percentage": 0.1 },
      "items": {
        "collections": { "add": ["gid://shopify/Collection/4000000001"] }
      }
    },
    "combinesWith": {
      "productDiscounts": false,
      "orderDiscounts": false,
      "shippingDiscounts": true
    }
  }
}

{
  "input": {
    "title": "Coffee Club free shipping over 40 EUR",
    "startsAt": "2026-11-01T00:00:00Z",
    "context": {
      "customerSegments": { "add": ["gid://shopify/Segment/7000000001"] }
    },
    "minimumRequirement": {
      "subtotal": { "greaterThanOrEqualToSubtotal": "40.00" }
    },
    "destination": { "all": true },
    "combinesWith": {
      "productDiscounts": true,
      "orderDiscounts": true,
      "shippingDiscounts": false
    }
  }
}

mutation IssueGiftCard($input: GiftCardCreateInput!) {
  giftCardCreate(input: $input) {
    giftCard {
      id
      maskedCode
      lastCharacters
      balance {
        amount
        currencyCode
      }
      expiresOn
    }
    giftCardCode
    userErrors {
      field
      message
      code
    }
  }
}

mutation GiftCardProduct($product: ProductCreateInput!) {
  productCreate(product: $product) {
    product {
      id
      isGiftCard
    }
    userErrors {
      field
      message
    }
  }
}

{
  "input": {
    "initialAmount": { "amount": "25.00", "currencyCode": "EUR" },
    "customerId": "gid://shopify/Customer/10000000001",
    "expiresOn": "2027-12-31",
    "note": "Goodwill gift for a delayed parcel"
  }
}

{
  "product": {
    "title": "Pocket Coffee gift card",
    "giftCard": true,
    "status": "DRAFT"
  }
}

{% doc %}
  Summarises the gift card shown on the gift card page.

  @param {gift_card} gift_card - The gift_card object of templates/gift_card.liquid

  @example
  {% render 'gift-card-summary', gift_card: gift_card %}
{% enddoc %}

{%- if gift_card.enabled == false or gift_card.expired -%}
  <p>This gift card can no longer be used.</p>
{%- else -%}
  <p>Balance {{ gift_card.balance | money }} of {{ gift_card.initial_value | money }}</p>
  <p>Code ending in {{ gift_card.last_four_characters }}</p>
  {%- if gift_card.expires_on -%}
    <p>Valid until {{ gift_card.expires_on | date: '%d %B %Y' }}</p>
  {%- endif -%}
{%- endif -%}

{% render 'gift-card-summary', gift_card: gift_card %}

export SHOPIFY_FLAG_STORE=pocket-coffee-dev.myshopify.com

shopify store auth --store "$SHOPIFY_FLAG_STORE" \
  --scopes read_products,write_products,read_inventory,write_inventory,read_locations,write_locations

shopify store execute --store "$SHOPIFY_FLAG_STORE" --version 2026-10 \
  --query-file 01-product-set.graphql \
  --variable-file 01-product-set.SetBeans.vars.json \
  --allow-mutations --json

jq -n --rawfile query 04-inventory.graphql \
      --slurpfile variables 04-set-quantities.CountBeans.vars.json \
      '{query: $query, operationName: "CountBeans", variables: $variables[0]}' > request.json

curl -sS -X POST "https://${SHOPIFY_STORE_DOMAIN}/admin/api/2026-10/graphql.json" \
  -H "Content-Type: application/json" \
  -H "X-Shopify-Access-Token: ${SHOPIFY_ACCESS_TOKEN}" \
  --data @request.json

// Usage: node validate-admin.mjs 2026-10 gql/01-product-set.graphql#SetBeans=vars/01.json ...
// Validates documents against the public Admin GraphQL schema and, when a variables file is
// given, checks the JSON variables against the declared variable types of that operation.
import fs from 'node:fs';
import { buildClientSchema, getIntrospectionQuery, getVariableValues, Kind, parse, validate } from 'graphql';

const [version, ...checks] = process.argv.slice(2);
const cache = `schema-${version}.json`;
if (!fs.existsSync(cache)) {
  const res = await fetch(`https://shopify.dev/admin-graphql-direct-proxy/${version}`, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ query: getIntrospectionQuery() }),
  });
  fs.writeFileSync(cache, await res.text());
}
const schema = buildClientSchema(JSON.parse(fs.readFileSync(cache, 'utf8')).data);

let failures = 0;
for (const check of checks) {
  const [file, rest] = check.split('#');
  const doc = parse(fs.readFileSync(file, 'utf8'));
  const errors = validate(schema, doc).map((e) => e.message);
  if (rest) {
    const [operation, varsFile] = rest.split('=');
    const op = doc.definitions.find((d) => d.kind === Kind.OPERATION_DEFINITION && d.name?.value === operation);
    if (!op) errors.push(`operation ${operation} not found`);
    else {
      const vars = getVariableValues(schema, op.variableDefinitions ?? [], JSON.parse(fs.readFileSync(varsFile, 'utf8')));
      if (vars.errors) errors.push(...vars.errors.map((e) => e.message));
    }
  }
  console.log(`${errors.length ? 'INVALID' : 'VALID  '} ${check}`);
  errors.forEach((m) => console.log(`        ${m}`));
  failures += errors.length;
}
process.exit(failures ? 1 : 0);

$ npm install graphql@16.14.2
$ node validate-admin.mjs 2026-10 \
    01-product-set.graphql#SetBeans=01-product-set.SetBeans.vars.json \
    04-inventory.graphql#CountBeans=04-set-quantities.CountBeans.vars.json
VALID   01-product-set.graphql#SetBeans=01-product-set.SetBeans.vars.json
VALID   04-inventory.graphql#CountBeans=04-set-quantities.CountBeans.vars.json