shop-cli 0.1.1

package/dist/cli/verbs/customer-segments.js

@@ -0,0 +1,193 @@
+"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 customer_segments_exports = {};
+__export(customer_segments_exports, {
+  runCustomerSegments: () => runCustomerSegments
+});
+module.exports = __toCommonJS(customer_segments_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_gid = require("../gid");
+var import_shared = require("./_shared");
+const customerSegmentMemberSummarySelection = {
+  id: true,
+  displayName: true,
+  numberOfOrders: true,
+  amountSpent: { amount: true, currencyCode: true }
+};
+const customerSegmentMemberFullSelection = {
+  ...customerSegmentMemberSummarySelection,
+  firstName: true,
+  lastName: true,
+  note: true,
+  lastOrderId: true,
+  defaultAddress: { address1: true, city: true, provinceCode: true, countryCode: true, zip: true },
+  defaultEmailAddress: { emailAddress: true, marketingState: true },
+  defaultPhoneNumber: { phoneNumber: true, marketingState: true }
+};
+const getCustomerSegmentMemberSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return customerSegmentMemberFullSelection;
+  if (view === "raw") return {};
+  return customerSegmentMemberSummarySelection;
+};
+const membersQuerySelection = {
+  id: true,
+  done: true,
+  currentCount: true
+};
+const runCustomerSegments = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (verb === "members") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "segment-id": { type: "string" },
+        "query-id": { type: "string" },
+        timezone: { type: "string" }
+      }
+    });
+    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 timezone = args.timezone;
+    const segmentIdRaw = args["segment-id"];
+    const queryIdRaw = args["query-id"];
+    const segmentId = segmentIdRaw ? (0, import_gid.coerceGid)(String(segmentIdRaw), "Segment") : void 0;
+    const queryId = queryIdRaw ? (0, import_gid.coerceGid)(String(queryIdRaw), "CustomerSegmentMembersQuery") : void 0;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "customer-segments",
+      view: ctx.view,
+      baseSelection: getCustomerSegmentMemberSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      customerSegmentMembers: {
+        __args: {
+          first,
+          after,
+          ...query ? { query } : {},
+          ...queryId ? { queryId } : {},
+          ...segmentId ? { segmentId } : {},
+          ...reverse ? { reverse } : {},
+          ...sortKey ? { sortKey } : {},
+          ...timezone ? { timezone } : {}
+        },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        edges: { cursor: true, node: nodeSelection }
+      }
+    });
+    if (result === void 0) return;
+    const edges = result.customerSegmentMembers?.edges ?? [];
+    const nodes = edges.map((e) => e?.node).filter(Boolean);
+    const pageInfo = result.customerSegmentMembers?.pageInfo;
+    const extraFlags = [];
+    if (segmentId) extraFlags.push({ flag: "--segment-id", value: segmentId });
+    if (queryId) extraFlags.push({ flag: "--query-id", value: queryId });
+    if (timezone) extraFlags.push({ flag: "--timezone", value: timezone });
+    (0, import_output.printConnection)({
+      connection: { nodes, pageInfo },
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: {
+        base: "shop customer-segments members",
+        first,
+        query,
+        sort: sortKey,
+        reverse: reverse === true,
+        extraFlags
+      }
+    });
+    return;
+  }
+  if (verb === "members-query") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "CustomerSegmentMembersQuery");
+    const result = await (0, import_router.runQuery)(ctx, { customerSegmentMembersQuery: { __args: { id }, ...membersQuerySelection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.customerSegmentMembersQuery, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "membership") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "customer-id": { type: "string" }, "segment-ids": { type: "string", multiple: true } }
+    });
+    const customerId = (0, import_shared.requireGidFlag)(args["customer-id"], "--customer-id", "Customer");
+    const segmentIdsRaw = (0, import_shared.parseStringList)(args["segment-ids"], "--segment-ids");
+    const segmentIds = segmentIdsRaw.map((id) => (0, import_gid.coerceGid)(id, "Segment"));
+    const result = await (0, import_router.runQuery)(ctx, {
+      customerSegmentMembership: {
+        __args: { customerId, segmentIds },
+        memberships: { segmentId: true, isMember: true }
+      }
+    });
+    if (result === void 0) return;
+    const memberships = result.customerSegmentMembership?.memberships ?? [];
+    if (ctx.quiet) {
+      const memberSegmentIds = memberships.filter((m) => m?.isMember === true).map((m) => m?.segmentId);
+      (0, import_output.printIds)(memberSegmentIds);
+      return;
+    }
+    (0, import_output.printConnection)({ connection: { nodes: memberships }, format: ctx.format, quiet: false });
+    return;
+  }
+  if (verb === "members-query-create") {
+    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 result = await (0, import_router.runMutation)(ctx, {
+      customerSegmentMembersQueryCreate: {
+        __args: { input: built.input },
+        customerSegmentMembersQuery: membersQuerySelection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.customerSegmentMembersQueryCreate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.customerSegmentMembersQueryCreate?.customerSegmentMembersQuery?.id ?? "");
+    (0, import_output.printJson)(result.customerSegmentMembersQueryCreate, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for customer-segments: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runCustomerSegments
+});
+//# sourceMappingURL=customer-segments.js.map

package/dist/cli/verbs/customers.d.ts

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