shop-cli 0.1.1

package/dist/cli/output.js

@@ -0,0 +1,332 @@
+"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 output_exports = {};
+__export(output_exports, {
+  printConnection: () => printConnection,
+  printIds: () => printIds,
+  printJson: () => printJson,
+  printJsonError: () => printJsonError,
+  printNode: () => printNode,
+  setGlobalCommand: () => setGlobalCommand,
+  setGlobalOutputFormat: () => setGlobalOutputFormat,
+  writeJson: () => writeJson
+});
+module.exports = __toCommonJS(output_exports);
+var import_errors = require("./errors");
+let globalOutputFormat;
+let globalCommand;
+const setGlobalOutputFormat = (format) => {
+  globalOutputFormat = format;
+};
+const setGlobalCommand = (command) => {
+  globalCommand = command?.trim() ? command : void 0;
+};
+const writeJson = (data, {
+  pretty = true,
+  stream = process.stdout
+} = {}) => {
+  const effectivePretty = globalOutputFormat === "jsonl" ? false : pretty;
+  stream.write(JSON.stringify(data, null, effectivePretty ? 2 : 0));
+  stream.write("\n");
+};
+const printJson = (data, pretty = true) => writeJson(data, { pretty });
+const printJsonError = (data, pretty = true) => writeJson(data, { pretty, stream: process.stderr });
+const printIds = (ids) => {
+  for (const id of ids) {
+    if (id) process.stdout.write(`${id}
+`);
+  }
+};
+const doubleQuote = (value) => `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+const withEffectiveBaseCommand = (base) => {
+  if (!globalCommand) return base;
+  return base.replace(/^(shop|shop-cli)(?=\s|$)/, globalCommand);
+};
+const buildNextPageCommand = ({
+  base,
+  endCursor,
+  first,
+  query,
+  sort,
+  reverse,
+  extraFlags
+}) => {
+  const parts = [withEffectiveBaseCommand(base)];
+  for (const extra of extraFlags ?? []) {
+    if (!extra?.flag) continue;
+    const value = extra.value;
+    if (typeof value === "boolean") {
+      if (value) parts.push(extra.flag);
+      continue;
+    }
+    if (typeof value === "number") {
+      if (Number.isFinite(value)) parts.push(extra.flag, String(value));
+      continue;
+    }
+    if (typeof value === "string" && value) {
+      parts.push(extra.flag, doubleQuote(value));
+    }
+  }
+  if (typeof first === "number" && Number.isFinite(first) && first > 0 && first !== 50) {
+    parts.push(`--first ${Math.floor(first)}`);
+  }
+  parts.push(`--after ${doubleQuote(endCursor)}`);
+  if (query) parts.push(`--query ${doubleQuote(query)}`);
+  if (sort) parts.push(`--sort ${sort}`);
+  if (reverse) parts.push("--reverse");
+  return parts.join(" ");
+};
+const toTableCell = (value) => {
+  if (value === null || value === void 0) return "";
+  const t = typeof value;
+  if (t === "string") return String(value);
+  if (t === "number" || t === "boolean") return String(value);
+  return JSON.stringify(value);
+};
+const formatPublicationsForTable = (value) => {
+  if (!Array.isArray(value)) return void 0;
+  const parts = [];
+  for (const p of value) {
+    if (!p || typeof p !== "object") continue;
+    const title = typeof p.title === "string" ? p.title : void 0;
+    if (!title) continue;
+    const isPublished = p.isPublished === true;
+    const publishDate = typeof p.publishDate === "string" ? p.publishDate : void 0;
+    const suffix = publishDate ? ` ${isPublished ? "published" : "staged"} ${publishDate}` : ` ${isPublished ? "published" : "staged"}`;
+    parts.push(`${title}${suffix}`);
+  }
+  return parts.join("; ");
+};
+const coerceComputedFieldsForTable = (node) => {
+  const computed = node["[publications]"];
+  if (computed !== void 0) {
+    const formatted = formatPublicationsForTable(computed);
+    if (formatted !== void 0) return { ...node, ["[publications]"]: formatted };
+  }
+  return node;
+};
+const escapeMarkdownTableCell = (value) => {
+  return value.replace(/\|/g, "\\|").replace(/\n/g, " ");
+};
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isPrimitive = (value) => value === null || value === void 0 || typeof value !== "object";
+const flattenSingleKeyPaths = (obj) => {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (isPlainObject(value)) {
+      const keys = Object.keys(value);
+      if (keys.length === 1) {
+        const flattened = flattenSingleKeyPaths(value);
+        const flattenedKeys = Object.keys(flattened);
+        if (flattenedKeys.length === 1) {
+          const childKey = flattenedKeys[0];
+          const childValue = flattened[childKey];
+          if (isPrimitive(childValue)) {
+            result[`${key}.${childKey}`] = childValue;
+            continue;
+          }
+        }
+      }
+      result[key] = value;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+};
+const printMarkdownTable = (rows) => {
+  if (rows.length === 0) return;
+  const keys = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const key of Object.keys(row)) keys.add(key);
+  }
+  const headers = Array.from(keys);
+  if (headers.length === 0) return;
+  const headerRow = "| " + headers.join(" | ") + " |";
+  const separatorRow = "| " + headers.map(() => "---").join(" | ") + " |";
+  const dataRows = rows.map((row) => {
+    const cells = headers.map((h) => escapeMarkdownTableCell(toTableCell(row[h])));
+    return "| " + cells.join(" | ") + " |";
+  });
+  process.stdout.write(headerRow + "\n");
+  process.stdout.write(separatorRow + "\n");
+  for (const row of dataRows) {
+    process.stdout.write(row + "\n");
+  }
+};
+const printMarkdownNode = (node, headingLevel = 2) => {
+  const prefix = "#".repeat(headingLevel);
+  for (const [key, value] of Object.entries(node)) {
+    process.stdout.write(`${prefix} ${key}
+
+`);
+    if (value === null || value === void 0) {
+      process.stdout.write("\n");
+    } else if (isPlainObject(value)) {
+      printMarkdownNode(value, headingLevel + 1);
+    } else if (Array.isArray(value)) {
+      if (key === "[publications]") {
+        for (const p of value) {
+          if (!p || typeof p !== "object") continue;
+          const title = typeof p.title === "string" ? p.title : void 0;
+          if (!title) continue;
+          process.stdout.write(`${"#".repeat(headingLevel + 1)} ${title}
+`);
+          process.stdout.write(`- isPublished: ${p.isPublished === true}
+`);
+          const publishDate = typeof p.publishDate === "string" ? p.publishDate : "";
+          process.stdout.write(`- publishDate: ${publishDate}
+
+`);
+        }
+      } else {
+        process.stdout.write(JSON.stringify(value, null, 2) + "\n\n");
+      }
+    } else {
+      process.stdout.write(String(value) + "\n\n");
+    }
+  }
+};
+const printNode = ({
+  node,
+  format,
+  quiet
+}) => {
+  if (quiet) {
+    const id = typeof node === "object" && node !== null ? node.id : void 0;
+    if (typeof id === "string") printIds([id]);
+    return;
+  }
+  if (format === "table") {
+    if (typeof node !== "object" || node === null) {
+      printMarkdownTable([{ value: node }]);
+      return;
+    }
+    const coerced = coerceComputedFieldsForTable(node);
+    const flattened = flattenSingleKeyPaths(coerced);
+    printMarkdownTable([flattened]);
+    return;
+  }
+  if (format === "markdown") {
+    if (typeof node !== "object" || node === null) {
+      process.stdout.write(`${node}
+`);
+      return;
+    }
+    printMarkdownNode(node);
+    return;
+  }
+  if (format === "jsonl") {
+    writeJson(node, { pretty: false });
+    return;
+  }
+  if (format === "raw") {
+    printJson(node, false);
+    return;
+  }
+  if (format === "json") {
+    printJson(node, true);
+    return;
+  }
+  throw new import_errors.CliError(`Unknown format: ${format}`, 2);
+};
+const printConnection = ({
+  connection,
+  format,
+  quiet,
+  nextPageArgs
+}) => {
+  const nodes = connection.nodes ?? [];
+  const pageInfo = connection.pageInfo;
+  const hasNextPage = pageInfo?.hasNextPage === true;
+  const endCursor = typeof pageInfo?.endCursor === "string" ? pageInfo.endCursor : void 0;
+  if (quiet) {
+    printIds(nodes.map((n) => n?.id));
+    return;
+  }
+  const nextPageCommand = hasNextPage && endCursor && nextPageArgs ? buildNextPageCommand({ ...nextPageArgs, endCursor }) : void 0;
+  if (format === "table") {
+    const rows = nodes.map((n) => {
+      if (typeof n !== "object" || n === null) return { value: n };
+      const coerced = coerceComputedFieldsForTable(n);
+      return flattenSingleKeyPaths(coerced);
+    });
+    printMarkdownTable(rows);
+    if (nextPageCommand) process.stderr.write(`
+Next page: ${nextPageCommand}
+`);
+    return;
+  }
+  if (format === "markdown") {
+    for (let i = 0; i < nodes.length; i++) {
+      const n = nodes[i];
+      if (typeof n !== "object" || n === null) {
+        process.stdout.write(`${n}
+`);
+      } else {
+        const title = n.title ?? n.name ?? n.id ?? `Item ${i + 1}`;
+        process.stdout.write(`# ${title}
+
+`);
+        printMarkdownNode(n, 2);
+      }
+    }
+    if (nextPageCommand) process.stderr.write(`
+Next page: ${nextPageCommand}
+`);
+    return;
+  }
+  if (format === "jsonl") {
+    for (const n of nodes) writeJson(n, { pretty: false });
+    if (nextPageCommand) process.stderr.write(`Next page: ${nextPageCommand}
+`);
+    return;
+  }
+  if (format === "raw") {
+    printJson(nodes, false);
+    if (nextPageCommand) process.stderr.write(`Next page: ${nextPageCommand}
+`);
+    return;
+  }
+  if (format === "json") {
+    const output = { nodes };
+    if (hasNextPage) {
+      output.pageInfo = {
+        hasNextPage: true,
+        ...endCursor ? { endCursor } : {},
+        ...nextPageCommand ? { nextPageCommand } : {}
+      };
+    }
+    printJson(output, true);
+    return;
+  }
+  throw new import_errors.CliError(`Unknown format: ${format}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  printConnection,
+  printIds,
+  printJson,
+  printJsonError,
+  printNode,
+  setGlobalCommand,
+  setGlobalOutputFormat,
+  writeJson
+});
+//# sourceMappingURL=output.js.map

package/dist/cli/parse-command.d.ts

@@ -0,0 +1,18 @@
+export declare const parseVerbAndRest: ({ resource, afterResource, }: {
+    resource: string;
+    afterResource: string[];
+}) => {
+    verb: string;
+    rest: string[];
+};
+export declare const rewritePositionalIdAsFlag: ({ resource, verb, rest, }: {
+    resource: string;
+    verb: string;
+    rest: string[];
+}) => string[];
+export declare const buildUnexpectedPositionalHint: ({ command, resource, verb, rest, }: {
+    command: string;
+    resource: string;
+    verb: string;
+    rest: string[];
+}) => string | undefined;

package/dist/cli/parse-command.js

@@ -0,0 +1,109 @@
+"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 parse_command_exports = {};
+__export(parse_command_exports, {
+  buildUnexpectedPositionalHint: () => buildUnexpectedPositionalHint,
+  parseVerbAndRest: () => parseVerbAndRest,
+  rewritePositionalIdAsFlag: () => rewritePositionalIdAsFlag
+});
+module.exports = __toCommonJS(parse_command_exports);
+var import_registry = require("./help/registry");
+var import_command = require("./command");
+const findResourceSpec = (resource) => import_registry.commandRegistry.find((entry) => entry.resource === resource);
+const findVerbSpec = (resource, verb) => {
+  const resourceSpec = findResourceSpec(resource);
+  return resourceSpec?.verbs.find((entry) => entry.verb === verb);
+};
+const isHelpLikeFlag = (token) => token === "--help" || token === "-h" || token === "--help-full" || token === "--help-all";
+const parseVerbAndRest = ({
+  resource,
+  afterResource
+}) => {
+  const firstFlagIndex = afterResource.findIndex((t) => t.startsWith("-"));
+  const beforeFlags = firstFlagIndex === -1 ? afterResource : afterResource.slice(0, firstFlagIndex);
+  if (resource === "types" || resource === "graphql") {
+    const verb = beforeFlags.join(" ");
+    const rest2 = firstFlagIndex === -1 ? [] : afterResource.slice(firstFlagIndex);
+    return { verb, rest: rest2 };
+  }
+  const resourceSpec = findResourceSpec(resource);
+  if (resourceSpec) {
+    const knownVerbs = new Set(resourceSpec.verbs.map((v) => v.verb));
+    for (let i = beforeFlags.length; i >= 1; i--) {
+      const candidate = beforeFlags.slice(0, i).join(" ");
+      if (knownVerbs.has(candidate)) {
+        return { verb: candidate, rest: afterResource.slice(i) };
+      }
+    }
+  }
+  const verbParts = beforeFlags;
+  const rest = firstFlagIndex === -1 ? [] : afterResource.slice(firstFlagIndex);
+  return { verb: verbParts.join(" "), rest };
+};
+const looksLikeShopifyId = (value) => {
+  if (/^\d+$/.test(value)) return true;
+  if (/^gid:\/\/shopify\//i.test(value)) return true;
+  return false;
+};
+const supportsIdFlag = (resource, verb) => {
+  const spec = findVerbSpec(resource, verb);
+  const all = [...spec?.requiredFlags ?? [], ...spec?.flags ?? []];
+  return all.some((f) => f.label === "--id <gid>" || f.label.startsWith("--id "));
+};
+const hasIdFlag = (args) => args.some((t) => t === "--id" || t.startsWith("--id="));
+const rewritePositionalIdAsFlag = ({
+  resource,
+  verb,
+  rest
+}) => {
+  if (!verb) return rest;
+  if (resource === "types" || resource === "graphql") return rest;
+  if (!supportsIdFlag(resource, verb)) return rest;
+  if (hasIdFlag(rest)) return rest;
+  const first = rest[0];
+  if (typeof first !== "string" || !first || first.startsWith("-")) return rest;
+  if (!looksLikeShopifyId(first)) return rest;
+  return ["--id", first, ...rest.slice(1)];
+};
+const buildUnexpectedPositionalHint = ({
+  command,
+  resource,
+  verb,
+  rest
+}) => {
+  if (!verb) return void 0;
+  if (resource === "types" || resource === "graphql") return void 0;
+  if (rest.some(isHelpLikeFlag)) return void 0;
+  const spec = findVerbSpec(resource, verb);
+  if (!spec) return void 0;
+  const first = rest[0];
+  if (typeof first !== "string" || !first || first.startsWith("-")) return void 0;
+  const seeHelp = (0, import_command.formatCommandRef)(`shop ${resource} ${verb} --help`, command);
+  return [
+    `Unexpected argument: \`${first}\`.`,
+    `This command only accepts flags. See \`${seeHelp}\`.`
+  ].join("\n");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildUnexpectedPositionalHint,
+  parseVerbAndRest,
+  rewritePositionalIdAsFlag
+});
+//# sourceMappingURL=parse-command.js.map

package/dist/cli/router.d.ts

@@ -0,0 +1,29 @@
+import type { Client } from '../generated/admin-2026-04';
+import { type OutputFormat } from './output';
+export type CliView = 'summary' | 'ids' | 'full' | 'raw' | 'all';
+export type CommandContext = {
+    client: Client;
+    format: OutputFormat;
+    quiet: boolean;
+    view: CliView;
+    dryRun: boolean;
+    failOnUserErrors: boolean;
+    warnMissingAccessToken: boolean;
+    shopDomain?: string;
+    graphqlEndpoint?: string;
+    accessToken?: string;
+    apiVersion?: string;
+    headers?: Record<string, string>;
+};
+export type RunCommandArgs = CommandContext & {
+    resource: string;
+    verb: string;
+    argv: string[];
+};
+export declare const runCommand: ({ client, resource, verb, argv, format, quiet, view, dryRun, failOnUserErrors, warnMissingAccessToken, shopDomain, graphqlEndpoint, accessToken, apiVersion, headers, }: RunCommandArgs) => Promise<void>;
+export declare const parseStandardArgs: ({ argv, extraOptions, }: {
+    argv: string[];
+    extraOptions: Record<string, any>;
+}) => any;
+export declare const runQuery: (ctx: CommandContext, request: any) => Promise<any>;
+export declare const runMutation: (ctx: CommandContext, request: any) => Promise<any>;