shop-cli 0.1.1

package/dist/cli/workflows/files/urlDownloads.js

@@ -0,0 +1,114 @@
+"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 urlDownloads_exports = {};
+__export(urlDownloads_exports, {
+  downloadUrlsToTempDir: () => downloadUrlsToTempDir,
+  inferFilenameFromUrl: () => inferFilenameFromUrl
+});
+module.exports = __toCommonJS(urlDownloads_exports);
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_promises2 = require("node:stream/promises");
+var import_node_stream = require("node:stream");
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_errors = require("../../errors");
+const safeBasename = (name) => name.replace(/[\\/]/g, "_");
+const inferFilenameFromUrl = (rawUrl) => {
+  let u;
+  try {
+    u = new URL(rawUrl);
+  } catch {
+    throw new import_errors.CliError(`Invalid URL: ${rawUrl}`, 2);
+  }
+  const base = import_node_path.default.posix.basename(u.pathname || "");
+  if (base && base !== "/" && base !== ".") {
+    try {
+      const decoded = decodeURIComponent(base);
+      return safeBasename(decoded) || "download";
+    } catch {
+      return safeBasename(base) || "download";
+    }
+  }
+  return "download";
+};
+const uniqueFilename = (requested, used) => {
+  const base = safeBasename(requested) || "download";
+  const count = used.get(base) ?? 0;
+  used.set(base, count + 1);
+  if (count === 0) return base;
+  const ext = import_node_path.default.extname(base);
+  const stem = ext ? base.slice(0, -ext.length) : base;
+  return `${stem}-${count + 1}${ext}`;
+};
+const downloadUrlsToTempDir = async ({
+  urls,
+  filenameOverride
+}) => {
+  if (urls.length === 0) throw new import_errors.CliError("Missing --url (repeatable)", 2);
+  if (filenameOverride && urls.length !== 1) {
+    throw new import_errors.CliError("--filename is only valid when exactly 1 --url is provided", 2);
+  }
+  const tempDir = await (0, import_promises.mkdtemp)(import_node_path.default.join(import_node_os.default.tmpdir(), "shop-cli-files-upload-"));
+  const cleanup = async () => {
+    await (0, import_promises.rm)(tempDir, { recursive: true, force: true });
+  };
+  try {
+    await (0, import_promises.mkdir)(tempDir, { recursive: true });
+    const used = /* @__PURE__ */ new Map();
+    const files = [];
+    for (let i = 0; i < urls.length; i++) {
+      const url = urls[i];
+      const inferred = filenameOverride ?? inferFilenameFromUrl(url);
+      const filename = uniqueFilename(inferred, used);
+      const filePath = import_node_path.default.join(tempDir, filename);
+      const res = await fetch(url, { redirect: "follow" });
+      if (!res.ok) {
+        throw new import_errors.CliError(`Failed to download ${url}: ${res.status} ${res.statusText}`, 2);
+      }
+      if (!res.body) {
+        throw new import_errors.CliError(`Failed to download ${url}: empty response body`, 2);
+      }
+      const nodeStream = import_node_stream.Readable.fromWeb(res.body);
+      const out = (0, import_node_fs.createWriteStream)(filePath);
+      await (0, import_promises2.pipeline)(nodeStream, out);
+      files.push({ url, filePath, filename });
+    }
+    return { tempDir, files, cleanup };
+  } catch (err) {
+    await cleanup();
+    throw err;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  downloadUrlsToTempDir,
+  inferFilenameFromUrl
+});
+//# sourceMappingURL=urlDownloads.js.map

package/dist/cli/workflows/files/waitForReady.d.ts

@@ -0,0 +1,20 @@
+import { type CommandContext } from '../../router';
+export type WaitForFilesResult = {
+    nodes: any[];
+    readyIds: string[];
+    failedIds: string[];
+};
+export declare const pollFilesReadyOrFailed: ({ ids, pollIntervalMs, timeoutMs, fetchNodes, now, sleep, }: {
+    ids: string[];
+    pollIntervalMs: number;
+    timeoutMs: number;
+    fetchNodes: (ids: string[]) => Promise<any[]>;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}) => Promise<WaitForFilesResult>;
+export declare const waitForFilesReadyOrFailed: ({ ctx, ids, pollIntervalMs, timeoutMs, }: {
+    ctx: CommandContext;
+    ids: string[];
+    pollIntervalMs: number;
+    timeoutMs: number;
+}) => Promise<WaitForFilesResult>;

package/dist/cli/workflows/files/waitForReady.js

@@ -0,0 +1,114 @@
+"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 waitForReady_exports = {};
+__export(waitForReady_exports, {
+  pollFilesReadyOrFailed: () => pollFilesReadyOrFailed,
+  waitForFilesReadyOrFailed: () => waitForFilesReadyOrFailed
+});
+module.exports = __toCommonJS(waitForReady_exports);
+var import_errors = require("../../errors");
+var import_router = require("../../router");
+const pollFilesReadyOrFailed = async ({
+  ids,
+  pollIntervalMs,
+  timeoutMs,
+  fetchNodes,
+  now = () => Date.now(),
+  sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+}) => {
+  const start = now();
+  const remaining = new Set(ids);
+  let lastNodes = [];
+  while (true) {
+    lastNodes = await fetchNodes(ids);
+    const readyIds = [];
+    const failedIds = [];
+    for (const node of lastNodes) {
+      if (!node || typeof node !== "object") continue;
+      const id = typeof node.id === "string" ? node.id : void 0;
+      if (!id) continue;
+      const status = node.fileStatus;
+      if (status === "READY") {
+        remaining.delete(id);
+        readyIds.push(id);
+      } else if (status === "FAILED") {
+        remaining.delete(id);
+        failedIds.push(id);
+      }
+    }
+    if (remaining.size === 0) {
+      return { nodes: lastNodes, readyIds, failedIds };
+    }
+    const elapsed = now() - start;
+    if (elapsed >= timeoutMs) {
+      const pending = Array.from(remaining);
+      throw new import_errors.CliError(
+        `Timed out after ${timeoutMs}ms waiting for files to be READY/FAILED: ${pending.join(", ")}`,
+        2
+      );
+    }
+    await sleep(pollIntervalMs);
+  }
+};
+const waitForFilesReadyOrFailed = async ({
+  ctx,
+  ids,
+  pollIntervalMs,
+  timeoutMs
+}) => {
+  if (ids.length === 0) return { nodes: [], readyIds: [], failedIds: [] };
+  const fileFields = {
+    id: true,
+    fileStatus: true,
+    fileErrors: { code: true, message: true, details: true },
+    preview: { status: true, image: { url: true } }
+  };
+  const nodeSelection = {
+    __typename: true,
+    // `nodes` returns `[Node]`. GenQL only allows inline fragments on concrete object types
+    // (not interfaces like `File`), so we select the known File implementations.
+    on_GenericFile: { ...fileFields, url: true },
+    on_MediaImage: fileFields,
+    on_Video: fileFields,
+    on_Model3d: fileFields,
+    on_ExternalVideo: fileFields
+  };
+  return pollFilesReadyOrFailed({
+    ids,
+    pollIntervalMs,
+    timeoutMs,
+    fetchNodes: async (fileIds) => {
+      const result = await (0, import_router.runQuery)(ctx, {
+        nodes: {
+          __args: { ids: fileIds },
+          ...nodeSelection
+        }
+      });
+      if (result === void 0) return [];
+      const nodes = result.nodes ?? [];
+      return Array.isArray(nodes) ? nodes : [];
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pollFilesReadyOrFailed,
+  waitForFilesReadyOrFailed
+});
+//# sourceMappingURL=waitForReady.js.map

package/dist/cli/workflows/inventory/resolveInventoryItemId.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext } from '../../router';
+export declare const resolveInventoryItemId: ({ ctx, inventoryItemId, variantId, }: {
+    ctx: CommandContext;
+    inventoryItemId?: string;
+    variantId?: string;
+}) => Promise<string>;

package/dist/cli/workflows/inventory/resolveInventoryItemId.js

@@ -0,0 +1,59 @@
+"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 resolveInventoryItemId_exports = {};
+__export(resolveInventoryItemId_exports, {
+  resolveInventoryItemId: () => resolveInventoryItemId
+});
+module.exports = __toCommonJS(resolveInventoryItemId_exports);
+var import_errors = require("../../errors");
+var import_gid = require("../../gid");
+var import_router = require("../../router");
+const resolveInventoryItemId = async ({
+  ctx,
+  inventoryItemId,
+  variantId
+}) => {
+  if (inventoryItemId && variantId) {
+    throw new import_errors.CliError("Pass only one of --inventory-item-id or --variant-id", 2);
+  }
+  if (inventoryItemId) return (0, import_gid.coerceGid)(inventoryItemId, "InventoryItem");
+  if (!variantId) {
+    throw new import_errors.CliError("Missing --inventory-item-id or --variant-id", 2);
+  }
+  if (ctx.dryRun) {
+    throw new import_errors.CliError(
+      "--dry-run with --variant-id is not supported (pass --inventory-item-id instead)",
+      2
+    );
+  }
+  const id = (0, import_gid.coerceGid)(variantId, "ProductVariant");
+  const result = await (0, import_router.runQuery)(ctx, {
+    productVariant: { __args: { id }, inventoryItem: { id: true } }
+  });
+  const inventoryItemGid = result?.productVariant?.inventoryItem?.id;
+  if (!inventoryItemGid) {
+    throw new import_errors.CliError(`Could not resolve inventory item for variant: ${variantId}`, 2);
+  }
+  return inventoryItemGid;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveInventoryItemId
+});
+//# sourceMappingURL=resolveInventoryItemId.js.map

package/dist/cli/workflows/productVariants/upsert.d.ts

@@ -0,0 +1,8 @@
+import { type CommandContext } from '../../router';
+export declare const upsertProductVariants: ({ ctx, productId, input, allowPartialUpdates, strategy, }: {
+    ctx: CommandContext;
+    productId: string | undefined;
+    input: any;
+    allowPartialUpdates: boolean;
+    strategy: string | undefined;
+}) => Promise<any>;

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>;