@s2-dev/streamstore 0.11.2 → 0.12.0

package/src/mcp-server/tools/recordsAppend.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { recordsAppend } from "../../funcs/recordsAppend.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.AppendRequest$inboundSchema,
+};
+
+export const tool$recordsAppend: ToolDefinition<typeof args> = {
+  name: "records-append",
+  description: `Append records.
+
+Append a batch of records to a stream.`,
+  scopes: ["write"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await recordsAppend(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/recordsRead.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { recordsRead } from "../../funcs/recordsRead.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.ReadRequest$inboundSchema,
+};
+
+export const tool$recordsRead: ToolDefinition<typeof args> = {
+  name: "records-read",
+  description: `Retrieve records.
+
+Retrieve a batch of records, or set \`Accept: text/event-stream\` to stream using server-sent events.`,
+  scopes: ["read"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await recordsRead(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/streamsCreateStream.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { streamsCreateStream } from "../../funcs/streamsCreateStream.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.CreateStreamRequest$inboundSchema,
+};
+
+export const tool$streamsCreateStream: ToolDefinition<typeof args> = {
+  name: "streams-create-stream",
+  description: `Create a stream.`,
+  scopes: ["write"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await streamsCreateStream(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/models/components/accesstokeninfo.ts

@@ -24,7 +24,7 @@ export type AccessTokenInfo = {
    */
   autoPrefixStreams?: boolean | undefined;
   /**
-   * Expiration time in seconds since Unix epoch.
+   * Expiration time in ISO 8601 format.
    *
    * @remarks
    * If not set, the expiration will be set to that of the requestor's token.

package/src/models/components/appendack.ts

@@ -0,0 +1,88 @@
+/*
+ * 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 {
+  StreamPosition,
+  StreamPosition$inboundSchema,
+  StreamPosition$Outbound,
+  StreamPosition$outboundSchema,
+} from "./streamposition.js";
+
+/**
+ * Success response message to an Append request.
+ */
+export type AppendAck = {
+  /**
+   * Position of a record in a stream.
+   */
+  end: StreamPosition;
+  /**
+   * Position of a record in a stream.
+   */
+  start: StreamPosition;
+  /**
+   * Position of a record in a stream.
+   */
+  tail: StreamPosition;
+};
+
+/** @internal */
+export const AppendAck$inboundSchema: z.ZodType<
+  AppendAck,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  end: StreamPosition$inboundSchema,
+  start: StreamPosition$inboundSchema,
+  tail: StreamPosition$inboundSchema,
+});
+
+/** @internal */
+export type AppendAck$Outbound = {
+  end: StreamPosition$Outbound;
+  start: StreamPosition$Outbound;
+  tail: StreamPosition$Outbound;
+};
+
+/** @internal */
+export const AppendAck$outboundSchema: z.ZodType<
+  AppendAck$Outbound,
+  z.ZodTypeDef,
+  AppendAck
+> = z.object({
+  end: StreamPosition$outboundSchema,
+  start: StreamPosition$outboundSchema,
+  tail: StreamPosition$outboundSchema,
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AppendAck$ {
+  /** @deprecated use `AppendAck$inboundSchema` instead. */
+  export const inboundSchema = AppendAck$inboundSchema;
+  /** @deprecated use `AppendAck$outboundSchema` instead. */
+  export const outboundSchema = AppendAck$outboundSchema;
+  /** @deprecated use `AppendAck$Outbound` instead. */
+  export type Outbound = AppendAck$Outbound;
+}
+
+export function appendAckToJSON(appendAck: AppendAck): string {
+  return JSON.stringify(AppendAck$outboundSchema.parse(appendAck));
+}
+
+export function appendAckFromJSON(
+  jsonString: string,
+): SafeParseResult<AppendAck, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AppendAck$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AppendAck' from JSON`,
+  );
+}

package/src/models/components/appendinput.ts

@@ -0,0 +1,99 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AppendRecord,
+  AppendRecord$inboundSchema,
+  AppendRecord$Outbound,
+  AppendRecord$outboundSchema,
+} from "./appendrecord.js";
+
+/**
+ * Payload of an Append request message.
+ */
+export type AppendInput = {
+  /**
+   * Enforce a fencing token which must have been previously set by a `fence` command record.
+   */
+  fencingToken?: string | null | undefined;
+  matchSeqNum?: number | null | undefined;
+  /**
+   * Batch of records to append atomically, which must contain at least one record, and no more
+   *
+   * @remarks
+   * than 1000. The total size of a batch of records may not exceed 1MiB of metered bytes.
+   */
+  records: Array<AppendRecord>;
+};
+
+/** @internal */
+export const AppendInput$inboundSchema: z.ZodType<
+  AppendInput,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  fencing_token: z.nullable(z.string()).optional(),
+  match_seq_num: z.nullable(z.number().int()).optional(),
+  records: z.array(AppendRecord$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "fencing_token": "fencingToken",
+    "match_seq_num": "matchSeqNum",
+  });
+});
+
+/** @internal */
+export type AppendInput$Outbound = {
+  fencing_token?: string | null | undefined;
+  match_seq_num?: number | null | undefined;
+  records: Array<AppendRecord$Outbound>;
+};
+
+/** @internal */
+export const AppendInput$outboundSchema: z.ZodType<
+  AppendInput$Outbound,
+  z.ZodTypeDef,
+  AppendInput
+> = z.object({
+  fencingToken: z.nullable(z.string()).optional(),
+  matchSeqNum: z.nullable(z.number().int()).optional(),
+  records: z.array(AppendRecord$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    fencingToken: "fencing_token",
+    matchSeqNum: "match_seq_num",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AppendInput$ {
+  /** @deprecated use `AppendInput$inboundSchema` instead. */
+  export const inboundSchema = AppendInput$inboundSchema;
+  /** @deprecated use `AppendInput$outboundSchema` instead. */
+  export const outboundSchema = AppendInput$outboundSchema;
+  /** @deprecated use `AppendInput$Outbound` instead. */
+  export type Outbound = AppendInput$Outbound;
+}
+
+export function appendInputToJSON(appendInput: AppendInput): string {
+  return JSON.stringify(AppendInput$outboundSchema.parse(appendInput));
+}
+
+export function appendInputFromJSON(
+  jsonString: string,
+): SafeParseResult<AppendInput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AppendInput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AppendInput' from JSON`,
+  );
+}

package/src/models/components/appendrecord.ts

@@ -0,0 +1,85 @@
+/*
+ * 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 {
+  Header,
+  Header$inboundSchema,
+  Header$Outbound,
+  Header$outboundSchema,
+} from "./header.js";
+
+/**
+ * Record to be appended to a stream.
+ */
+export type AppendRecord = {
+  /**
+   * Body of the record.
+   */
+  body?: string | undefined;
+  /**
+   * Series of name-value pairs for this record.
+   */
+  headers?: Array<Header> | undefined;
+  timestamp?: number | null | undefined;
+};
+
+/** @internal */
+export const AppendRecord$inboundSchema: z.ZodType<
+  AppendRecord,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  body: z.string().optional(),
+  headers: z.array(Header$inboundSchema).optional(),
+  timestamp: z.nullable(z.number().int()).optional(),
+});
+
+/** @internal */
+export type AppendRecord$Outbound = {
+  body?: string | undefined;
+  headers?: Array<Header$Outbound> | undefined;
+  timestamp?: number | null | undefined;
+};
+
+/** @internal */
+export const AppendRecord$outboundSchema: z.ZodType<
+  AppendRecord$Outbound,
+  z.ZodTypeDef,
+  AppendRecord
+> = z.object({
+  body: z.string().optional(),
+  headers: z.array(Header$outboundSchema).optional(),
+  timestamp: z.nullable(z.number().int()).optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AppendRecord$ {
+  /** @deprecated use `AppendRecord$inboundSchema` instead. */
+  export const inboundSchema = AppendRecord$inboundSchema;
+  /** @deprecated use `AppendRecord$outboundSchema` instead. */
+  export const outboundSchema = AppendRecord$outboundSchema;
+  /** @deprecated use `AppendRecord$Outbound` instead. */
+  export type Outbound = AppendRecord$Outbound;
+}
+
+export function appendRecordToJSON(appendRecord: AppendRecord): string {
+  return JSON.stringify(AppendRecord$outboundSchema.parse(appendRecord));
+}
+
+export function appendRecordFromJSON(
+  jsonString: string,
+): SafeParseResult<AppendRecord, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AppendRecord$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AppendRecord' from JSON`,
+  );
+}

package/src/models/components/basinconfig.ts

@@ -21,14 +21,14 @@ export type BasinConfig = {
    * @remarks
    * using the default stream configuration.
    */
-  createStreamOnAppend?: boolean | null | undefined;
+  createStreamOnAppend?: boolean | undefined;
   /**
    * Create stream on read if it doesn't exist,
    *
    * @remarks
    * using the default stream configuration.
    */
-  createStreamOnRead?: boolean | null | undefined;
+  createStreamOnRead?: boolean | undefined;
   defaultStreamConfig?: StreamConfig | null | undefined;
 };
 
@@ -38,8 +38,8 @@ export const BasinConfig$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  create_stream_on_append: z.nullable(z.boolean()).optional(),
-  create_stream_on_read: z.nullable(z.boolean()).optional(),
+  create_stream_on_append: z.boolean().optional(),
+  create_stream_on_read: z.boolean().optional(),
   default_stream_config: z.nullable(StreamConfig$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -51,8 +51,8 @@ export const BasinConfig$inboundSchema: z.ZodType<
 
 /** @internal */
 export type BasinConfig$Outbound = {
-  create_stream_on_append?: boolean | null | undefined;
-  create_stream_on_read?: boolean | null | undefined;
+  create_stream_on_append?: boolean | undefined;
+  create_stream_on_read?: boolean | undefined;
   default_stream_config?: StreamConfig$Outbound | null | undefined;
 };
 
@@ -62,8 +62,8 @@ export const BasinConfig$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   BasinConfig
 > = z.object({
-  createStreamOnAppend: z.nullable(z.boolean()).optional(),
-  createStreamOnRead: z.nullable(z.boolean()).optional(),
+  createStreamOnAppend: z.boolean().optional(),
+  createStreamOnRead: z.boolean().optional(),
   defaultStreamConfig: z.nullable(StreamConfig$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/createbasinrequest.ts

@@ -21,6 +21,10 @@ import {
 export type Scope = BasinScope;
 
 export type CreateBasinRequest = {
+  /**
+   * Basin name.
+   */
+  basin: string;
   config?: BasinConfig | null | undefined;
   scope?: BasinScope | undefined;
 };
@@ -72,12 +76,14 @@ export const CreateBasinRequest$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  basin: z.string(),
   config: z.nullable(BasinConfig$inboundSchema).optional(),
   scope: BasinScope$inboundSchema.optional(),
 });
 
 /** @internal */
 export type CreateBasinRequest$Outbound = {
+  basin: string;
   config?: BasinConfig$Outbound | null | undefined;
   scope?: string | undefined;
 };
@@ -88,6 +94,7 @@ export const CreateBasinRequest$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateBasinRequest
 > = z.object({
+  basin: z.string(),
   config: z.nullable(BasinConfig$outboundSchema).optional(),
   scope: BasinScope$outboundSchema.optional(),
 });

package/src/models/components/createorreconfigurebasinrequest.ts

@@ -0,0 +1,138 @@
+/*
+ * 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 {
+  BasinConfig,
+  BasinConfig$inboundSchema,
+  BasinConfig$Outbound,
+  BasinConfig$outboundSchema,
+} from "./basinconfig.js";
+import {
+  BasinScope,
+  BasinScope$inboundSchema,
+  BasinScope$outboundSchema,
+} from "./basinscope.js";
+
+export type CreateOrReconfigureBasinRequestScope = BasinScope;
+
+export type CreateOrReconfigureBasinRequest = {
+  config?: BasinConfig | null | undefined;
+  scope?: BasinScope | undefined;
+};
+
+/** @internal */
+export const CreateOrReconfigureBasinRequestScope$inboundSchema: z.ZodType<
+  CreateOrReconfigureBasinRequestScope,
+  z.ZodTypeDef,
+  unknown
+> = BasinScope$inboundSchema;
+
+/** @internal */
+export type CreateOrReconfigureBasinRequestScope$Outbound = string;
+
+/** @internal */
+export const CreateOrReconfigureBasinRequestScope$outboundSchema: z.ZodType<
+  CreateOrReconfigureBasinRequestScope$Outbound,
+  z.ZodTypeDef,
+  CreateOrReconfigureBasinRequestScope
+> = BasinScope$outboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace CreateOrReconfigureBasinRequestScope$ {
+  /** @deprecated use `CreateOrReconfigureBasinRequestScope$inboundSchema` instead. */
+  export const inboundSchema =
+    CreateOrReconfigureBasinRequestScope$inboundSchema;
+  /** @deprecated use `CreateOrReconfigureBasinRequestScope$outboundSchema` instead. */
+  export const outboundSchema =
+    CreateOrReconfigureBasinRequestScope$outboundSchema;
+  /** @deprecated use `CreateOrReconfigureBasinRequestScope$Outbound` instead. */
+  export type Outbound = CreateOrReconfigureBasinRequestScope$Outbound;
+}
+
+export function createOrReconfigureBasinRequestScopeToJSON(
+  createOrReconfigureBasinRequestScope: CreateOrReconfigureBasinRequestScope,
+): string {
+  return JSON.stringify(
+    CreateOrReconfigureBasinRequestScope$outboundSchema.parse(
+      createOrReconfigureBasinRequestScope,
+    ),
+  );
+}
+
+export function createOrReconfigureBasinRequestScopeFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateOrReconfigureBasinRequestScope, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateOrReconfigureBasinRequestScope$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateOrReconfigureBasinRequestScope' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateOrReconfigureBasinRequest$inboundSchema: z.ZodType<
+  CreateOrReconfigureBasinRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  config: z.nullable(BasinConfig$inboundSchema).optional(),
+  scope: BasinScope$inboundSchema.optional(),
+});
+
+/** @internal */
+export type CreateOrReconfigureBasinRequest$Outbound = {
+  config?: BasinConfig$Outbound | null | undefined;
+  scope?: string | undefined;
+};
+
+/** @internal */
+export const CreateOrReconfigureBasinRequest$outboundSchema: z.ZodType<
+  CreateOrReconfigureBasinRequest$Outbound,
+  z.ZodTypeDef,
+  CreateOrReconfigureBasinRequest
+> = z.object({
+  config: z.nullable(BasinConfig$outboundSchema).optional(),
+  scope: BasinScope$outboundSchema.optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace CreateOrReconfigureBasinRequest$ {
+  /** @deprecated use `CreateOrReconfigureBasinRequest$inboundSchema` instead. */
+  export const inboundSchema = CreateOrReconfigureBasinRequest$inboundSchema;
+  /** @deprecated use `CreateOrReconfigureBasinRequest$outboundSchema` instead. */
+  export const outboundSchema = CreateOrReconfigureBasinRequest$outboundSchema;
+  /** @deprecated use `CreateOrReconfigureBasinRequest$Outbound` instead. */
+  export type Outbound = CreateOrReconfigureBasinRequest$Outbound;
+}
+
+export function createOrReconfigureBasinRequestToJSON(
+  createOrReconfigureBasinRequest: CreateOrReconfigureBasinRequest,
+): string {
+  return JSON.stringify(
+    CreateOrReconfigureBasinRequest$outboundSchema.parse(
+      createOrReconfigureBasinRequest,
+    ),
+  );
+}
+
+export function createOrReconfigureBasinRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateOrReconfigureBasinRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateOrReconfigureBasinRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateOrReconfigureBasinRequest' from JSON`,
+  );
+}

package/src/models/components/createstreamrequest.ts

@@ -0,0 +1,79 @@
+/*
+ * 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 {
+  StreamConfig,
+  StreamConfig$inboundSchema,
+  StreamConfig$Outbound,
+  StreamConfig$outboundSchema,
+} from "./streamconfig.js";
+
+export type CreateStreamRequest = {
+  config?: StreamConfig | null | undefined;
+  /**
+   * Stream name.
+   */
+  stream: string;
+};
+
+/** @internal */
+export const CreateStreamRequest$inboundSchema: z.ZodType<
+  CreateStreamRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  config: z.nullable(StreamConfig$inboundSchema).optional(),
+  stream: z.string(),
+});
+
+/** @internal */
+export type CreateStreamRequest$Outbound = {
+  config?: StreamConfig$Outbound | null | undefined;
+  stream: string;
+};
+
+/** @internal */
+export const CreateStreamRequest$outboundSchema: z.ZodType<
+  CreateStreamRequest$Outbound,
+  z.ZodTypeDef,
+  CreateStreamRequest
+> = z.object({
+  config: z.nullable(StreamConfig$outboundSchema).optional(),
+  stream: 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 CreateStreamRequest$ {
+  /** @deprecated use `CreateStreamRequest$inboundSchema` instead. */
+  export const inboundSchema = CreateStreamRequest$inboundSchema;
+  /** @deprecated use `CreateStreamRequest$outboundSchema` instead. */
+  export const outboundSchema = CreateStreamRequest$outboundSchema;
+  /** @deprecated use `CreateStreamRequest$Outbound` instead. */
+  export type Outbound = CreateStreamRequest$Outbound;
+}
+
+export function createStreamRequestToJSON(
+  createStreamRequest: CreateStreamRequest,
+): string {
+  return JSON.stringify(
+    CreateStreamRequest$outboundSchema.parse(createStreamRequest),
+  );
+}
+
+export function createStreamRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateStreamRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateStreamRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateStreamRequest' from JSON`,
+  );
+}