shop-cli 0.1.0

package/dist/cli/introspection/format.js

@@ -0,0 +1,63 @@
+"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 format_exports = {};
+__export(format_exports, {
+  printFieldsTable: () => printFieldsTable
+});
+module.exports = __toCommonJS(format_exports);
+const formatConnectionNodeType = (field) => {
+  const nodeType = field.connectionNodeTypeName;
+  if (nodeType) return nodeType;
+  return field.typeName.replace(/Connection$/, "");
+};
+const printFieldsTable = ({
+  resource,
+  typeName,
+  fields
+}) => {
+  const selectable = fields.filter((f) => !f.hasRequiredArgs);
+  const scalars = selectable.filter((f) => f.isScalar && !f.isConnection);
+  const objects = selectable.filter((f) => !f.isScalar && !f.isConnection);
+  const connections = selectable.filter((f) => f.isConnection);
+  console.log(`Selectable fields for "${resource}" (GraphQL type: ${typeName})`);
+  console.log("Use with --select (repeatable; dot paths).");
+  console.log("");
+  if (scalars.length) {
+    console.log("Scalar fields:");
+    for (const f of scalars) console.log(`  ${f.name}`);
+    console.log("");
+  }
+  if (objects.length) {
+    console.log("Object fields (use dot notation, e.g. --select seo.title):");
+    for (const f of objects) console.log(`  ${f.name}  ->  ${f.typeName}`);
+    console.log("");
+  }
+  if (connections.length) {
+    console.log("Connection fields (use .nodes, e.g. --select variants.nodes.sku):");
+    for (const f of connections) {
+      console.log(`  ${f.name}.nodes  ->  ${formatConnectionNodeType(f)}`);
+    }
+    console.log("");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  printFieldsTable
+});
+//# sourceMappingURL=format.js.map

package/dist/cli/introspection/index.d.ts

@@ -0,0 +1,14 @@
+import type { LinkedType, LinkedTypeMap } from '../../generated/admin-2026-04/runtime/types';
+export type { LinkedType, LinkedTypeMap } from '../../generated/admin-2026-04/runtime/types';
+export declare const getTypeMap: () => LinkedTypeMap;
+export declare const getType: (name: string) => LinkedType | undefined;
+export type FieldInfo = {
+    name: string;
+    typeName: string;
+    isScalar: boolean;
+    isConnection: boolean;
+    connectionNodeTypeName?: string;
+    hasRequiredArgs: boolean;
+};
+export declare const getFields: (typeName: string) => FieldInfo[];
+export { resourceToType } from './resources';

package/dist/cli/introspection/index.js

@@ -0,0 +1,89 @@
+"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 __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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var introspection_exports = {};
+__export(introspection_exports, {
+  getFields: () => getFields,
+  getType: () => getType,
+  getTypeMap: () => getTypeMap,
+  resourceToType: () => import_resources.resourceToType
+});
+module.exports = __toCommonJS(introspection_exports);
+var import_types = __toESM(require("../../generated/admin-2026-04/types"));
+var import_runtime = require("../../generated/admin-2026-04/runtime");
+var import_resources = require("./resources");
+let cachedTypeMap;
+const getTypeMap = () => {
+  if (!cachedTypeMap) {
+    cachedTypeMap = (0, import_runtime.linkTypeMap)(import_types.default);
+  }
+  return cachedTypeMap;
+};
+const getType = (name) => getTypeMap()[name];
+const hasRequiredArgs = (field) => {
+  const args = field.args ?? {};
+  return Object.values(args).some((arg) => arg?.[1]?.endsWith("!"));
+};
+const getConnectionNodeTypeName = (connectionType) => {
+  const nodes = connectionType.fields?.nodes?.type;
+  if (nodes?.name) return nodes.name;
+  const edges = connectionType.fields?.edges?.type;
+  const edgeNode = edges?.fields?.node?.type;
+  if (edgeNode?.name) return edgeNode.name;
+  return void 0;
+};
+const getFields = (typeName) => {
+  const type = getType(typeName);
+  if (!type?.fields) return [];
+  const scalarFields = new Set(type.scalar ?? []);
+  const out = [];
+  for (const [name, field] of Object.entries(type.fields)) {
+    if (!field) continue;
+    const targetTypeName = field.type?.name ?? "Unknown";
+    const isConnection = targetTypeName.endsWith("Connection");
+    const requiredArgs = hasRequiredArgs(field);
+    out.push({
+      name,
+      typeName: targetTypeName,
+      isScalar: scalarFields.has(name),
+      isConnection,
+      connectionNodeTypeName: isConnection ? getConnectionNodeTypeName(field.type) : void 0,
+      hasRequiredArgs: requiredArgs
+    });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFields,
+  getType,
+  getTypeMap,
+  resourceToType
+});
+//# sourceMappingURL=index.js.map

package/dist/cli/introspection/resources.d.ts

@@ -0,0 +1 @@
+export declare const resourceToType: Record<string, string>;

package/dist/cli/introspection/resources.js

@@ -0,0 +1,127 @@
+"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 resources_exports = {};
+__export(resources_exports, {
+  resourceToType: () => resourceToType
+});
+module.exports = __toCommonJS(resources_exports);
+const resourceToType = {
+  "abandoned-checkouts": "Abandonment",
+  "app-billing": "AppInstallation",
+  apps: "App",
+  articles: "Article",
+  blogs: "Blog",
+  "bulk-operations": "BulkOperation",
+  "business-entities": "BusinessEntity",
+  "carrier-services": "DeliveryCarrierService",
+  "cash-tracking": "CashTrackingSession",
+  catalogs: "Catalog",
+  "cart-transforms": "CartTransform",
+  collections: "Collection",
+  comments: "Comment",
+  companies: "Company",
+  "company-contacts": "CompanyContact",
+  "company-locations": "CompanyLocation",
+  "checkout-profiles": "CheckoutProfile",
+  "customer-payment-methods": "CustomerPaymentMethod",
+  "customer-privacy": "PrivacySettings",
+  "customer-segments": "CustomerSegmentMember",
+  "customer-account-pages": "CustomerAccountPage",
+  customers: "Customer",
+  channels: "Channel",
+  "delivery-customizations": "DeliveryCustomization",
+  "delivery-profile-locations": "Location",
+  "delivery-profiles": "DeliveryProfile",
+  "discounts-automatic": "DiscountAutomaticNode",
+  "discounts-code": "DiscountCodeNode",
+  "discount-nodes": "DiscountNode",
+  "discount-redeem-codes": "DiscountRedeemCodeBulkCreation",
+  "discount-saved-searches": "SavedSearch",
+  "draft-orders": "DraftOrder",
+  events: "Event",
+  finance: "FinanceKycInformation",
+  files: "File",
+  "file-saved-searches": "SavedSearch",
+  "fulfillment-orders": "FulfillmentOrder",
+  "fulfillment-services": "FulfillmentService",
+  fulfillments: "Fulfillment",
+  functions: "ShopifyFunction",
+  "gift-cards": "GiftCard",
+  "inventory-items": "InventoryItem",
+  "inventory-shipments": "InventoryShipment",
+  "inventory-transfers": "InventoryTransfer",
+  locations: "Location",
+  "marketing-activities": "MarketingActivity",
+  "marketing-events": "MarketingEvent",
+  markets: "Market",
+  backup: "MarketRegion",
+  locales: "Locale",
+  "market-localizations": "MarketLocalizableResource",
+  "market-web-presences": "MarketWebPresence",
+  "metafield-definitions": "MetafieldDefinition",
+  "metaobject-definitions": "MetaobjectDefinition",
+  metaobjects: "Metaobject",
+  menus: "Menu",
+  "order-edit": "CalculatedOrder",
+  orders: "Order",
+  pages: "Page",
+  "payment-customizations": "PaymentCustomization",
+  "payment-terms": "PaymentTerms",
+  "point-of-sale": "PointOfSaleDevice",
+  "price-lists": "PriceList",
+  "product-variants": "ProductVariant",
+  "product-feeds": "ProductFeed",
+  products: "Product",
+  publishables: "Publishable",
+  publications: "Publication",
+  refunds: "Refund",
+  returns: "Return",
+  "returnable-fulfillments": "ReturnableFulfillment",
+  "reverse-deliveries": "ReverseDelivery",
+  "reverse-fulfillment-orders": "ReverseFulfillmentOrder",
+  "saved-searches": "SavedSearch",
+  "script-tags": "ScriptTag",
+  segments: "Segment",
+  "selling-plan-groups": "SellingPlanGroup",
+  "selling-plan-group-products": "SellingPlanGroup",
+  "server-pixels": "ServerPixel",
+  "shopify-payments": "ShopifyPaymentsAccount",
+  staff: "StaffMember",
+  "store-credit": "StoreCreditAccount",
+  "storefront-access-tokens": "StorefrontAccessToken",
+  "subscription-contracts": "SubscriptionContract",
+  "subscription-drafts": "SubscriptionDraft",
+  "subscription-billing-cycles": "SubscriptionBillingCycle",
+  "tender-transactions": "TenderTransaction",
+  themes: "OnlineStoreTheme",
+  translations: "TranslatableResource",
+  "url-redirects": "UrlRedirect",
+  validations: "Validation",
+  "web-pixels": "WebPixel",
+  webhooks: "WebhookSubscription",
+  "web-presences": "MarketWebPresence",
+  "staged-uploads": "StagedUploadTarget",
+  // Resource name differs from file name:
+  config: "Shop"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resourceToType
+});
+//# sourceMappingURL=resources.js.map

package/dist/cli/output/computedFields.d.ts

@@ -0,0 +1,39 @@
+import type { CliView } from '../router';
+export type ComputedPublication = {
+    isPublished: boolean;
+    title: string;
+    publishDate: string | null;
+};
+export declare const computedPublicationsSelection: {
+    readonly resourcePublicationsV2: {
+        readonly __args: {
+            readonly first: 50;
+            readonly onlyPublished: false;
+        };
+        readonly nodes: {
+            readonly isPublished: true;
+            readonly publishDate: true;
+            readonly publication: {
+                readonly id: true;
+                readonly catalog: {
+                    readonly title: true;
+                    readonly on_AppCatalog: {
+                        readonly apps: {
+                            readonly __args: {
+                                readonly first: 10;
+                            };
+                            readonly nodes: {
+                                readonly title: true;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare const computePublications: (node: unknown) => ComputedPublication[] | undefined;
+export declare const applyComputedFieldsToNode: (node: unknown, { view, stripResourcePublicationsV2, }: {
+    view: CliView;
+    stripResourcePublicationsV2?: boolean;
+}) => unknown;

package/dist/cli/output/computedFields.js

@@ -0,0 +1,104 @@
+"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 computedFields_exports = {};
+__export(computedFields_exports, {
+  applyComputedFieldsToNode: () => applyComputedFieldsToNode,
+  computePublications: () => computePublications,
+  computedPublicationsSelection: () => computedPublicationsSelection
+});
+module.exports = __toCommonJS(computedFields_exports);
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const computedPublicationsSelection = {
+  resourcePublicationsV2: {
+    __args: { first: 50, onlyPublished: false },
+    nodes: {
+      isPublished: true,
+      publishDate: true,
+      publication: {
+        id: true,
+        catalog: {
+          title: true,
+          on_AppCatalog: {
+            apps: { __args: { first: 10 }, nodes: { title: true } }
+          }
+        }
+      }
+    }
+  }
+};
+const getPublicationTitle = (publication) => {
+  if (!publication || typeof publication !== "object") return void 0;
+  const catalog = publication.catalog;
+  if (catalog && typeof catalog === "object") {
+    const appNodes = catalog.apps?.nodes ?? catalog.on_AppCatalog?.apps?.nodes;
+    if (Array.isArray(appNodes)) {
+      const titles = appNodes.map((a) => a && typeof a === "object" ? a.title : void 0).filter((t) => typeof t === "string" && t.trim().length > 0);
+      if (titles.length === 1) return titles[0];
+      if (titles.length > 1) return titles.join(", ");
+    }
+  }
+  const name = publication.name;
+  if (typeof name === "string" && name.trim().length > 0) return name;
+  if (catalog && typeof catalog === "object") {
+    const catalogTitle = catalog.title;
+    if (typeof catalogTitle === "string" && catalogTitle.trim().length > 0) return catalogTitle;
+  }
+  const id = publication.id;
+  if (typeof id === "string" && id.trim().length > 0) return id;
+  return void 0;
+};
+const computePublications = (node) => {
+  if (!isPlainObject(node)) return void 0;
+  const pubs = node.resourcePublicationsV2?.nodes;
+  if (!Array.isArray(pubs)) return void 0;
+  const out = [];
+  for (const p of pubs) {
+    if (!p || typeof p !== "object") continue;
+    const title = getPublicationTitle(p.publication) ?? "Unknown publication";
+    const publishDateRaw = p.publishDate;
+    const publishDate = typeof publishDateRaw === "string" ? publishDateRaw : null;
+    out.push({
+      isPublished: p.isPublished === true,
+      title,
+      publishDate
+    });
+  }
+  return out;
+};
+const applyComputedFieldsToNode = (node, {
+  view,
+  stripResourcePublicationsV2 = view === "summary" || view === "full"
+}) => {
+  if (view === "raw" || view === "ids") return node;
+  if (!isPlainObject(node)) return node;
+  const publications = computePublications(node);
+  if (!publications) return node;
+  const out = { ...node, ["[publications]"]: publications };
+  if (stripResourcePublicationsV2) {
+    delete out.resourcePublicationsV2;
+  }
+  return out;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyComputedFieldsToNode,
+  computePublications,
+  computedPublicationsSelection
+});
+//# sourceMappingURL=computedFields.js.map

package/dist/cli/output.d.ts

@@ -0,0 +1,37 @@
+export type OutputFormat = 'json' | 'jsonl' | 'table' | 'raw' | 'markdown';
+export declare const setGlobalOutputFormat: (format: OutputFormat) => void;
+export declare const setGlobalCommand: (command: string | undefined) => void;
+type NextPageExtraFlag = {
+    flag: string;
+    value?: string | number | boolean;
+};
+type NextPageArgs = {
+    base: string;
+    first?: number;
+    query?: string;
+    sort?: string;
+    reverse?: boolean;
+    extraFlags?: NextPageExtraFlag[];
+};
+export declare const writeJson: (data: unknown, { pretty, stream, }?: {
+    pretty?: boolean;
+    stream?: NodeJS.WritableStream;
+}) => void;
+export declare const printJson: (data: unknown, pretty?: boolean) => void;
+export declare const printJsonError: (data: unknown, pretty?: boolean) => void;
+export declare const printIds: (ids: Array<string | undefined | null>) => void;
+export declare const printNode: ({ node, format, quiet, }: {
+    node: any;
+    format: OutputFormat;
+    quiet: boolean;
+}) => void;
+export declare const printConnection: ({ connection, format, quiet, nextPageArgs, }: {
+    connection: {
+        nodes?: any[];
+        pageInfo?: any;
+    };
+    format: OutputFormat;
+    quiet: boolean;
+    nextPageArgs?: NextPageArgs;
+}) => void;
+export {};