The counts match. 65 products don’t.

#!/usr/bin/env node
/**
 * Exports the catalog from a Shopify store as the "target" side of the
 * reconciliation: one JSON array of products with their variants.
 *
 *   SHOP=example.myshopify.com SHOPIFY_ADMIN_TOKEN=shpat_... node export-catalog.mjs > target.json
 *
 * Needs Node 20 or later and an Admin API access token for an app with the
 * read_products scope, installed on the store: a Dev Dashboard app using the
 * client credentials grant (stores in the app's own organization only; the
 * token lasts 24 hours), or the shpat_ token of a custom app already created in
 * the store's admin. Shopify no longer allows new admin-created custom apps.
 *
 * Uses a bulk operation, so it is one request to start and one file to read,
 * whatever the size of the catalog.
 *
 * Status: every query here validates against the Admin GraphQL schema
 * (checked October 4, 2026). The script has not yet been run against a store.
 */
import { readFile } from 'node:fs/promises';
import { createInterface } from 'node:readline';
import { Readable } from 'node:stream';

const { SHOP, SHOPIFY_ADMIN_TOKEN, SHOPIFY_API_VERSION = '2026-07' } = process.env;
if (!SHOP || !SHOPIFY_ADMIN_TOKEN) {
  console.error('Set SHOP and SHOPIFY_ADMIN_TOKEN.');
  process.exit(1);
}

const endpoint = `https://${SHOP}/admin/api/${SHOPIFY_API_VERSION}/graphql.json`;

async function admin(query, variables = {}) {
  const response = await fetch(endpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-Shopify-Access-Token': SHOPIFY_ADMIN_TOKEN },
    body: JSON.stringify({ query, variables }),
  });
  if (!response.ok) throw new Error(`Admin API ${response.status}: ${await response.text()}`);
  const body = await response.json();
  if (body.errors) throw new Error(JSON.stringify(body.errors));
  return body.data;
}

// Strip the comment lines: the bulk operation takes the bare query.
const catalogQuery = (await readFile(new URL('../graphql/catalog-export.graphql', import.meta.url), 'utf8'))
  .split('\n')
  .filter((line) => !line.trimStart().startsWith('#'))
  .join('\n');

const started = await admin(
  `mutation RunCatalogExport($query: String!) {
    bulkOperationRunQuery(query: $query) {
      bulkOperation { id status }
      userErrors { field message }
    }
  }`,
  { query: catalogQuery },
);

const { bulkOperation, userErrors } = started.bulkOperationRunQuery;
if (userErrors.length) throw new Error(JSON.stringify(userErrors));

// Poll by id. bulkOperation(id:) is available from API version 2026-01, where currentBulkOperation is deprecated.
let operation = bulkOperation;
while (operation.status === 'CREATED' || operation.status === 'RUNNING') {
  await new Promise((resolve) => setTimeout(resolve, 2000));
  const data = await admin(
    `query ExportStatus($id: ID!) {
      bulkOperation(id: $id) { id status errorCode objectCount url }
    }`,
    { id: operation.id },
  );
  operation = data.bulkOperation;
  console.error(`${operation.status} · ${operation.objectCount} objects`);
}
if (operation.status !== 'COMPLETED') throw new Error(`Export ${operation.status}: ${operation.errorCode ?? 'no error code'}`);
if (!operation.url) {
  console.log('[]');
  process.exit(0);
}

/**
 * How the check reads Shopify's product status. ARCHIVED counts as draft: neither has a public page.
 * UNLISTED (reachable by link, kept out of listings and search) is left out on purpose. Whether it
 * counts as public depends on the migration, so the export stops and asks instead of guessing.
 */
const STATUS = { ACTIVE: 'active', DRAFT: 'draft', ARCHIVED: 'draft' };

/** The old store's id, from the migration.source_id metafield. Missing is allowed; garbage is not. */
function sourceIdOf(row) {
  if (!row.sourceId) return null;
  const id = Number(row.sourceId.value);
  if (!Number.isInteger(id)) throw new Error(`${row.id}: migration.source_id is "${row.sourceId.value}", not a number.`);
  return id;
}

const toCents = (money) => (money === null ? null : Math.round(Number(money) * 100));

// The file is JSONL, one object per line. Each variant names its product in __parentId.
// It is read line by line so a large catalog never sits in memory as one string.
const download = await fetch(operation.url);
if (!download.ok || !download.body) throw new Error(`Export file ${download.status}: could not download it.`);

const products = new Map();
const variants = [];
for await (const line of createInterface({ input: Readable.fromWeb(download.body), crlfDelay: Infinity })) {
  if (!line.trim()) continue;
  const row = JSON.parse(line);
  if (row.__parentId) {
    variants.push(row);
    continue;
  }
  const status = STATUS[row.status];
  if (!status) throw new Error(`${row.id}: product status ${row.status} is not mapped. Decide how the check should treat it, then add it to STATUS.`);
  products.set(row.id, {
    sourceId: sourceIdOf(row),
    handle: row.handle,
    title: row.title,
    status,
    casePack: row.casePack ? Number(row.casePack.value) : null,
    variants: [],
  });
}

for (const row of variants) {
  const product = products.get(row.__parentId);
  if (!product) throw new Error(`${row.id}: variant with no product in the export (parent ${row.__parentId}).`);
  product.variants.push({
    sourceId: sourceIdOf(row),
    sku: row.sku ?? '',
    options: row.selectedOptions.map((option) => [option.name, option.value]),
    price: toCents(row.price),
    compareAtPrice: toCents(row.compareAtPrice),
    inventoryPolicy: row.inventoryPolicy === 'CONTINUE' ? 'continue' : 'deny',
  });
}

console.log(JSON.stringify([...products.values()], null, 2));

# The catalog as the new store holds it, in the shape the reconciliation needs.
# Run as a bulk operation: Shopify strips the pagination arguments and returns
# every product and variant as one JSONL file.
#
# migration.source_id is a metafield written during import. It carries the old
# store's id so records can be matched even when a SKU or handle has changed.
#
# Scope: read_products
{
  products {
    edges {
      node {
        id
        handle
        title
        status
        sourceId: metafield(namespace: "migration", key: "source_id") {
          value
        }
        casePack: metafield(namespace: "custom", key: "case_pack") {
          value
        }
        variants {
          edges {
            node {
              id
              sku
              price
              compareAtPrice
              inventoryPolicy
              selectedOptions {
                name
                value
              }
              sourceId: metafield(namespace: "migration", key: "source_id") {
                value
              }
            }
          }
        }
      }
    }
  }
}

# Loads the reconciled redirect map (redirects.csv, columns "Redirect from" and
# "Redirect to") through the Admin API instead of the admin screen.
#
# Three mutations and a status query, in order:
#   1. StageRedirectCsv      reserve an upload target, then POST the CSV to it
#   2. CreateRedirectImport  point Shopify at the uploaded file; read how many rows
#                            the file holds and preview the first few, before
#                            anything is applied
#   3. SubmitRedirectImport  apply it, once the row count matches the map
#   4. RedirectImportStatus  poll until finished, then read created, updated and
#                            failed counts
#
# Variables for StageRedirectCsv:
#   {"input":[{"resource":"URL_REDIRECT_IMPORT","filename":"redirects.csv",
#              "mimeType":"text/csv","httpMethod":"POST"}]}
#
# Not yet confirmed against a store: whether CreateRedirectImport wants the staged
# target's url or its resourceUrl. I would try resourceUrl first.
#
# Scopes: write_online_store_navigation, read_online_store_navigation

mutation StageRedirectCsv($input: [StagedUploadInput!]!) {
  stagedUploadsCreate(input: $input) {
    stagedTargets {
      url
      resourceUrl
      parameters {
        name
        value
      }
    }
    userErrors {
      field
      message
    }
  }
}

mutation CreateRedirectImport($url: URL!) {
  urlRedirectImportCreate(url: $url) {
    urlRedirectImport {
      id
      count
      previewRedirects {
        path
        target
      }
    }
    userErrors {
      field
      message
    }
  }
}

mutation SubmitRedirectImport($id: ID!) {
  urlRedirectImportSubmit(id: $id) {
    job {
      id
      done
    }
    userErrors {
      field
      message
    }
  }
}

query RedirectImportStatus($id: ID!) {
  urlRedirectImport(id: $id) {
    id
    count
    createdCount
    updatedCount
    failedCount
    finished
    finishedAt
  }
}

{% comment %}
  Case-pack price

  Shows the case price, how many units a case holds and the price per unit.
  The pack size is read from the product metafield custom.case_pack (integer).

  If the metafield is missing or 1, the section renders nothing on the
  storefront. A product whose pack size was lost in a migration then shows a
  normal price instead of a wrong unit price, and the theme editor says why the
  section is hidden.

  The login setting hides only this section's prices. Real wholesale price
  gating also needs the theme's other price outputs hidden: the product form,
  product cards, search results and the cart.

  The price shown is for the selected or first available variant. Case products
  normally have one variant. For multi-variant products, re-render this section
  from the theme's variant-change handler.
{% endcomment %}

{%- liquid
  assign variant = product.selected_or_first_available_variant
  assign case_pack = product.metafields.custom.case_pack.value | default: 0 | plus: 0
  assign gated = false
  if section.settings.require_login and customer == blank
    assign gated = true
  endif
-%}

{%- if case_pack > 1 -%}
  <div class="case-pack">
    {%- if section.settings.heading != blank -%}
      <h2 class="case-pack__heading">{{ section.settings.heading | escape }}</h2>
    {%- endif -%}

    {%- if gated -%}
      <p class="case-pack__gate">
        {{ section.settings.login_text | escape }}
        <a href="{{ routes.account_login_url }}">{{ section.settings.login_link_label | escape }}</a>
      </p>
    {%- else -%}
      <dl class="case-pack__list">
        <div class="case-pack__row">
          <dt>{{ section.settings.case_label | escape }}</dt>
          <dd>{{ variant.price | money }}</dd>
        </div>
        <div class="case-pack__row">
          <dt>{{ section.settings.units_label | escape }}</dt>
          <dd>{{ case_pack }}</dd>
        </div>
        {%- if section.settings.show_unit_price -%}
          <div class="case-pack__row">
            <dt>{{ section.settings.unit_label | escape }}</dt>
            <dd>{{ variant.price | times: 1.0 | divided_by: case_pack | round | money }}</dd>
          </div>
        {%- endif -%}
      </dl>
    {%- endif -%}
  </div>
{%- elsif request.design_mode -%}
  <p class="case-pack__empty">
    This product has no pack size above 1 in custom.case_pack, so this section is hidden on the storefront.
  </p>
{%- endif -%}

{% stylesheet %}
  .case-pack__heading {
    margin: 0 0 0.5rem;
    font-size: 1rem;
  }

  .case-pack__list {
    margin: 0;
    display: grid;
    gap: 0.25rem;
  }

  .case-pack__row {
    display: flex;
    justify-content: space-between;
    gap: 1rem;
  }

  .case-pack__row dd {
    margin: 0;
    font-variant-numeric: tabular-nums;
  }
{% endstylesheet %}

{% schema %}
{
  "name": "Case-pack price",
  "tag": "section",
  "class": "section-case-pack",
  "enabled_on": {
    "templates": ["product"]
  },
  "settings": [
    {
      "type": "text",
      "id": "heading",
      "label": "Heading",
      "default": "Sold by the case"
    },
    {
      "type": "text",
      "id": "case_label",
      "label": "Case price label",
      "default": "Price per case"
    },
    {
      "type": "text",
      "id": "units_label",
      "label": "Units label",
      "default": "Units per case"
    },
    {
      "type": "checkbox",
      "id": "show_unit_price",
      "label": "Show price per unit",
      "default": true
    },
    {
      "type": "text",
      "id": "unit_label",
      "label": "Unit price label",
      "default": "Price per unit"
    },
    {
      "type": "checkbox",
      "id": "require_login",
      "label": "Hide this section’s prices from logged-out visitors",
      "default": false
    },
    {
      "type": "text",
      "id": "login_text",
      "label": "Message for logged-out visitors",
      "default": "Case pricing is available to trade accounts."
    },
    {
      "type": "text",
      "id": "login_link_label",
      "label": "Login link label",
      "default": "Log in"
    }
  ],
  "presets": [
    {
      "name": "Case-pack price"
    }
  ]
}
{% endschema %}