shop-cli 0.1.1

package/dist/cli/verbs/subscription-billing.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_exports = {};
+__export(subscription_billing_exports, {
+  runSubscriptionBilling: () => runSubscriptionBilling
+});
+module.exports = __toCommonJS(subscription_billing_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_userErrors = require("../userErrors");
+var import_shared = require("./_shared");
+const subscriptionBillingAttemptSummarySelection = {
+  id: true,
+  createdAt: true,
+  ready: true,
+  errorCode: true,
+  errorMessage: true,
+  originTime: true
+};
+const subscriptionBillingCycleSummarySelection = {
+  cycleIndex: true,
+  status: true,
+  billingAttemptExpectedDate: true,
+  cycleStartAt: true,
+  cycleEndAt: true,
+  skipped: true,
+  edited: true
+};
+const subscriptionDraftSummarySelection = {
+  id: true,
+  customer: { id: true, displayName: true, email: true },
+  currencyCode: true,
+  billingPolicy: {
+    interval: true,
+    intervalCount: true
+  },
+  deliveryPolicy: {
+    interval: true,
+    intervalCount: true
+  },
+  lines: {
+    __args: { first: 10 },
+    nodes: {
+      id: true,
+      title: true,
+      quantity: true,
+      variantId: true
+    }
+  }
+};
+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 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 parseCycleIndexes = (value) => {
+  if (typeof value !== "string" || !value.trim()) throw new import_errors.CliError("Missing --cycle-indexes", 2);
+  const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
+  if (parts.length === 0) throw new import_errors.CliError("--cycle-indexes must include at least one index", 2);
+  const indexes = parts.map((part) => {
+    const n = Number(part);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+      throw new import_errors.CliError(`Invalid cycle index: ${part}`, 2);
+    }
+    return n;
+  });
+  return indexes;
+};
+const runSubscriptionBilling = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop subscription-billing <verb> [flags]",
+        "",
+        "Verbs:",
+        "  get-attempt|list-attempts|create-attempt|get-cycle|list-cycles|charge",
+        "  bulk-charge|bulk-search|skip-cycle|unskip-cycle|edit-schedule|edit-cycle|delete-edits",
+        "",
+        "Notes:",
+        "  - Use --cycle-index (not --id) for cycle-specific operations.",
+        "",
+        "Common output flags:",
+        "  --format json|jsonl|table|raw",
+        "  --quiet"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "get-attempt") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "SubscriptionBillingAttempt");
+    const result = await (0, import_router.runQuery)(ctx, {
+      subscriptionBillingAttempt: {
+        __args: { id },
+        ...subscriptionBillingAttemptSummarySelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.subscriptionBillingAttempt, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list-attempts") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "contract-id": { type: "string" } } });
+    const contractId = requireContractId(args["contract-id"]);
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const result = await (0, import_router.runQuery)(ctx, {
+      subscriptionContract: {
+        __args: { id: contractId },
+        billingAttempts: {
+          __args: { first, after, reverse },
+          pageInfo: { hasNextPage: true, endCursor: true },
+          nodes: subscriptionBillingAttemptSummarySelection
+        }
+      }
+    });
+    if (result === void 0) return;
+    if (!result.subscriptionContract) throw new import_errors.CliError("Subscription contract not found", 2);
+    (0, import_output.printConnection)({
+      connection: result.subscriptionContract.billingAttempts,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: {
+        base: "shop subscription-billing list-attempts",
+        first,
+        reverse,
+        extraFlags: [{ flag: "--contract-id", value: contractId }]
+      }
+    });
+    return;
+  }
+  if (verb === "create-attempt") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "contract-id": { type: "string" } } });
+    const subscriptionContractId = requireContractId(args["contract-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 result = await (0, import_router.runMutation)(ctx, {
+      subscriptionBillingAttemptCreate: {
+        __args: { subscriptionContractId, subscriptionBillingAttemptInput: built.input },
+        subscriptionBillingAttempt: subscriptionBillingAttemptSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.subscriptionBillingAttemptCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.subscriptionBillingAttemptCreate?.subscriptionBillingAttempt?.id ?? "");
+    (0, import_output.printJson)(result.subscriptionBillingAttemptCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "get-cycle") {
+    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 } };
+    const result = await (0, import_router.runQuery)(ctx, {
+      subscriptionBillingCycle: {
+        __args: { billingCycleInput },
+        ...subscriptionBillingCycleSummarySelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.subscriptionBillingCycle, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list-cycles") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "contract-id": { type: "string" } } });
+    const contractId = requireContractId(args["contract-id"]);
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const result = await (0, import_router.runQuery)(ctx, {
+      subscriptionBillingCycles: {
+        __args: { contractId, first, after, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: subscriptionBillingCycleSummarySelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.subscriptionBillingCycles,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: {
+        base: "shop subscription-billing list-cycles",
+        first,
+        sort: typeof sortKey === "string" ? sortKey : void 0,
+        reverse,
+        extraFlags: [{ flag: "--contract-id", value: contractId }]
+      }
+    });
+    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 === "bulk-charge" || verb === "bulk-search") {
+    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 hasDateRange = Boolean(built.input?.billingAttemptExpectedDateRange);
+    if (!hasDateRange) {
+      if (ctx.dryRun) {
+        ;
+        built.input.billingAttemptExpectedDateRange = {
+          startDate: "2000-01-01T00:00:00Z",
+          endDate: "2000-01-02T00:00:00Z"
+        };
+      } else {
+        throw new import_errors.CliError("Missing billingAttemptExpectedDateRange in --input/--set", 2);
+      }
+    }
+    const mutationField = verb === "bulk-charge" ? "subscriptionBillingCycleBulkCharge" : "subscriptionBillingCycleBulkSearch";
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutationField]: {
+        __args: built.input,
+        job: { id: true, done: true },
+        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?.job?.id ?? "");
+    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "skip-cycle" || verb === "unskip-cycle") {
+    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 } };
+    const mutationField = verb === "skip-cycle" ? "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 === "edit-schedule") {
+    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 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 billingCycleInput = { contractId, selector: { index: cycleIndex } };
+    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 === "edit-cycle") {
+    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 built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const billingCycleInput = { contractId, selector: { index: cycleIndex } };
+    const editResult = await (0, import_router.runMutation)(ctx, {
+      subscriptionBillingCycleContractEdit: {
+        __args: { billingCycleInput },
+        draft: subscriptionDraftSummarySelection,
+        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: subscriptionDraftSummarySelection,
+        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 === "delete-edits") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "contract-id": { type: "string" }, "cycle-indexes": { type: "string" } } });
+    const contractId = requireContractId(args["contract-id"]);
+    const cycleIndexes = parseCycleIndexes(args["cycle-indexes"]);
+    const billingCycles = [];
+    for (const cycleIndex of cycleIndexes) {
+      const billingCycleInput = { contractId, selector: { index: cycleIndex } };
+      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 });
+      const cycles = result.subscriptionBillingCycleEditDelete?.billingCycles ?? [];
+      billingCycles.push(...cycles);
+    }
+    if (ctx.quiet) return;
+    (0, import_output.printJson)({ billingCycles }, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for subscription-billing: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runSubscriptionBilling
+});
+//# sourceMappingURL=subscription-billing.js.map

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

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