fresh-squeezy 0.1.3 → 0.1.4

package/dist/cli.js

@@ -167,6 +167,25 @@ var ISSUE_CODES = {
   WEBHOOK_NOT_FOUND: "WEBHOOK_NOT_FOUND",
   WEBHOOK_EVENTS_MISSING: "WEBHOOK_EVENTS_MISSING",
   WEBHOOK_OPTIONAL_EVENTS: "WEBHOOK_OPTIONAL_EVENTS",
+  DISCOUNT_NOT_FOUND: "DISCOUNT_NOT_FOUND",
+  DISCOUNT_DRAFT: "DISCOUNT_DRAFT",
+  DISCOUNT_EXPIRED: "DISCOUNT_EXPIRED",
+  DISCOUNT_NOT_STARTED: "DISCOUNT_NOT_STARTED",
+  DISCOUNT_REDEMPTIONS_EXHAUSTED: "DISCOUNT_REDEMPTIONS_EXHAUSTED",
+  DISCOUNT_INVALID_AMOUNT: "DISCOUNT_INVALID_AMOUNT",
+  DISCOUNT_STORE_MISMATCH: "DISCOUNT_STORE_MISMATCH",
+  LICENSE_KEY_NOT_FOUND: "LICENSE_KEY_NOT_FOUND",
+  LICENSE_KEY_DISABLED: "LICENSE_KEY_DISABLED",
+  LICENSE_KEY_EXPIRED: "LICENSE_KEY_EXPIRED",
+  LICENSE_KEY_AT_ACTIVATION_LIMIT: "LICENSE_KEY_AT_ACTIVATION_LIMIT",
+  LICENSE_KEY_STORE_MISMATCH: "LICENSE_KEY_STORE_MISMATCH",
+  PLAN_VARIANT_NOT_FOUND: "PLAN_VARIANT_NOT_FOUND",
+  PLAN_NOT_SUBSCRIPTION: "PLAN_NOT_SUBSCRIPTION",
+  PLAN_INVALID_INTERVAL: "PLAN_INVALID_INTERVAL",
+  PLAN_FREE_PRICE: "PLAN_FREE_PRICE",
+  PLAN_TRIAL_INCONSISTENT: "PLAN_TRIAL_INCONSISTENT",
+  PLAN_DRAFT: "PLAN_DRAFT",
+  PLAN_STORE_MISMATCH: "PLAN_STORE_MISMATCH",
   NETWORK_ERROR: "NETWORK_ERROR",
   UNKNOWN: "UNKNOWN"
 };
@@ -298,6 +317,9 @@ async function getProduct(http, productId) {
 }
 
 // src/resources/variants.ts
+async function getVariant(http, variantId) {
+  return http.getResource(`/v1/variants/${variantId}`);
+}
 async function listVariantsForProduct(http, productId) {
   return http.getCollection("/v1/variants", {
     "filter[product_id]": String(productId)
@@ -490,6 +512,358 @@ function normalizeUrl(raw) {
   return raw.replace(/\/+$/, "").toLowerCase();
 }
 
+// src/resources/discounts.ts
+async function getDiscount(http, discountId) {
+  return http.getResource(`/v1/discounts/${discountId}`);
+}
+
+// src/validate/discount.ts
+async function validateDiscount(http, mode, options) {
+  const issues = [];
+  let discount;
+  try {
+    discount = await getDiscount(http, options.discountId);
+  } catch (err) {
+    if (err instanceof FreshSqueezyError && err.status === 404) {
+      issues.push(
+        issue(ISSUE_CODES.DISCOUNT_NOT_FOUND, "error", `Discount ${options.discountId} not found.`, {
+          suggestedFix: "Verify the discount ID in the Lemon Squeezy dashboard.",
+          context: { discountId: String(options.discountId) }
+        })
+      );
+      return buildResult("discount", mode, issues);
+    }
+    const message = err instanceof Error ? err.message : "Unknown error";
+    issues.push(issue(ISSUE_CODES.UNKNOWN, "error", message));
+    return buildResult("discount", mode, issues);
+  }
+  const attrs = discount.attributes;
+  const expectedStore = String(options.storeId);
+  const actualStore = String(attrs.store_id);
+  if (expectedStore !== actualStore) {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_STORE_MISMATCH,
+        "error",
+        `Discount belongs to store ${actualStore}, expected ${expectedStore}.`,
+        {
+          suggestedFix: "Use the correct store ID or discount ID \u2014 discounts should not cross stores.",
+          context: { expectedStoreId: expectedStore, actualStoreId: actualStore }
+        }
+      )
+    );
+  }
+  if (attrs.status === "draft") {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_DRAFT,
+        "warning",
+        `Discount "${attrs.name}" is in draft status \u2014 customers cannot redeem it.`,
+        {
+          suggestedFix: "Publish the discount in the Lemon Squeezy dashboard before sharing the code.",
+          context: { name: attrs.name, code: attrs.code }
+        }
+      )
+    );
+  }
+  const now = /* @__PURE__ */ new Date();
+  if (attrs.expires_at && new Date(attrs.expires_at) < now) {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_EXPIRED,
+        "error",
+        `Discount "${attrs.name}" expired at ${attrs.expires_at}.`,
+        {
+          suggestedFix: "Extend the expiration date or create a new discount.",
+          context: { name: attrs.name, expiresAt: attrs.expires_at }
+        }
+      )
+    );
+  }
+  if (attrs.starts_at && new Date(attrs.starts_at) > now) {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_NOT_STARTED,
+        "warning",
+        `Discount "${attrs.name}" starts at ${attrs.starts_at} \u2014 not yet active.`,
+        {
+          suggestedFix: "Wait for the start date or adjust it in the dashboard.",
+          context: { name: attrs.name, startsAt: attrs.starts_at }
+        }
+      )
+    );
+  }
+  if (attrs.is_limited_redemptions && attrs.max_redemptions <= 0) {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_REDEMPTIONS_EXHAUSTED,
+        "warning",
+        `Discount "${attrs.name}" has limited redemptions with max_redemptions \u2264 0.`,
+        {
+          suggestedFix: "Increase max_redemptions or disable the redemption limit.",
+          context: { name: attrs.name, maxRedemptions: attrs.max_redemptions }
+        }
+      )
+    );
+  }
+  if (attrs.amount <= 0) {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_INVALID_AMOUNT,
+        "error",
+        `Discount "${attrs.name}" has amount ${attrs.amount} \u2014 must be positive.`,
+        {
+          suggestedFix: "Set a positive discount amount in the dashboard.",
+          context: { name: attrs.name, amount: attrs.amount }
+        }
+      )
+    );
+  } else if (attrs.amount_type === "percent" && attrs.amount > 100) {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_INVALID_AMOUNT,
+        "error",
+        `Discount "${attrs.name}" is ${attrs.amount}% \u2014 percent discounts cannot exceed 100%.`,
+        {
+          suggestedFix: "Set the discount to 100% or less.",
+          context: { name: attrs.name, amount: attrs.amount, amountType: attrs.amount_type }
+        }
+      )
+    );
+  }
+  return buildResult("discount", mode, issues, attrs);
+}
+
+// src/resources/licenseKeys.ts
+async function getLicenseKey(http, licenseKeyId) {
+  return http.getResource(`/v1/license-keys/${licenseKeyId}`);
+}
+
+// src/validate/licenseKey.ts
+async function validateLicenseKey(http, mode, options) {
+  const issues = [];
+  let licenseKey;
+  try {
+    licenseKey = await getLicenseKey(http, options.licenseKeyId);
+  } catch (err) {
+    if (err instanceof FreshSqueezyError && err.status === 404) {
+      issues.push(
+        issue(
+          ISSUE_CODES.LICENSE_KEY_NOT_FOUND,
+          "error",
+          `License key ${options.licenseKeyId} not found.`,
+          {
+            suggestedFix: "Verify the license key ID in the Lemon Squeezy dashboard.",
+            context: { licenseKeyId: String(options.licenseKeyId) }
+          }
+        )
+      );
+      return buildResult("licenseKey", mode, issues);
+    }
+    const message = err instanceof Error ? err.message : "Unknown error";
+    issues.push(issue(ISSUE_CODES.UNKNOWN, "error", message));
+    return buildResult("licenseKey", mode, issues);
+  }
+  const attrs = licenseKey.attributes;
+  const expectedStore = String(options.storeId);
+  const actualStore = String(attrs.store_id);
+  if (expectedStore !== actualStore) {
+    issues.push(
+      issue(
+        ISSUE_CODES.LICENSE_KEY_STORE_MISMATCH,
+        "error",
+        `License key belongs to store ${actualStore}, expected ${expectedStore}.`,
+        {
+          suggestedFix: "Use the correct store ID or license key ID \u2014 keys should not cross stores.",
+          context: { expectedStoreId: expectedStore, actualStoreId: actualStore }
+        }
+      )
+    );
+  }
+  if (attrs.disabled) {
+    issues.push(
+      issue(
+        ISSUE_CODES.LICENSE_KEY_DISABLED,
+        "error",
+        `License key ${attrs.key_short} is disabled.`,
+        {
+          suggestedFix: "Re-enable the license key in the Lemon Squeezy dashboard.",
+          context: { keyShort: attrs.key_short }
+        }
+      )
+    );
+  }
+  if (attrs.expires_at && new Date(attrs.expires_at) < /* @__PURE__ */ new Date()) {
+    issues.push(
+      issue(
+        ISSUE_CODES.LICENSE_KEY_EXPIRED,
+        "error",
+        `License key ${attrs.key_short} expired at ${attrs.expires_at}.`,
+        {
+          suggestedFix: "Extend the expiration date or issue a new license key.",
+          context: { keyShort: attrs.key_short, expiresAt: attrs.expires_at }
+        }
+      )
+    );
+  }
+  if (attrs.activation_limit !== null && attrs.instances_count >= attrs.activation_limit) {
+    issues.push(
+      issue(
+        ISSUE_CODES.LICENSE_KEY_AT_ACTIVATION_LIMIT,
+        "warning",
+        `License key ${attrs.key_short} has reached its activation limit (${attrs.instances_count}/${attrs.activation_limit}).`,
+        {
+          suggestedFix: "Increase the activation limit or deactivate unused instances.",
+          context: {
+            keyShort: attrs.key_short,
+            instancesCount: attrs.instances_count,
+            activationLimit: attrs.activation_limit
+          }
+        }
+      )
+    );
+  }
+  return buildResult("licenseKey", mode, issues, attrs);
+}
+
+// src/validate/subscriptionPlan.ts
+var VALID_INTERVALS = /* @__PURE__ */ new Set(["day", "week", "month", "year"]);
+async function validateSubscriptionPlan(http, mode, options) {
+  const issues = [];
+  let variant;
+  try {
+    variant = await getVariant(http, options.variantId);
+  } catch (err) {
+    if (err instanceof FreshSqueezyError && err.status === 404) {
+      issues.push(
+        issue(
+          ISSUE_CODES.PLAN_VARIANT_NOT_FOUND,
+          "error",
+          `Variant ${options.variantId} not found.`,
+          {
+            suggestedFix: "Verify the variant ID in the Lemon Squeezy dashboard.",
+            context: { variantId: String(options.variantId) }
+          }
+        )
+      );
+      return buildResult("subscriptionPlan", mode, issues);
+    }
+    const message = err instanceof Error ? err.message : "Unknown error";
+    issues.push(issue(ISSUE_CODES.UNKNOWN, "error", message));
+    return buildResult("subscriptionPlan", mode, issues);
+  }
+  const attrs = variant.attributes;
+  if (!attrs.is_subscription) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_NOT_SUBSCRIPTION,
+        "error",
+        `Variant ${options.variantId} is not a subscription variant (is_subscription is false).`,
+        {
+          suggestedFix: "Use a variant that has subscription billing enabled, or use the regular variant validator.",
+          context: { variantId: String(options.variantId) }
+        }
+      )
+    );
+  }
+  if (!attrs.interval || !VALID_INTERVALS.has(attrs.interval)) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_INVALID_INTERVAL,
+        "error",
+        `Subscription variant has invalid interval: "${attrs.interval ?? "missing"}". Expected one of: day, week, month, year.`,
+        {
+          suggestedFix: "Set a valid billing interval in the variant configuration.",
+          context: { interval: attrs.interval ?? null }
+        }
+      )
+    );
+  }
+  if (attrs.interval_count === null || attrs.interval_count <= 0) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_INVALID_INTERVAL,
+        "error",
+        `Subscription variant has invalid interval_count: ${attrs.interval_count}. Must be a positive integer.`,
+        {
+          suggestedFix: "Set interval_count to a positive value (e.g. 1 for monthly, 2 for biweekly).",
+          context: { intervalCount: attrs.interval_count }
+        }
+      )
+    );
+  }
+  if (attrs.price === 0 && attrs.is_subscription) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_FREE_PRICE,
+        "warning",
+        `Subscription variant has a price of 0 \u2014 this is almost always a misconfiguration for paid plans.`,
+        {
+          suggestedFix: "Set the variant price to the intended amount in cents, or confirm this is intentionally free.",
+          context: { price: attrs.price }
+        }
+      )
+    );
+  }
+  if (attrs.has_free_trial && (!attrs.trial_interval || (attrs.trial_interval_count ?? 0) <= 0)) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_TRIAL_INCONSISTENT,
+        "warning",
+        `Subscription variant has free trial enabled but trial interval is misconfigured (interval: "${attrs.trial_interval ?? "missing"}", count: ${attrs.trial_interval_count ?? 0}).`,
+        {
+          suggestedFix: "Set a valid trial interval and count, or disable the free trial.",
+          context: {
+            trialInterval: attrs.trial_interval ?? null,
+            trialIntervalCount: attrs.trial_interval_count ?? null
+          }
+        }
+      )
+    );
+  }
+  if (attrs.status === "draft") {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_DRAFT,
+        "warning",
+        `Subscription variant is in draft status \u2014 customers cannot subscribe.`,
+        {
+          suggestedFix: "Publish the variant in the Lemon Squeezy dashboard.",
+          context: { status: attrs.status }
+        }
+      )
+    );
+  }
+  try {
+    const product = await getProduct(http, attrs.product_id);
+    const expectedStore = String(options.storeId);
+    const actualStore = String(product.attributes.store_id);
+    if (expectedStore !== actualStore) {
+      issues.push(
+        issue(
+          ISSUE_CODES.PLAN_STORE_MISMATCH,
+          "error",
+          `Subscription variant belongs to store ${actualStore} (via product ${attrs.product_id}), expected ${expectedStore}.`,
+          {
+            suggestedFix: "Use the correct store ID or variant ID \u2014 plans should not cross stores.",
+            context: { expectedStoreId: expectedStore, actualStoreId: actualStore, productId: String(attrs.product_id) }
+          }
+        )
+      );
+    }
+  } catch {
+  }
+  const summary = {
+    variantId: variant.id,
+    interval: attrs.interval,
+    intervalCount: attrs.interval_count,
+    price: attrs.price,
+    hasFreeTrial: attrs.has_free_trial,
+    status: attrs.status
+  };
+  return buildResult("subscriptionPlan", mode, issues, summary);
+}
+
 // src/validate/doctor.ts
 async function doctor(http, mode, options = {}) {
   const results = [];
@@ -517,6 +891,30 @@ async function doctor(http, mode, options = {}) {
       })
     );
   }
+  if (options.storeId !== void 0 && options.discountId !== void 0) {
+    results.push(
+      await validateDiscount(http, mode, {
+        storeId: options.storeId,
+        discountId: options.discountId
+      })
+    );
+  }
+  if (options.storeId !== void 0 && options.licenseKeyId !== void 0) {
+    results.push(
+      await validateLicenseKey(http, mode, {
+        storeId: options.storeId,
+        licenseKeyId: options.licenseKeyId
+      })
+    );
+  }
+  if (options.storeId !== void 0 && options.variantId !== void 0) {
+    results.push(
+      await validateSubscriptionPlan(http, mode, {
+        storeId: options.storeId,
+        variantId: options.variantId
+      })
+    );
+  }
   const ok = results.every((result) => result.ok);
   return { ok, mode, results };
 }
@@ -532,10 +930,16 @@ function createFreshSqueezy(config = {}) {
     validateStore: (storeId) => validateStore(http, resolved.mode, storeId),
     validateProduct: (options) => validateProduct(http, resolved.mode, options),
     validateWebhook: (options) => validateWebhook(http, resolved.mode, options),
+    validateDiscount: (options) => validateDiscount(http, resolved.mode, options),
+    validateLicenseKey: (options) => validateLicenseKey(http, resolved.mode, options),
+    validateSubscriptionPlan: (options) => validateSubscriptionPlan(http, resolved.mode, options),
     doctor: (options) => doctor(http, resolved.mode, {
       storeId: options?.storeId ?? resolved.storeId,
       productId: options?.productId,
-      webhookUrl: options?.webhookUrl
+      webhookUrl: options?.webhookUrl,
+      discountId: options?.discountId,
+      licenseKeyId: options?.licenseKeyId,
+      variantId: options?.variantId
     })
   };
 }
@@ -778,6 +1182,15 @@ async function runValidateCommand(target, options) {
     if (target === "product") {
       return emit(await runProduct(client, options), options);
     }
+    if (target === "discount") {
+      return emit(await runDiscount(client, options), options);
+    }
+    if (target === "license-key") {
+      return emit(await runLicenseKey(client, options), options);
+    }
+    if (target === "subscription-plan") {
+      return emit(await runSubscriptionPlan(client, options), options);
+    }
     const storeIds = await resolveStoresForTarget(client, target, options);
     const results = await runPerStore(client, target, storeIds, options);
     if (options.json) {
@@ -832,6 +1245,21 @@ async function runProduct(client, options) {
     expectedStoreId: expected
   });
 }
+async function runDiscount(client, options) {
+  const discountId = required(options.discountId, "--discount-id is required for `validate discount`.");
+  const storeId = required(options.storeIds?.[0], "--store-ids is required for `validate discount`.");
+  return client.validateDiscount({ storeId, discountId });
+}
+async function runLicenseKey(client, options) {
+  const licenseKeyId = required(options.licenseKeyId, "--license-key-id is required for `validate license-key`.");
+  const storeId = required(options.storeIds?.[0], "--store-ids is required for `validate license-key`.");
+  return client.validateLicenseKey({ storeId, licenseKeyId });
+}
+async function runSubscriptionPlan(client, options) {
+  const variantId = required(options.variantId, "--variant-id is required for `validate subscription-plan`.");
+  const storeId = required(options.storeIds?.[0], "--store-ids is required for `validate subscription-plan`.");
+  return client.validateSubscriptionPlan({ storeId, variantId });
+}
 function emit(result, options) {
   if (options.json) {
     process.stdout.write(`${JSON.stringify(result, null, 2)}
@@ -922,6 +1350,9 @@ validate.command("connection").description("Check that the API key authenticates
 validate.command("store").description("Check one or more stores are reachable").option("--store-ids <ids>", "Comma-separated store IDs", parseCsv).option("--all-stores", "Run against every reachable store").option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("store", opts));
 validate.command("product").description("Check a product is published with at least one variant").requiredOption("--product-id <id>", "Product ID to validate").option("--store-ids <ids>", "Expected owning store IDs (first is used for cross-check)", parseCsv).option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("product", opts));
 validate.command("webhook").description("Check a webhook is registered with the recommended events").requiredOption("--webhook-url <url>", "Public webhook URL").option("--store-ids <ids>", "Comma-separated store IDs", parseCsv).option("--all-stores", "Run against every reachable store").option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("webhook", opts));
+validate.command("discount").description("Check a discount code is valid and redeemable").requiredOption("--discount-id <id>", "Discount ID to validate").option("--store-ids <ids>", "Store ID for ownership check (first ID used)", parseCsv).option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("discount", opts));
+validate.command("license-key").description("Check a license key is active and not at its activation limit").requiredOption("--license-key-id <id>", "License key ID to validate").option("--store-ids <ids>", "Store ID for ownership check (first ID used)", parseCsv).option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("license-key", opts));
+validate.command("subscription-plan").description("Check a subscription plan variant has valid billing interval and trial config").requiredOption("--variant-id <id>", "Variant ID of the subscription plan").option("--store-ids <ids>", "Store ID for ownership check (first ID used)", parseCsv).option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("subscription-plan", opts));
 program.command("init").description("Interactive setup: ask for credentials, pick a store, run doctor").option("--env-file <path>", "Where to write credentials (default: .env.local)").action(async (opts) => {
   const code = await runInitCommand({ envFile: opts.envFile });
   process.exit(code);
@@ -946,6 +1377,9 @@ async function runValidate(target, opts) {
     allStores: Boolean(opts.allStores),
     productId: opts.productId,
     webhookUrl: opts.webhookUrl,
+    discountId: opts.discountId,
+    licenseKeyId: opts.licenseKeyId,
+    variantId: opts.variantId,
     json: Boolean(opts.json),
     isInteractive
   });