svix 2.3.0 → 2.5.0

package/src/autoconfig.ts

@@ -1,4 +1,5 @@
 import { SvixInternal } from "./api_internal";
+import { AutoconfigSubscription } from "./api_internal/autoconfigSubscription";
 import { Endpoint as InternalEndpoint } from "./api_internal/endpoint";
 import type { EndpointIn } from "./models/endpointIn";
 import type { EndpointOut } from "./models/endpointOut";
@@ -10,14 +11,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;
 }
 
@@ -45,66 +66,107 @@ export function isAutoConfigTokenContentV1(
   );
 }
 
-export function decodeAutoconfigTokenV1(token: string): AutoConfigTokenContentV1 {
-  if (!token.startsWith(AUTOCONFIG_TOKEN_PREFIX_V1)) {
-    throw new AutoConfigError(UNSUPPORTED_TOKEN_VERSION);
+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 new AutoconfigSubscription(this.requestCtx).endpoint.subscribe(
+        this.appId,
+        this.autoconfigId,
+        this.endpointIn
+      );
+    }
+    return endpoint.autoConfigDeprecated.update(this.appId, this.endpointId as string, {
+      endpoint: this.endpointIn,
+    });
   }
 
   public verify(

package/src/autoconfigConsumer.ts

@@ -1,66 +1,112 @@
 import { SvixInternal } from "./api_internal";
+import { AutoconfigSubscription } from "./api_internal/autoconfigSubscription";
 import { Endpoint as InternalEndpoint } from "./api_internal/endpoint";
 import {
   MessagePollerv2 as InternalMessagePollerv2,
   type MessagePollerv2ConsumerCommitOptions,
   type MessagePollerv2ConsumerPollOptions,
 } from "./api_internal/messagePollerv2";
-import { decodeAutoconfigTokenV1 } from "./autoconfig";
+import { decodeAutoconfigToken } from "./autoconfig";
+import type { DestinationIn } from "./models/destinationIn";
+import type { DestinationOut } from "./models/destinationOut";
 import type { EndpointOut } from "./models/endpointOut";
 import type { PollerV2PollOut } from "./models/pollerV2PollOut";
 import type { SinkInCommon } from "./models/sinkInCommon";
+import { DestinationStatus } from "./models/destinationStatus";
 import type { SvixRequestContext } from "./request";
 
 export class AutoConfigConsumer {
   private readonly appId: string;
-  private readonly sinkId: string;
   private readonly sinkIn: SinkInCommon;
   private readonly requestCtx: SvixRequestContext;
+  private sinkId?: string;
+  private readonly autoconfigId?: string;
 
   public constructor(token: string, sinkIn: SinkInCommon) {
-    const content = decodeAutoconfigTokenV1(token);
+    const decoded = decodeAutoconfigToken(token);
 
-    this.appId = content.aid;
-    this.sinkId = content.eid;
+    this.appId = decoded.content.aid;
     this.sinkIn = sinkIn;
 
-    const svix = new SvixInternal(content.tok, { serverUrl: content.surl });
+    if (decoded.version === "v1") {
+      this.sinkId = 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.sinkId,
-      {
+  public async subscribe(): Promise<DestinationOut> {
+    const endpoint = new InternalEndpoint(this.requestCtx);
+    if (this.autoconfigId != null) {
+      // v2
+      const destination = await new AutoconfigSubscription(
+        this.requestCtx
+      ).destination.subscribe(
+        this.appId,
+        this.autoconfigId,
+        sinkInCommonToPollingDestination(this.sinkIn)
+      );
+      this.sinkId = destination.id;
+      return destination;
+    }
+
+    // v1
+    return destinationOutFromV1Endpoint(
+      await endpoint.autoConfigDeprecated.update(this.appId, this.sinkId as string, {
         sink: {
           type: "poller",
           config: this.sinkIn,
         },
-      }
+      })
     );
   }
 
-  public receive(
+  private async getSinkId(): Promise<string> {
+    if (this.sinkId != null) {
+      // Already have the sink id from subscribe() or the v1 token
+      return this.sinkId;
+    }
+
+    // Get the sink id from the autoconfig id (v2)
+    const destId = (
+      await new AutoconfigSubscription(this.requestCtx).get(
+        this.appId,
+        this.autoconfigId as string
+      )
+    ).destId;
+    if (destId == null) {
+      throw new Error("autoconfig subscription is pending. Have you called subscribe()?");
+    }
+    return destId;
+  }
+
+  public async receive(
     consumerId: string,
     options?: MessagePollerv2ConsumerPollOptions
   ): Promise<PollerV2PollOut> {
+    const sinkId = await this.getSinkId();
     return new InternalMessagePollerv2(this.requestCtx).consumerPoll(
       this.appId,
-      this.sinkId,
+      sinkId,
       consumerId,
       options
     );
   }
 
-  public commit(
+  public async commit(
     consumerId: string,
     offset: number,
     options?: MessagePollerv2ConsumerCommitOptions
   ): Promise<void> {
+    const sinkId = await this.getSinkId();
     return new InternalMessagePollerv2(this.requestCtx).consumerCommit(
       this.appId,
-      this.sinkId,
+      sinkId,
       consumerId,
       {
         offset,
@@ -69,3 +115,31 @@ export class AutoConfigConsumer {
     );
   }
 }
+
+function sinkInCommonToPollingDestination(sink: SinkInCommon): DestinationIn {
+  return {
+    type: "pollingEndpoint",
+    eventTypes: sink.eventTypes ?? undefined,
+    channels: sink.channels ?? undefined,
+    metadata: sink.metadata,
+    uid: sink.uid,
+  };
+}
+
+function destinationOutFromV1Endpoint(endpoint: EndpointOut): DestinationOut {
+  return {
+    id: endpoint.id,
+    uid: endpoint.uid,
+    status: endpoint.disabled ? DestinationStatus.Disabled : DestinationStatus.Enabled,
+    currentIterator: "",
+    createdAt: endpoint.createdAt,
+    updatedAt: endpoint.updatedAt,
+    batchSize: 0,
+    maxWaitSecs: 0,
+    eventTypes: endpoint.eventTypes ?? undefined,
+    channels: endpoint.channels ?? undefined,
+    metadata: endpoint.metadata,
+    type: "pollingEndpoint",
+    config: {},
+  };
+}

package/src/index.ts

@@ -1,8 +1,10 @@
 // this file is @generated
 import { Application } from "./api/application";
 import { Authentication } from "./api/authentication";
+import { AutoconfigSubscription } from "./api/autoconfigSubscription";
 import { BackgroundTask } from "./api/backgroundTask";
 import { Connector } from "./api/connector";
+import { Destination } from "./api/destination";
 import { Endpoint } from "./api/endpoint";
 import { Environment } from "./api/environment";
 import { EventType } from "./api/eventType";
@@ -69,6 +71,10 @@ export class Svix {
     return new Authentication(this.requestCtx);
   }
 
+  public get autoconfigSubscription() {
+    return new AutoconfigSubscription(this.requestCtx);
+  }
+
   public get backgroundTask() {
     return new BackgroundTask(this.requestCtx);
   }
@@ -77,6 +83,10 @@ export class Svix {
     return new Connector(this.requestCtx);
   }
 
+  public get destination() {
+    return new Destination(this.requestCtx);
+  }
+
   public get endpoint() {
     return new Endpoint(this.requestCtx);
   }

package/src/models/autoConfigOut.ts

@@ -0,0 +1,26 @@
+// this file is @generated
+
+export interface AutoConfigOut {
+  createdAt: Date;
+  token: string;
+  /** The AutoConfigSubscription's ID. */
+  id: string;
+}
+
+export const AutoConfigOutSerializer = {
+  _fromJsonObject(object: any): AutoConfigOut {
+    return {
+      createdAt: new Date(object["createdAt"]),
+      token: object["token"],
+      id: object["id"],
+    };
+  },
+
+  _toJsonObject(self: AutoConfigOut): any {
+    return {
+      createdAt: self.createdAt,
+      token: self.token,
+      id: self.id,
+    };
+  },
+};

package/src/models/autoConfigSubscriptionOut.ts

@@ -0,0 +1,38 @@
+// this file is @generated
+import { type Status, StatusSerializer } from "./status";
+
+export interface AutoConfigSubscriptionOut {
+  createdAt: Date;
+  tokenCensored: string;
+  /** The AutoConfigSubscription's ID. */
+  id: string;
+  /** The Endpoint's ID. */
+  endpId?: string | null;
+  /** The StreamSink's ID. */
+  destId?: string | null;
+  status: Status;
+}
+
+export const AutoConfigSubscriptionOutSerializer = {
+  _fromJsonObject(object: any): AutoConfigSubscriptionOut {
+    return {
+      createdAt: new Date(object["createdAt"]),
+      tokenCensored: object["tokenCensored"],
+      id: object["id"],
+      endpId: object["endpId"],
+      destId: object["destId"],
+      status: StatusSerializer._fromJsonObject(object["status"]),
+    };
+  },
+
+  _toJsonObject(self: AutoConfigSubscriptionOut): any {
+    return {
+      createdAt: self.createdAt,
+      tokenCensored: self.tokenCensored,
+      id: self.id,
+      endpId: self.endpId,
+      destId: self.destId,
+      status: StatusSerializer._toJsonObject(self.status),
+    };
+  },
+};