fresh-squeezy 0.1.19 → 0.2.0

package/README.md

@@ -137,6 +137,11 @@ npx fresh-squeezy create webhook --body-file webhook.json --mode test
 npx fresh-squeezy cancel subscription --id 9 --yes
 npx fresh-squeezy refund order --id 100 --yes --mode live
 npx fresh-squeezy generate-invoice order --id 100 --yes
+
+# Bulk delete / cancel / refund: --all, --ids, --match, --dry-run
+npx fresh-squeezy delete discount --all --store-ids 12 --dry-run
+npx fresh-squeezy delete discount --all --store-ids 12 --match TEST --yes
+npx fresh-squeezy delete webhook --ids 1,2,3 --yes
 ```
 
 **Safety:** `delete` / `cancel` / `refund` always require `--yes` or a TTY confirm. Live-mode writes need `--yes` or TTY confirm too. Bodies are JSON:API documents via `--body` or `--body-file` (not flat flags).
@@ -206,7 +211,7 @@ The CLI default is `--mode test`. Override with `--mode live`. Guided setup asks
 | `LEMON_SQUEEZY_MODE` | no | `test` (default) or `live` |
 | `LEMON_SQUEEZY_STORE_ID` | no | Convenience default for `client.doctor()` — library only |
 
-The CLI does not read `LEMON_SQUEEZY_STORE_ID`; use `--store-ids` or `--all-stores` so store selection stays explicit per command.
+`doctor` and `validate` do not read `LEMON_SQUEEZY_STORE_ID`; use `--store-ids` or `--all-stores` there. Only the `ops` verbs (`list`, `delete --all`, …) fall back to it when `--store-ids` is omitted.
 
 ## Issue codes
 

package/dist/cli.js

@@ -2477,6 +2477,10 @@ var pickLauncherAction = async () => {
         name: "Run doctor now \u2014 pick stores interactively when needed",
         value: "doctor"
       },
+      {
+        name: "Manage resources \u2014 bulk delete / cancel / refund",
+        value: "manage"
+      },
       {
         name: "Show command examples \u2014 copy/paste friendly",
         value: "examples"
@@ -2712,6 +2716,29 @@ var isPromptCancel = (error) => {
   if (!(error instanceof Error)) return false;
   return error.name === "ExitPromptError" || error.message.includes("User force closed");
 };
+var pickManageOperation = async (ops) => {
+  return select({
+    message: "Which operation?",
+    theme: PROMPT_THEME,
+    choices: ops.map((op) => ({ name: `${op.verb} ${op.resource}`, value: op }))
+  });
+};
+var askParentId = async (resource) => {
+  const value = await input({
+    message: `Parent id to list ${resource} items from:`,
+    theme: PROMPT_THEME,
+    validate: (entry) => entry.trim().length > 0 ? true : "A parent id is required."
+  });
+  return value.trim();
+};
+var pickBulkTargets = async (verb, items) => {
+  return checkbox({
+    message: `Pick items to ${verb} (space toggles, a selects all, enter confirms):`,
+    theme: PROMPT_THEME,
+    choices: items.map((item) => ({ name: `${item.label} \u2014 id ${item.id}`, value: item.id })),
+    validate: (selected) => selected.length > 0 ? true : "Pick at least one item."
+  });
+};
 
 // src/cli/resolveStores.ts
 var resolveStores = async (client, input2) => {
@@ -2947,6 +2974,11 @@ var renderCommandExamples = () => {
     "  fresh-squeezy validate connection",
     "  fresh-squeezy validate webhook --store-ids 12 --webhook-url https://app.example.com/api/webhooks/lemon-squeezy",
     "",
+    `${chalk2.bold("Bulk ops (delete / cancel / refund)")}`,
+    "  fresh-squeezy delete discount --all --store-ids 12 --dry-run",
+    "  fresh-squeezy delete discount --all --store-ids 12 --match TEST --yes",
+    "  fresh-squeezy delete webhook --ids 1,2,3 --yes",
+    "",
     `${chalk2.bold("Automation")}`,
     "  fresh-squeezy doctor --all-stores --json",
     ""
@@ -3290,6 +3322,176 @@ var pathExists = async (filePath) => {
   }
 };
 
+// src/cli/commands/bulkOps.ts
+var supportsBulk = (spec) => Boolean(spec.destructive) && spec.idRole === "id";
+var describeBulkTarget = (item) => {
+  const attrs = item.attributes ?? {};
+  const id = String(item.id);
+  for (const key of ["code", "name", "url", "identifier", "user_email", "status"]) {
+    const value = attrs[key];
+    if (typeof value === "string" && value.length > 0) return { id, label: value };
+  }
+  return { id, label: id };
+};
+var matchesText = (item, text) => {
+  const needle = text.toLowerCase();
+  return Object.values(item.attributes ?? {}).some(
+    (value) => typeof value === "string" && value.toLowerCase().includes(needle)
+  );
+};
+var collectBulkTargets = async (http, spec, selector) => {
+  if (selector.ids?.length) {
+    return selector.ids.map((id) => ({ id, label: id }));
+  }
+  const listSpec = findResourceVerb(spec.resource, "list");
+  if (!listSpec) {
+    throw new FreshSqueezyError({
+      code: "UNKNOWN_OP",
+      message: `Cannot use --all: ${spec.resource} has no list op. Pass --ids instead.`
+    });
+  }
+  if (listSpec.idRole === "store" && !selector.storeId) {
+    throw new FreshSqueezyError({
+      code: "MISSING_ARG",
+      message: "--all needs a store: pass --store-ids or set LEMON_SQUEEZY_STORE_ID."
+    });
+  }
+  if (listSpec.idRole === "parent" && !selector.parentId) {
+    throw new FreshSqueezyError({
+      code: "MISSING_ARG",
+      message: `--all needs --parent-id to list ${spec.resource} items.`
+    });
+  }
+  const items = await invokeOp(http, spec.resource, "list", {
+    storeId: selector.storeId,
+    parentId: selector.parentId
+  });
+  return items.filter((item) => selector.match ? matchesText(item, selector.match) : true).map(describeBulkTarget);
+};
+var executeBulk = async (http, spec, targets, opts = {}) => {
+  const dryRun = Boolean(opts.dryRun);
+  const results = [];
+  for (const target of targets) {
+    if (dryRun) {
+      results.push({ ...target, ok: true });
+      continue;
+    }
+    try {
+      await invokeOp(http, spec.resource, spec.verb, { id: target.id, body: opts.body });
+      results.push({ ...target, ok: true });
+    } catch (err) {
+      results.push({
+        ...target,
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const failed = results.filter((r) => !r.ok).length;
+  return { dryRun, total: results.length, succeeded: results.length - failed, failed, results };
+};
+var previewTargets = (targets, max = 5) => {
+  const shown = targets.slice(0, max).map((t) => t.label);
+  const more = targets.length - shown.length;
+  return more > 0 ? `${shown.join(", ")}, \u2026 +${more} more` : shown.join(", ");
+};
+var renderBulkSummary = (spec, summary) => {
+  if (summary.total === 0) return `No ${spec.resource} items matched \u2014 nothing to ${spec.verb}.
+`;
+  const verb = summary.dryRun ? `would ${spec.verb}` : spec.verb;
+  const lines = summary.results.map(
+    (r) => r.ok ? `  \u2713 ${verb} ${spec.resource} ${r.id} (${r.label})` : `  \u2717 ${spec.verb} ${spec.resource} ${r.id} (${r.label}): ${r.error}`
+  );
+  const tail = summary.dryRun ? `dry run \u2014 ${summary.total} ${spec.resource} item(s) would be affected, nothing sent` : `${summary.succeeded}/${summary.total} succeeded${summary.failed ? `, ${summary.failed} failed` : ""}`;
+  return `${lines.join("\n")}
+${tail}
+`;
+};
+
+// src/cli/commands/manage.ts
+var listManageOperations = () => resourceRegistry.filter((spec) => supportsBulk(spec) && findResourceVerb(spec.resource, "list")).map((spec) => ({ resource: spec.resource, verb: spec.verb }));
+var renderEquivalentCommand = (input2) => {
+  const parts = ["fresh-squeezy", input2.verb, input2.resource];
+  if (input2.picked.length === input2.total) {
+    parts.push("--all");
+    if (input2.storeId) parts.push("--store-ids", input2.storeId);
+    if (input2.parentId) parts.push("--parent-id", input2.parentId);
+  } else {
+    parts.push("--ids", input2.picked.join(","));
+  }
+  parts.push("--yes");
+  if (input2.mode === "live") parts.push("--mode", "live");
+  return parts.join(" ");
+};
+var runManageCommand = async () => {
+  try {
+    const client = createFreshSqueezy();
+    const http = new HttpClient(resolveConfig());
+    const op = await pickManageOperation(listManageOperations());
+    const spec = findResourceVerb(op.resource, op.verb);
+    const listSpec = findResourceVerb(op.resource, "list");
+    if (!spec || !listSpec) {
+      throw new FreshSqueezyError({
+        code: "UNKNOWN_OP",
+        message: `${op.verb} ${op.resource} is not available.`
+      });
+    }
+    process.stdout.write(`
+${op.verb} ${op.resource} \u2014 mode=${client.mode}
+`);
+    let scopes = [{}];
+    if (listSpec.idRole === "store") {
+      const { storeIds } = await resolveStores(client, { isInteractive: true });
+      scopes = storeIds.map((storeId) => ({ storeId }));
+    } else if (listSpec.idRole === "parent") {
+      scopes = [{ parentId: await askParentId(op.resource) }];
+    }
+    let exitCode = 0;
+    for (const scope of scopes) {
+      const targets = await collectBulkTargets(http, spec, { all: true, ...scope });
+      if (targets.length === 0) {
+        process.stdout.write(
+          `No ${op.resource} items found${scope.storeId ? ` in store ${scope.storeId}` : ""}.
+`
+        );
+        continue;
+      }
+      const pickedIds = await pickBulkTargets(op.verb, targets);
+      const picked = targets.filter((t) => pickedIds.includes(t.id));
+      const mark = client.mode === "live" ? "LIVE mode: " : "";
+      const go = await confirmResourceOp(
+        `${mark}${op.verb} ${picked.length} ${op.resource} item(s) (${previewTargets(picked)})?`
+      );
+      if (!go) {
+        process.stdout.write("Skipped \u2014 nothing changed.\n");
+        continue;
+      }
+      const summary = await executeBulk(http, spec, picked);
+      process.stdout.write(renderBulkSummary(spec, summary));
+      process.stdout.write(
+        `
+Next time:
+  ${renderEquivalentCommand({
+          verb: op.verb,
+          resource: op.resource,
+          mode: client.mode,
+          ...scope,
+          picked: pickedIds,
+          total: targets.length
+        })}
+`
+      );
+      if (summary.failed > 0) exitCode = 1;
+    }
+    return exitCode;
+  } catch (err) {
+    if (isPromptCancel(err)) throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(renderCliError(message, ["fresh-squeezy ops --list"]));
+    return 2;
+  }
+};
+
 // src/cli/commands/launcher.ts
 var runLauncherCommand = async (options) => {
   if (!options.isInteractive) return 2;
@@ -3329,6 +3531,8 @@ var routeLauncherAction = async (action) => {
       return startGuidedSetup();
     case "doctor":
       return runDoctorCommand({ isInteractive: true });
+    case "manage":
+      return runManageCommand();
     case "examples":
       process.stdout.write(renderCommandExamples());
       return 0;
@@ -3380,6 +3584,14 @@ var runResourceOpCommand = async (options) => {
     );
     return 2;
   }
+  const bulkError = validateBulkFlags(spec, options);
+  if (bulkError) {
+    writeFatal2(
+      new FreshSqueezyError({ code: "INVALID_ARGS", message: bulkError }),
+      options.json ?? false
+    );
+    return 2;
+  }
   try {
     const body = readBody(options);
     if (spec.body === "required" && body === void 0) {
@@ -3389,13 +3601,17 @@ var runResourceOpCommand = async (options) => {
       });
     }
     const client = createFreshSqueezy({ mode: options.mode });
-    const allowed = await assertWriteSafety(spec, client.mode, options);
-    if (!allowed) return 2;
     const config = resolveConfig({ mode: options.mode });
     const http = new HttpClient(config);
+    const storeId = options.storeIds?.[0] ?? config.storeId;
+    if (options.all || options.ids) {
+      return await runBulk(http, spec, client.mode, options, { storeId, body });
+    }
+    const allowed = await assertWriteSafety(spec, client.mode, options);
+    if (!allowed) return 2;
     const opBody = await invokeOp(http, options.resource, options.verb, {
       id: options.id,
-      storeId: options.storeIds?.[0],
+      storeId,
       parentId: options.parentId,
       body
     });
@@ -3453,22 +3669,74 @@ var writeCatalog = (asJson) => {
     "\nCatalog resources (product, variant, price, file, store, \u2026) are read-only in the API.\n"
   );
 };
-var assertWriteSafety = async (spec, mode, options) => {
+var validateBulkFlags = (spec, options) => {
+  const bulk = Boolean(options.all || options.ids);
+  if (!bulk) {
+    if (options.match) return "--match needs --all.";
+    if (options.dryRun) return "--dry-run needs --all or --ids.";
+    return void 0;
+  }
+  if (!supportsBulk(spec)) {
+    return `--all/--ids only apply to delete, cancel, and refund ops (not ${spec.verb} ${spec.resource}).`;
+  }
+  if (options.all && options.ids) return "Use either --all or --ids, not both.";
+  if (options.id) return "--id targets one resource; drop it when using --all or --ids.";
+  if (options.match && !options.all) return "--match needs --all.";
+  return void 0;
+};
+var runBulk = async (http, spec, mode, options, scope) => {
+  const selector = {
+    all: options.all,
+    ids: options.ids,
+    match: options.match,
+    storeId: scope.storeId,
+    parentId: options.parentId
+  };
+  const targets = await collectBulkTargets(http, spec, selector);
+  if (!options.dryRun && targets.length > 0) {
+    const allowed = await assertWriteSafety(spec, mode, options, {
+      count: targets.length,
+      preview: previewTargets(targets)
+    });
+    if (!allowed) return 2;
+  }
+  const summary = await executeBulk(http, spec, targets, {
+    dryRun: options.dryRun,
+    body: scope.body
+  });
+  if (options.json) {
+    const envelope = {
+      ok: summary.failed === 0,
+      mode,
+      resource: spec.resource,
+      verb: spec.verb,
+      docs: `https://docs.lemonsqueezy.com/api/${spec.docsPath}`,
+      ...summary
+    };
+    process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${spec.verb} ${spec.resource} (mode=${mode})
+`);
+    process.stdout.write(renderBulkSummary(spec, summary));
+  }
+  return summary.failed > 0 ? 1 : 0;
+};
+var assertWriteSafety = async (spec, mode, options, bulk) => {
   const isWrite = spec.verb !== "get" && spec.verb !== "list" && spec.verb !== "current-usage";
   if (!isWrite) return true;
   const needsGate = Boolean(spec.destructive) || mode === "live";
   if (!needsGate) return true;
   if (options.yes) return true;
   if (options.isInteractive) {
-    return confirmResourceOp(
-      mode === "live" ? `LIVE mode: allow ${spec.verb} ${spec.resource}?` : `Confirm ${spec.verb} ${spec.resource}?`
-    );
+    const what = bulk ? `${spec.verb} ${bulk.count} ${spec.resource} item(s) (${bulk.preview})` : `${spec.verb} ${spec.resource}`;
+    return confirmResourceOp(mode === "live" ? `LIVE mode: allow ${what}?` : `Confirm ${what}?`);
   }
   process.stderr.write(
     renderCliError(
       `${spec.verb} ${spec.resource} requires --yes in non-interactive ${mode} mode${spec.destructive ? " (destructive op)" : ""}`,
       [
-        `fresh-squeezy ${spec.verb} ${spec.resource} --yes \u2026`,
+        `fresh-squeezy ${spec.verb} ${spec.resource}${bulk ? " --all" : ""} --yes \u2026`,
         "Use test mode for safer experimentation: --mode test"
       ]
     )
@@ -3840,6 +4108,28 @@ program.command("ops").description("List docs-backed resource ops (Lemon Squeezy
     })
   );
 });
+var BULK_VERBS = ["delete", "cancel", "refund"];
+var opHelpText = (verb) => {
+  if (!BULK_VERBS.includes(verb)) {
+    return `
+Example:
+  fresh-squeezy ${verb} <resource> --id 42 --json
+`;
+  }
+  const r = verb === "delete" ? "discount" : verb === "cancel" ? "subscription" : "order";
+  return `
+Examples:
+  fresh-squeezy ${verb} ${r} --id 42 --yes
+  fresh-squeezy ${verb} ${r} --ids 1,2,3 --yes
+  fresh-squeezy ${verb} ${r} --all --store-ids 12 --dry-run
+  fresh-squeezy ${verb} ${r} --all --store-ids 12 --match TEST --yes --json
+
+Bulk notes:
+  --all lists every page first, then asks once (TTY) or needs --yes (non-TTY).
+  Store falls back to LEMON_SQUEEZY_STORE_ID when --store-ids is omitted.
+  Exit codes: 0 ok, 1 some items failed, 2 usage error / declined.
+`;
+};
 for (const verb of OP_VERBS) {
   program.command(`${verb} <resource>`).description(`Docs-backed ${verb} for a Lemon Squeezy resource`).option("-m, --mode <mode>", "test or live", parseMode).option("--id <id>", "Resource id").option(
     "--store-ids <ids>",
@@ -3848,7 +4138,7 @@ for (const verb of OP_VERBS) {
   ).option(
     "--parent-id <id>",
     "Parent resource id for nested lists (product, order, subscription, \u2026)"
-  ).option("--body <json>", "JSON:API body string").option("--body-file <path>", "Path to JSON:API body file").option("--yes", "Skip confirm; required for live writes and destructive ops when non-TTY").option("--json", "Emit machine-readable JSON").action(async (resource, opts) => {
+  ).option("--body <json>", "JSON:API body string").option("--body-file <path>", "Path to JSON:API body file").option("--yes", "Skip confirm; required for live writes and destructive ops when non-TTY").option("--json", "Emit machine-readable JSON").option("--all", "Bulk: apply to every item from `list` (delete, cancel, refund)").option("--ids <ids>", "Bulk: comma-separated ids (delete, cancel, refund)", parseCsv).option("--match <text>", "Bulk: with --all, only items whose name/code/url contain <text>").option("--dry-run", "Bulk: show what would be affected; send nothing").addHelpText("after", opHelpText(verb)).action(async (resource, opts) => {
     await exitWith(
       runResourceOpCommand({
         verb,
@@ -3861,7 +4151,11 @@ for (const verb of OP_VERBS) {
         bodyFile: opts.bodyFile,
         yes: Boolean(opts.yes),
         json: Boolean(opts.json),
-        isInteractive
+        isInteractive,
+        all: Boolean(opts.all),
+        ids: opts.ids,
+        match: opts.match,
+        dryRun: Boolean(opts.dryRun)
       })
     );
   });