@s2-dev/streamstore 0.3.9 → 0.3.13

package/src/funcs/streamCheckTail.ts

@@ -10,6 +10,7 @@ import { safeParse } from "../lib/schemas.js";
 import { RequestOptions } from "../lib/sdks.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
+import * as components from "../models/components/index.js";
 import { APIError } from "../models/errors/apierror.js";
 import {
   ConnectionError,
@@ -36,9 +37,10 @@ export async function streamCheckTail(
   options?: RequestOptions,
 ): Promise<
   Result<
-    operations.CheckTailResponse,
-    | errors.ErrorResponse
+    components.CheckTailResponse,
     | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -110,7 +112,7 @@ export async function streamCheckTail(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "404", "4XX", "500", "5XX"],
+    errorCodes: ["400", "401", "404", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });
@@ -124,9 +126,10 @@ export async function streamCheckTail(
   };
 
   const [result] = await M.match<
-    operations.CheckTailResponse,
-    | errors.ErrorResponse
+    components.CheckTailResponse,
     | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -135,14 +138,13 @@ export async function streamCheckTail(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, operations.CheckTailResponse$inboundSchema, {
-      key: "CheckTailResponse",
-    }),
+    M.json(200, components.CheckTailResponse$inboundSchema),
     M.jsonErr([400, 401, 404], errors.ErrorResponse$inboundSchema),
-    M.jsonErr(500, errors.ErrorResponse$inboundSchema),
+    M.jsonErr(499, errors.RetryableError$inboundSchema),
+    M.jsonErr([500, 503, 504], errors.RetryableError$inboundSchema),
     M.fail("4XX"),
     M.fail("5XX"),
-  )(response, req, { extraFields: responseFields });
+  )(response, { extraFields: responseFields });
   if (!result.ok) {
     return result;
   }

package/src/funcs/streamRead.ts

@@ -43,7 +43,8 @@ export async function streamRead(
   Result<
     operations.ReadResponse,
     | errors.ErrorResponse
-    | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -126,7 +127,7 @@ export async function streamRead(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "404", "4XX", "500", "5XX"],
+    errorCodes: ["400", "401", "404", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });
@@ -142,7 +143,8 @@ export async function streamRead(
   const [result] = await M.match<
     operations.ReadResponse,
     | errors.ErrorResponse
-    | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -151,13 +153,14 @@ export async function streamRead(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, operations.ReadResponse$inboundSchema, { key: "Output" }),
-    M.sse(200, operations.ReadResponse$inboundSchema, { key: "ReadResponse" }),
+    M.json(200, operations.ReadResponse$inboundSchema),
+    M.sse(200, operations.ReadResponse$inboundSchema),
     M.jsonErr([400, 401, 404], errors.ErrorResponse$inboundSchema),
-    M.jsonErr(500, errors.ErrorResponse$inboundSchema),
+    M.jsonErr(499, errors.RetryableError$inboundSchema),
+    M.jsonErr([500, 503, 504], errors.RetryableError$inboundSchema),
     M.fail("4XX"),
     M.fail("5XX"),
-  )(response, req, { extraFields: responseFields });
+  )(response, { extraFields: responseFields });
   if (!result.ok) {
     return result;
   }

package/src/index.extras.ts

@@ -14,7 +14,7 @@ import {
     StreamConfig,
     StreamInfo,
 } from "./models/components";
-import { ErrorResponse, NotFoundError } from "./models/errors";
+import { NotFoundError, RetryableError } from "./models/errors";
 import {
     GetBasinConfigRequest,
     ListBasinsRequest,
@@ -66,13 +66,24 @@ export type S2ClientConfig = {
     authToken?: string;
     requestTimeout?: number;
     endpoints?: S2Endpoints;
+    appedRetryPolicy?: AppendRetryPolicy;
+    maxRetries?: number;
+    initialBackoffMs?: number;
+    maxBackoffMs?: number;
 };
 
+export enum AppendRetryPolicy {
+    All,
+    NoSideEffects,
+}
+
 const defaultS2ClientConfig: S2ClientConfig = {
     requestTimeout: 3000,
     endpoints: S2Endpoints.forCloud(S2Cloud.Aws),
+    appedRetryPolicy: AppendRetryPolicy.All,
 };
 
+
 export class S2Client {
     private config: S2ClientConfig;
     private _account?: S2Account;
@@ -116,15 +127,23 @@ class S2Account {
         request?: ListBasinsRequest
     ): Promise<PageIterator<ListBasinsResponse, { cursor: string }>> {
         const url = this.URL;
-        return this._account.listBasins(request ?? {}, url ? { serverURL: url } : {});
+        return retryWithExponentialBackoff(
+            () => this._account.listBasins(request ?? {}, url ? { serverURL: url } : {}),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
     async getBasinConfig(basin: string): Promise<BasinConfig | undefined> {
         const _request: GetBasinConfigRequest = { basin };
         const url = this.URL;
-        return (await this._account.getBasinConfig(_request
-            , url ? { serverURL: url } : {}
-        )).basinConfig;
+        return retryWithExponentialBackoff(
+            () => this._account.getBasinConfig(_request, url ? { serverURL: url } : {}),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
     async createBasin(basin: string, request?: CreateBasinRequest): Promise<BasinInfo | undefined> {
@@ -134,14 +153,22 @@ class S2Account {
             createBasinRequest: request ?? {},
         };
         const url = this.URL;
-        return (await this._account.createBasin(_request,
-            url ? { serverURL: url } : {}
-        )).basinInfo;
+        return retryWithExponentialBackoff(
+            () => this._account.createBasin(_request, url ? { serverURL: url } : {}),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
-    async deleteBasin(basin: string, if_exists?: boolean): Promise<void | undefined> {
+    async deleteBasin(basin: string, if_exists?: boolean): Promise<void> {
         const url = this.URL;
-        const response = await accountDeleteBasin(this._account, { basin }, url ? { serverURL: url } : {});
+        const response = await retryWithExponentialBackoff(
+            () => accountDeleteBasin(this._account, { basin }, url ? { serverURL: url } : {}),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
         if (if_exists && response.error instanceof NotFoundError) return;
         if (response.error) throw new Error(response.error.message);
         return;
@@ -150,9 +177,12 @@ class S2Account {
     async reconfigureBasin(basin: string, config: BasinConfig): Promise<BasinConfig | undefined> {
         const url = this.URL;
         const _request: ReconfigureBasinRequest = { basin, basinConfig: config };
-        return (await this._account.reconfigureBasin(_request
-            , url ? { serverURL: url } : {}
-        )).basinConfig;
+        return retryWithExponentialBackoff(
+            () => this._account.reconfigureBasin(_request, url ? { serverURL: url } : {}),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 }
 
@@ -185,13 +215,21 @@ class S2Basin {
     async listStreams(
         request: ListStreamsRequest
     ): Promise<PageIterator<ListStreamsResponse, { cursor: string }>> {
-        return this._basin.listStreams(request, { serverURL: this.URL });
+        return retryWithExponentialBackoff(
+            () => this._basin.listStreams(request, { serverURL: this.URL }),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
     async getStreamConfig(stream: string): Promise<StreamConfig | undefined> {
-        return (
-            await this._basin.getStreamConfig({ stream }, { serverURL: this.URL })
-        ).streamConfig;
+        return retryWithExponentialBackoff(
+            () => this._basin.getStreamConfig({ stream }, { serverURL: this.URL }),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
     async createStream(stream: string, request?: CreateStreamRequest): Promise<StreamInfo | undefined> {
@@ -200,27 +238,33 @@ class S2Basin {
             s2RequestToken: genS2RequestToken(),
             createStreamRequest: request ?? {},
         };
-        return (
-            await this._basin.createStream(_request, { serverURL: this.URL })
-        ).streamInfo;
+        return retryWithExponentialBackoff(
+            () => this._basin.createStream(_request, { serverURL: this.URL }),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
     async deleteStream(stream: string, if_exists?: boolean): Promise<void | undefined> {
-        const response = await basinDeleteStream(this._basin, { stream }, {
-            serverURL: this.URL,
-        });
+        const response = await retryWithExponentialBackoff(
+            () => basinDeleteStream(this._basin, { stream }, { serverURL: this.URL }),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
         if (if_exists && response instanceof NotFoundError) return;
         if (response.error) throw new Error(response.error.message);
         return;
     }
 
-    async reconfigureStream(stream: string, config: StreamConfig): Promise<StreamConfig | undefined> {
-        return (
-            await this._basin.reconfigureStream(
-                { stream, streamConfig: config },
-                { serverURL: this.URL }
-            )
-        ).streamConfig;
+    async reconfigureStream(stream: string, config: StreamConfig): Promise<StreamConfig> {
+        return retryWithExponentialBackoff(
+            () => this._basin.reconfigureStream({ stream, streamConfig: config }, { serverURL: this.URL }),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 }
 
@@ -245,29 +289,44 @@ class Stream {
         });
     }
 
-    async checkTail(): Promise<CheckTailResponse | undefined> {
+    async checkTail(): Promise<CheckTailResponse> {
         return (
             await this._stream.checkTail({ stream: this.streamName }, { serverURL: this.basinURL })
-        ).checkTailResponse;
+        );
     }
 
-    async append(request: AppendRequest): Promise<AppendOutput | undefined> {
-        return (
-            await this._stream.append({ ...request, stream: this.streamName }, { serverURL: this.basinURL })
-        ).appendOutput;
+    async append(request: AppendRequest): Promise<AppendOutput> {
+        switch (this.config.appedRetryPolicy) {
+            case AppendRetryPolicy.All:
+            case undefined:
+                return retryWithExponentialBackoff(
+                    () => this._stream.append({ ...request, stream: this.streamName }, { serverURL: this.basinURL }),
+                    this.config.maxRetries,
+                    this.config.initialBackoffMs,
+                    this.config.maxBackoffMs
+                );
+            case AppendRetryPolicy.NoSideEffects:
+                return (
+                    await this._stream.append({ ...request, stream: this.streamName }, {
+                        serverURL: this.basinURL,
+                    })
+                );
+            default:
+                throw new Error("Invalid AppendRetryPolicy");
+        }
     }
 
-    async read(request: ReadRequest): Promise<Output | undefined> {
+    async read(request: ReadRequest): Promise<Output> {
         return (
-            await this._stream.read({ ...request, stream: this.streamName }, { serverURL: this.basinURL })
-        ).output;
+            await this._stream.read({ ...request, stream: this.streamName }, { serverURL: this.basinURL }) as Output
+        );
     }
 
     async *readStream(request: ReadRequest): AsyncGenerator<ReadResponse, void, undefined> {
         let currentRequest: ReadRequest = { ...request };
-        let backoffMs = 100;
+        let initialBackoffMs = this.config.initialBackoffMs ?? 100;
         const maxBackoffMs = 5000;
-        const maxRetries = 5;
+        const maxRetries = this.config.maxRetries ?? 5;
         let retryCount = 0;
 
         while (true) {
@@ -281,7 +340,7 @@ class Stream {
                         acceptHeaderOverride: ReadAcceptEnum.textEventStream
                     }
                 );
-                stream = response.readResponse;
+                stream = response as EventStream<ReadResponse>;
                 if (!stream) return;
 
                 for await (const event of stream) {
@@ -310,13 +369,16 @@ class Stream {
                 }
                 return;
             } catch (error) {
-                if (error instanceof ErrorResponse || error instanceof NotFoundError) return;
-                if (retryCount >= maxRetries) {
+                if (error instanceof RetryableError) {
+                    if (retryCount >= maxRetries) {
+                        throw error;
+                    }
+                    retryCount++;
+                    await new Promise(resolve => setTimeout(resolve, initialBackoffMs));
+                    initialBackoffMs = Math.min(initialBackoffMs * 2, maxBackoffMs);
+                } else {
                     throw error;
                 }
-                retryCount++;
-                await new Promise(resolve => setTimeout(resolve, backoffMs));
-                backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
             }
         }
     }
@@ -336,4 +398,33 @@ function meteredBatchSize(batch: SequencedRecordBatch): number {
 
 export function genS2RequestToken(): string {
     return uuidv4().replace(/-/g, "");
-}
+}
+
+async function retryWithExponentialBackoff<T>(
+    operation: () => Promise<T>,
+    maxAttempts: number = 5,
+    initialBackoffMs: number = 100,
+    maxBackoffMs: number = 5000
+): Promise<T> {
+    let attempt = 0;
+
+    while (attempt < maxAttempts) {
+        try {
+            return await operation();
+        } catch (error) {
+            if (error instanceof RetryableError) {
+                attempt++;
+                if (attempt >= maxAttempts) throw error;
+
+                const jitter = Math.random() * 0.3 + 0.85;
+                const delayMs = Math.min(initialBackoffMs * Math.pow(2, attempt) * jitter, maxBackoffMs);
+
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+            } else {
+                throw error;
+            }
+        }
+    }
+
+    throw new Error("Max retry attempts reached");
+}

package/src/lib/config.ts

@@ -54,7 +54,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.3.9",
+  sdkVersion: "0.3.13",
   genVersion: "2.506.0",
-  userAgent: "speakeasy-sdk/typescript 0.3.9 2.506.0 1.0.0 @s2-dev/streamstore",
+  userAgent:
+    "speakeasy-sdk/typescript 0.3.13 2.506.0 1.0.0 @s2-dev/streamstore",
 } as const;

package/src/lib/matchers.ts

@@ -160,7 +160,6 @@ export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[]
   : never;
 export type MatchFunc<T, E> = (
   response: Response,
-  request: Request,
   options?: { resultKey?: string; extraFields?: Record<string, unknown> },
 ) => Promise<[result: Result<T, E>, raw: unknown]>;
 
@@ -169,7 +168,6 @@ export function match<T, E>(
 ): MatchFunc<T, E | APIError | SDKValidationError> {
   return async function matchFunc(
     response: Response,
-    request: Request,
     options?: { resultKey?: string; extraFields?: Record<string, unknown> },
   ): Promise<
     [result: Result<T, E | APIError | SDKValidationError>, raw: unknown]
@@ -191,14 +189,15 @@ export function match<T, E>(
     }
 
     if (!matcher) {
-      await discardResponseBody(response);
+      const responseBody = await response.text();
       return [{
         ok: false,
-        error: new APIError("Unexpected API response status or content-type", {
+        error: new APIError(
+          "Unexpected API response status or content-type",
           response,
-          request,
-        }),
-      }, raw];
+          responseBody,
+        ),
+      }, responseBody];
     }
 
     const encoding = matcher.enc;
@@ -224,7 +223,7 @@ export function match<T, E>(
         raw = await discardResponseBody(response);
         break;
       case "fail":
-        raw = await discardResponseBody(response);
+        raw = await response.text();
         break;
       default:
         encoding satisfies never;
@@ -234,7 +233,11 @@ export function match<T, E>(
     if (matcher.enc === "fail") {
       return [{
         ok: false,
-        error: new APIError("API error occurred", { response, request }),
+        error: new APIError(
+          "API error occurred",
+          response,
+          typeof raw === "string" ? raw : "",
+        ),
       }, raw];
     }
 
@@ -253,11 +256,14 @@ export function match<T, E>(
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
         [resultKey]: raw,
       };
-    } else {
+    } else if (matcher.hdrs) {
       data = {
         ...options?.extraFields,
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
+        ...(isPlainObject(raw) ? raw : null),
       };
+    } else {
+      data = raw;
     }
 
     if ("err" in matcher) {

package/src/models/components/index.ts

@@ -14,7 +14,6 @@ export * from "./createbasinrequest.js";
 export * from "./createstreamrequest.js";
 export * from "./formatoption.js";
 export * from "./header.js";
-export * from "./httpmetadata.js";
 export * from "./listbasinsresponse.js";
 export * from "./liststreamsresponse.js";
 export * from "./output.js";

package/src/models/errors/apierror.ts

@@ -3,19 +3,25 @@
  */
 
 export class APIError extends Error {
+  public readonly statusCode: number;
+  public readonly contentType: string;
+
   constructor(
     message: string,
-    public readonly httpMeta: {
-      response: Response;
-      request: Request;
-    },
+    public readonly rawResponse: Response,
+    public readonly body: string = "",
   ) {
+    const statusCode = rawResponse.status;
+    const contentType = rawResponse.headers.get("content-type") || "";
+    const bodyString = body.length > 0 ? `\n${body}` : "";
+
     super(
-      `${message}: Status ${httpMeta.response.status} Content-Type ${
-        httpMeta.response.headers.get("content-type") || ""
-      }`,
+      `${message}: Status ${statusCode} Content-Type ${contentType} Body ${bodyString}`,
     );
 
+    this.statusCode = statusCode;
+    this.contentType = contentType;
+
     this.name = "APIError";
   }
 }

package/src/models/errors/index.ts

@@ -6,4 +6,5 @@ export * from "./apierror.js";
 export * from "./errorresponse.js";
 export * from "./httpclienterrors.js";
 export * from "./notfounderror.js";
+export * from "./retryableerror.js";
 export * from "./sdkvalidationerror.js";

package/src/models/errors/retryableerror.ts

@@ -0,0 +1,69 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export type RetryableErrorData = {
+  error: string;
+};
+
+export class RetryableError extends Error {
+  error: string;
+
+  /** The original data that was passed to this error instance. */
+  data$: RetryableErrorData;
+
+  constructor(err: RetryableErrorData) {
+    const message = "message" in err && typeof err.message === "string"
+      ? err.message
+      : `API error occurred: ${JSON.stringify(err)}`;
+    super(message);
+    this.data$ = err;
+
+    this.error = err.error;
+
+    this.name = "RetryableError";
+  }
+}
+
+/** @internal */
+export const RetryableError$inboundSchema: z.ZodType<
+  RetryableError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.string(),
+})
+  .transform((v) => {
+    return new RetryableError(v);
+  });
+
+/** @internal */
+export type RetryableError$Outbound = {
+  error: string;
+};
+
+/** @internal */
+export const RetryableError$outboundSchema: z.ZodType<
+  RetryableError$Outbound,
+  z.ZodTypeDef,
+  RetryableError
+> = z.instanceof(RetryableError)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    error: z.string(),
+  }));
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace RetryableError$ {
+  /** @deprecated use `RetryableError$inboundSchema` instead. */
+  export const inboundSchema = RetryableError$inboundSchema;
+  /** @deprecated use `RetryableError$outboundSchema` instead. */
+  export const outboundSchema = RetryableError$outboundSchema;
+  /** @deprecated use `RetryableError$Outbound` instead. */
+  export type Outbound = RetryableError$Outbound;
+}