shop-cli 0.1.0

package/dist/cli/workflows/productVariants/upsert.js

@@ -0,0 +1,110 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var upsert_exports = {};
+__export(upsert_exports, {
+  upsertProductVariants: () => upsertProductVariants
+});
+module.exports = __toCommonJS(upsert_exports);
+var import_errors = require("../../errors");
+var import_gid = require("../../gid");
+var import_output = require("../../output");
+var import_router = require("../../router");
+var import_userErrors = require("../../userErrors");
+const requireProductId = (id) => {
+  if (!id) throw new import_errors.CliError("Missing --product-id", 2);
+  return (0, import_gid.coerceGid)(id, "Product");
+};
+const requireVariantsInput = (input) => {
+  if (Array.isArray(input)) return { variants: input, extra: {} };
+  if (input && typeof input === "object" && Array.isArray(input.variants)) {
+    const { variants, ...extra } = input;
+    return { variants, extra };
+  }
+  throw new import_errors.CliError("Missing variants input: pass --input as an array or { variants: [...] }", 2);
+};
+const upsertProductVariants = async ({
+  ctx,
+  productId,
+  input,
+  allowPartialUpdates,
+  strategy
+}) => {
+  const resolvedProductId = requireProductId(productId);
+  const { variants, extra } = requireVariantsInput(input);
+  if (variants.length === 0) throw new import_errors.CliError("variants must include at least one item", 2);
+  const toCreate = variants.filter((v) => !v?.id);
+  const toUpdate = variants.filter((v) => Boolean(v?.id));
+  const createdIds = [];
+  const updatedIds = [];
+  const out = {};
+  if (toCreate.length > 0) {
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkCreate: {
+        __args: {
+          productId: resolvedProductId,
+          variants: toCreate,
+          ...extra.media ? { media: extra.media } : {},
+          ...strategy ? { strategy } : extra.strategy ? { strategy: extra.strategy } : {}
+        },
+        productVariants: { id: true },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return void 0;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.productVariantsBulkCreate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    out.created = result.productVariantsBulkCreate;
+    for (const v of result.productVariantsBulkCreate?.productVariants ?? []) createdIds.push(v?.id);
+  }
+  if (toUpdate.length > 0) {
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkUpdate: {
+        __args: {
+          productId: resolvedProductId,
+          variants: toUpdate,
+          allowPartialUpdates,
+          ...extra.media ? { media: extra.media } : {}
+        },
+        productVariants: { id: true },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return void 0;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.productVariantsBulkUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    out.updated = result.productVariantsBulkUpdate;
+    for (const v of result.productVariantsBulkUpdate?.productVariants ?? []) updatedIds.push(v?.id);
+  }
+  if (ctx.quiet) {
+    (0, import_output.printIds)([...createdIds, ...updatedIds]);
+    return;
+  }
+  if (toCreate.length > 0 && toUpdate.length === 0) return out.created;
+  if (toUpdate.length > 0 && toCreate.length === 0) return out.updated;
+  return out;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  upsertProductVariants
+});
+//# sourceMappingURL=upsert.js.map

package/dist/cli/workflows/products/metafieldsUpsert.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext } from '../../router';
+export declare const metafieldsUpsert: ({ ctx, id, input, }: {
+    ctx: CommandContext;
+    id: string | undefined;
+    input: any;
+}) => Promise<any>;

package/dist/cli/workflows/products/metafieldsUpsert.js

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var metafieldsUpsert_exports = {};
+__export(metafieldsUpsert_exports, {
+  metafieldsUpsert: () => metafieldsUpsert
+});
+module.exports = __toCommonJS(metafieldsUpsert_exports);
+var import_errors = require("../../errors");
+var import_gid = require("../../gid");
+var import_output = require("../../output");
+var import_router = require("../../router");
+var import_userErrors = require("../../userErrors");
+const requireProductId = (id) => {
+  if (!id) throw new import_errors.CliError("Missing --id", 2);
+  return (0, import_gid.coerceGid)(id, "Product");
+};
+const asArray = (value) => {
+  if (Array.isArray(value)) return value;
+  if (value && Array.isArray(value.metafields)) return value.metafields;
+  if (value && typeof value === "object") return [value];
+  return [];
+};
+const chunk = (items, size) => {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+};
+const metafieldsUpsert = async ({
+  ctx,
+  id,
+  input
+}) => {
+  const ownerId = requireProductId(id);
+  const items = asArray(input);
+  if (items.length === 0) throw new import_errors.CliError("Missing metafield input: pass --input/--set/--set-json", 2);
+  const normalized = items.map((m) => {
+    if (!m || typeof m !== "object") throw new import_errors.CliError("Metafield inputs must be objects", 2);
+    const { key, namespace, type, value, compareDigest } = m;
+    if (!key) throw new import_errors.CliError("Metafield input missing key", 2);
+    if (value === void 0) throw new import_errors.CliError("Metafield input missing value", 2);
+    return {
+      ownerId,
+      key,
+      namespace,
+      type,
+      value: String(value),
+      compareDigest
+    };
+  });
+  const payloads = [];
+  const ids = [];
+  for (const group of chunk(normalized, 25)) {
+    const result = await (0, import_router.runMutation)(ctx, {
+      metafieldsSet: {
+        __args: { metafields: group },
+        metafields: { id: true },
+        userErrors: { field: true, message: true, elementIndex: true, code: true }
+      }
+    });
+    if (result === void 0) return void 0;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.metafieldsSet,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    payloads.push(result.metafieldsSet);
+    for (const mf of result.metafieldsSet?.metafields ?? []) ids.push(mf?.id);
+  }
+  if (ctx.quiet) {
+    (0, import_output.printIds)(ids);
+    return;
+  }
+  return payloads.length === 1 ? payloads[0] : payloads;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  metafieldsUpsert
+});
+//# sourceMappingURL=metafieldsUpsert.js.map

package/dist/cli/workflows/products/publishablePublish.d.ts

@@ -0,0 +1,21 @@
+import { type CommandContext } from '../../router';
+export declare const parsePublishDate: ({ at, now, }: {
+    at: string | undefined;
+    now: boolean | undefined;
+}) => string | undefined;
+export declare const resolvePublicationIds: ({ ctx, publicationIds, publicationNames, }: {
+    ctx: CommandContext;
+    publicationIds: string[];
+    publicationNames: string[];
+}) => Promise<string[]>;
+export declare const publishProduct: ({ ctx, id, publicationIds, publishDate, }: {
+    ctx: CommandContext;
+    id: string | undefined;
+    publicationIds: string[];
+    publishDate?: string;
+}) => Promise<any>;
+export declare const unpublishProduct: ({ ctx, id, publicationIds, }: {
+    ctx: CommandContext;
+    id: string | undefined;
+    publicationIds: string[];
+}) => Promise<any>;

package/dist/cli/workflows/products/publishablePublish.js

@@ -0,0 +1,131 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var publishablePublish_exports = {};
+__export(publishablePublish_exports, {
+  parsePublishDate: () => parsePublishDate,
+  publishProduct: () => publishProduct,
+  resolvePublicationIds: () => resolvePublicationIds,
+  unpublishProduct: () => unpublishProduct
+});
+module.exports = __toCommonJS(publishablePublish_exports);
+var import_errors = require("../../errors");
+var import_gid = require("../../gid");
+var import_router = require("../../router");
+var import_userErrors = require("../../userErrors");
+var import_resolvePublicationId = require("../publications/resolvePublicationId");
+const requireProductId = (id) => {
+  if (!id) throw new import_errors.CliError("Missing --id", 2);
+  return (0, import_gid.coerceGid)(id, "Product");
+};
+const parsePublishDate = ({
+  at,
+  now
+}) => {
+  if (at && now) throw new import_errors.CliError("Pass either --at <iso> or --now, not both", 2);
+  if (now) return (/* @__PURE__ */ new Date()).toISOString();
+  return at;
+};
+const normalizePublicationId = (value) => {
+  const raw = value.trim();
+  if (!raw) throw new import_errors.CliError("publication ID cannot be empty", 2);
+  if ((0, import_gid.isGid)(raw)) {
+    if (!raw.startsWith("gid://shopify/Publication/")) {
+      throw new import_errors.CliError(`Expected a Publication GID (gid://shopify/Publication/...). Got: ${value}`, 2);
+    }
+    return raw;
+  }
+  if (/^\d+$/.test(raw)) return (0, import_gid.coerceGid)(raw, "Publication");
+  throw new import_errors.CliError(`Expected a numeric ID or full GID for Publication. Got: ${value}`, 2);
+};
+const resolvePublicationIds = async ({
+  ctx,
+  publicationIds,
+  publicationNames
+}) => {
+  if (ctx.dryRun && publicationNames.length > 0) {
+    throw new import_errors.CliError(
+      "In --dry-run mode, --publication cannot be resolved without executing a query. Use --publication-id <gid|num> instead.",
+      2
+    );
+  }
+  const ids = publicationIds.map(normalizePublicationId);
+  if (publicationNames.length > 0) {
+    const publications = await (0, import_resolvePublicationId.listPublications)(ctx);
+    for (const name of publicationNames) {
+      ids.push((0, import_resolvePublicationId.resolvePublicationIdFromList)({ publications, identifier: name }));
+    }
+  }
+  const unique = Array.from(new Set(ids));
+  if (unique.length === 0) throw new import_errors.CliError("Missing --publication-id or --publication", 2);
+  return unique;
+};
+const publishProduct = async ({
+  ctx,
+  id,
+  publicationIds,
+  publishDate
+}) => {
+  const productId = requireProductId(id);
+  const input = publicationIds.map((publicationId) => ({
+    publicationId,
+    ...publishDate ? { publishDate } : {}
+  }));
+  const result = await (0, import_router.runMutation)(ctx, {
+    publishablePublish: {
+      __args: { id: productId, input },
+      publishable: { __typename: true, on_Product: { id: true } },
+      userErrors: { field: true, message: true }
+    }
+  });
+  if (result === void 0) return void 0;
+  (0, import_userErrors.maybeFailOnUserErrors)({
+    payload: result.publishablePublish,
+    failOnUserErrors: ctx.failOnUserErrors
+  });
+  return result.publishablePublish;
+};
+const unpublishProduct = async ({
+  ctx,
+  id,
+  publicationIds
+}) => {
+  const productId = requireProductId(id);
+  const input = publicationIds.map((publicationId) => ({ publicationId }));
+  const result = await (0, import_router.runMutation)(ctx, {
+    publishableUnpublish: {
+      __args: { id: productId, input },
+      publishable: { __typename: true, on_Product: { id: true } },
+      userErrors: { field: true, message: true }
+    }
+  });
+  if (result === void 0) return void 0;
+  (0, import_userErrors.maybeFailOnUserErrors)({
+    payload: result.publishableUnpublish,
+    failOnUserErrors: ctx.failOnUserErrors
+  });
+  return result.publishableUnpublish;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parsePublishDate,
+  publishProduct,
+  resolvePublicationIds,
+  unpublishProduct
+});
+//# sourceMappingURL=publishablePublish.js.map

package/dist/cli/workflows/publications/resolvePublicationId.d.ts

@@ -0,0 +1,17 @@
+import { type CommandContext } from '../../router';
+export type PublicationSummary = {
+    id: string;
+    name?: string | null;
+    catalogTitle?: string | null;
+    autoPublish?: boolean | null;
+};
+export declare const listPublications: (ctx: CommandContext) => Promise<PublicationSummary[]>;
+export declare const resolvePublicationIdFromList: ({ publications, identifier, }: {
+    publications: PublicationSummary[];
+    identifier: string;
+}) => string;
+export declare const resolvePublicationId: ({ ctx, publications, identifier, }: {
+    ctx: CommandContext;
+    publications?: PublicationSummary[];
+    identifier: string;
+}) => Promise<string>;

package/dist/cli/workflows/publications/resolvePublicationId.js

@@ -0,0 +1,93 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolvePublicationId_exports = {};
+__export(resolvePublicationId_exports, {
+  listPublications: () => listPublications,
+  resolvePublicationId: () => resolvePublicationId,
+  resolvePublicationIdFromList: () => resolvePublicationIdFromList
+});
+module.exports = __toCommonJS(resolvePublicationId_exports);
+var import_errors = require("../../errors");
+var import_gid = require("../../gid");
+var import_router = require("../../router");
+const listPublications = async (ctx) => {
+  const result = await (0, import_router.runQuery)(ctx, {
+    publications: {
+      __args: { first: 250 },
+      nodes: {
+        id: true,
+        name: true,
+        autoPublish: true,
+        catalog: { title: true }
+      }
+    }
+  });
+  if (result === void 0) return [];
+  const nodes = result.publications?.nodes ?? [];
+  return nodes.map((p) => ({
+    id: p?.id,
+    name: p?.name,
+    catalogTitle: p?.catalog?.title,
+    autoPublish: p?.autoPublish
+  }));
+};
+const normalize = (value) => value.trim().toLowerCase();
+const resolvePublicationIdFromList = ({
+  publications,
+  identifier
+}) => {
+  const raw = identifier.trim();
+  if (!raw) throw new import_errors.CliError("Missing publication identifier", 2);
+  if ((0, import_gid.isGid)(raw)) {
+    if (!raw.startsWith("gid://shopify/Publication/")) {
+      throw new import_errors.CliError(`Expected a Publication GID (gid://shopify/Publication/...). Got: ${raw}`, 2);
+    }
+    return raw;
+  }
+  if (/^\d+$/.test(raw)) return (0, import_gid.coerceGid)(raw, "Publication");
+  const target = normalize(raw);
+  const matches = publications.filter((p) => {
+    const names = [p.name, p.catalogTitle].filter((v) => Boolean(v));
+    return names.some((n) => normalize(n) === target);
+  });
+  if (matches.length === 1) return matches[0].id;
+  if (matches.length > 1) {
+    throw new import_errors.CliError(
+      `Publication name is ambiguous (${raw}): ${matches.map((m) => `${m.name ?? m.catalogTitle ?? "(unknown)"} (${m.id})`).join(", ")}`,
+      2
+    );
+  }
+  const hint = publications.length === 0 ? "" : ` Known publications: ${publications.map((p) => p.name ?? p.catalogTitle ?? "(unknown)").filter((v, i, arr) => v && arr.indexOf(v) === i).slice(0, 12).join(", ")}`;
+  throw new import_errors.CliError(`No publication found matching: ${raw}.${hint}`, 2);
+};
+const resolvePublicationId = async ({
+  ctx,
+  publications,
+  identifier
+}) => {
+  const list = publications ?? await listPublications(ctx);
+  return resolvePublicationIdFromList({ publications: list, identifier });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  listPublications,
+  resolvePublicationId,
+  resolvePublicationIdFromList
+});
+//# sourceMappingURL=resolvePublicationId.js.map

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,152 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_dotenv = __toESM(require("dotenv"));
+var import_path = require("path");
+var import_client = require("./cli/client");
+var import_errors = require("./cli/errors");
+var import_globalFlags = require("./cli/globalFlags");
+var import_headers = require("./cli/headers");
+var import_render = require("./cli/help/render");
+var import_router = require("./cli/router");
+var import_adminClient = require("./adminClient");
+var import_defaults = require("./defaults");
+var import_command = require("./cli/command");
+var import_output = require("./cli/output");
+import_dotenv.default.config({ path: (0, import_path.resolve)(process.cwd(), ".env"), quiet: true });
+const helpFlags = /* @__PURE__ */ new Set(["--help", "-h", "--help-full", "--help-all"]);
+const hasHelpFlag = (args) => args.some((arg) => helpFlags.has(arg));
+const wantsFullHelp = (args) => args.some((arg) => arg === "--help-full" || arg === "--help-all");
+const main = async () => {
+  const command = (0, import_command.resolveCliCommand)();
+  (0, import_output.setGlobalCommand)(command);
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv[0] === "help" || hasHelpFlag([argv[0]])) {
+    console.log((0, import_render.renderTopLevelHelp)(command));
+    return;
+  }
+  const resource = argv[0];
+  if (!resource) {
+    console.log((0, import_render.renderTopLevelHelp)(command));
+    throw new import_errors.CliError("Missing <resource>", 2);
+  }
+  const afterResource = argv.slice(1);
+  const firstFlagIndex = afterResource.findIndex((t) => t.startsWith("-"));
+  const verbParts = firstFlagIndex === -1 ? afterResource : afterResource.slice(0, firstFlagIndex);
+  const rest = firstFlagIndex === -1 ? [] : afterResource.slice(firstFlagIndex);
+  const verb = verbParts.join(" ");
+  const isTypesCommand = resource === "types";
+  if (!verb) {
+    if (isTypesCommand && hasHelpFlag(afterResource)) {
+    } else {
+      const resourceHelp = (0, import_render.renderResourceHelp)(resource, command);
+      if (resourceHelp) {
+        console.log(resourceHelp);
+        if (hasHelpFlag(afterResource)) return;
+        throw new import_errors.CliError(`
+Missing <verb> for "${resource}"`, 2);
+      } else if (!isTypesCommand) {
+        console.log((0, import_render.renderTopLevelHelp)(command));
+        throw new import_errors.CliError(`
+Unknown resource: ${resource}`, 2);
+      }
+    }
+  }
+  if (hasHelpFlag(rest)) {
+    if (isTypesCommand) {
+    } else {
+      const verbHelp = (0, import_render.renderVerbHelp)(resource, verb, { showAllFields: wantsFullHelp(rest) }, command);
+      if (verbHelp) {
+        console.log(verbHelp);
+        return;
+      }
+      const resourceHelp = (0, import_render.renderResourceHelp)(resource, command);
+      if (resourceHelp) {
+        console.log(resourceHelp);
+        return;
+      }
+      console.log((0, import_render.renderTopLevelHelp)(command));
+      return;
+    }
+  }
+  const parsed = (0, import_globalFlags.parseGlobalFlags)(rest);
+  const dryRun = parsed.dryRun ?? false;
+  const isOfflineCommand = verb === "fields" || isTypesCommand;
+  const shopDomain = parsed.shopDomain;
+  const graphqlEndpoint = parsed.graphqlEndpoint;
+  const accessToken = parsed.accessToken;
+  const envHeaders = (0, import_headers.parseHeadersFromEnv)(process.env.SHOPIFY_HEADERS);
+  const cliHeaders = (0, import_headers.parseHeaderValues)(parsed.headers, "--header");
+  const headers = { ...envHeaders, ...cliHeaders };
+  const resolvedAccessToken = accessToken ?? process.env.SHOPIFY_ACCESS_TOKEN;
+  const hasAuthHeader = Object.keys(headers).some((name) => {
+    const normalized = name.toLowerCase();
+    return normalized === "authorization" || normalized === "x-shopify-access-token";
+  });
+  const apiVersion = parsed.apiVersion;
+  const warnMissingAccessToken = !resolvedAccessToken && !hasAuthHeader;
+  const verbose = parsed.verbose ?? false;
+  const resolvedApiVersion = (0, import_defaults.resolveAdminApiVersion)(apiVersion ?? process.env.SHOPIFY_API_VERSION);
+  const client = dryRun || isOfflineCommand ? (0, import_adminClient.createShopifyAdminClient)({
+    shopDomain: shopDomain ?? process.env.SHOPIFY_SHOP ?? "example.myshopify.com",
+    graphqlEndpoint: graphqlEndpoint ?? process.env.GRAPHQL_ENDPOINT,
+    accessToken: resolvedAccessToken ?? "DUMMY",
+    apiVersion: resolvedApiVersion,
+    headers,
+    verbose
+  }) : (0, import_client.createCliClientFromEnv)({
+    shopDomain,
+    graphqlEndpoint,
+    accessToken,
+    apiVersion,
+    headers,
+    verbose
+  });
+  await (0, import_router.runCommand)({
+    client,
+    resource,
+    verb,
+    argv: parsed.passthrough,
+    format: parsed.format ?? (isOfflineCommand ? "table" : "json"),
+    quiet: parsed.quiet ?? false,
+    view: parsed.view ?? "summary",
+    dryRun,
+    failOnUserErrors: !(parsed.noFailOnUserErrors ?? false),
+    warnMissingAccessToken,
+    // Raw GraphQL client options (for graphql command)
+    shopDomain: shopDomain ?? process.env.SHOPIFY_SHOP,
+    graphqlEndpoint: graphqlEndpoint ?? process.env.GRAPHQL_ENDPOINT,
+    accessToken: resolvedAccessToken,
+    apiVersion: resolvedApiVersion,
+    headers
+  });
+};
+main().catch((err) => {
+  if (err instanceof import_errors.CliError) {
+    console.error(err.message);
+    process.exit(err.exitCode);
+  }
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/defaults.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ADMIN_API_VERSION: "2026-04";
+export declare const resolveAdminApiVersion: (apiVersion: unknown) => string;

package/dist/defaults.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var defaults_exports = {};
+__export(defaults_exports, {
+  DEFAULT_ADMIN_API_VERSION: () => DEFAULT_ADMIN_API_VERSION,
+  resolveAdminApiVersion: () => resolveAdminApiVersion
+});
+module.exports = __toCommonJS(defaults_exports);
+const DEFAULT_ADMIN_API_VERSION = "2026-04";
+const resolveAdminApiVersion = (apiVersion) => {
+  if (typeof apiVersion === "string") {
+    const trimmed = apiVersion.trim();
+    if (trimmed.length > 0) return trimmed;
+  }
+  return DEFAULT_ADMIN_API_VERSION;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_ADMIN_API_VERSION,
+  resolveAdminApiVersion
+});
+//# sourceMappingURL=defaults.js.map