shop-cli 0.1.0

package/dist/cli/verbs/webhooks.js

@@ -0,0 +1,336 @@
+"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 webhooks_exports = {};
+__export(webhooks_exports, {
+  runWebhooks: () => runWebhooks
+});
+module.exports = __toCommonJS(webhooks_exports);
+var import_errors = require("../errors");
+var import_input = require("../input");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_userErrors = require("../userErrors");
+var import_shared = require("./_shared");
+const webhookSummarySelection = {
+  id: true,
+  topic: true,
+  uri: true,
+  format: true,
+  createdAt: true,
+  updatedAt: true
+};
+const webhookFullSelection = {
+  ...webhookSummarySelection,
+  filter: true,
+  includeFields: true,
+  metafieldNamespaces: true
+};
+const getWebhookSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return webhookFullSelection;
+  if (view === "raw") return {};
+  return webhookSummarySelection;
+};
+const runWebhooks = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop webhooks <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|update|delete|count",
+        "  pubsub-create|pubsub-update",
+        "  event-bridge-create|event-bridge-update",
+        "",
+        "Common output flags:",
+        "  --view summary|ids|full|raw",
+        "  --select <path>        (repeatable; dot paths; adds to base view selection)",
+        "  --selection <graphql>  (selection override; can be @file.gql)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "count") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { limit: { type: "string" } }
+    });
+    const query = args.query;
+    const limitRaw = args.limit;
+    const limit = limitRaw === void 0 || limitRaw === null || limitRaw === "" ? void 0 : Number(limitRaw);
+    if (limit !== void 0 && (!Number.isFinite(limit) || limit <= 0)) {
+      throw new import_errors.CliError("--limit must be a positive number", 2);
+    }
+    const result = await (0, import_router.runQuery)(ctx, {
+      webhookSubscriptionsCount: {
+        __args: {
+          ...query ? { query } : {},
+          ...limit !== void 0 ? { limit: Math.floor(limit) } : {}
+        },
+        count: true,
+        precision: true
+      }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.webhookSubscriptionsCount?.count ?? "");
+    (0, import_output.printJson)(result.webhookSubscriptionsCount, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "event-bridge-create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { topic: { type: "string" } } });
+    const topic = args.topic;
+    if (!topic) throw new import_errors.CliError("Missing --topic", 2);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json (webhookSubscription)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      eventBridgeWebhookSubscriptionCreate: {
+        __args: { topic, webhookSubscription: built.input },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.eventBridgeWebhookSubscriptionCreate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.eventBridgeWebhookSubscriptionCreate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.eventBridgeWebhookSubscriptionCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "event-bridge-update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "WebhookSubscription");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json (webhookSubscription)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      eventBridgeWebhookSubscriptionUpdate: {
+        __args: { id, webhookSubscription: built.input },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.eventBridgeWebhookSubscriptionUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.eventBridgeWebhookSubscriptionUpdate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.eventBridgeWebhookSubscriptionUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "WebhookSubscription");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "webhooks",
+      view: ctx.view,
+      baseSelection: getWebhookSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { webhookSubscription: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.webhookSubscription, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const query = args.query;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "webhooks",
+      view: ctx.view,
+      baseSelection: getWebhookSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      webhookSubscriptions: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.webhookSubscriptions,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("webhooks", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "pubsub-create") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { topic: { type: "string" }, "pubsub-project": { type: "string" }, "pubsub-topic": { type: "string" } }
+    });
+    const topic = args.topic;
+    if (!topic) throw new import_errors.CliError("Missing --topic", 2);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = built.used ? built.input : {};
+    const pubSubProject = args["pubsub-project"] ?? input.pubSubProject;
+    const pubSubTopic = args["pubsub-topic"] ?? input.pubSubTopic;
+    if (!pubSubProject) throw new import_errors.CliError("Missing --pubsub-project", 2);
+    if (!pubSubTopic) throw new import_errors.CliError("Missing --pubsub-topic", 2);
+    const webhookSubscription = { ...input, pubSubProject, pubSubTopic };
+    const result = await (0, import_router.runMutation)(ctx, {
+      pubSubWebhookSubscriptionCreate: {
+        __args: { topic, webhookSubscription },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.pubSubWebhookSubscriptionCreate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.pubSubWebhookSubscriptionCreate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.pubSubWebhookSubscriptionCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "pubsub-update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "pubsub-project": { type: "string" }, "pubsub-topic": { type: "string" } }
+    });
+    const id = (0, import_shared.requireId)(args.id, "WebhookSubscription");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = built.used ? built.input : {};
+    const pubSubProject = args["pubsub-project"] ?? input.pubSubProject;
+    const pubSubTopic = args["pubsub-topic"] ?? input.pubSubTopic;
+    if (!pubSubProject) throw new import_errors.CliError("Missing --pubsub-project", 2);
+    if (!pubSubTopic) throw new import_errors.CliError("Missing --pubsub-topic", 2);
+    const webhookSubscription = { ...input, pubSubProject, pubSubTopic };
+    const result = await (0, import_router.runMutation)(ctx, {
+      pubSubWebhookSubscriptionUpdate: {
+        __args: { id, webhookSubscription },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.pubSubWebhookSubscriptionUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.pubSubWebhookSubscriptionUpdate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.pubSubWebhookSubscriptionUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { topic: { type: "string" } } });
+    const topic = args.topic;
+    if (!topic) throw new import_errors.CliError("Missing --topic", 2);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json (webhookSubscription)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      webhookSubscriptionCreate: {
+        __args: { topic, webhookSubscription: built.input },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.webhookSubscriptionCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.webhookSubscriptionCreate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.webhookSubscriptionCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "WebhookSubscription");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json (webhookSubscription)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      webhookSubscriptionUpdate: {
+        __args: { id, webhookSubscription: built.input },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.webhookSubscriptionUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.webhookSubscriptionUpdate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.webhookSubscriptionUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "WebhookSubscription");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      webhookSubscriptionDelete: {
+        __args: { id },
+        deletedWebhookSubscriptionId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.webhookSubscriptionDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.webhookSubscriptionDelete?.deletedWebhookSubscriptionId ?? "");
+    (0, import_output.printJson)(result.webhookSubscriptionDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for webhooks: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runWebhooks
+});
+//# sourceMappingURL=webhooks.js.map

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

@@ -0,0 +1,28 @@
+import { type CommandContext } from '../../router';
+export type StagedUploadResource = 'FILE' | 'IMAGE' | 'VIDEO' | 'MODEL_3D';
+export type LocalFileForStagedUpload = {
+    filePath: string;
+    filename: string;
+    mimeType: string;
+    resource: StagedUploadResource;
+    fileSize: number;
+};
+export type StagedUploadTarget = {
+    url: string;
+    resourceUrl: string;
+    parameters: Array<{
+        name: string;
+        value: string;
+    }>;
+};
+export declare const buildLocalFilesForStagedUpload: ({ filePaths, contentType, resource, }: {
+    filePaths: string[];
+    contentType?: string;
+    resource?: StagedUploadResource;
+}) => LocalFileForStagedUpload[];
+export declare const stagedUploadsCreate: (ctx: CommandContext, localFiles: LocalFileForStagedUpload[]) => Promise<StagedUploadTarget[] | undefined>;
+export declare const uploadToStagedTarget: ({ target, localFile, }: {
+    target: StagedUploadTarget;
+    localFile: LocalFileForStagedUpload;
+}) => Promise<void>;
+export declare const stagedUploadLocalFiles: (ctx: CommandContext, localFiles: LocalFileForStagedUpload[]) => Promise<StagedUploadTarget[] | undefined>;

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

@@ -0,0 +1,175 @@
+"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 stagedUploads_exports = {};
+__export(stagedUploads_exports, {
+  buildLocalFilesForStagedUpload: () => buildLocalFilesForStagedUpload,
+  stagedUploadLocalFiles: () => stagedUploadLocalFiles,
+  stagedUploadsCreate: () => stagedUploadsCreate,
+  uploadToStagedTarget: () => uploadToStagedTarget
+});
+module.exports = __toCommonJS(stagedUploads_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var import_mime_types = require("mime-types");
+var import_errors = require("../../errors");
+var import_router = require("../../router");
+var import_userErrors = require("../../userErrors");
+const guessMimeTypeFromFilename = (filename) => {
+  const mimeType = (0, import_mime_types.lookup)(filename);
+  if (typeof mimeType === "string") return mimeType;
+  return "application/octet-stream";
+};
+const inferStagedUploadResource = ({
+  filename,
+  mimeType
+}) => {
+  if (mimeType.startsWith("image/")) return "IMAGE";
+  if (mimeType.startsWith("video/")) return "VIDEO";
+  const ext = import_node_path.default.extname(filename).toLowerCase();
+  if (mimeType.startsWith("model/") || ext === ".glb" || ext === ".gltf" || ext === ".usdz") {
+    return "MODEL_3D";
+  }
+  return "FILE";
+};
+const buildLocalFilesForStagedUpload = ({
+  filePaths,
+  contentType,
+  resource
+}) => {
+  if (filePaths.length === 0) return [];
+  return filePaths.map((filePath) => {
+    const stats = (0, import_node_fs.statSync)(filePath);
+    if (!stats.isFile()) throw new import_errors.CliError(`Not a file: ${filePath}`, 2);
+    const filename = import_node_path.default.basename(filePath);
+    const mimeType = contentType ?? guessMimeTypeFromFilename(filename);
+    const inferredResource = inferStagedUploadResource({ filename, mimeType });
+    return {
+      filePath,
+      filename,
+      mimeType,
+      resource: resource ?? inferredResource,
+      fileSize: stats.size
+    };
+  });
+};
+const stagedUploadsCreate = async (ctx, localFiles) => {
+  const input = localFiles.map((f) => ({
+    filename: f.filename,
+    mimeType: f.mimeType,
+    resource: f.resource,
+    fileSize: String(f.fileSize),
+    httpMethod: "POST"
+  }));
+  if (ctx.dryRun) {
+    await (0, import_router.runMutation)(ctx, {
+      stagedUploadsCreate: {
+        __args: { input },
+        stagedTargets: {
+          url: true,
+          resourceUrl: true,
+          parameters: { name: true, value: true }
+        },
+        userErrors: { field: true, message: true }
+      }
+    });
+    return localFiles.map((f, i) => ({
+      url: `https://example.invalid/staged-uploads/${i}`,
+      resourceUrl: `https://example.invalid/staged-resources/${encodeURIComponent(f.filename)}`,
+      parameters: []
+    }));
+  }
+  const result = await (0, import_router.runMutation)(ctx, {
+    stagedUploadsCreate: {
+      __args: { input },
+      stagedTargets: {
+        url: true,
+        resourceUrl: true,
+        parameters: { name: true, value: true }
+      },
+      userErrors: { field: true, message: true }
+    }
+  });
+  if (result === void 0) return void 0;
+  (0, import_userErrors.maybeFailOnUserErrors)({
+    payload: result.stagedUploadsCreate,
+    failOnUserErrors: ctx.failOnUserErrors
+  });
+  const targets = result.stagedUploadsCreate?.stagedTargets ?? [];
+  if (!Array.isArray(targets) || targets.length !== localFiles.length) {
+    throw new import_errors.CliError(
+      `Expected ${localFiles.length} stagedTargets, got ${Array.isArray(targets) ? targets.length : "non-array"}`,
+      2
+    );
+  }
+  return targets.map((t) => ({
+    url: String(t.url ?? ""),
+    resourceUrl: String(t.resourceUrl ?? ""),
+    parameters: (t.parameters ?? []).map((p) => ({ name: p.name, value: p.value }))
+  }));
+};
+const uploadToStagedTarget = async ({
+  target,
+  localFile
+}) => {
+  const body = (0, import_node_fs.readFileSync)(localFile.filePath);
+  const form = new FormData();
+  for (const p of target.parameters) form.set(p.name, p.value);
+  form.set("file", new Blob([body], { type: localFile.mimeType }), localFile.filename);
+  const res = await fetch(target.url, { method: "POST", body: form });
+  if (res.ok) return;
+  let details = "";
+  try {
+    details = await res.text();
+  } catch {
+  }
+  throw new import_errors.CliError(
+    `Staged upload failed for ${localFile.filename}: ${res.status} ${res.statusText}${details ? `
+${details}` : ""}`,
+    2
+  );
+};
+const stagedUploadLocalFiles = async (ctx, localFiles) => {
+  const targets = await stagedUploadsCreate(ctx, localFiles);
+  if (targets === void 0) return void 0;
+  if (ctx.dryRun) return targets;
+  for (let i = 0; i < targets.length; i++) {
+    const target = targets[i];
+    const localFile = localFiles[i];
+    await uploadToStagedTarget({ target, localFile });
+  }
+  return targets;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildLocalFilesForStagedUpload,
+  stagedUploadLocalFiles,
+  stagedUploadsCreate,
+  uploadToStagedTarget
+});
+//# sourceMappingURL=stagedUploads.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>;