shop-cli 0.1.0

package/dist/cli/verbs/subscription-billing-cycles.js

@@ -0,0 +1,391 @@
+"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 subscription_billing_cycles_exports = {};
+__export(subscription_billing_cycles_exports, {
+  runSubscriptionBillingCycles: () => runSubscriptionBillingCycles
+});
+module.exports = __toCommonJS(subscription_billing_cycles_exports);
+var import_errors = require("../errors");
+var import_gid = require("../gid");
+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 subscriptionBillingAttemptSummarySelection = {
+  id: true,
+  createdAt: true,
+  ready: true,
+  errorCode: true,
+  errorMessage: true,
+  originTime: true,
+  nextActionUrl: true
+};
+const subscriptionBillingCycleSummarySelection = {
+  cycleIndex: true,
+  status: true,
+  billingAttemptExpectedDate: true,
+  cycleStartAt: true,
+  cycleEndAt: true,
+  skipped: true,
+  edited: true,
+  sourceContract: { id: true, status: true }
+};
+const subscriptionBillingCycleFullSelection = {
+  ...subscriptionBillingCycleSummarySelection,
+  editedContract: { updatedAt: true, createdAt: true },
+  billingAttempts: {
+    __args: { first: 10 },
+    nodes: subscriptionBillingAttemptSummarySelection,
+    pageInfo: { hasNextPage: true, endCursor: true }
+  }
+};
+const getSubscriptionBillingCycleSelection = (view) => {
+  if (view === "full") return subscriptionBillingCycleFullSelection;
+  if (view === "raw") return {};
+  return subscriptionBillingCycleSummarySelection;
+};
+const requireContractId = (value) => {
+  if (typeof value !== "string" || !value) throw new import_errors.CliError("Missing --contract-id", 2);
+  return (0, import_gid.coerceGid)(value, "SubscriptionContract");
+};
+const requireDraftId = (value) => {
+  if (typeof value !== "string" || !value) throw new import_errors.CliError("Missing --draft-id", 2);
+  return (0, import_gid.coerceGid)(value, "SubscriptionDraft");
+};
+const requireJobId = (value) => {
+  if (typeof value !== "string" || !value) throw new import_errors.CliError("Missing --job-id", 2);
+  return (0, import_gid.coerceGid)(value, "Job");
+};
+const parseCycleIndex = (value) => {
+  if (value === void 0 || value === null || value === "") throw new import_errors.CliError("Missing --cycle-index", 2);
+  const n = Number(value);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) throw new import_errors.CliError("--cycle-index must be a positive integer", 2);
+  return n;
+};
+const parseDateTime = (value) => {
+  if (typeof value !== "string" || !value.trim()) throw new import_errors.CliError("Missing --date", 2);
+  return value.trim();
+};
+const extractArrayField = (input, field) => {
+  if (Array.isArray(input)) return input;
+  if (input && Array.isArray(input[field])) return input[field];
+  return void 0;
+};
+const runSubscriptionBillingCycles = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop subscription-billing-cycles <verb> [flags]",
+        "",
+        "Verbs:",
+        "  get|bulk-results|attempts",
+        "  charge|skip|unskip|schedule-edit",
+        "  contract-edit|edit-delete|edits-delete",
+        "  contract-draft-commit|contract-draft-concatenate",
+        "",
+        "Common output flags:",
+        "  --view summary|full|raw|all",
+        "  --select <path>        (repeatable; dot paths; adds to base view selection)",
+        "  --selection <graphql>  (selection override; can be @file.gql)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "contract-id": { type: "string" }, "cycle-index": { type: "string" }, date: { type: "string" } }
+    });
+    const contractId = requireContractId(args["contract-id"]);
+    const cycleIndexRaw = args["cycle-index"];
+    const dateRaw = args.date;
+    const selector = cycleIndexRaw !== void 0 ? { index: parseCycleIndex(cycleIndexRaw) } : dateRaw ? { date: parseDateTime(dateRaw) } : void 0;
+    if (!selector) throw new import_errors.CliError("Missing --cycle-index or --date", 2);
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "SubscriptionBillingCycle",
+      view: ctx.view,
+      baseSelection: getSubscriptionBillingCycleSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: false
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      subscriptionBillingCycle: {
+        __args: { billingCycleInput: { contractId, selector } },
+        ...selection
+      }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.subscriptionBillingCycle?.cycleIndex ?? "");
+    (0, import_output.printNode)({ node: result.subscriptionBillingCycle, format: ctx.format, quiet: false });
+    return;
+  }
+  if (verb === "bulk-results") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "job-id": { type: "string" } } });
+    const jobId = requireJobId(args["job-id"]);
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      typeName: "SubscriptionBillingCycle",
+      view: ctx.view,
+      baseSelection: getSubscriptionBillingCycleSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: false
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      subscriptionBillingCycleBulkResults: {
+        __args: { jobId, first, after, reverse },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.subscriptionBillingCycleBulkResults,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: {
+        base: "shop subscription-billing-cycles bulk-results",
+        first,
+        reverse: reverse === true,
+        extraFlags: [{ flag: "--job-id", value: jobId }]
+      }
+    });
+    return;
+  }
+  if (verb === "attempts") {
+    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 selection = (0, import_select.resolveSelection)({
+      typeName: "SubscriptionBillingAttempt",
+      view: ctx.view,
+      baseSelection: subscriptionBillingAttemptSummarySelection,
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: true
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      subscriptionBillingAttempts: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: selection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.subscriptionBillingAttempts,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("subscription-billing-cycles", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "charge") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "contract-id": { type: "string" }, "cycle-index": { type: "string" } } });
+    const subscriptionContractId = requireContractId(args["contract-id"]);
+    const cycleIndex = parseCycleIndex(args["cycle-index"]);
+    const result = await (0, import_router.runMutation)(ctx, {
+      subscriptionBillingCycleCharge: {
+        __args: { subscriptionContractId, billingCycleSelector: { index: cycleIndex } },
+        subscriptionBillingAttempt: subscriptionBillingAttemptSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.subscriptionBillingCycleCharge, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.subscriptionBillingCycleCharge?.subscriptionBillingAttempt?.id ?? "");
+    (0, import_output.printJson)(result.subscriptionBillingCycleCharge, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "skip" || verb === "unskip" || verb === "schedule-edit" || verb === "contract-edit" || verb === "edit-delete") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "contract-id": { type: "string" }, "cycle-index": { type: "string" } }
+    });
+    const contractId = requireContractId(args["contract-id"]);
+    const cycleIndex = parseCycleIndex(args["cycle-index"]);
+    const billingCycleInput = { contractId, selector: { index: cycleIndex } };
+    if (verb === "skip" || verb === "unskip") {
+      const mutationField = verb === "skip" ? "subscriptionBillingCycleSkip" : "subscriptionBillingCycleUnskip";
+      const result = await (0, import_router.runMutation)(ctx, {
+        [mutationField]: {
+          __args: { billingCycleInput },
+          billingCycle: subscriptionBillingCycleSummarySelection,
+          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;
+      (0, import_output.printJson)(payload, ctx.format !== "raw");
+      return;
+    }
+    if (verb === "schedule-edit") {
+      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, {
+        subscriptionBillingCycleScheduleEdit: {
+          __args: { billingCycleInput, input: built.input },
+          billingCycle: subscriptionBillingCycleSummarySelection,
+          userErrors: { field: true, message: true }
+        }
+      });
+      if (result === void 0) return;
+      (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.subscriptionBillingCycleScheduleEdit, failOnUserErrors: ctx.failOnUserErrors });
+      if (ctx.quiet) return;
+      (0, import_output.printJson)(result.subscriptionBillingCycleScheduleEdit, ctx.format !== "raw");
+      return;
+    }
+    if (verb === "contract-edit") {
+      const built = (0, import_input.buildInput)({
+        inputArg: args.input,
+        setArgs: args.set,
+        setJsonArgs: args["set-json"]
+      });
+      const editResult = await (0, import_router.runMutation)(ctx, {
+        subscriptionBillingCycleContractEdit: {
+          __args: { billingCycleInput },
+          draft: { id: true },
+          userErrors: { field: true, message: true }
+        }
+      });
+      if (editResult === void 0) return;
+      (0, import_userErrors.maybeFailOnUserErrors)({ payload: editResult.subscriptionBillingCycleContractEdit, failOnUserErrors: ctx.failOnUserErrors });
+      const draftId = editResult.subscriptionBillingCycleContractEdit?.draft?.id;
+      if (!draftId || !built.used) {
+        if (ctx.quiet) return console.log(draftId ?? "");
+        (0, import_output.printJson)(editResult.subscriptionBillingCycleContractEdit, ctx.format !== "raw");
+        return;
+      }
+      const updateResult = await (0, import_router.runMutation)(ctx, {
+        subscriptionDraftUpdate: {
+          __args: { draftId, input: built.input },
+          draft: { id: true },
+          userErrors: { field: true, message: true }
+        }
+      });
+      if (updateResult === void 0) return;
+      (0, import_userErrors.maybeFailOnUserErrors)({ payload: updateResult.subscriptionDraftUpdate, failOnUserErrors: ctx.failOnUserErrors });
+      if (ctx.quiet) return console.log(updateResult.subscriptionDraftUpdate?.draft?.id ?? "");
+      (0, import_output.printJson)(updateResult.subscriptionDraftUpdate, ctx.format !== "raw");
+      return;
+    }
+    if (verb === "edit-delete") {
+      if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+      const result = await (0, import_router.runMutation)(ctx, {
+        subscriptionBillingCycleEditDelete: {
+          __args: { billingCycleInput },
+          billingCycles: subscriptionBillingCycleSummarySelection,
+          userErrors: { field: true, message: true }
+        }
+      });
+      if (result === void 0) return;
+      (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.subscriptionBillingCycleEditDelete, failOnUserErrors: ctx.failOnUserErrors });
+      if (ctx.quiet) return;
+      (0, import_output.printJson)(result.subscriptionBillingCycleEditDelete, ctx.format !== "raw");
+      return;
+    }
+  }
+  if (verb === "edits-delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "contract-id": { type: "string" } } });
+    const contractId = requireContractId(args["contract-id"]);
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      subscriptionBillingCycleEditsDelete: {
+        __args: { contractId, targetSelection: "ALL" },
+        billingCycles: subscriptionBillingCycleSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.subscriptionBillingCycleEditsDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return;
+    (0, import_output.printJson)(result.subscriptionBillingCycleEditsDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "contract-draft-commit") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "draft-id": { type: "string" } } });
+    const draftId = requireDraftId(args["draft-id"]);
+    const result = await (0, import_router.runMutation)(ctx, {
+      subscriptionBillingCycleContractDraftCommit: {
+        __args: { draftId },
+        contract: { createdAt: true, updatedAt: true },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.subscriptionBillingCycleContractDraftCommit, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return;
+    (0, import_output.printJson)(result.subscriptionBillingCycleContractDraftCommit, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "contract-draft-concatenate") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "draft-id": { type: "string" } } });
+    const draftId = requireDraftId(args["draft-id"]);
+    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 concatenatedBillingCycleContracts = extractArrayField(built.input, "concatenatedBillingCycleContracts");
+    if (!concatenatedBillingCycleContracts || concatenatedBillingCycleContracts.length === 0) {
+      throw new import_errors.CliError("Missing concatenatedBillingCycleContracts array", 2);
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      subscriptionBillingCycleContractDraftConcatenate: {
+        __args: { draftId, concatenatedBillingCycleContracts },
+        draft: { id: true },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.subscriptionBillingCycleContractDraftConcatenate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.subscriptionBillingCycleContractDraftConcatenate?.draft?.id ?? "");
+    (0, import_output.printJson)(result.subscriptionBillingCycleContractDraftConcatenate, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for subscription-billing-cycles: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runSubscriptionBillingCycles
+});
+//# sourceMappingURL=subscription-billing-cycles.js.map

package/dist/cli/verbs/subscription-billing.d.ts

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