svix 2.2.0 → 2.4.0

package/package.json

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

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/destination.ts

@@ -0,0 +1,12 @@
+// this file is @generated
+
+import { DestinationAutoconfig } from "./destinationAutoconfig";
+import type { SvixRequestContext } from "../request";
+
+export class Destination {
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
+
+  public get autoconfig() {
+    return new DestinationAutoconfig(this.requestCtx);
+  }
+}

package/src/api_internal/destinationAutoconfig.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 DestinationAutoconfig {
+  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/endpoint.ts

@@ -4,14 +4,19 @@ import {
   type EndpointTransformationIn,
   EndpointTransformationInSerializer,
 } from "../models/endpointTransformationIn";
-import { EndpointAutoConfig } from "./endpointAutoConfig";
+import { EndpointAutoConfigDeprecated } from "./endpointAutoConfigDeprecated";
+import { EndpointAutoconfig } from "./endpointAutoconfig";
 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);
+  }
+
+  public get autoconfig() {
+    return new EndpointAutoconfig(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/api_internal/endpointAutoconfig.ts

@@ -0,0 +1,50 @@
+// this file is @generated
+
+import {
+  type AutoConfigSubscriptionOut,
+  AutoConfigSubscriptionOutSerializer,
+} from "../models/autoConfigSubscriptionOut";
+import { type EndpointIn, EndpointInSerializer } from "../models/endpointIn";
+import { type EndpointOut, EndpointOutSerializer } from "../models/endpointOut";
+import { HttpMethod, SvixRequest, type SvixRequestContext } from "../request";
+
+export class EndpointAutoconfig {
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
+
+  /** 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
+    );
+  }
+
+  /** 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/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({
@@ -42,10 +58,159 @@ test("AutoConfig rejects wrong prefix", () => {
     tok: "t",
   });
   const token = `wrong_${Buffer.from(json, "utf8").toString("base64")}`;
-  assert.throws(() => new AutoConfig(token, { url: "https://x" }), AutoConfigError);
+  assert.throws(
+    () => new AutoConfig(token, { url: "https://x" }),
+    (err: unknown) =>
+      err instanceof AutoConfigError &&
+      err.message ===
+        "Unsupported token version. You might need to update the Svix SDK to use this token"
+  );
 });
 
 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);
+  });
+});

package/src/autoconfig.ts

@@ -10,12 +10,34 @@ import {
 } from "./webhook";
 
 const AUTOCONFIG_TOKEN_PREFIX_V1 = "auto_v1_";
+const AUTOCONFIG_TOKEN_PREFIX_V2 = "auto_v2_";
+
+const UNSUPPORTED_TOKEN_VERSION =
+  "Unsupported token version. You might need to update the Svix SDK to use this token";
 
 export interface AutoConfigTokenContentV1 {
+  // Application ID
   aid: string;
+  // Endpoint ID
   eid: string;
+  // Server URL
+  surl: string;
+  // Endpoint secret
+  esec: string;
+  // Token
+  tok: string;
+}
+
+export interface AutoConfigTokenContentV2 {
+  // Application ID
+  aid: string;
+  // Autoconfig ID
+  sid: string;
+  // Server URL
   surl: string;
+  // Endpoint secret
   esec: string;
+  // Token
   tok: string;
 }
 
@@ -43,66 +65,107 @@ export function isAutoConfigTokenContentV1(
   );
 }
 
-export function decodeAutoconfigTokenV1(token: string): AutoConfigTokenContentV1 {
-  if (!token.startsWith(AUTOCONFIG_TOKEN_PREFIX_V1)) {
-    throw new AutoConfigError();
+function isAutoConfigTokenContentV2(value: unknown): value is AutoConfigTokenContentV2 {
+  if (typeof value !== "object" || value === null) {
+    return false;
   }
-  const b64 = token.slice(AUTOCONFIG_TOKEN_PREFIX_V1.length);
-  let json: string;
+  const { aid, sid, surl, esec, tok } = value as AutoConfigTokenContentV2;
+  return (
+    typeof aid === "string" &&
+    typeof sid === "string" &&
+    typeof surl === "string" &&
+    typeof esec === "string" &&
+    typeof tok === "string"
+  );
+}
 
-  try {
-    json = Buffer.from(b64, "base64").toString("utf8");
-  } catch {
-    throw new AutoConfigError();
+function parseTokenPayload(token: string, prefix: string): unknown {
+  if (!token.startsWith(prefix)) {
+    throw new AutoConfigError(UNSUPPORTED_TOKEN_VERSION);
   }
-
-  let parsed: unknown;
   try {
-    parsed = JSON.parse(json);
+    return JSON.parse(Buffer.from(token.slice(prefix.length), "base64").toString("utf8"));
   } catch {
     throw new AutoConfigError();
   }
+}
 
+export function decodeAutoconfigTokenV1(token: string): AutoConfigTokenContentV1 {
+  const parsed = parseTokenPayload(token, AUTOCONFIG_TOKEN_PREFIX_V1);
   if (!isAutoConfigTokenContentV1(parsed)) {
     throw new AutoConfigError();
   }
+  return parsed;
+}
 
+export function decodeAutoconfigTokenV2(token: string): AutoConfigTokenContentV2 {
+  const parsed = parseTokenPayload(token, AUTOCONFIG_TOKEN_PREFIX_V2);
+  if (!isAutoConfigTokenContentV2(parsed)) {
+    throw new AutoConfigError();
+  }
   return parsed;
 }
 
+export function decodeAutoconfigToken(
+  token: string
+):
+  | { version: "v1"; content: AutoConfigTokenContentV1 }
+  | { version: "v2"; content: AutoConfigTokenContentV2 } {
+  if (token.startsWith(AUTOCONFIG_TOKEN_PREFIX_V1)) {
+    return { version: "v1", content: decodeAutoconfigTokenV1(token) };
+  }
+  if (token.startsWith(AUTOCONFIG_TOKEN_PREFIX_V2)) {
+    return { version: "v2", content: decodeAutoconfigTokenV2(token) };
+  }
+  throw new AutoConfigError(UNSUPPORTED_TOKEN_VERSION);
+}
+
 export class AutoConfig {
   private readonly appId: string;
-  private readonly endpointId: string;
-  private readonly endpointIn: EndpointIn;
   private readonly webhook: Webhook;
   private readonly requestCtx: SvixRequestContext;
+  private readonly endpointIn: EndpointIn;
+  private readonly endpointId?: string;
+  private readonly autoconfigId?: string;
 
   public constructor(token: string, endpoint: EndpointIn) {
-    const content = decodeAutoconfigTokenV1(token);
+    const decoded = decodeAutoconfigToken(token);
+
     let webhook: Webhook;
     try {
-      webhook = new Webhook(content.esec);
+      webhook = new Webhook(decoded.content.esec);
     } catch {
       throw new AutoConfigError();
     }
 
-    this.appId = content.aid;
-    this.endpointId = content.eid;
+    this.appId = decoded.content.aid;
     this.endpointIn = endpoint;
     this.webhook = webhook;
 
-    const svix = new SvixInternal(content.tok, { serverUrl: content.surl });
+    if (decoded.version === "v1") {
+      this.endpointId = decoded.content.eid;
+    } else {
+      this.autoconfigId = decoded.content.sid;
+    }
+
+    const svix = new SvixInternal(decoded.content.tok, {
+      serverUrl: decoded.content.surl,
+    });
     this.requestCtx = svix.getRequestCtx();
   }
 
   public subscribe(): Promise<EndpointOut> {
-    return new InternalEndpoint(this.requestCtx).autoConfig.update(
-      this.appId,
-      this.endpointId,
-      {
-        endpoint: this.endpointIn,
-      }
-    );
+    const endpoint = new InternalEndpoint(this.requestCtx);
+    if (this.autoconfigId != null) {
+      return endpoint.autoconfig.subscribe(
+        this.appId,
+        this.autoconfigId,
+        this.endpointIn
+      );
+    }
+    return endpoint.autoConfigDeprecated.update(this.appId, this.endpointId as string, {
+      endpoint: this.endpointIn,
+    });
   }
 
   public verify(