@commet/node 7.0.0 → 7.2.0

package/dist/index.mjs

@@ -200,6 +200,35 @@ var InvoicesResource = class {
   }
 };
 
+// src/resources/payments.ts
+var PaymentsResource = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /** List payments with cursor-based pagination. Filter by customer. */
+  async list(params, options) {
+    return this.httpClient.get("/payments", params, options);
+  }
+  /** Create a hosted payment link. Returns a url the customer opens to pay with any card. Calculates tax, generates an invoice, and vaults the payment method on confirmation. No subscription or plan required. */
+  async create(params, options) {
+    return this.httpClient.post("/payments", params, options);
+  }
+  /** Charge a customer's vaulted payment method off-session. Calculates tax, generates an invoice, and sends a receipt. No subscription or plan required. */
+  async charge(params, options) {
+    return this.httpClient.post("/payments/charge", params, options);
+  }
+  /** Retrieve a payment by its public ID. */
+  async get(params, options) {
+    const { id } = params;
+    return this.httpClient.get(`/payments/${id}`, void 0, options);
+  }
+  /** Cancel a pending payment link so it can no longer be paid. Only a link that has not been paid or started processing can be canceled; canceling an already canceled link is a no-op. Charges cannot be canceled. */
+  async cancel(params, options) {
+    const { id } = params;
+    return this.httpClient.post(`/payments/${id}/cancel`, {}, options);
+  }
+};
+
 // src/resources/payouts.ts
 var PayoutsResource = class {
   constructor(httpClient) {
@@ -507,6 +536,29 @@ var SubscriptionsResource = class {
     const { id } = params;
     return this.httpClient.post(`/subscriptions/${id}/uncancel`, {}, options);
   }
+  /** Retries the outstanding renewal charge for a past_due subscription. On a successful charge the subscription recovers to active and a payment.recovered webhook is delivered; a declined charge returns an error and the subscription stays past_due. */
+  async reactivate(params, options) {
+    const { id } = params;
+    return this.httpClient.post(`/subscriptions/${id}/reactivate`, {}, options);
+  }
+  /** Generates a hosted, signed recovery link that lets the customer pay the outstanding renewal charge for a past_due subscription. Unlike reactivate, which charges server-to-server, this returns a link the merchant can deliver through their own email, SMS, or dashboard. The link carries a self-contained signed token and stays valid until the charge is paid or the subscription is no longer past due. */
+  async createRecoveryLink(params, options) {
+    const { id } = params;
+    return this.httpClient.post(
+      `/subscriptions/${id}/recovery-link`,
+      {},
+      options
+    );
+  }
+  /** Creates a hosted checkout session for the customer to update the subscription's default payment method. */
+  async updatePaymentMethod(params, options) {
+    const { id, ...rest } = params;
+    return this.httpClient.post(
+      `/subscriptions/${id}/payment-method/update`,
+      rest,
+      options
+    );
+  }
   /** Upgrade, downgrade, or change billing interval. */
   async changePlan(params, options) {
     const { id, ...rest } = params;
@@ -602,7 +654,7 @@ var TransactionsResource = class {
     const { id } = params;
     return this.httpClient.post(`/transactions/${id}/refund`, {}, options);
   }
-  /** Retry a failed payment transaction. Creates a new invoice and initiates a new payment attempt. */
+  /** Retry a failed subscription renewal. Re-charges the outstanding renewal invoice through the recovery engine. */
   async retry(params, options) {
     const { id } = params;
     return this.httpClient.post(`/transactions/${id}/retry`, {}, options);
@@ -619,6 +671,7 @@ var GeneratedResources = class {
     this.featureAccess = new FeatureAccessResource(http);
     this.features = new FeaturesResource(http);
     this.invoices = new InvoicesResource(http);
+    this.payments = new PaymentsResource(http);
     this.payouts = new PayoutsResource(http);
     this.planGroups = new PlanGroupsResource(http);
     this.plans = new PlansResource(http);
@@ -764,7 +817,7 @@ var CommetValidationError = class extends CommetError {
 
 // src/version.ts
 var API_VERSION = "2026-06-10";
-var SDK_VERSION = "7.0.0";
+var SDK_VERSION = "7.2.0";
 
 // src/utils/telemetry.ts
 var registeredIntegrations = /* @__PURE__ */ new Set();
@@ -848,6 +901,7 @@ var DEFAULT_RETRY_CONFIG = {
   // 8s
   retryableStatusCodes: [408, 429, 500, 502, 503, 504]
 };
+var RETRY_AFTER_CAP_MS = 3e4;
 var _CommetHTTPClient = class _CommetHTTPClient {
   constructor(config) {
     this.lastRequestMetrics = null;
@@ -959,17 +1013,16 @@ var _CommetHTTPClient = class _CommetHTTPClient {
       }
       if (!response.ok) {
         if (attempt <= this.retryConfig.maxRetries && this.retryConfig.retryableStatusCodes.includes(response.status)) {
-          const delay = Math.min(
-            this.retryConfig.baseDelay * 2 ** (attempt - 1),
-            this.retryConfig.maxDelay
-          );
-          if (this.config.debug) {
-            console.log(
-              `[Commet SDK] Retrying in ${delay}ms (attempt ${attempt}/${this.retryConfig.maxRetries})`
-            );
+          const delay = this.retryDelayMs(attempt, response);
+          if (delay !== null) {
+            if (this.config.debug) {
+              console.log(
+                `[Commet SDK] Retrying in ${delay}ms (attempt ${attempt}/${this.retryConfig.maxRetries})`
+              );
+            }
+            await this.sleep(delay);
+            return this.executeRequest(method, url, data, options, attempt + 1);
           }
-          await this.sleep(delay);
-          return this.executeRequest(method, url, data, options, attempt + 1);
         }
         if (this.config.debug) {
           console.log(
@@ -1019,10 +1072,7 @@ var _CommetHTTPClient = class _CommetHTTPClient {
       const isTimeoutErrorModern = typeof globalThis.DOMException !== "undefined" && error instanceof DOMException && error.name === "TimeoutError";
       if (isNetworkError || isTimeoutError || isTimeoutErrorModern) {
         if (attempt <= this.retryConfig.maxRetries) {
-          const delay = Math.min(
-            this.retryConfig.baseDelay * 2 ** (attempt - 1),
-            this.retryConfig.maxDelay
-          );
+          const delay = this.backoffDelayMs(attempt);
           if (this.config.debug) {
             console.log(`[Commet SDK] Network error, retrying in ${delay}ms`);
           }
@@ -1058,6 +1108,26 @@ var _CommetHTTPClient = class _CommetHTTPClient {
     }
     return finalUrl;
   }
+  // 429 retries wait exactly what the rate limiter reports in Retry-After
+  // (seconds until the window resets); a 429 without the header did not come
+  // from the rate limiter, so it is not retried (returns null). Exponential
+  // backoff only applies to statuses that carry no server-provided wait.
+  retryDelayMs(attempt, response) {
+    if (response.status === 429) {
+      const retryAfterSeconds = Number(response.headers.get("retry-after"));
+      if (Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0) {
+        return Math.min(retryAfterSeconds * 1e3, RETRY_AFTER_CAP_MS);
+      }
+      return null;
+    }
+    return this.backoffDelayMs(attempt);
+  }
+  backoffDelayMs(attempt) {
+    return Math.min(
+      this.retryConfig.baseDelay * 2 ** (attempt - 1),
+      this.retryConfig.maxDelay
+    );
+  }
   generateIdempotencyKey() {
     return `commet-node-retry-${crypto.randomUUID()}`;
   }