svix 2.3.0 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svix",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Svix webhooks API client and webhook verification library",
   "author": "svix",
   "repository": "https://github.com/svix/svix-webhooks",

package/src/api/autoconfigSubscription.ts

@@ -0,0 +1,53 @@
+// this file is @generated
+
+import { type AutoConfigOut, AutoConfigOutSerializer } from "../models/autoConfigOut";
+import {
+  type RotateSubscriptionIn2,
+  RotateSubscriptionIn2Serializer,
+} from "../models/rotateSubscriptionIn2";
+import { HttpMethod, SvixRequest, type SvixRequestContext } from "../request";
+
+export interface AutoconfigSubscriptionCreateOptions {
+  idempotencyKey?: string;
+}
+
+export interface AutoconfigSubscriptionRotateOptions {
+  idempotencyKey?: string;
+}
+
+export class AutoconfigSubscription {
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
+
+  /** Create an AutoConfig subscription. */
+  public async create(
+    appId: string,
+    options?: AutoconfigSubscriptionCreateOptions
+  ): Promise<AutoConfigOut> {
+    const request = new SvixRequest(HttpMethod.POST, "/api/v1/app/{app_id}/autoconfig");
+
+    request.setPathParam("app_id", appId);
+    request.setHeaderParam("idempotency-key", options?.idempotencyKey);
+
+    return await request.send(this.requestCtx, AutoConfigOutSerializer._fromJsonObject);
+  }
+
+  /** Rotate the auth token and signing secret for an AutoConfig subscription. */
+  public async rotate(
+    appId: string,
+    autoconfigId: string,
+    rotateSubscriptionIn2: RotateSubscriptionIn2 = {},
+    options?: AutoconfigSubscriptionRotateOptions
+  ): Promise<AutoConfigOut> {
+    const request = new SvixRequest(
+      HttpMethod.POST,
+      "/api/v1/app/{app_id}/autoconfig/{autoconfig_id}/rotate"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setPathParam("autoconfig_id", autoconfigId);
+    request.setHeaderParam("idempotency-key", options?.idempotencyKey);
+    request.setBody(RotateSubscriptionIn2Serializer._toJsonObject(rotateSubscriptionIn2));
+
+    return await request.send(this.requestCtx, AutoConfigOutSerializer._fromJsonObject);
+  }
+}

package/src/api/destination.ts

@@ -0,0 +1,133 @@
+// this file is @generated
+
+import { type DestinationIn, DestinationInSerializer } from "../models/destinationIn";
+import { type DestinationOut, DestinationOutSerializer } from "../models/destinationOut";
+import {
+  type DestinationPatch,
+  DestinationPatchSerializer,
+} from "../models/destinationPatch";
+import {
+  type ListResponseDestinationOut,
+  ListResponseDestinationOutSerializer,
+} from "../models/listResponseDestinationOut";
+import type { Ordering } from "../models/ordering";
+import { DestinationTransformation } from "./destinationTransformation";
+import { HttpMethod, SvixRequest, type SvixRequestContext } from "../request";
+
+export interface DestinationListOptions {
+  /** Limit the number of returned items */
+  limit?: number;
+  /** The iterator returned from a prior invocation */
+  iterator?: string | null;
+  /** The sorting order of the returned items */
+  order?: Ordering;
+}
+
+export interface DestinationCreateOptions {
+  idempotencyKey?: string;
+}
+
+export class Destination {
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
+
+  public get transformation() {
+    return new DestinationTransformation(this.requestCtx);
+  }
+
+  /** List of all the application's destinations. */
+  public async list(
+    appId: string,
+    options?: DestinationListOptions
+  ): Promise<ListResponseDestinationOut> {
+    const request = new SvixRequest(HttpMethod.GET, "/api/v1/app/{app_id}/destination");
+
+    request.setPathParam("app_id", appId);
+    request.setQueryParams({
+      limit: options?.limit,
+      iterator: options?.iterator,
+      order: options?.order,
+    });
+
+    return await request.send(
+      this.requestCtx,
+      ListResponseDestinationOutSerializer._fromJsonObject
+    );
+  }
+
+  /** Creates a new destination. */
+  public async create(
+    appId: string,
+    destinationIn: DestinationIn,
+    options?: DestinationCreateOptions
+  ): Promise<DestinationOut> {
+    const request = new SvixRequest(HttpMethod.POST, "/api/v1/app/{app_id}/destination");
+
+    request.setPathParam("app_id", appId);
+    request.setHeaderParam("idempotency-key", options?.idempotencyKey);
+    request.setBody(DestinationInSerializer._toJsonObject(destinationIn));
+
+    return await request.send(this.requestCtx, DestinationOutSerializer._fromJsonObject);
+  }
+
+  /** Get a destination by id or uid. */
+  public async get(appId: string, destinationId: string): Promise<DestinationOut> {
+    const request = new SvixRequest(
+      HttpMethod.GET,
+      "/api/v1/app/{app_id}/destination/{destination_id}"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setPathParam("destination_id", destinationId);
+
+    return await request.send(this.requestCtx, DestinationOutSerializer._fromJsonObject);
+  }
+
+  /** Create or update a destination. */
+  public async upsert(
+    appId: string,
+    destinationId: string,
+    destinationIn: DestinationIn
+  ): Promise<DestinationOut> {
+    const request = new SvixRequest(
+      HttpMethod.PUT,
+      "/api/v1/app/{app_id}/destination/{destination_id}"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setPathParam("destination_id", destinationId);
+    request.setBody(DestinationInSerializer._toJsonObject(destinationIn));
+
+    return await request.send(this.requestCtx, DestinationOutSerializer._fromJsonObject);
+  }
+
+  /** Delete a destination. */
+  public async delete(appId: string, destinationId: string): Promise<void> {
+    const request = new SvixRequest(
+      HttpMethod.DELETE,
+      "/api/v1/app/{app_id}/destination/{destination_id}"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setPathParam("destination_id", destinationId);
+
+    return await request.sendNoResponseBody(this.requestCtx);
+  }
+
+  /** Partially update a destination. */
+  public async patch(
+    appId: string,
+    destinationId: string,
+    destinationPatch: DestinationPatch
+  ): Promise<DestinationOut> {
+    const request = new SvixRequest(
+      HttpMethod.PATCH,
+      "/api/v1/app/{app_id}/destination/{destination_id}"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setPathParam("destination_id", destinationId);
+    request.setBody(DestinationPatchSerializer._toJsonObject(destinationPatch));
+
+    return await request.send(this.requestCtx, DestinationOutSerializer._fromJsonObject);
+  }
+}

package/src/api/destinationTransformation.ts

@@ -0,0 +1,55 @@
+// this file is @generated
+
+import {
+  type DestinationTransformIn,
+  DestinationTransformInSerializer,
+} from "../models/destinationTransformIn";
+import {
+  type DestinationTransformationOut,
+  DestinationTransformationOutSerializer,
+} from "../models/destinationTransformationOut";
+import { type EmptyResponse, EmptyResponseSerializer } from "../models/emptyResponse";
+import { HttpMethod, SvixRequest, type SvixRequestContext } from "../request";
+
+export class DestinationTransformation {
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
+
+  /** Get the transformation code associated with this destination. */
+  public async get(
+    appId: string,
+    destinationId: string
+  ): Promise<DestinationTransformationOut> {
+    const request = new SvixRequest(
+      HttpMethod.GET,
+      "/api/v1/app/{app_id}/destination/{destination_id}/transformation"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setPathParam("destination_id", destinationId);
+
+    return await request.send(
+      this.requestCtx,
+      DestinationTransformationOutSerializer._fromJsonObject
+    );
+  }
+
+  /** Set or unset the transformation code associated with this destination. */
+  public async patch(
+    appId: string,
+    destinationId: string,
+    destinationTransformIn: DestinationTransformIn = {}
+  ): Promise<EmptyResponse> {
+    const request = new SvixRequest(
+      HttpMethod.PATCH,
+      "/api/v1/app/{app_id}/destination/{destination_id}/transformation"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setPathParam("destination_id", destinationId);
+    request.setBody(
+      DestinationTransformInSerializer._toJsonObject(destinationTransformIn)
+    );
+
+    return await request.send(this.requestCtx, EmptyResponseSerializer._fromJsonObject);
+  }
+}

package/src/api_internal/autoconfigSubscription.ts

@@ -0,0 +1,40 @@
+// this file is @generated
+
+import {
+  type AutoConfigSubscriptionOut,
+  AutoConfigSubscriptionOutSerializer,
+} from "../models/autoConfigSubscriptionOut";
+import { AutoconfigSubscriptionDestination } from "./autoconfigSubscriptionDestination";
+import { AutoconfigSubscriptionEndpoint } from "./autoconfigSubscriptionEndpoint";
+import { HttpMethod, SvixRequest, type SvixRequestContext } from "../request";
+
+export class AutoconfigSubscription {
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
+
+  public get destination() {
+    return new AutoconfigSubscriptionDestination(this.requestCtx);
+  }
+
+  public get endpoint() {
+    return new AutoconfigSubscriptionEndpoint(this.requestCtx);
+  }
+
+  /** Get an AutoConfig subscription, including the bound endpoint or destination if any. */
+  public async get(
+    appId: string,
+    autoconfigId: string
+  ): Promise<AutoConfigSubscriptionOut> {
+    const request = new SvixRequest(
+      HttpMethod.GET,
+      "/api/v1/app/{app_id}/autoconfig/{autoconfig_id}"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setPathParam("autoconfig_id", autoconfigId);
+
+    return await request.send(
+      this.requestCtx,
+      AutoConfigSubscriptionOutSerializer._fromJsonObject
+    );
+  }
+}

package/src/api_internal/autoconfigSubscriptionDestination.ts

@@ -0,0 +1,27 @@
+// this file is @generated
+
+import { type DestinationIn, DestinationInSerializer } from "../models/destinationIn";
+import { type DestinationOut, DestinationOutSerializer } from "../models/destinationOut";
+import { HttpMethod, SvixRequest, type SvixRequestContext } from "../request";
+
+export class AutoconfigSubscriptionDestination {
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
+
+  /** Create or update the destination for an AutoConfig subscription. */
+  public async subscribe(
+    appId: string,
+    autoconfigId: string,
+    destinationIn: DestinationIn
+  ): Promise<DestinationOut> {
+    const request = new SvixRequest(
+      HttpMethod.PUT,
+      "/api/v1/app/{app_id}/autoconfig/{autoconfig_id}/destination"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setPathParam("autoconfig_id", autoconfigId);
+    request.setBody(DestinationInSerializer._toJsonObject(destinationIn));
+
+    return await request.send(this.requestCtx, DestinationOutSerializer._fromJsonObject);
+  }
+}

package/src/api_internal/autoconfigSubscriptionEndpoint.ts

@@ -0,0 +1,27 @@
+// this file is @generated
+
+import { type EndpointIn, EndpointInSerializer } from "../models/endpointIn";
+import { type EndpointOut, EndpointOutSerializer } from "../models/endpointOut";
+import { HttpMethod, SvixRequest, type SvixRequestContext } from "../request";
+
+export class AutoconfigSubscriptionEndpoint {
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
+
+  /** Create or update the HTTP endpoint for an AutoConfig subscription. */
+  public async subscribe(
+    appId: string,
+    autoconfigId: string,
+    endpointIn: EndpointIn
+  ): Promise<EndpointOut> {
+    const request = new SvixRequest(
+      HttpMethod.PUT,
+      "/api/v1/app/{app_id}/autoconfig/{autoconfig_id}/endpoint"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setPathParam("autoconfig_id", autoconfigId);
+    request.setBody(EndpointInSerializer._toJsonObject(endpointIn));
+
+    return await request.send(this.requestCtx, EndpointOutSerializer._fromJsonObject);
+  }
+}

package/src/api_internal/endpoint.ts

@@ -4,14 +4,14 @@ import {
   type EndpointTransformationIn,
   EndpointTransformationInSerializer,
 } from "../models/endpointTransformationIn";
-import { EndpointAutoConfig } from "./endpointAutoConfig";
+import { EndpointAutoConfigDeprecated } from "./endpointAutoConfigDeprecated";
 import { HttpMethod, SvixRequest, type SvixRequestContext } from "../request";
 
 export class Endpoint {
   public constructor(private readonly requestCtx: SvixRequestContext) {}
 
-  public get autoConfig() {
-    return new EndpointAutoConfig(this.requestCtx);
+  public get autoConfigDeprecated() {
+    return new EndpointAutoConfigDeprecated(this.requestCtx);
   }
 
   /**

package/src/api_internal/{endpointAutoConfig.ts → endpointAutoConfigDeprecated.ts}

@@ -4,7 +4,7 @@ import { type EndpointOut, EndpointOutSerializer } from "../models/endpointOut";
 import { type SubscribeIn, SubscribeInSerializer } from "../models/subscribeIn";
 import { HttpMethod, SvixRequest, type SvixRequestContext } from "../request";
 
-export class EndpointAutoConfig {
+export class EndpointAutoConfigDeprecated {
   public constructor(private readonly requestCtx: SvixRequestContext) {}
 
   /** Update an auto-config endpoint by providing endpoint details. */

package/src/autoconfig.test.ts

@@ -1,13 +1,29 @@
 import { test } from "node:test";
 import { strict as assert } from "node:assert/strict";
+import * as mockttp from "mockttp";
 
-import { AutoConfig, AutoConfigError, Webhook } from "./index";
+import { AutoConfig, AutoConfigConsumer, AutoConfigError, Webhook } from "./index";
 
-function makeTokenV1(payload: Record<string, string>): string {
+function makeToken(
+  prefix: "auto_v1_" | "auto_v2_",
+  payload: Record<string, string>
+): string {
   const json = JSON.stringify(payload);
-  return `auto_v1_${Buffer.from(json, "utf8").toString("base64")}`;
+  return `${prefix}${Buffer.from(json, "utf8").toString("base64")}`;
+}
+
+function makeTokenV1(payload: Record<string, string>): string {
+  return makeToken("auto_v1_", payload);
+}
+
+function makeTokenV2(payload: Record<string, string>): string {
+  return makeToken("auto_v2_", payload);
 }
 
+const endpointOut = `{"id":"ep_2","metadata":{},"url":"https://consumer.example/webhook","description":"","createdAt":"2019-08-24T14:15:22Z","updatedAt":"2019-08-24T14:15:22Z"}`;
+const destinationOut = `{"type":"pollingEndpoint","config":{},"id":"dst_123","status":"enabled","currentIterator":"0","createdAt":"2019-08-24T14:15:22Z","updatedAt":"2019-08-24T14:15:22Z","batchSize":100,"maxWaitSecs":10,"metadata":{}}`;
+const pollOut = `{"data":[],"done":true}`;
+
 test("AutoConfig accepts valid auto_v1 token and verify matches Webhook", () => {
   const esec = "whsec_Zm9v";
   const token = makeTokenV1({
@@ -55,3 +71,146 @@ test("AutoConfig rejects invalid JSON payload", () => {
   const token = `auto_v1_${Buffer.from("not json", "utf8").toString("base64")}`;
   assert.throws(() => new AutoConfig(token, { url: "https://x" }), AutoConfigError);
 });
+
+test("AutoConfig accepts valid auto_v2 token and verify matches Webhook", () => {
+  const esec = "whsec_Zm9v";
+  const token = makeTokenV2({
+    aid: "app_1",
+    sid: "acfg_2",
+    surl: "https://api.example.test",
+    esec,
+    tok: "sk_test_xyz",
+  });
+  const ac = new AutoConfig(token, { url: "https://consumer.example/webhook" });
+
+  const payload = '{"hello":"world"}';
+  const id = "msg_test_autoconfig_v2";
+  const ts = new Date();
+  const wh = new Webhook(esec);
+  const sig = wh.sign(id, ts, payload);
+  const headers = {
+    "svix-id": id,
+    "svix-timestamp": Math.floor(ts.getTime() / 1000).toString(),
+    "svix-signature": sig,
+  };
+
+  ac.verify(payload, headers);
+});
+
+test("subscribe", async (t) => {
+  const mockServer = mockttp.getLocal();
+  t.beforeEach(async () => await mockServer.start(0));
+  t.afterEach(async () => await mockServer.stop());
+
+  await t.test("v1 AutoConfig", async () => {
+    const mock = await mockServer
+      .forPut("/api/v1/app/app_1/endpoint/ep_2/auto-config")
+      .thenReply(200, endpointOut);
+    const token = makeTokenV1({
+      aid: "app_1",
+      eid: "ep_2",
+      surl: mockServer.url,
+      esec: "whsec_Zm9v",
+      tok: "sk_test_xyz",
+    });
+    const ac = new AutoConfig(token, { url: "https://consumer.example/webhook" });
+    const out = await ac.subscribe();
+    assert.equal(out.id, "ep_2");
+    const requests = await mock.getSeenRequests();
+    assert.equal(requests.length, 1);
+    assert.equal(
+      await requests[0].body.getText(),
+      `{"endpoint":{"url":"https://consumer.example/webhook"}}`
+    );
+  });
+
+  await t.test("v2 AutoConfig", async () => {
+    const mock = await mockServer
+      .forPut("/api/v1/app/app_1/autoconfig/acfg_2/endpoint")
+      .thenReply(200, endpointOut);
+    const token = makeTokenV2({
+      aid: "app_1",
+      sid: "acfg_2",
+      surl: mockServer.url,
+      esec: "whsec_Zm9v",
+      tok: "sk_test_xyz",
+    });
+    const ac = new AutoConfig(token, { url: "https://consumer.example/webhook" });
+    const out = await ac.subscribe();
+    assert.equal(out.id, "ep_2");
+    const requests = await mock.getSeenRequests();
+    assert.equal(requests.length, 1);
+    assert.equal(
+      await requests[0].body.getText(),
+      `{"url":"https://consumer.example/webhook"}`
+    );
+  });
+
+  await t.test("v1 AutoConfigConsumer", async () => {
+    const mock = await mockServer
+      .forPut("/api/v1/app/app_1/endpoint/ep_2/auto-config")
+      .thenReply(200, endpointOut);
+    const token = makeTokenV1({
+      aid: "app_1",
+      eid: "ep_2",
+      surl: mockServer.url,
+      esec: "whsec_Zm9v",
+      tok: "sk_test_xyz",
+    });
+    const consumer = new AutoConfigConsumer(token, {
+      eventTypes: ["issue.opened"],
+    });
+    await consumer.subscribe();
+    const requests = await mock.getSeenRequests();
+    assert.equal(requests.length, 1);
+    assert.equal(
+      await requests[0].body.getText(),
+      `{"sink":{"type":"poller","config":{"eventTypes":["issue.opened"]}}}`
+    );
+  });
+
+  await t.test("v2 AutoConfigConsumer", async () => {
+    const mock = await mockServer
+      .forPut("/api/v1/app/app_1/autoconfig/acfg_2/destination")
+      .thenReply(200, destinationOut);
+    const token = makeTokenV2({
+      aid: "app_1",
+      sid: "acfg_2",
+      surl: mockServer.url,
+      esec: "whsec_Zm9v",
+      tok: "sk_test_xyz",
+    });
+    const consumer = new AutoConfigConsumer(token, {
+      channels: ["ch1"],
+    });
+    const out = await consumer.subscribe();
+    assert.equal(out.id, "dst_123");
+    const requests = await mock.getSeenRequests();
+    assert.equal(requests.length, 1);
+    assert.equal(
+      await requests[0].body.getText(),
+      `{"type":"pollingEndpoint","config":{},"channels":["ch1"]}`
+    );
+  });
+
+  await t.test("v2 receive gets subscription", async () => {
+    const subscriptionOut = `{"id":"auto_1srOrx2ZWZBpBUvZwXKQmoEYga2","tokenCensored":"***","createdAt":"2019-08-24T14:15:22Z","status":"active","destId":"dst_123"}`;
+    await mockServer
+      .forGet("/api/v1/app/app_1/autoconfig/acfg_2")
+      .thenReply(200, subscriptionOut);
+    const pollMock = await mockServer
+      .forGet("/api/v1/app/app_1/polling-endpoint/dst_123/consumer/c1")
+      .thenReply(200, pollOut);
+    const token = makeTokenV2({
+      aid: "app_1",
+      sid: "acfg_2",
+      surl: mockServer.url,
+      esec: "whsec_Zm9v",
+      tok: "sk_test_xyz",
+    });
+    const consumer = new AutoConfigConsumer(token, {});
+    await consumer.receive("c1");
+    const requests = await pollMock.getSeenRequests();
+    assert.equal(requests.length, 1);
+  });
+});