shop-cli 0.1.1

package/dist/cli/verbs/fulfillment-orders.js

@@ -0,0 +1,689 @@
+"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 fulfillment_orders_exports = {};
+__export(fulfillment_orders_exports, {
+  runFulfillmentOrders: () => runFulfillmentOrders
+});
+module.exports = __toCommonJS(fulfillment_orders_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 fulfillmentOrderSummarySelection = {
+  id: true,
+  status: true,
+  requestStatus: true,
+  order: { id: true, name: true },
+  assignedLocation: {
+    name: true,
+    location: { id: true }
+  },
+  fulfillAt: true,
+  fulfillBy: true,
+  supportedActions: { action: true, externalUrl: true },
+  lineItems: {
+    __args: { first: 20 },
+    nodes: {
+      id: true,
+      totalQuantity: true,
+      remainingQuantity: true,
+      sku: true,
+      lineItem: { id: true, title: true }
+    }
+  }
+};
+const fulfillmentOrderFullSelection = {
+  ...fulfillmentOrderSummarySelection,
+  destination: {
+    firstName: true,
+    lastName: true,
+    address1: true,
+    city: true,
+    provinceCode: true,
+    countryCode: true,
+    zip: true,
+    phone: true
+  },
+  fulfillmentHolds: {
+    id: true,
+    reason: true,
+    reasonNotes: true,
+    displayReason: true,
+    heldByRequestingApp: true,
+    heldByApp: { id: true, title: true }
+  },
+  merchantRequests: {
+    __args: { first: 5 },
+    nodes: {
+      id: true,
+      kind: true,
+      message: true,
+      requestedAt: true,
+      responseData: true
+    }
+  },
+  fulfillments: {
+    __args: { first: 5 },
+    nodes: {
+      id: true,
+      status: true,
+      trackingInfo: {
+        company: true,
+        number: true,
+        url: true
+      }
+    }
+  },
+  locationsForMove: {
+    __args: { first: 10 },
+    nodes: {
+      location: { id: true, name: true },
+      message: true,
+      movable: true
+    }
+  }
+};
+const getFulfillmentOrderSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return fulfillmentOrderFullSelection;
+  if (view === "raw") return {};
+  return fulfillmentOrderSummarySelection;
+};
+const parseLineItemsInput = (input) => {
+  if (input === void 0) return void 0;
+  if (Array.isArray(input)) return input;
+  if (input && typeof input === "object" && "fulfillmentOrderLineItems" in input) {
+    return input.fulfillmentOrderLineItems;
+  }
+  return input;
+};
+const runFulfillmentOrders = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop fulfillment-orders <verb> [flags]",
+        "",
+        "Verbs:",
+        "  assigned|manual-holds",
+        "  get|list|accept-request|reject-request|submit-request",
+        "  accept-cancellation|reject-cancellation|submit-cancellation|cancel|close|open",
+        "  hold|release-hold|reschedule|move|split|merge|report-progress|mark-prepared",
+        "  set-deadline|reroute",
+        "",
+        "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 === "assigned") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "assignment-status": { type: "string" },
+        "location-ids": { type: "string", multiple: true }
+      }
+    });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const assignmentStatus = args["assignment-status"];
+    const locationIdsRaw = args["location-ids"];
+    const locationIds = locationIdsRaw ? (0, import_shared.parseIds)(locationIdsRaw, "Location") : void 0;
+    const result = await (0, import_router.runQuery)(ctx, {
+      assignedFulfillmentOrders: {
+        __args: {
+          first,
+          after,
+          reverse,
+          ...sortKey ? { sortKey } : {},
+          ...assignmentStatus ? { assignmentStatus } : {},
+          ...locationIds && locationIds.length ? { locationIds } : {}
+        },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: getFulfillmentOrderSelection(ctx.view)
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.assignedFulfillmentOrders,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: {
+        base: "shop fulfillment-orders assigned",
+        first,
+        sort: typeof sortKey === "string" ? sortKey : void 0,
+        reverse: reverse === true,
+        extraFlags: [
+          ...assignmentStatus ? [{ flag: "--assignment-status", value: assignmentStatus }] : [],
+          ...locationIdsRaw ? locationIdsRaw.map((v) => ({ flag: "--location-ids", value: v })) : []
+        ]
+      }
+    });
+    return;
+  }
+  if (verb === "manual-holds") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const query = args.query;
+    const result = await (0, import_router.runQuery)(ctx, {
+      manualHoldsFulfillmentOrders: {
+        __args: { first, after, reverse, ...query ? { query } : {} },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: getFulfillmentOrderSelection(ctx.view)
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.manualHoldsFulfillmentOrders,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: { base: "shop fulfillment-orders manual-holds", first, query, reverse: reverse === true }
+    });
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "fulfillment-orders",
+      view: ctx.view,
+      baseSelection: getFulfillmentOrderSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { fulfillmentOrder: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.fulfillmentOrder, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        status: { type: "string" },
+        "location-ids": { type: "string", multiple: true },
+        "include-closed": { type: "boolean" }
+      }
+    });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const includeClosed = args["include-closed"];
+    const locationIds = args["location-ids"] ? (0, import_shared.parseIds)(args["location-ids"], "Location") : [];
+    const queryParts = [];
+    if (args.query) queryParts.push(String(args.query));
+    if (args.status) queryParts.push(`status:${args.status}`);
+    for (const id of locationIds) queryParts.push(`assigned_location_id:${id}`);
+    const query = queryParts.length > 0 ? queryParts.join(" ") : void 0;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "fulfillment-orders",
+      view: ctx.view,
+      baseSelection: getFulfillmentOrderSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      fulfillmentOrders: {
+        __args: { first, after, query, reverse, sortKey, includeClosed },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.fulfillmentOrders,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)(
+        "fulfillment-orders",
+        { first, query, sort: sortKey, reverse },
+        includeClosed ? [{ flag: "--include-closed", value: true }] : void 0
+      )
+    });
+    return;
+  }
+  if (verb === "accept-request") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { message: { type: "string" }, "estimated-shipped-at": { type: "string" } }
+    });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const message = args.message;
+    const estimatedShippedAt = args["estimated-shipped-at"];
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderAcceptFulfillmentRequest: {
+        __args: { id, message, estimatedShippedAt },
+        fulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.fulfillmentOrderAcceptFulfillmentRequest,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderAcceptFulfillmentRequest?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderAcceptFulfillmentRequest, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "reject-request") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { message: { type: "string" }, reason: { type: "string" } }
+    });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const message = args.message;
+    const reason = args.reason;
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderRejectFulfillmentRequest: {
+        __args: { id, message, reason },
+        fulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.fulfillmentOrderRejectFulfillmentRequest,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderRejectFulfillmentRequest?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderRejectFulfillmentRequest, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "submit-request") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { message: { type: "string" }, "notify-customer": { type: "boolean" } }
+    });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const fulfillmentOrderLineItems = built.used ? parseLineItemsInput(built.input) : void 0;
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderSubmitFulfillmentRequest: {
+        __args: {
+          id,
+          message: args.message,
+          notifyCustomer: args["notify-customer"] ? true : void 0,
+          ...fulfillmentOrderLineItems ? { fulfillmentOrderLineItems } : {}
+        },
+        submittedFulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.fulfillmentOrderSubmitFulfillmentRequest,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) {
+      return console.log(result.fulfillmentOrderSubmitFulfillmentRequest?.submittedFulfillmentOrder?.id ?? "");
+    }
+    (0, import_output.printJson)(result.fulfillmentOrderSubmitFulfillmentRequest, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "accept-cancellation") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { message: { type: "string" } } });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderAcceptCancellationRequest: {
+        __args: { id, message: args.message },
+        fulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.fulfillmentOrderAcceptCancellationRequest,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderAcceptCancellationRequest?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderAcceptCancellationRequest, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "reject-cancellation") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { message: { type: "string" } } });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderRejectCancellationRequest: {
+        __args: { id, message: args.message },
+        fulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.fulfillmentOrderRejectCancellationRequest,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderRejectCancellationRequest?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderRejectCancellationRequest, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "submit-cancellation") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { message: { type: "string" } } });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderSubmitCancellationRequest: {
+        __args: { id, message: args.message },
+        fulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.fulfillmentOrderSubmitCancellationRequest,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderSubmitCancellationRequest?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderSubmitCancellationRequest, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "cancel" || verb === "close" || verb === "open") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { message: { type: "string" } } });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const mutationField = verb === "cancel" ? "fulfillmentOrderCancel" : verb === "close" ? "fulfillmentOrderClose" : "fulfillmentOrderOpen";
+    const mutationArgs = verb === "close" ? { id, message: args.message } : { id };
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutationField]: {
+        __args: mutationArgs,
+        fulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    const payload = result[mutationField];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(payload?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "hold") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { reason: { type: "string" }, notes: { type: "string" } }
+    });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const reason = args.reason;
+    if (!reason) throw new import_errors.CliError("Missing --reason", 2);
+    const fulfillmentHold = {
+      reason,
+      ...args.notes ? { reasonNotes: args.notes } : {}
+    };
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderHold: {
+        __args: { id, fulfillmentHold },
+        fulfillmentOrder: fulfillmentOrderSummarySelection,
+        fulfillmentHold: { id: true, reason: true, reasonNotes: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fulfillmentOrderHold, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderHold?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderHold, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "release-hold") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "hold-ids": { type: "string", multiple: true } } });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const holdIds = args["hold-ids"] ? (0, import_shared.parseIds)(args["hold-ids"], "FulfillmentHold") : void 0;
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderReleaseHold: {
+        __args: { id, ...holdIds ? { holdIds } : {} },
+        fulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fulfillmentOrderReleaseHold, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderReleaseHold?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderReleaseHold, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "reschedule") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "fulfill-at": { type: "string" } } });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const fulfillAt = (0, import_shared.parseDateTime)(args["fulfill-at"], "--fulfill-at");
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderReschedule: {
+        __args: { id, fulfillAt },
+        fulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fulfillmentOrderReschedule, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderReschedule?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderReschedule, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "move") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "location-id": { type: "string" } } });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const newLocationId = (0, import_shared.requireLocationId)(args["location-id"]);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const fulfillmentOrderLineItems = built.used ? parseLineItemsInput(built.input) : void 0;
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderMove: {
+        __args: {
+          id,
+          newLocationId,
+          ...fulfillmentOrderLineItems ? { fulfillmentOrderLineItems } : {}
+        },
+        movedFulfillmentOrder: fulfillmentOrderSummarySelection,
+        originalFulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fulfillmentOrderMove, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderMove?.movedFulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderMove, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "split") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    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", 2);
+    const fulfillmentOrderSplits = Array.isArray(built.input) ? built.input : built.input.fulfillmentOrderSplits ?? built.input;
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderSplit: {
+        __args: { fulfillmentOrderSplits },
+        fulfillmentOrderSplits: {
+          fulfillmentOrder: fulfillmentOrderSummarySelection,
+          remainingFulfillmentOrder: fulfillmentOrderSummarySelection,
+          replacementFulfillmentOrder: fulfillmentOrderSummarySelection
+        },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fulfillmentOrderSplit, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderSplit?.fulfillmentOrderSplits?.[0]?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderSplit, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "merge") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    let fulfillmentOrderMergeInputs;
+    if (built.used) {
+      fulfillmentOrderMergeInputs = Array.isArray(built.input) ? built.input : built.input.fulfillmentOrderMergeInputs ?? built.input;
+    } else {
+      const ids = (0, import_shared.parseIds)(args.ids, "FulfillmentOrder");
+      fulfillmentOrderMergeInputs = [
+        {
+          mergeIntents: ids.map((id) => ({ fulfillmentOrderId: id }))
+        }
+      ];
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderMerge: {
+        __args: { fulfillmentOrderMergeInputs },
+        fulfillmentOrderMerges: {
+          fulfillmentOrder: fulfillmentOrderSummarySelection
+        },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fulfillmentOrderMerge, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderMerge?.fulfillmentOrderMerges?.[0]?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderMerge, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "report-progress") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { message: { type: "string" } } });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const progressReport = args.message ? { reasonNotes: args.message } : void 0;
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderReportProgress: {
+        __args: { id, progressReport },
+        fulfillmentOrder: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fulfillmentOrderReportProgress, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.fulfillmentOrderReportProgress?.fulfillmentOrder?.id ?? "");
+    (0, import_output.printJson)(result.fulfillmentOrderReportProgress, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "mark-prepared") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "FulfillmentOrder");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = built.used ? built.input : { lineItemsByFulfillmentOrder: [{ fulfillmentOrderId: id }] };
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrderLineItemsPreparedForPickup: {
+        __args: { input },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.fulfillmentOrderLineItemsPreparedForPickup,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    const requestedIds = Array.from(
+      new Set(
+        (input?.lineItemsByFulfillmentOrder ?? []).map((x) => x?.fulfillmentOrderId).filter((x) => typeof x === "string" && x.length > 0)
+      )
+    );
+    if (ctx.quiet || ctx.view === "ids") {
+      (0, import_output.printIds)(requestedIds);
+      return;
+    }
+    (0, import_output.printNode)({ node: { fulfillmentOrderIds: requestedIds }, format: ctx.format, quiet: false });
+    return;
+  }
+  if (verb === "set-deadline") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { deadline: { type: "string" } } });
+    const fulfillmentOrderIds = (0, import_shared.parseIds)(args.ids, "FulfillmentOrder");
+    const fulfillmentDeadline = (0, import_shared.parseDateTime)(args.deadline, "--deadline");
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrdersSetFulfillmentDeadline: {
+        __args: { fulfillmentOrderIds, fulfillmentDeadline },
+        success: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.fulfillmentOrdersSetFulfillmentDeadline,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet || ctx.view === "ids") {
+      (0, import_output.printIds)(fulfillmentOrderIds);
+      return;
+    }
+    const out = {
+      success: result.fulfillmentOrdersSetFulfillmentDeadline?.success === true,
+      fulfillmentOrderIds
+    };
+    (0, import_output.printNode)({ node: out, format: ctx.format, quiet: false });
+    return;
+  }
+  if (verb === "reroute") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "location-id": { type: "string" } } });
+    const fulfillmentOrderIds = (0, import_shared.parseIds)(args.ids, "FulfillmentOrder");
+    const locationId = (0, import_shared.requireLocationId)(args["location-id"]);
+    const result = await (0, import_router.runMutation)(ctx, {
+      fulfillmentOrdersReroute: {
+        __args: { fulfillmentOrderIds, includedLocationIds: [locationId] },
+        movedFulfillmentOrders: fulfillmentOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fulfillmentOrdersReroute, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      const ids = (result.fulfillmentOrdersReroute?.movedFulfillmentOrders ?? []).map((fo) => fo?.id);
+      for (const id of ids) if (id) console.log(id);
+      return;
+    }
+    (0, import_output.printJson)(result.fulfillmentOrdersReroute, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for fulfillment-orders: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runFulfillmentOrders
+});
+//# sourceMappingURL=fulfillment-orders.js.map

package/dist/cli/verbs/fulfillment-services.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext } from '../router';
+export declare const runFulfillmentServices: ({ ctx, verb, argv, }: {
+    ctx: CommandContext;
+    verb: string;
+    argv: string[];
+}) => Promise<void>;