@s2-dev/streamstore 0.15.0 → 0.15.2

package/src/models/components/readbatch.ts

@@ -12,9 +12,22 @@ import {
   SequencedRecord$Outbound,
   SequencedRecord$outboundSchema,
 } from "./sequencedrecord.js";
+import {
+  StreamPosition,
+  StreamPosition$inboundSchema,
+  StreamPosition$Outbound,
+  StreamPosition$outboundSchema,
+} from "./streamposition.js";
 
 export type ReadBatch = {
+  /**
+   * Records that are durably sequenced on the stream, retrieved based on the requested criteria.
+   *
+   * @remarks
+   * This can only be empty in response to a regular (non-SSE) read, if the request cannot be satisfied without violating an explicit limit.
+   */
   records: Array<SequencedRecord>;
+  tail?: StreamPosition | null | undefined;
 };
 
 /** @internal */
@@ -24,11 +37,13 @@ export const ReadBatch$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   records: z.array(SequencedRecord$inboundSchema),
+  tail: z.nullable(StreamPosition$inboundSchema).optional(),
 });
 
 /** @internal */
 export type ReadBatch$Outbound = {
   records: Array<SequencedRecord$Outbound>;
+  tail?: StreamPosition$Outbound | null | undefined;
 };
 
 /** @internal */
@@ -38,6 +53,7 @@ export const ReadBatch$outboundSchema: z.ZodType<
   ReadBatch
 > = z.object({
   records: z.array(SequencedRecord$outboundSchema),
+  tail: z.nullable(StreamPosition$outboundSchema).optional(),
 });
 
 /**

package/src/models/components/readevent.ts

@@ -19,40 +19,24 @@ import {
   ReadBatch$Outbound,
   ReadBatch$outboundSchema,
 } from "./readbatch.js";
-import {
-  TailResponse,
-  TailResponse$inboundSchema,
-  TailResponse$Outbound,
-  TailResponse$outboundSchema,
-} from "./tailresponse.js";
 
-export const ReadEvent4Event = {
+export const ReadEvent3Event = {
   Ping: "ping",
 } as const;
-export type ReadEvent4Event = ClosedEnum<typeof ReadEvent4Event>;
+export type ReadEvent3Event = ClosedEnum<typeof ReadEvent3Event>;
 
 export type Ping = {
   data: PingEventData;
-  event: ReadEvent4Event;
-};
-
-export const ReadEvent3Event = {
-  Error: "error",
-} as const;
-export type ReadEvent3Event = ClosedEnum<typeof ReadEvent3Event>;
-
-export type ErrorT = {
-  data: string;
   event: ReadEvent3Event;
 };
 
 export const ReadEventEvent = {
-  Tail: "tail",
+  Error: "error",
 } as const;
 export type ReadEventEvent = ClosedEnum<typeof ReadEventEvent>;
 
-export type ReadEvent2 = {
-  data: TailResponse;
+export type ErrorT = {
+  data: string;
   event: ReadEventEvent;
 };
 
@@ -67,27 +51,27 @@ export type Batch = {
   id: string;
 };
 
-export type ReadEvent = ReadEvent2 | ErrorT | Ping | Batch;
+export type ReadEvent = Batch | ErrorT | Ping;
 
 /** @internal */
-export const ReadEvent4Event$inboundSchema: z.ZodNativeEnum<
-  typeof ReadEvent4Event
-> = z.nativeEnum(ReadEvent4Event);
+export const ReadEvent3Event$inboundSchema: z.ZodNativeEnum<
+  typeof ReadEvent3Event
+> = z.nativeEnum(ReadEvent3Event);
 
 /** @internal */
-export const ReadEvent4Event$outboundSchema: z.ZodNativeEnum<
-  typeof ReadEvent4Event
-> = ReadEvent4Event$inboundSchema;
+export const ReadEvent3Event$outboundSchema: z.ZodNativeEnum<
+  typeof ReadEvent3Event
+> = ReadEvent3Event$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ReadEvent4Event$ {
-  /** @deprecated use `ReadEvent4Event$inboundSchema` instead. */
-  export const inboundSchema = ReadEvent4Event$inboundSchema;
-  /** @deprecated use `ReadEvent4Event$outboundSchema` instead. */
-  export const outboundSchema = ReadEvent4Event$outboundSchema;
+export namespace ReadEvent3Event$ {
+  /** @deprecated use `ReadEvent3Event$inboundSchema` instead. */
+  export const inboundSchema = ReadEvent3Event$inboundSchema;
+  /** @deprecated use `ReadEvent3Event$outboundSchema` instead. */
+  export const outboundSchema = ReadEvent3Event$outboundSchema;
 }
 
 /** @internal */
@@ -104,7 +88,7 @@ export const Ping$inboundSchema: z.ZodType<Ping, z.ZodTypeDef, unknown> = z
         return z.NEVER;
       }
     }).pipe(PingEventData$inboundSchema),
-    event: ReadEvent4Event$inboundSchema,
+    event: ReadEvent3Event$inboundSchema,
   });
 
 /** @internal */
@@ -117,7 +101,7 @@ export type Ping$Outbound = {
 export const Ping$outboundSchema: z.ZodType<Ping$Outbound, z.ZodTypeDef, Ping> =
   z.object({
     data: PingEventData$outboundSchema,
-    event: ReadEvent4Event$outboundSchema,
+    event: ReadEvent3Event$outboundSchema,
   });
 
 /**
@@ -148,31 +132,31 @@ export function pingFromJSON(
 }
 
 /** @internal */
-export const ReadEvent3Event$inboundSchema: z.ZodNativeEnum<
-  typeof ReadEvent3Event
-> = z.nativeEnum(ReadEvent3Event);
+export const ReadEventEvent$inboundSchema: z.ZodNativeEnum<
+  typeof ReadEventEvent
+> = z.nativeEnum(ReadEventEvent);
 
 /** @internal */
-export const ReadEvent3Event$outboundSchema: z.ZodNativeEnum<
-  typeof ReadEvent3Event
-> = ReadEvent3Event$inboundSchema;
+export const ReadEventEvent$outboundSchema: z.ZodNativeEnum<
+  typeof ReadEventEvent
+> = ReadEventEvent$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ReadEvent3Event$ {
-  /** @deprecated use `ReadEvent3Event$inboundSchema` instead. */
-  export const inboundSchema = ReadEvent3Event$inboundSchema;
-  /** @deprecated use `ReadEvent3Event$outboundSchema` instead. */
-  export const outboundSchema = ReadEvent3Event$outboundSchema;
+export namespace ReadEventEvent$ {
+  /** @deprecated use `ReadEventEvent$inboundSchema` instead. */
+  export const inboundSchema = ReadEventEvent$inboundSchema;
+  /** @deprecated use `ReadEventEvent$outboundSchema` instead. */
+  export const outboundSchema = ReadEventEvent$outboundSchema;
 }
 
 /** @internal */
 export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> = z
   .object({
     data: z.string(),
-    event: ReadEvent3Event$inboundSchema,
+    event: ReadEventEvent$inboundSchema,
   });
 
 /** @internal */
@@ -188,7 +172,7 @@ export const ErrorT$outboundSchema: z.ZodType<
   ErrorT
 > = z.object({
   data: z.string(),
-  event: ReadEvent3Event$outboundSchema,
+  event: ReadEventEvent$outboundSchema,
 });
 
 /**
@@ -218,90 +202,6 @@ export function errorFromJSON(
   );
 }
 
-/** @internal */
-export const ReadEventEvent$inboundSchema: z.ZodNativeEnum<
-  typeof ReadEventEvent
-> = z.nativeEnum(ReadEventEvent);
-
-/** @internal */
-export const ReadEventEvent$outboundSchema: z.ZodNativeEnum<
-  typeof ReadEventEvent
-> = ReadEventEvent$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ReadEventEvent$ {
-  /** @deprecated use `ReadEventEvent$inboundSchema` instead. */
-  export const inboundSchema = ReadEventEvent$inboundSchema;
-  /** @deprecated use `ReadEventEvent$outboundSchema` instead. */
-  export const outboundSchema = ReadEventEvent$outboundSchema;
-}
-
-/** @internal */
-export const ReadEvent2$inboundSchema: z.ZodType<
-  ReadEvent2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  data: z.string().transform((v, ctx) => {
-    try {
-      return JSON.parse(v);
-    } catch (err) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `malformed json: ${err}`,
-      });
-      return z.NEVER;
-    }
-  }).pipe(TailResponse$inboundSchema),
-  event: ReadEventEvent$inboundSchema,
-});
-
-/** @internal */
-export type ReadEvent2$Outbound = {
-  data: TailResponse$Outbound;
-  event: string;
-};
-
-/** @internal */
-export const ReadEvent2$outboundSchema: z.ZodType<
-  ReadEvent2$Outbound,
-  z.ZodTypeDef,
-  ReadEvent2
-> = z.object({
-  data: TailResponse$outboundSchema,
-  event: ReadEventEvent$outboundSchema,
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ReadEvent2$ {
-  /** @deprecated use `ReadEvent2$inboundSchema` instead. */
-  export const inboundSchema = ReadEvent2$inboundSchema;
-  /** @deprecated use `ReadEvent2$outboundSchema` instead. */
-  export const outboundSchema = ReadEvent2$outboundSchema;
-  /** @deprecated use `ReadEvent2$Outbound` instead. */
-  export type Outbound = ReadEvent2$Outbound;
-}
-
-export function readEvent2ToJSON(readEvent2: ReadEvent2): string {
-  return JSON.stringify(ReadEvent2$outboundSchema.parse(readEvent2));
-}
-
-export function readEvent2FromJSON(
-  jsonString: string,
-): SafeParseResult<ReadEvent2, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ReadEvent2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ReadEvent2' from JSON`,
-  );
-}
-
 /** @internal */
 export const Event$inboundSchema: z.ZodNativeEnum<typeof Event> = z.nativeEnum(
   Event,
@@ -391,18 +291,16 @@ export const ReadEvent$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => ReadEvent2$inboundSchema),
+  z.lazy(() => Batch$inboundSchema),
   z.lazy(() => ErrorT$inboundSchema),
   z.lazy(() => Ping$inboundSchema),
-  z.lazy(() => Batch$inboundSchema),
 ]);
 
 /** @internal */
 export type ReadEvent$Outbound =
-  | ReadEvent2$Outbound
+  | Batch$Outbound
   | ErrorT$Outbound
-  | Ping$Outbound
-  | Batch$Outbound;
+  | Ping$Outbound;
 
 /** @internal */
 export const ReadEvent$outboundSchema: z.ZodType<
@@ -410,10 +308,9 @@ export const ReadEvent$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ReadEvent
 > = z.union([
-  z.lazy(() => ReadEvent2$outboundSchema),
+  z.lazy(() => Batch$outboundSchema),
   z.lazy(() => ErrorT$outboundSchema),
   z.lazy(() => Ping$outboundSchema),
-  z.lazy(() => Batch$outboundSchema),
 ]);
 
 /**

package/src/models/components/retentionpolicy.ts

@@ -7,7 +7,19 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+/**
+ * Age in seconds for automatic trimming of records older than this threshold.
+ *
+ * @remarks
+ * If this is set to 0, the stream will have infinite retention.
+ */
 export type One = {
+  /**
+   * Age in seconds for automatic trimming of records older than this threshold.
+   *
+   * @remarks
+   * If this is set to 0, the stream will have infinite retention.
+   */
   age: number;
 };
 

package/src/models/components/streamposition.ts

@@ -17,7 +17,7 @@ export type StreamPosition = {
    */
   seqNum: number;
   /**
-   * Timestamp, which may be user-specified or assigned by the service.
+   * Timestamp, which may be client-specified or assigned by the service.
    *
    * @remarks
    * If it is assigned by the service, it will represent milliseconds since Unix epoch.

package/src/models/components/timestampingconfig.ts

@@ -18,7 +18,7 @@ export type TimestampingConfig = {
    * Allow client-specified timestamps to exceed the arrival time.
    *
    * @remarks
-   * If this is false or not set, client timestamps will be capped at the arrival time.
+   * If this is `false` or not set, client timestamps will be capped at the arrival time.
    */
   uncapped?: boolean | null | undefined;
 };

package/src/models/errors/apierror.ts

@@ -2,26 +2,33 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-export class APIError extends Error {
-  public readonly statusCode: number;
-  public readonly contentType: string;
+import { S2Error } from "./s2error.js";
 
+/** The fallback error class if no more specific error class is matched */
+export class APIError extends S2Error {
   constructor(
     message: string,
-    public readonly rawResponse: Response,
-    public readonly body: string = "",
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
   ) {
-    const statusCode = rawResponse.status;
-    const contentType = rawResponse.headers.get("content-type") || "";
-    const bodyString = body.length > 0 ? `\n${body}` : "";
-
-    super(
-      `${message}: Status ${statusCode} Content-Type ${contentType} Body ${bodyString}`,
-    );
-
-    this.statusCode = statusCode;
-    this.contentType = contentType;
-
+    if (message) {
+      message += `: `;
+    }
+    message += `Status ${httpMeta.response.status}`;
+    const contentType = httpMeta.response.headers.get("content-type") || `""`;
+    if (contentType !== "application/json") {
+      message += ` Content-Type ${
+        contentType.includes(" ") ? `"${contentType}"` : contentType
+      }`;
+    }
+    const body = httpMeta.body || `""`;
+    message += body.length > 100 ? "\n" : " ";
+    message += `Body ${body}`;
+    message = message.trim();
+    super(message, httpMeta);
     this.name = "APIError";
   }
 }

package/src/models/errors/appendconditionfailed.ts

@@ -6,6 +6,7 @@ import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { S2Error } from "./s2error.js";
 import { SDKValidationError } from "./sdkvalidationerror.js";
 
 /**
@@ -30,7 +31,7 @@ export type SeqNumData = {
  * @remarks
  * The expected next sequence number is returned.
  */
-export class SeqNum extends Error {
+export class SeqNum extends S2Error {
   /**
    * Sequence number did not match the tail of the stream.
    *
@@ -42,13 +43,15 @@ export class SeqNum extends Error {
   /** The original data that was passed to this error instance. */
   data$: SeqNumData;
 
-  constructor(err: SeqNumData) {
+  constructor(
+    err: SeqNumData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.seqNumMismatch = err.seqNumMismatch;
 
     this.name = "SeqNum";
@@ -77,7 +80,7 @@ export type FencingTokenData = {
  * @remarks
  * The expected fencing token is returned.
  */
-export class FencingToken extends Error {
+export class FencingToken extends S2Error {
   /**
    * Fencing token did not match.
    *
@@ -89,13 +92,15 @@ export class FencingToken extends Error {
   /** The original data that was passed to this error instance. */
   data$: FencingTokenData;
 
-  constructor(err: FencingTokenData) {
+  constructor(
+    err: FencingTokenData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.fencingTokenMismatch = err.fencingTokenMismatch;
 
     this.name = "FencingToken";
@@ -103,7 +108,7 @@ export class FencingToken extends Error {
 }
 
 /**
- * Failure response message when an Append is aborted due to a failed condition.
+ * Aborted due to a failed condition.
  */
 export type AppendConditionFailed = FencingToken | SeqNum;
 
@@ -111,13 +116,20 @@ export type AppendConditionFailed = FencingToken | SeqNum;
 export const SeqNum$inboundSchema: z.ZodType<SeqNum, z.ZodTypeDef, unknown> = z
   .object({
     seq_num_mismatch: z.number().int(),
+    request$: z.instanceof(Request),
+    response$: z.instanceof(Response),
+    body$: z.string(),
   })
   .transform((v) => {
     const remapped = remap$(v, {
       "seq_num_mismatch": "seqNumMismatch",
     });
 
-    return new SeqNum(remapped);
+    return new SeqNum(remapped, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */
@@ -162,13 +174,20 @@ export const FencingToken$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   fencing_token_mismatch: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
     const remapped = remap$(v, {
       "fencing_token_mismatch": "fencingTokenMismatch",
     });
 
-    return new FencingToken(remapped);
+    return new FencingToken(remapped, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/errorresponse.ts

@@ -3,25 +3,28 @@
  */
 
 import * as z from "zod";
+import { S2Error } from "./s2error.js";
 
 export type ErrorResponseData = {
   code?: string | null | undefined;
   message: string;
 };
 
-export class ErrorResponse extends Error {
+export class ErrorResponse extends S2Error {
   code?: string | null | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: ErrorResponseData;
 
-  constructor(err: ErrorResponseData) {
+  constructor(
+    err: ErrorResponseData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     if (err.code != null) this.code = err.code;
 
     this.name = "ErrorResponse";
@@ -36,9 +39,16 @@ export const ErrorResponse$inboundSchema: z.ZodType<
 > = z.object({
   code: z.nullable(z.string()).optional(),
   message: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new ErrorResponse(v);
+    return new ErrorResponse(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/index.ts

@@ -6,5 +6,6 @@ export * from "./apierror.js";
 export * from "./appendconditionfailed.js";
 export * from "./errorresponse.js";
 export * from "./httpclienterrors.js";
+export * from "./responsevalidationerror.js";
 export * from "./sdkvalidationerror.js";
 export * from "./tailresponse.js";

package/src/models/errors/responsevalidationerror.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { S2Error } from "./s2error.js";
+import { formatZodError } from "./sdkvalidationerror.js";
+
+export class ResponseValidationError extends S2Error {
+  /**
+   * The raw value that failed validation.
+   */
+  public readonly rawValue: unknown;
+
+  /**
+   * The raw message that failed validation.
+   */
+  public readonly rawMessage: unknown;
+
+  constructor(
+    message: string,
+    extra: {
+      response: Response;
+      request: Request;
+      body: string;
+      cause: unknown;
+      rawValue: unknown;
+      rawMessage: unknown;
+    },
+  ) {
+    super(message, extra);
+    this.name = "ResponseValidationError";
+    this.cause = extra.cause;
+    this.rawValue = extra.rawValue;
+    this.rawMessage = extra.rawMessage;
+  }
+
+  /**
+   * Return a pretty-formatted error message if the underlying validation error
+   * is a ZodError or some other recognized error type, otherwise return the
+   * default error message.
+   */
+  public pretty(): string {
+    if (this.cause instanceof z.ZodError) {
+      return `${this.rawMessage}\n${formatZodError(this.cause)}`;
+    } else {
+      return this.toString();
+    }
+  }
+}

package/src/models/errors/s2error.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/** The base class for all HTTP error responses */
+export class S2Error extends Error {
+  /** HTTP status code */
+  public readonly statusCode: number;
+  /** HTTP body */
+  public readonly body: string;
+  /** HTTP headers */
+  public readonly headers: Headers;
+  /** HTTP content type */
+  public readonly contentType: string;
+  /** Raw response */
+  public readonly rawResponse: Response;
+
+  constructor(
+    message: string,
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
+  ) {
+    super(message);
+    this.statusCode = httpMeta.response.status;
+    this.body = httpMeta.body;
+    this.headers = httpMeta.response.headers;
+    this.contentType = httpMeta.response.headers.get("content-type") || "";
+    this.rawResponse = httpMeta.response;
+
+    this.name = "S2Error";
+  }
+}