@kurrent/kurrentdb-client 1.2.0-alpha.0 → 1.2.0

package/generated/kurrentdb/protocols/v2/streams/streams_grpc_pb.d.ts

@@ -10,6 +10,7 @@ import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/stru
 
 interface IStreamsServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
     appendSession: IStreamsServiceService_IAppendSession;
+    appendRecords: IStreamsServiceService_IAppendRecords;
 }
 
 interface IStreamsServiceService_IAppendSession extends grpc.MethodDefinition<kurrentdb_protocols_v2_streams_streams_pb.AppendRequest, kurrentdb_protocols_v2_streams_streams_pb.AppendSessionResponse> {
@@ -21,11 +22,21 @@ interface IStreamsServiceService_IAppendSession extends grpc.MethodDefinition<ku
     responseSerialize: grpc.serialize<kurrentdb_protocols_v2_streams_streams_pb.AppendSessionResponse>;
     responseDeserialize: grpc.deserialize<kurrentdb_protocols_v2_streams_streams_pb.AppendSessionResponse>;
 }
+interface IStreamsServiceService_IAppendRecords extends grpc.MethodDefinition<kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest, kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse> {
+    path: "/kurrentdb.protocol.v2.streams.StreamsService/AppendRecords";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest>;
+    requestDeserialize: grpc.deserialize<kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest>;
+    responseSerialize: grpc.serialize<kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse>;
+    responseDeserialize: grpc.deserialize<kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse>;
+}
 
 export const StreamsServiceService: IStreamsServiceService;
 
 export interface IStreamsServiceServer extends grpc.UntypedServiceImplementation {
     appendSession: grpc.handleClientStreamingCall<kurrentdb_protocols_v2_streams_streams_pb.AppendRequest, kurrentdb_protocols_v2_streams_streams_pb.AppendSessionResponse>;
+    appendRecords: grpc.handleUnaryCall<kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest, kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse>;
 }
 
 export interface IStreamsServiceClient {
@@ -33,6 +44,9 @@ export interface IStreamsServiceClient {
     appendSession(metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendSessionResponse) => void): grpc.ClientWritableStream<kurrentdb_protocols_v2_streams_streams_pb.AppendRequest>;
     appendSession(options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendSessionResponse) => void): grpc.ClientWritableStream<kurrentdb_protocols_v2_streams_streams_pb.AppendRequest>;
     appendSession(metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendSessionResponse) => void): grpc.ClientWritableStream<kurrentdb_protocols_v2_streams_streams_pb.AppendRequest>;
+    appendRecords(request: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse) => void): grpc.ClientUnaryCall;
+    appendRecords(request: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse) => void): grpc.ClientUnaryCall;
+    appendRecords(request: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse) => void): grpc.ClientUnaryCall;
 }
 
 export class StreamsServiceClient extends grpc.Client implements IStreamsServiceClient {
@@ -41,4 +55,7 @@ export class StreamsServiceClient extends grpc.Client implements IStreamsService
     public appendSession(metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendSessionResponse) => void): grpc.ClientWritableStream<kurrentdb_protocols_v2_streams_streams_pb.AppendRequest>;
     public appendSession(options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendSessionResponse) => void): grpc.ClientWritableStream<kurrentdb_protocols_v2_streams_streams_pb.AppendRequest>;
     public appendSession(metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendSessionResponse) => void): grpc.ClientWritableStream<kurrentdb_protocols_v2_streams_streams_pb.AppendRequest>;
+    public appendRecords(request: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse) => void): grpc.ClientUnaryCall;
+    public appendRecords(request: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse) => void): grpc.ClientUnaryCall;
+    public appendRecords(request: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse) => void): grpc.ClientUnaryCall;
 }

package/generated/kurrentdb/protocols/v2/streams/streams_grpc_pb.js

@@ -10,6 +10,28 @@ var grpc = require('@grpc/grpc-js');
 var kurrentdb_protocols_v2_streams_streams_pb = require('../../../../kurrentdb/protocols/v2/streams/streams_pb.js');
 var google_protobuf_struct_pb = require('google-protobuf/google/protobuf/struct_pb.js');
 
+function serialize_kurrentdb_protocol_v2_streams_AppendRecordsRequest(arg) {
+  if (!(arg instanceof kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest)) {
+    throw new Error('Expected argument of type kurrentdb.protocol.v2.streams.AppendRecordsRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_kurrentdb_protocol_v2_streams_AppendRecordsRequest(buffer_arg) {
+  return kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_kurrentdb_protocol_v2_streams_AppendRecordsResponse(arg) {
+  if (!(arg instanceof kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse)) {
+    throw new Error('Expected argument of type kurrentdb.protocol.v2.streams.AppendRecordsResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_kurrentdb_protocol_v2_streams_AppendRecordsResponse(buffer_arg) {
+  return kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_kurrentdb_protocol_v2_streams_AppendRequest(arg) {
   if (!(arg instanceof kurrentdb_protocols_v2_streams_streams_pb.AppendRequest)) {
     throw new Error('Expected argument of type kurrentdb.protocol.v2.streams.AppendRequest');
@@ -64,6 +86,37 @@ appendSession: {
     responseSerialize: serialize_kurrentdb_protocol_v2_streams_AppendSessionResponse,
     responseDeserialize: deserialize_kurrentdb_protocol_v2_streams_AppendSessionResponse,
   },
+  // Appends records to multiple streams atomically with cross-stream consistency checks.
+//
+// This is a unary RPC where the client sends all records and consistency checks
+// in a single request and receives a single AppendRecordsResponse.
+//
+// Records can be interleaved across streams in any order and the global log preserves
+// the exact sequence from the request.
+//
+// Consistency checks are decoupled from writes: a check can reference any stream,
+// whether or not the request writes to it. This enables Dynamic Consistency Boundary
+// (DCB) patterns where a decision depends on multiple streams but only produces
+// events for a subset.
+//
+// Guarantees:
+// - Atomicity: All writes succeed or all fail together
+// - Ordering: Records maintain the exact send order in the global log
+// - Cross-stream checks: Consistency checks can reference any stream
+//
+// On consistency check failure, no records are written and all failing checks
+// are reported in the response so the client can refresh stale state in one round trip.
+appendRecords: {
+    path: '/kurrentdb.protocol.v2.streams.StreamsService/AppendRecords',
+    requestStream: false,
+    responseStream: false,
+    requestType: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsRequest,
+    responseType: kurrentdb_protocols_v2_streams_streams_pb.AppendRecordsResponse,
+    requestSerialize: serialize_kurrentdb_protocol_v2_streams_AppendRecordsRequest,
+    requestDeserialize: deserialize_kurrentdb_protocol_v2_streams_AppendRecordsRequest,
+    responseSerialize: serialize_kurrentdb_protocol_v2_streams_AppendRecordsResponse,
+    responseDeserialize: deserialize_kurrentdb_protocol_v2_streams_AppendRecordsResponse,
+  },
 };
 
 exports.StreamsServiceClient = grpc.makeGenericClientConstructor(StreamsServiceService, 'StreamsService');

package/generated/kurrentdb/protocols/v2/streams/streams_pb.d.ts

@@ -139,6 +139,8 @@ export class AppendRecord extends jspb.Message {
     getData_asU8(): Uint8Array;
     getData_asB64(): string;
     setData(value: Uint8Array | string): AppendRecord;
+    getStream(): string;
+    setStream(value: string): AppendRecord;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): AppendRecord.AsObject;
@@ -157,6 +159,138 @@ export namespace AppendRecord {
         propertiesMap: Array<[string, google_protobuf_struct_pb.Value.AsObject]>,
         schema?: SchemaInfo.AsObject,
         data: Uint8Array | string,
+        stream: string,
+    }
+}
+
+export class AppendRecordsRequest extends jspb.Message { 
+    clearRecordsList(): void;
+    getRecordsList(): Array<AppendRecord>;
+    setRecordsList(value: Array<AppendRecord>): AppendRecordsRequest;
+    addRecords(value?: AppendRecord, index?: number): AppendRecord;
+    clearChecksList(): void;
+    getChecksList(): Array<ConsistencyCheck>;
+    setChecksList(value: Array<ConsistencyCheck>): AppendRecordsRequest;
+    addChecks(value?: ConsistencyCheck, index?: number): ConsistencyCheck;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): AppendRecordsRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: AppendRecordsRequest): AppendRecordsRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: AppendRecordsRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): AppendRecordsRequest;
+    static deserializeBinaryFromReader(message: AppendRecordsRequest, reader: jspb.BinaryReader): AppendRecordsRequest;
+}
+
+export namespace AppendRecordsRequest {
+    export type AsObject = {
+        recordsList: Array<AppendRecord.AsObject>,
+        checksList: Array<ConsistencyCheck.AsObject>,
+    }
+}
+
+export class AppendRecordsResponse extends jspb.Message { 
+    clearRevisionsList(): void;
+    getRevisionsList(): Array<StreamRevision>;
+    setRevisionsList(value: Array<StreamRevision>): AppendRecordsResponse;
+    addRevisions(value?: StreamRevision, index?: number): StreamRevision;
+    getPosition(): string;
+    setPosition(value: string): AppendRecordsResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): AppendRecordsResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: AppendRecordsResponse): AppendRecordsResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: AppendRecordsResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): AppendRecordsResponse;
+    static deserializeBinaryFromReader(message: AppendRecordsResponse, reader: jspb.BinaryReader): AppendRecordsResponse;
+}
+
+export namespace AppendRecordsResponse {
+    export type AsObject = {
+        revisionsList: Array<StreamRevision.AsObject>,
+        position: string,
+    }
+}
+
+export class ConsistencyCheck extends jspb.Message { 
+
+    hasStreamState(): boolean;
+    clearStreamState(): void;
+    getStreamState(): ConsistencyCheck.StreamStateCheck | undefined;
+    setStreamState(value?: ConsistencyCheck.StreamStateCheck): ConsistencyCheck;
+
+    getTypeCase(): ConsistencyCheck.TypeCase;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ConsistencyCheck.AsObject;
+    static toObject(includeInstance: boolean, msg: ConsistencyCheck): ConsistencyCheck.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ConsistencyCheck, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ConsistencyCheck;
+    static deserializeBinaryFromReader(message: ConsistencyCheck, reader: jspb.BinaryReader): ConsistencyCheck;
+}
+
+export namespace ConsistencyCheck {
+    export type AsObject = {
+        streamState?: ConsistencyCheck.StreamStateCheck.AsObject,
+    }
+
+
+    export class StreamStateCheck extends jspb.Message { 
+        getStream(): string;
+        setStream(value: string): StreamStateCheck;
+        getExpectedState(): string;
+        setExpectedState(value: string): StreamStateCheck;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): StreamStateCheck.AsObject;
+        static toObject(includeInstance: boolean, msg: StreamStateCheck): StreamStateCheck.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: StreamStateCheck, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): StreamStateCheck;
+        static deserializeBinaryFromReader(message: StreamStateCheck, reader: jspb.BinaryReader): StreamStateCheck;
+    }
+
+    export namespace StreamStateCheck {
+        export type AsObject = {
+            stream: string,
+            expectedState: string,
+        }
+    }
+
+
+    export enum TypeCase {
+        TYPE_NOT_SET = 0,
+        STREAM_STATE = 1,
+    }
+
+}
+
+export class StreamRevision extends jspb.Message { 
+    getStream(): string;
+    setStream(value: string): StreamRevision;
+    getRevision(): string;
+    setRevision(value: string): StreamRevision;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): StreamRevision.AsObject;
+    static toObject(includeInstance: boolean, msg: StreamRevision): StreamRevision.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: StreamRevision, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): StreamRevision;
+    static deserializeBinaryFromReader(message: StreamRevision, reader: jspb.BinaryReader): StreamRevision;
+}
+
+export namespace StreamRevision {
+    export type AsObject = {
+        stream: string,
+        revision: string,
     }
 }