@garuhq/node 0.11.1 → 0.12.0

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to `@garuhq/node` are documented in this file. Format:
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning: [SemVer](https://semver.org/).
 
+## [0.12.0] — 2026-05-19
+
+### Added
+
+- `webhookEvents.resend(id)` — `POST /api/webhook-events/{id}/resend`,
+  the audit-trail-preserving counterpart to `retry()`. The backend
+  inserts a *clone* event (new numeric id) that points back at the
+  source via `manualResendOf`, then dispatches that clone. The
+  original row is untouched, so the historical record of the prior
+  failure (status, response status/body, attempts) survives. Works on
+  any source status (`success` / `failed` / `pending`).
+  - Outbound delivery uses `Idempotency-Key: resend_<originalId>`, so
+    recipient handlers can distinguish a resend from a fresh delivery
+    both by the header prefix and by reading the response payload's
+    `manualResendOf` field.
+- `WebhookEvent.manualResendOf: number | null` — populated with the
+  source event's numeric id on rows produced by `resend()`, `null`
+  everywhere else (originally-fired events and legacy `retry()`
+  outputs).
+
+### Deprecated
+
+- `webhookEvents.retry(id)` is soft-deprecated. It still works and is
+  not scheduled for removal — older CLI / MCP releases depend on it —
+  but new integrations should prefer `resend()`, which preserves the
+  original event's audit trail by cloning instead of mutating the row
+  in place.
+
 ## [0.11.1] — 2026-05-19
 
 ### Fixed

package/dist/index.cjs

@@ -898,10 +898,16 @@ var WebhookEvents = class {
     );
   }
   /**
+   * @deprecated For most cases prefer {@link resend}, which preserves the
+   * original event's audit trail by cloning rather than mutating. `retry()`
+   * resets the original row in place — once it succeeds, the historical
+   * record of the prior failure is gone. Kept here for callers that
+   * explicitly want the legacy in-place semantics (and for backwards
+   * compatibility with older CLI / MCP releases).
+   *
    * Re-deliver a webhook event by ID. Resets it to `pending`, clears the
    * retry schedule, and triggers an immediate delivery attempt. Works on
-   * any status (`success`, `failed`, `pending`) — use this when a
-   * customer reports a missed or unprocessed event.
+   * any status (`success`, `failed`, `pending`).
    *
    * @example
    * const failed = await garu.webhookEvents.list({ status: 'failed', limit: 5 });
@@ -917,6 +923,43 @@ var WebhookEvents = class {
       }).then((r) => r)
     );
   }
+  /**
+   * Re-deliver a webhook event by ID, audit-trail preserving. Unlike
+   * {@link retry}, this does *not* mutate the original row — it inserts a
+   * fresh event (new numeric id) that points back at the source via
+   * `manualResendOf`, then dispatches that clone. The original row is
+   * untouched, so the historical record of the prior failure (and its
+   * response status / body) is preserved.
+   *
+   * Works on any source status (`success`, `failed`, `pending`). Use this
+   * when a customer reports a missed or unprocessed event, or to replay an
+   * event during a backfill — both reasons where you want the original
+   * delivery's outcome to remain on the record.
+   *
+   * **Outbound delivery semantics**: the gateway POSTs the clone with
+   * `Idempotency-Key: resend_<originalId>` (where `<originalId>` is the id
+   * of the source event, not the clone). Recipient handlers that key off
+   * `Idempotency-Key` will see this as a distinct delivery from the
+   * original — distinguishable both by the `resend_` prefix and by reading
+   * the response payload's `manualResendOf` field.
+   *
+   * Returns the *clone* event (new id), not the original. The original is
+   * unchanged on the server.
+   *
+   * @example
+   * const event = await garu.webhookEvents.get(42);
+   * const clone = await garu.webhookEvents.resend(42);
+   * clone.id !== event.id;            // true — clone has its own id
+   * clone.manualResendOf === event.id; // true — points back at the source
+   */
+  async resend(id) {
+    return this.http.call(
+      (signal) => this.http.client.POST(`/api/webhook-events/${id}/resend`, {
+        body: {},
+        signal
+      }).then((r) => r)
+    );
+  }
 };
 var webhooks = {
   verify(params) {

package/dist/index.d.cts

@@ -596,6 +596,14 @@ interface WebhookEvent {
     responseStatus: number | null;
     /** Response body from the most recent attempt, truncated by the gateway. */
     responseBody: string | null;
+    /**
+     * When this row is a clone produced by `webhookEvents.resend(id)`, this is
+     * the numeric id of the original event the clone was forked from. `null`
+     * on every originally-fired event (and on events resurrected via the
+     * legacy `webhookEvents.retry(id)` mutation, which mutates in place
+     * instead of cloning).
+     */
+    manualResendOf: number | null;
     createdAt: string;
     [key: string]: unknown;
 }
@@ -1117,10 +1125,16 @@ declare class WebhookEvents {
      */
     get(id: number): Promise<WebhookEvent>;
     /**
+     * @deprecated For most cases prefer {@link resend}, which preserves the
+     * original event's audit trail by cloning rather than mutating. `retry()`
+     * resets the original row in place — once it succeeds, the historical
+     * record of the prior failure is gone. Kept here for callers that
+     * explicitly want the legacy in-place semantics (and for backwards
+     * compatibility with older CLI / MCP releases).
+     *
      * Re-deliver a webhook event by ID. Resets it to `pending`, clears the
      * retry schedule, and triggers an immediate delivery attempt. Works on
-     * any status (`success`, `failed`, `pending`) — use this when a
-     * customer reports a missed or unprocessed event.
+     * any status (`success`, `failed`, `pending`).
      *
      * @example
      * const failed = await garu.webhookEvents.list({ status: 'failed', limit: 5 });
@@ -1129,6 +1143,36 @@ declare class WebhookEvents {
      * }
      */
     retry(id: number): Promise<WebhookEvent>;
+    /**
+     * Re-deliver a webhook event by ID, audit-trail preserving. Unlike
+     * {@link retry}, this does *not* mutate the original row — it inserts a
+     * fresh event (new numeric id) that points back at the source via
+     * `manualResendOf`, then dispatches that clone. The original row is
+     * untouched, so the historical record of the prior failure (and its
+     * response status / body) is preserved.
+     *
+     * Works on any source status (`success`, `failed`, `pending`). Use this
+     * when a customer reports a missed or unprocessed event, or to replay an
+     * event during a backfill — both reasons where you want the original
+     * delivery's outcome to remain on the record.
+     *
+     * **Outbound delivery semantics**: the gateway POSTs the clone with
+     * `Idempotency-Key: resend_<originalId>` (where `<originalId>` is the id
+     * of the source event, not the clone). Recipient handlers that key off
+     * `Idempotency-Key` will see this as a distinct delivery from the
+     * original — distinguishable both by the `resend_` prefix and by reading
+     * the response payload's `manualResendOf` field.
+     *
+     * Returns the *clone* event (new id), not the original. The original is
+     * unchanged on the server.
+     *
+     * @example
+     * const event = await garu.webhookEvents.get(42);
+     * const clone = await garu.webhookEvents.resend(42);
+     * clone.id !== event.id;            // true — clone has its own id
+     * clone.manualResendOf === event.id; // true — points back at the source
+     */
+    resend(id: number): Promise<WebhookEvent>;
 }
 
 interface GaruOptions {

package/dist/index.d.ts

@@ -596,6 +596,14 @@ interface WebhookEvent {
     responseStatus: number | null;
     /** Response body from the most recent attempt, truncated by the gateway. */
     responseBody: string | null;
+    /**
+     * When this row is a clone produced by `webhookEvents.resend(id)`, this is
+     * the numeric id of the original event the clone was forked from. `null`
+     * on every originally-fired event (and on events resurrected via the
+     * legacy `webhookEvents.retry(id)` mutation, which mutates in place
+     * instead of cloning).
+     */
+    manualResendOf: number | null;
     createdAt: string;
     [key: string]: unknown;
 }
@@ -1117,10 +1125,16 @@ declare class WebhookEvents {
      */
     get(id: number): Promise<WebhookEvent>;
     /**
+     * @deprecated For most cases prefer {@link resend}, which preserves the
+     * original event's audit trail by cloning rather than mutating. `retry()`
+     * resets the original row in place — once it succeeds, the historical
+     * record of the prior failure is gone. Kept here for callers that
+     * explicitly want the legacy in-place semantics (and for backwards
+     * compatibility with older CLI / MCP releases).
+     *
      * Re-deliver a webhook event by ID. Resets it to `pending`, clears the
      * retry schedule, and triggers an immediate delivery attempt. Works on
-     * any status (`success`, `failed`, `pending`) — use this when a
-     * customer reports a missed or unprocessed event.
+     * any status (`success`, `failed`, `pending`).
      *
      * @example
      * const failed = await garu.webhookEvents.list({ status: 'failed', limit: 5 });
@@ -1129,6 +1143,36 @@ declare class WebhookEvents {
      * }
      */
     retry(id: number): Promise<WebhookEvent>;
+    /**
+     * Re-deliver a webhook event by ID, audit-trail preserving. Unlike
+     * {@link retry}, this does *not* mutate the original row — it inserts a
+     * fresh event (new numeric id) that points back at the source via
+     * `manualResendOf`, then dispatches that clone. The original row is
+     * untouched, so the historical record of the prior failure (and its
+     * response status / body) is preserved.
+     *
+     * Works on any source status (`success`, `failed`, `pending`). Use this
+     * when a customer reports a missed or unprocessed event, or to replay an
+     * event during a backfill — both reasons where you want the original
+     * delivery's outcome to remain on the record.
+     *
+     * **Outbound delivery semantics**: the gateway POSTs the clone with
+     * `Idempotency-Key: resend_<originalId>` (where `<originalId>` is the id
+     * of the source event, not the clone). Recipient handlers that key off
+     * `Idempotency-Key` will see this as a distinct delivery from the
+     * original — distinguishable both by the `resend_` prefix and by reading
+     * the response payload's `manualResendOf` field.
+     *
+     * Returns the *clone* event (new id), not the original. The original is
+     * unchanged on the server.
+     *
+     * @example
+     * const event = await garu.webhookEvents.get(42);
+     * const clone = await garu.webhookEvents.resend(42);
+     * clone.id !== event.id;            // true — clone has its own id
+     * clone.manualResendOf === event.id; // true — points back at the source
+     */
+    resend(id: number): Promise<WebhookEvent>;
 }
 
 interface GaruOptions {

package/dist/index.js

@@ -892,10 +892,16 @@ var WebhookEvents = class {
     );
   }
   /**
+   * @deprecated For most cases prefer {@link resend}, which preserves the
+   * original event's audit trail by cloning rather than mutating. `retry()`
+   * resets the original row in place — once it succeeds, the historical
+   * record of the prior failure is gone. Kept here for callers that
+   * explicitly want the legacy in-place semantics (and for backwards
+   * compatibility with older CLI / MCP releases).
+   *
    * Re-deliver a webhook event by ID. Resets it to `pending`, clears the
    * retry schedule, and triggers an immediate delivery attempt. Works on
-   * any status (`success`, `failed`, `pending`) — use this when a
-   * customer reports a missed or unprocessed event.
+   * any status (`success`, `failed`, `pending`).
    *
    * @example
    * const failed = await garu.webhookEvents.list({ status: 'failed', limit: 5 });
@@ -911,6 +917,43 @@ var WebhookEvents = class {
       }).then((r) => r)
     );
   }
+  /**
+   * Re-deliver a webhook event by ID, audit-trail preserving. Unlike
+   * {@link retry}, this does *not* mutate the original row — it inserts a
+   * fresh event (new numeric id) that points back at the source via
+   * `manualResendOf`, then dispatches that clone. The original row is
+   * untouched, so the historical record of the prior failure (and its
+   * response status / body) is preserved.
+   *
+   * Works on any source status (`success`, `failed`, `pending`). Use this
+   * when a customer reports a missed or unprocessed event, or to replay an
+   * event during a backfill — both reasons where you want the original
+   * delivery's outcome to remain on the record.
+   *
+   * **Outbound delivery semantics**: the gateway POSTs the clone with
+   * `Idempotency-Key: resend_<originalId>` (where `<originalId>` is the id
+   * of the source event, not the clone). Recipient handlers that key off
+   * `Idempotency-Key` will see this as a distinct delivery from the
+   * original — distinguishable both by the `resend_` prefix and by reading
+   * the response payload's `manualResendOf` field.
+   *
+   * Returns the *clone* event (new id), not the original. The original is
+   * unchanged on the server.
+   *
+   * @example
+   * const event = await garu.webhookEvents.get(42);
+   * const clone = await garu.webhookEvents.resend(42);
+   * clone.id !== event.id;            // true — clone has its own id
+   * clone.manualResendOf === event.id; // true — points back at the source
+   */
+  async resend(id) {
+    return this.http.call(
+      (signal) => this.http.client.POST(`/api/webhook-events/${id}/resend`, {
+        body: {},
+        signal
+      }).then((r) => r)
+    );
+  }
 };
 var webhooks = {
   verify(params) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@garuhq/node",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Official Node.js / TypeScript SDK for the Garu payment gateway.",
   "license": "MIT",
   "homepage": "https://garu.com.br",