svix 2.2.0 → 2.4.0

package/src/autoconfigConsumer.ts

@@ -1,66 +1,112 @@
 import { SvixInternal } from "./api_internal";
+import { Destination as InternalDestination } from "./api_internal/destination";
 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 InternalDestination(
+        this.requestCtx
+      ).autoconfig.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 InternalEndpoint(this.requestCtx).autoconfig.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

@@ -3,6 +3,7 @@ import { Application } from "./api/application";
 import { Authentication } from "./api/authentication";
 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";
@@ -77,6 +78,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/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),
+    };
+  },
+};

package/src/models/destinationIn.ts

@@ -0,0 +1,303 @@
+// this file is @generated
+import {
+  type AzureBlobStorageConfigIn,
+  AzureBlobStorageConfigInSerializer,
+} from "./azureBlobStorageConfigIn";
+import { type BigQueryConfigIn, BigQueryConfigInSerializer } from "./bigQueryConfigIn";
+import {
+  type ClickhouseConfigIn,
+  ClickhouseConfigInSerializer,
+} from "./clickhouseConfigIn";
+import {
+  type DestinationStatusIn,
+  DestinationStatusInSerializer,
+} from "./destinationStatusIn";
+import {
+  type EventBridgeConfigIn,
+  EventBridgeConfigInSerializer,
+} from "./eventBridgeConfigIn";
+import {
+  type FifoEndpointConfigIn,
+  FifoEndpointConfigInSerializer,
+} from "./fifoEndpointConfigIn";
+import {
+  type GoogleCloudPubSubConfigIn,
+  GoogleCloudPubSubConfigInSerializer,
+} from "./googleCloudPubSubConfigIn";
+import {
+  type GoogleCloudStorageConfigIn,
+  GoogleCloudStorageConfigInSerializer,
+} from "./googleCloudStorageConfigIn";
+import {
+  type OtelTracingConfigIn,
+  OtelTracingConfigInSerializer,
+} from "./otelTracingConfigIn";
+import { type PostgresConfigIn, PostgresConfigInSerializer } from "./postgresConfigIn";
+import { type RabbitMqConfigIn, RabbitMqConfigInSerializer } from "./rabbitMqConfigIn";
+import { type RedshiftConfigIn, RedshiftConfigInSerializer } from "./redshiftConfigIn";
+import { type S3ConfigIn, S3ConfigInSerializer } from "./s3ConfigIn";
+import { type SnowflakeConfigIn, SnowflakeConfigInSerializer } from "./snowflakeConfigIn";
+import { type SnsConfigIn, SnsConfigInSerializer } from "./snsConfigIn";
+import { type SqsConfigIn, SqsConfigInSerializer } from "./sqsConfigIn";
+
+interface _DestinationInFields {
+  /** An optional unique identifier for the destination. */
+  uid?: string | null;
+  /**
+   * Whether the destination will receive events.
+   *
+   * If the destination is `enabled`, events sent to the application will be dispatched to the destination in order.
+   *
+   * If the destination is `disabled`, events will not be dispatched until the destination is reenabled.
+   */
+  status?: DestinationStatusIn;
+  /** How many events will be batched in a request to the destination. */
+  batchSize?: number;
+  /**
+   * How long to wait before a batch of events is sent, if the `batchSize` is not reached.
+   *
+   * For example, with a `batchSize` of 100 and `maxWaitSecs` of 10, a request is sent after 10 seconds or 100 events, whichever comes first.
+   *
+   * Note that an empty batch is never sent to the destination.
+   */
+  maxWaitSecs?: number;
+  /** A list of event types that filter which events are dispatched to the destination. An empty list (or null) will not filter out any events. */
+  eventTypes?: string[];
+  /** A list of channels that filter which events are dispatched to the destination. An empty list (or null) will not filter out any events. */
+  channels?: string[];
+  metadata?: { [key: string]: string };
+}
+
+// biome-ignore lint/suspicious/noEmptyInterface: backwards compat
+interface DestinationInPollingEndpointConfig {}
+
+interface DestinationInPollingEndpoint {
+  type: "pollingEndpoint";
+  config?: DestinationInPollingEndpointConfig;
+}
+
+interface DestinationInAzureBlobStorage {
+  type: "azureBlobStorage";
+  config: AzureBlobStorageConfigIn;
+}
+
+interface DestinationInOtelTracing {
+  type: "otelTracing";
+  config: OtelTracingConfigIn;
+}
+
+interface DestinationInFifoEndpoint {
+  type: "fifoEndpoint";
+  config: FifoEndpointConfigIn;
+}
+
+interface DestinationInAmazonS3 {
+  type: "amazonS3";
+  config: S3ConfigIn;
+}
+
+interface DestinationInGoogleCloudStorage {
+  type: "googleCloudStorage";
+  config: GoogleCloudStorageConfigIn;
+}
+
+interface DestinationInGoogleCloudPubSub {
+  type: "googleCloudPubSub";
+  config: GoogleCloudPubSubConfigIn;
+}
+
+interface DestinationInSqs {
+  type: "sqs";
+  config: SqsConfigIn;
+}
+
+interface DestinationInSns {
+  type: "sns";
+  config: SnsConfigIn;
+}
+
+interface DestinationInBigQuery {
+  type: "bigQuery";
+  config: BigQueryConfigIn;
+}
+
+interface DestinationInClickhouse {
+  type: "clickhouse";
+  config: ClickhouseConfigIn;
+}
+
+interface DestinationInEventBridge {
+  type: "eventBridge";
+  config: EventBridgeConfigIn;
+}
+
+interface DestinationInSnowflake {
+  type: "snowflake";
+  config: SnowflakeConfigIn;
+}
+
+interface DestinationInRabbitMq {
+  type: "rabbitMq";
+  config: RabbitMqConfigIn;
+}
+
+interface DestinationInRedshift {
+  type: "redshift";
+  config: RedshiftConfigIn;
+}
+
+interface DestinationInPostgres {
+  type: "postgres";
+  config: PostgresConfigIn;
+}
+
+/** The destination's type and type-specific configuration. */
+export type DestinationIn = _DestinationInFields &
+  (
+    | DestinationInPollingEndpoint
+    | DestinationInAzureBlobStorage
+    | DestinationInOtelTracing
+    | DestinationInFifoEndpoint
+    | DestinationInAmazonS3
+    | DestinationInGoogleCloudStorage
+    | DestinationInGoogleCloudPubSub
+    | DestinationInSqs
+    | DestinationInSns
+    | DestinationInBigQuery
+    | DestinationInClickhouse
+    | DestinationInEventBridge
+    | DestinationInSnowflake
+    | DestinationInRabbitMq
+    | DestinationInRedshift
+    | DestinationInPostgres
+  );
+
+export const DestinationInSerializer = {
+  _fromJsonObject(object: any): DestinationIn {
+    const type = object["type"];
+
+    function getConfig(type: string): any {
+      switch (type) {
+        case "pollingEndpoint":
+          return {};
+        case "azureBlobStorage":
+          return AzureBlobStorageConfigInSerializer._fromJsonObject(object["config"]);
+        case "otelTracing":
+          return OtelTracingConfigInSerializer._fromJsonObject(object["config"]);
+        case "fifoEndpoint":
+          return FifoEndpointConfigInSerializer._fromJsonObject(object["config"]);
+        case "amazonS3":
+          return S3ConfigInSerializer._fromJsonObject(object["config"]);
+        case "googleCloudStorage":
+          return GoogleCloudStorageConfigInSerializer._fromJsonObject(object["config"]);
+        case "googleCloudPubSub":
+          return GoogleCloudPubSubConfigInSerializer._fromJsonObject(object["config"]);
+        case "sqs":
+          return SqsConfigInSerializer._fromJsonObject(object["config"]);
+        case "sns":
+          return SnsConfigInSerializer._fromJsonObject(object["config"]);
+        case "bigQuery":
+          return BigQueryConfigInSerializer._fromJsonObject(object["config"]);
+        case "clickhouse":
+          return ClickhouseConfigInSerializer._fromJsonObject(object["config"]);
+        case "eventBridge":
+          return EventBridgeConfigInSerializer._fromJsonObject(object["config"]);
+        case "snowflake":
+          return SnowflakeConfigInSerializer._fromJsonObject(object["config"]);
+        case "rabbitMq":
+          return RabbitMqConfigInSerializer._fromJsonObject(object["config"]);
+        case "redshift":
+          return RedshiftConfigInSerializer._fromJsonObject(object["config"]);
+        case "postgres":
+          return PostgresConfigInSerializer._fromJsonObject(object["config"]);
+        default:
+          throw new Error(`Unexpected type: ${type}`);
+      }
+    }
+
+    return {
+      type,
+      config: getConfig(type),
+      uid: object["uid"],
+      status:
+        object["status"] != null
+          ? DestinationStatusInSerializer._fromJsonObject(object["status"])
+          : undefined,
+      batchSize: object["batchSize"],
+      maxWaitSecs: object["maxWaitSecs"],
+      eventTypes: object["eventTypes"],
+      channels: object["channels"],
+      metadata: object["metadata"],
+    };
+  },
+
+  _toJsonObject(self: DestinationIn): any {
+    // biome-ignore lint/suspicious/noImplicitAnyLet: the return type needs to be any
+    let config;
+    switch (self.type) {
+      case "pollingEndpoint":
+        config = {};
+        break;
+      case "azureBlobStorage":
+        config = AzureBlobStorageConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "otelTracing":
+        config = OtelTracingConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "fifoEndpoint":
+        config = FifoEndpointConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "amazonS3":
+        config = S3ConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "googleCloudStorage":
+        config = GoogleCloudStorageConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "googleCloudPubSub":
+        config = GoogleCloudPubSubConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "sqs":
+        config = SqsConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "sns":
+        config = SnsConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "bigQuery":
+        config = BigQueryConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "clickhouse":
+        config = ClickhouseConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "eventBridge":
+        config = EventBridgeConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "snowflake":
+        config = SnowflakeConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "rabbitMq":
+        config = RabbitMqConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "redshift":
+        config = RedshiftConfigInSerializer._toJsonObject(self.config);
+        break;
+      case "postgres":
+        config = PostgresConfigInSerializer._toJsonObject(self.config);
+        break;
+    }
+
+    return {
+      type: self.type,
+      config: config,
+      uid: self.uid,
+      status:
+        self.status != null
+          ? DestinationStatusInSerializer._toJsonObject(self.status)
+          : undefined,
+      batchSize: self.batchSize,
+      maxWaitSecs: self.maxWaitSecs,
+      eventTypes: self.eventTypes,
+      channels: self.channels,
+      metadata: self.metadata,
+    };
+  },
+};