@s2-dev/streamstore 0.14.0 → 0.15.1

package/src/models/components/readevent.ts

@@ -19,24 +19,40 @@ import {
   ReadBatch$Outbound,
   ReadBatch$outboundSchema,
 } from "./readbatch.js";
+import {
+  TailResponse,
+  TailResponse$inboundSchema,
+  TailResponse$Outbound,
+  TailResponse$outboundSchema,
+} from "./tailresponse.js";
 
-export const ReadEvent3Event = {
+export const ReadEvent4Event = {
   Ping: "ping",
 } as const;
-export type ReadEvent3Event = ClosedEnum<typeof ReadEvent3Event>;
+export type ReadEvent4Event = ClosedEnum<typeof ReadEvent4Event>;
 
 export type Ping = {
   data: PingEventData;
-  event: ReadEvent3Event;
+  event: ReadEvent4Event;
 };
 
-export const ReadEventEvent = {
+export const ReadEvent3Event = {
   Error: "error",
 } as const;
-export type ReadEventEvent = ClosedEnum<typeof ReadEventEvent>;
+export type ReadEvent3Event = ClosedEnum<typeof ReadEvent3Event>;
 
 export type ErrorT = {
   data: string;
+  event: ReadEvent3Event;
+};
+
+export const ReadEventEvent = {
+  Tail: "tail",
+} as const;
+export type ReadEventEvent = ClosedEnum<typeof ReadEventEvent>;
+
+export type ReadEvent2 = {
+  data: TailResponse;
   event: ReadEventEvent;
 };
 
@@ -51,27 +67,27 @@ export type Batch = {
   id: string;
 };
 
-export type ReadEvent = ErrorT | Ping | Batch;
+export type ReadEvent = ReadEvent2 | ErrorT | Ping | Batch;
 
 /** @internal */
-export const ReadEvent3Event$inboundSchema: z.ZodNativeEnum<
-  typeof ReadEvent3Event
-> = z.nativeEnum(ReadEvent3Event);
+export const ReadEvent4Event$inboundSchema: z.ZodNativeEnum<
+  typeof ReadEvent4Event
+> = z.nativeEnum(ReadEvent4Event);
 
 /** @internal */
-export const ReadEvent3Event$outboundSchema: z.ZodNativeEnum<
-  typeof ReadEvent3Event
-> = ReadEvent3Event$inboundSchema;
+export const ReadEvent4Event$outboundSchema: z.ZodNativeEnum<
+  typeof ReadEvent4Event
+> = ReadEvent4Event$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 ReadEvent4Event$ {
+  /** @deprecated use `ReadEvent4Event$inboundSchema` instead. */
+  export const inboundSchema = ReadEvent4Event$inboundSchema;
+  /** @deprecated use `ReadEvent4Event$outboundSchema` instead. */
+  export const outboundSchema = ReadEvent4Event$outboundSchema;
 }
 
 /** @internal */
@@ -88,7 +104,7 @@ export const Ping$inboundSchema: z.ZodType<Ping, z.ZodTypeDef, unknown> = z
         return z.NEVER;
       }
     }).pipe(PingEventData$inboundSchema),
-    event: ReadEvent3Event$inboundSchema,
+    event: ReadEvent4Event$inboundSchema,
   });
 
 /** @internal */
@@ -101,7 +117,7 @@ export type Ping$Outbound = {
 export const Ping$outboundSchema: z.ZodType<Ping$Outbound, z.ZodTypeDef, Ping> =
   z.object({
     data: PingEventData$outboundSchema,
-    event: ReadEvent3Event$outboundSchema,
+    event: ReadEvent4Event$outboundSchema,
   });
 
 /**
@@ -132,31 +148,31 @@ export function pingFromJSON(
 }
 
 /** @internal */
-export const ReadEventEvent$inboundSchema: z.ZodNativeEnum<
-  typeof ReadEventEvent
-> = z.nativeEnum(ReadEventEvent);
+export const ReadEvent3Event$inboundSchema: z.ZodNativeEnum<
+  typeof ReadEvent3Event
+> = z.nativeEnum(ReadEvent3Event);
 
 /** @internal */
-export const ReadEventEvent$outboundSchema: z.ZodNativeEnum<
-  typeof ReadEventEvent
-> = ReadEventEvent$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 ReadEventEvent$ {
-  /** @deprecated use `ReadEventEvent$inboundSchema` instead. */
-  export const inboundSchema = ReadEventEvent$inboundSchema;
-  /** @deprecated use `ReadEventEvent$outboundSchema` instead. */
-  export const outboundSchema = ReadEventEvent$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 */
 export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> = z
   .object({
     data: z.string(),
-    event: ReadEventEvent$inboundSchema,
+    event: ReadEvent3Event$inboundSchema,
   });
 
 /** @internal */
@@ -172,7 +188,7 @@ export const ErrorT$outboundSchema: z.ZodType<
   ErrorT
 > = z.object({
   data: z.string(),
-  event: ReadEventEvent$outboundSchema,
+  event: ReadEvent3Event$outboundSchema,
 });
 
 /**
@@ -202,6 +218,90 @@ 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,
@@ -291,6 +391,7 @@ export const ReadEvent$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
+  z.lazy(() => ReadEvent2$inboundSchema),
   z.lazy(() => ErrorT$inboundSchema),
   z.lazy(() => Ping$inboundSchema),
   z.lazy(() => Batch$inboundSchema),
@@ -298,6 +399,7 @@ export const ReadEvent$inboundSchema: z.ZodType<
 
 /** @internal */
 export type ReadEvent$Outbound =
+  | ReadEvent2$Outbound
   | ErrorT$Outbound
   | Ping$Outbound
   | Batch$Outbound;
@@ -308,6 +410,7 @@ export const ReadEvent$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ReadEvent
 > = z.union([
+  z.lazy(() => ReadEvent2$outboundSchema),
   z.lazy(() => ErrorT$outboundSchema),
   z.lazy(() => Ping$outboundSchema),
   z.lazy(() => Batch$outboundSchema),

package/src/models/components/scalar.ts

@@ -0,0 +1,78 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  MetricUnit,
+  MetricUnit$inboundSchema,
+  MetricUnit$outboundSchema,
+} from "./metricunit.js";
+
+export type Scalar = {
+  /**
+   * Metric name.
+   */
+  name: string;
+  unit: MetricUnit;
+  /**
+   * Metric value.
+   */
+  value: number;
+};
+
+/** @internal */
+export const Scalar$inboundSchema: z.ZodType<Scalar, z.ZodTypeDef, unknown> = z
+  .object({
+    name: z.string(),
+    unit: MetricUnit$inboundSchema,
+    value: z.number(),
+  });
+
+/** @internal */
+export type Scalar$Outbound = {
+  name: string;
+  unit: string;
+  value: number;
+};
+
+/** @internal */
+export const Scalar$outboundSchema: z.ZodType<
+  Scalar$Outbound,
+  z.ZodTypeDef,
+  Scalar
+> = z.object({
+  name: z.string(),
+  unit: MetricUnit$outboundSchema,
+  value: z.number(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Scalar$ {
+  /** @deprecated use `Scalar$inboundSchema` instead. */
+  export const inboundSchema = Scalar$inboundSchema;
+  /** @deprecated use `Scalar$outboundSchema` instead. */
+  export const outboundSchema = Scalar$outboundSchema;
+  /** @deprecated use `Scalar$Outbound` instead. */
+  export type Outbound = Scalar$Outbound;
+}
+
+export function scalarToJSON(scalar: Scalar): string {
+  return JSON.stringify(Scalar$outboundSchema.parse(scalar));
+}
+
+export function scalarFromJSON(
+  jsonString: string,
+): SafeParseResult<Scalar, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Scalar$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Scalar' from JSON`,
+  );
+}

package/src/models/components/timeseriesinterval.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const TimeseriesInterval = {
+  Minute: "minute",
+  Hour: "hour",
+  Day: "day",
+} as const;
+export type TimeseriesInterval = ClosedEnum<typeof TimeseriesInterval>;
+
+/** @internal */
+export const TimeseriesInterval$inboundSchema: z.ZodNativeEnum<
+  typeof TimeseriesInterval
+> = z.nativeEnum(TimeseriesInterval);
+
+/** @internal */
+export const TimeseriesInterval$outboundSchema: z.ZodNativeEnum<
+  typeof TimeseriesInterval
+> = TimeseriesInterval$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace TimeseriesInterval$ {
+  /** @deprecated use `TimeseriesInterval$inboundSchema` instead. */
+  export const inboundSchema = TimeseriesInterval$inboundSchema;
+  /** @deprecated use `TimeseriesInterval$outboundSchema` instead. */
+  export const outboundSchema = TimeseriesInterval$outboundSchema;
+}

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";
@@ -59,14 +62,14 @@ export class SeqNum extends Error {
  * Fencing token did not match.
  *
  * @remarks
- * The expected fencing token is returned, encoded with base64.
+ * The expected fencing token is returned.
  */
 export type FencingTokenData = {
   /**
    * Fencing token did not match.
    *
    * @remarks
-   * The expected fencing token is returned, encoded with base64.
+   * The expected fencing token is returned.
    */
   fencingTokenMismatch: string;
 };
@@ -75,27 +78,29 @@ export type FencingTokenData = {
  * Fencing token did not match.
  *
  * @remarks
- * The expected fencing token is returned, encoded with base64.
+ * The expected fencing token is returned.
  */
-export class FencingToken extends Error {
+export class FencingToken extends S2Error {
   /**
    * Fencing token did not match.
    *
    * @remarks
-   * The expected fencing token is returned, encoded with base64.
+   * The expected fencing token is returned.
    */
   fencingTokenMismatch: string;
 
   /** 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";
@@ -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();
+    }
+  }
+}