shop-cli 0.1.0

package/dist/cli/verbs/blogs.js

@@ -0,0 +1,273 @@
+"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 blogs_exports = {};
+__export(blogs_exports, {
+  runBlogs: () => runBlogs
+});
+module.exports = __toCommonJS(blogs_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_publishablePublish = require("../workflows/products/publishablePublish");
+var import_shared = require("./_shared");
+const blogSummarySelection = {
+  id: true,
+  title: true,
+  handle: true,
+  updatedAt: true
+};
+const blogFullSelection = {
+  ...blogSummarySelection,
+  templateSuffix: true,
+  tags: true
+};
+const getBlogSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return blogFullSelection;
+  if (view === "raw") return {};
+  return blogSummarySelection;
+};
+const runBlogs = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop blogs <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|update|delete|publish|unpublish|count",
+        "",
+        "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)",
+        "",
+        "Notes:",
+        "  Shopify blogs do not have a direct published/unpublished state.",
+        "  blogs publish/unpublish updates isPublished for all articles in the blog."
+      ].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, {
+      blogsCount: {
+        __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.blogsCount?.count ?? "");
+    (0, import_output.printJson)(result.blogsCount, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "publish" || verb === "unpublish") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        at: { type: "string" },
+        now: { type: "boolean" }
+      }
+    });
+    if (ctx.dryRun) {
+      throw new import_errors.CliError("blogs publish/unpublish is not supported in --dry-run mode (requires pagination)", 2);
+    }
+    const id = (0, import_shared.requireId)(args.id, "Blog");
+    const publishDate = verb === "publish" ? (0, import_publishablePublish.parsePublishDate)({ at: args.at, now: args.now }) : void 0;
+    const desired = verb === "publish" ? { isPublished: true, ...publishDate ? { publishDate } : {} } : { isPublished: false };
+    const updated = [];
+    let after = void 0;
+    for (; ; ) {
+      const page = await (0, import_router.runQuery)(ctx, {
+        blog: {
+          __args: { id },
+          id: true,
+          articles: {
+            __args: { first: 50, after },
+            pageInfo: { hasNextPage: true, endCursor: true },
+            nodes: { id: true, isPublished: true }
+          }
+        }
+      });
+      if (page === void 0) return;
+      const connection = page.blog?.articles;
+      const nodes = connection?.nodes ?? [];
+      for (const a of nodes) {
+        const articleId = a?.id;
+        if (!articleId) continue;
+        const result = await (0, import_router.runMutation)(ctx, {
+          articleUpdate: {
+            __args: { id: articleId, article: desired },
+            article: { id: true, isPublished: true, publishedAt: true, updatedAt: true },
+            userErrors: { field: true, message: true }
+          }
+        });
+        if (result === void 0) return;
+        (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.articleUpdate, failOnUserErrors: ctx.failOnUserErrors });
+        updated.push(result.articleUpdate);
+      }
+      if (!connection?.pageInfo?.hasNextPage) break;
+      after = connection.pageInfo.endCursor;
+      if (!after) break;
+    }
+    if (ctx.quiet) {
+      for (const u of updated) {
+        const aid = u?.article?.id;
+        if (aid) process.stdout.write(`${aid}
+`);
+      }
+      return;
+    }
+    (0, import_output.printJson)(updated, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Blog");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "blogs",
+      view: ctx.view,
+      baseSelection: getBlogSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { blog: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.blog, 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: "blogs",
+      view: ctx.view,
+      baseSelection: getBlogSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      blogs: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.blogs,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("blogs", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "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, {
+      blogCreate: {
+        __args: { blog: built.input },
+        blog: blogSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.blogCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.blogCreate?.blog?.id ?? "");
+    (0, import_output.printJson)(result.blogCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Blog");
+    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, {
+      blogUpdate: {
+        __args: { id, blog: built.input },
+        blog: blogSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.blogUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.blogUpdate?.blog?.id ?? "");
+    (0, import_output.printJson)(result.blogUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Blog");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      blogDelete: {
+        __args: { id },
+        deletedBlogId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.blogDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.blogDelete?.deletedBlogId ?? "");
+    (0, import_output.printJson)(result.blogDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for blogs: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runBlogs
+});
+//# sourceMappingURL=blogs.js.map

package/dist/cli/verbs/bulk-operations.d.ts

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

package/dist/cli/verbs/bulk-operations.js

@@ -0,0 +1,272 @@
+"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 bulk_operations_exports = {};
+__export(bulk_operations_exports, {
+  runBulkOperations: () => runBulkOperations
+});
+module.exports = __toCommonJS(bulk_operations_exports);
+var import_errors = require("../errors");
+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 bulkOperationSelection = {
+  id: true,
+  type: true,
+  status: true,
+  errorCode: true,
+  createdAt: true,
+  completedAt: true,
+  objectCount: true,
+  fileSize: true,
+  url: true,
+  partialDataUrl: true,
+  rootObjectCount: true,
+  query: true
+};
+const getBulkOperationSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "raw") return {};
+  return bulkOperationSelection;
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const waitForBulkOperation = async ({
+  ctx,
+  id,
+  intervalMs
+}) => {
+  while (true) {
+    const result = await (0, import_router.runQuery)(ctx, { bulkOperation: { __args: { id }, ...bulkOperationSelection } });
+    if (result === void 0) return void 0;
+    const op = result.bulkOperation;
+    const status = op?.status;
+    if (status && ["COMPLETED", "FAILED", "CANCELED", "EXPIRED"].includes(status)) {
+      return op;
+    }
+    await sleep(intervalMs);
+  }
+};
+const runBulkOperations = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop bulk-operations <verb> [flags]",
+        "",
+        "Verbs:",
+        "  run-query|run-mutation|get|list|current|cancel|job",
+        "",
+        "Common output flags:",
+        "  --view summary|ids|raw",
+        "  --select <path>        (repeatable; dot paths; adds to base view selection)",
+        "  --selection <graphql>  (selection override; can be @file.gql)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "job") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = args.id;
+    if (!id) throw new import_errors.CliError("Missing --id", 2);
+    const result = await (0, import_router.runQuery)(ctx, {
+      job: { __args: { id }, id: true, done: true }
+    });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.job, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "run-query") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { wait: { type: "boolean" }, "wait-interval": { type: "string" } } });
+    const query = (0, import_shared.parseTextArg)(args.query, "--query");
+    const wait = Boolean(args.wait);
+    const intervalMs = args["wait-interval"] ? Number(args["wait-interval"]) * 1e3 : 2e3;
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+      throw new import_errors.CliError("--wait-interval must be a positive number (seconds)", 2);
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      bulkOperationRunQuery: {
+        __args: { query },
+        bulkOperation: bulkOperationSelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.bulkOperationRunQuery, failOnUserErrors: ctx.failOnUserErrors });
+    const op = result.bulkOperationRunQuery?.bulkOperation;
+    if (!wait) {
+      if (ctx.quiet) return console.log(op?.id ?? "");
+      (0, import_output.printJson)(result.bulkOperationRunQuery, ctx.format !== "raw");
+      return;
+    }
+    if (!op?.id) throw new import_errors.CliError("Bulk operation did not return an ID", 2);
+    const finalOp = await waitForBulkOperation({ ctx, id: op.id, intervalMs });
+    if (!finalOp) return;
+    if (ctx.quiet) return console.log(finalOp.id ?? "");
+    (0, import_output.printJson)(finalOp, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "run-mutation") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        mutation: { type: "string" },
+        "staged-upload-path": { type: "string" },
+        "client-id": { type: "string" },
+        wait: { type: "boolean" },
+        "wait-interval": { type: "string" }
+      }
+    });
+    const mutation = (0, import_shared.parseTextArg)(args.mutation, "--mutation");
+    const stagedUploadPath = args["staged-upload-path"];
+    if (!stagedUploadPath) throw new import_errors.CliError("Missing --staged-upload-path", 2);
+    const clientIdentifier = args["client-id"];
+    const wait = Boolean(args.wait);
+    const intervalMs = args["wait-interval"] ? Number(args["wait-interval"]) * 1e3 : 2e3;
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+      throw new import_errors.CliError("--wait-interval must be a positive number (seconds)", 2);
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      bulkOperationRunMutation: {
+        __args: {
+          mutation,
+          stagedUploadPath,
+          ...clientIdentifier ? { clientIdentifier } : {}
+        },
+        bulkOperation: bulkOperationSelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.bulkOperationRunMutation, failOnUserErrors: ctx.failOnUserErrors });
+    const op = result.bulkOperationRunMutation?.bulkOperation;
+    if (!wait) {
+      if (ctx.quiet) return console.log(op?.id ?? "");
+      (0, import_output.printJson)(result.bulkOperationRunMutation, ctx.format !== "raw");
+      return;
+    }
+    if (!op?.id) throw new import_errors.CliError("Bulk operation did not return an ID", 2);
+    const finalOp = await waitForBulkOperation({ ctx, id: op.id, intervalMs });
+    if (!finalOp) return;
+    if (ctx.quiet) return console.log(finalOp.id ?? "");
+    (0, import_output.printJson)(finalOp, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "BulkOperation");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "bulk-operations",
+      view: ctx.view,
+      baseSelection: getBulkOperationSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { bulkOperation: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.bulkOperation, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { status: { type: "string" } } });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const status = args.status;
+    const type = args.type;
+    const queryParts = [];
+    if (args.query) queryParts.push(args.query);
+    if (status) queryParts.push(`status:${status.toLowerCase()}`);
+    if (type) queryParts.push(`operation_type:${type.toLowerCase()}`);
+    const query = queryParts.length > 0 ? queryParts.join(" ") : void 0;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "bulk-operations",
+      view: ctx.view,
+      baseSelection: getBulkOperationSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      bulkOperations: {
+        __args: { first, after, reverse, sortKey, ...query ? { query } : {} },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.bulkOperations,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("bulk-operations", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "current") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { type: { type: "string" } } });
+    const type = args.type;
+    const selection = (0, import_select.resolveSelection)({
+      resource: "bulk-operations",
+      view: ctx.view,
+      baseSelection: getBulkOperationSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      currentBulkOperation: { __args: { ...type ? { type } : {} }, ...selection }
+    });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.currentBulkOperation, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "cancel") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "BulkOperation");
+    if (!args.yes) throw new import_errors.CliError("Refusing to cancel without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      bulkOperationCancel: {
+        __args: { id },
+        bulkOperation: bulkOperationSelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.bulkOperationCancel, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.bulkOperationCancel?.bulkOperation?.id ?? "");
+    (0, import_output.printJson)(result.bulkOperationCancel, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for bulk-operations: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runBulkOperations
+});
+//# sourceMappingURL=bulk-operations.js.map

package/dist/cli/verbs/business-entities.d.ts

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

package/dist/cli/verbs/business-entities.js

@@ -0,0 +1,102 @@
+"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 business_entities_exports = {};
+__export(business_entities_exports, {
+  runBusinessEntities: () => runBusinessEntities
+});
+module.exports = __toCommonJS(business_entities_exports);
+var import_errors = require("../errors");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_gid = require("../gid");
+var import_shared = require("./_shared");
+const businessEntitySummarySelection = {
+  id: true,
+  displayName: true,
+  companyName: true,
+  primary: true,
+  archived: true,
+  address: { countryCode: true, city: true, province: true }
+};
+const businessEntityFullSelection = {
+  ...businessEntitySummarySelection,
+  address: {
+    ...businessEntitySummarySelection.address,
+    address1: true,
+    address2: true,
+    zip: true
+  },
+  shopifyPaymentsAccount: { id: true, activated: true }
+};
+const getBusinessEntitySelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return businessEntityFullSelection;
+  if (view === "raw") return {};
+  return businessEntitySummarySelection;
+};
+const runBusinessEntities = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const selection = (0, import_select.resolveSelection)({
+      resource: "business-entities",
+      view: ctx.view,
+      baseSelection: getBusinessEntitySelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { businessEntities: selection });
+    if (result === void 0) return;
+    const nodes = (result.businessEntities ?? []).slice(0, first);
+    (0, import_output.printConnection)({ connection: { nodes }, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const idRaw = args.id;
+    const selection = (0, import_select.resolveSelection)({
+      resource: "business-entities",
+      view: ctx.view,
+      baseSelection: getBusinessEntitySelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      businessEntity: { __args: { ...idRaw ? { id: (0, import_gid.coerceGid)(idRaw, "BusinessEntity") } : {} }, ...selection }
+    });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.businessEntity, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for business-entities: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runBusinessEntities
+});
+//# sourceMappingURL=business-entities.js.map

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

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