@delali/sirannon-db 0.1.4 → 0.1.5

package/dist/transport/grpc.d.ts

@@ -0,0 +1,316 @@
+import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
+import { Client, ClientDuplexStream, CallOptions, Metadata, ServiceError, ClientUnaryCall, ChannelCredentials, ClientOptions, ServerDuplexStream, Server } from '@grpc/grpc-js';
+import { HealthImplementation } from 'grpc-health-check';
+import { R as ReplicationBatch, a as ReplicationAck, F as ForwardedTransaction, b as ForwardedTransactionResult, N as NodeInfo, S as SyncRequest, c as SyncBatch, d as SyncComplete, e as SyncAck, f as ReplicationTransport, T as TopologyRole, g as TransportConfig } from '../types-B2byqt0B.js';
+import '../change-tracker-CFTQ9TSn.js';
+import '../types-BFSsG77t.js';
+import '../types-D-74JiXb.js';
+import '../types-BEu1I_9_.js';
+
+interface ColumnValue {
+    nullValue?: boolean | undefined;
+    stringValue?: string | undefined;
+    intValue?: bigint | undefined;
+    floatValue?: number | undefined;
+    blobValue?: Buffer | undefined;
+    boolValue?: boolean | undefined;
+}
+declare const ColumnValue: MessageFns<ColumnValue>;
+interface RowData {
+    fields: {
+        [key: string]: ColumnValue;
+    };
+}
+declare const RowData: MessageFns<RowData>;
+interface HlcRange {
+    min: string;
+    max: string;
+}
+declare const HlcRange: MessageFns<HlcRange>;
+interface ReplicationChange {
+    table: string;
+    operation: string;
+    rowId: string;
+    primaryKey: RowData | undefined;
+    hlc: string;
+    txId: string;
+    nodeId: string;
+    newData: RowData | undefined;
+    oldData: RowData | undefined;
+    ddlStatement: string;
+}
+declare const ReplicationChange: MessageFns<ReplicationChange>;
+interface BatchPayload {
+    sourceNodeId: string;
+    batchId: string;
+    fromSeq: bigint;
+    toSeq: bigint;
+    hlcRange: HlcRange | undefined;
+    changes: ReplicationChange[];
+    checksum: string;
+    groupId: string;
+    primaryTerm: bigint;
+}
+declare const BatchPayload: MessageFns<BatchPayload>;
+interface AckPayload {
+    batchId: string;
+    ackedSeq: bigint;
+    nodeId: string;
+    groupId: string;
+    primaryTerm: bigint;
+}
+declare const AckPayload: MessageFns<AckPayload>;
+interface Hello {
+    nodeId: string;
+    role: string;
+    groupId: string;
+    primaryTerm: bigint;
+    protocolVersion: string;
+}
+declare const Hello: MessageFns<Hello>;
+interface ReplicationMessage {
+    hello?: Hello | undefined;
+    batch?: BatchPayload | undefined;
+    ack?: AckPayload | undefined;
+}
+declare const ReplicationMessage: MessageFns<ReplicationMessage>;
+interface SyncRequestPayload {
+    requestId: string;
+    joinerNodeId: string;
+    completedTables: string[];
+    groupId: string;
+    primaryTerm: bigint;
+}
+declare const SyncRequestPayload: MessageFns<SyncRequestPayload>;
+interface SyncBatchPayload {
+    requestId: string;
+    table: string;
+    batchIndex: number;
+    rows: RowData[];
+    schema: string[];
+    checksum: string;
+    isLastBatchForTable: boolean;
+    groupId: string;
+    primaryTerm: bigint;
+}
+declare const SyncBatchPayload: MessageFns<SyncBatchPayload>;
+interface SyncCompletePayload {
+    requestId: string;
+    snapshotSeq: bigint;
+    manifests: SyncTableManifest[];
+    groupId: string;
+    primaryTerm: bigint;
+}
+declare const SyncCompletePayload: MessageFns<SyncCompletePayload>;
+interface SyncTableManifest {
+    table: string;
+    rowCount: number;
+    pkHash: string;
+}
+declare const SyncTableManifest: MessageFns<SyncTableManifest>;
+interface SyncAckPayload {
+    requestId: string;
+    joinerNodeId: string;
+    table: string;
+    batchIndex: number;
+    success: boolean;
+    error: string;
+    groupId: string;
+    primaryTerm: bigint;
+}
+declare const SyncAckPayload: MessageFns<SyncAckPayload>;
+interface SyncMessage {
+    hello?: Hello | undefined;
+    syncRequest?: SyncRequestPayload | undefined;
+    syncBatch?: SyncBatchPayload | undefined;
+    syncComplete?: SyncCompletePayload | undefined;
+    syncAck?: SyncAckPayload | undefined;
+}
+declare const SyncMessage: MessageFns<SyncMessage>;
+interface Statement {
+    sql: string;
+    namedParams: {
+        [key: string]: ColumnValue;
+    };
+    positionalParams: ColumnValue[];
+}
+declare const Statement: MessageFns<Statement>;
+interface ForwardRequest {
+    requestId: string;
+    statements: Statement[];
+    groupId: string;
+    primaryTerm: bigint;
+}
+declare const ForwardRequest: MessageFns<ForwardRequest>;
+interface StatementResult {
+    changes: number;
+    lastInsertRowId: bigint;
+}
+declare const StatementResult: MessageFns<StatementResult>;
+interface ForwardResponse {
+    requestId: string;
+    results: StatementResult[];
+    error: string;
+    groupId: string;
+    primaryTerm: bigint;
+}
+declare const ForwardResponse: MessageFns<ForwardResponse>;
+type ReplicationService = typeof ReplicationService;
+declare const ReplicationService: {
+    readonly replicate: {
+        readonly path: "/sirannon.replication.v1.Replication/Replicate";
+        readonly requestStream: true;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: ReplicationMessage) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ReplicationMessage;
+        readonly responseSerialize: (value: ReplicationMessage) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ReplicationMessage;
+    };
+    readonly sync: {
+        readonly path: "/sirannon.replication.v1.Replication/Sync";
+        readonly requestStream: true;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: SyncMessage) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SyncMessage;
+        readonly responseSerialize: (value: SyncMessage) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => SyncMessage;
+    };
+    readonly forward: {
+        readonly path: "/sirannon.replication.v1.Replication/Forward";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ForwardRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ForwardRequest;
+        readonly responseSerialize: (value: ForwardResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ForwardResponse;
+    };
+};
+interface ReplicationClient extends Client {
+    replicate(): ClientDuplexStream<ReplicationMessage, ReplicationMessage>;
+    replicate(options: Partial<CallOptions>): ClientDuplexStream<ReplicationMessage, ReplicationMessage>;
+    replicate(metadata: Metadata, options?: Partial<CallOptions>): ClientDuplexStream<ReplicationMessage, ReplicationMessage>;
+    sync(): ClientDuplexStream<SyncMessage, SyncMessage>;
+    sync(options: Partial<CallOptions>): ClientDuplexStream<SyncMessage, SyncMessage>;
+    sync(metadata: Metadata, options?: Partial<CallOptions>): ClientDuplexStream<SyncMessage, SyncMessage>;
+    forward(request: ForwardRequest, callback: (error: ServiceError | null, response: ForwardResponse) => void): ClientUnaryCall;
+    forward(request: ForwardRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ForwardResponse) => void): ClientUnaryCall;
+    forward(request: ForwardRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ForwardResponse) => void): ClientUnaryCall;
+}
+declare const ReplicationClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): ReplicationClient;
+    service: typeof ReplicationService;
+    serviceName: string;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+
+declare function toColumnValue(value: unknown): ColumnValue;
+declare function fromColumnValue(cv: ColumnValue): unknown;
+
+interface GrpcReplicationOptions {
+    host?: string;
+    port?: number;
+    tlsCert?: string;
+    tlsKey?: string;
+    tlsCaCert?: string;
+    insecure?: boolean;
+    forwardDeadlineMs?: number;
+}
+
+interface PeerStreamEntry {
+    replicateStream: ServerDuplexStream<ReplicationMessage, ReplicationMessage> | null;
+    syncStream: ServerDuplexStream<SyncMessage, SyncMessage> | null;
+}
+interface ClientPeerEntry {
+    client: InstanceType<typeof ReplicationClient>;
+    replicateStream: ClientDuplexStream<ReplicationMessage, ReplicationMessage> | null;
+    syncStream: ClientDuplexStream<SyncMessage, SyncMessage> | null;
+}
+type BatchHandler = (batch: ReplicationBatch, fromPeerId: string) => Promise<void>;
+type AckHandler = (ack: ReplicationAck, fromPeerId: string) => void;
+type ForwardHandler = (request: ForwardedTransaction, fromPeerId: string) => Promise<ForwardedTransactionResult>;
+type PeerConnectedHandler = (peer: NodeInfo) => void;
+type PeerDisconnectedHandler = (peerId: string) => void;
+type SyncRequestHandler = (request: SyncRequest, fromPeerId: string) => Promise<void>;
+type SyncBatchHandler = (batch: SyncBatch, fromPeerId: string) => Promise<void>;
+type SyncCompleteHandler = (complete: SyncComplete, fromPeerId: string) => Promise<void>;
+type SyncAckHandler = (ack: SyncAck, fromPeerId: string) => void;
+
+declare class GrpcReplicationTransport implements ReplicationTransport {
+    readonly options: GrpcReplicationOptions;
+    localNodeId: string;
+    localRole: TopologyRole;
+    localGroupId: string | undefined;
+    localPrimaryTerm: bigint | undefined;
+    localProtocolVersion: string | undefined;
+    connected: boolean;
+    server: Server | null;
+    boundPort: number;
+    healthImpl: HealthImplementation | null;
+    readonly connectedPeers: Map<string, NodeInfo>;
+    readonly serverPeerStreams: Map<string, PeerStreamEntry>;
+    readonly clientPeerStreams: Map<string, ClientPeerEntry>;
+    batchHandler: BatchHandler | null;
+    ackHandler: AckHandler | null;
+    forwardHandler: ForwardHandler | null;
+    peerConnectedHandler: PeerConnectedHandler | null;
+    peerDisconnectedHandler: PeerDisconnectedHandler | null;
+    syncRequestHandler: SyncRequestHandler | null;
+    syncBatchHandler: SyncBatchHandler | null;
+    syncCompleteHandler: SyncCompleteHandler | null;
+    syncAckHandler: SyncAckHandler | null;
+    constructor(options?: GrpcReplicationOptions);
+    getPort(): number;
+    connect(localNodeId: string, config: TransportConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    send(peerId: string, batch: ReplicationBatch): Promise<void>;
+    broadcast(batch: ReplicationBatch): Promise<void>;
+    sendAck(peerId: string, ack: ReplicationAck): Promise<void>;
+    forward(peerId: string, request: ForwardedTransaction): Promise<ForwardedTransactionResult>;
+    requestSync(peerId: string, request: SyncRequest): Promise<void>;
+    sendSyncBatch(peerId: string, batch: SyncBatch): Promise<void>;
+    sendSyncComplete(peerId: string, complete: SyncComplete): Promise<void>;
+    sendSyncAck(peerId: string, ack: SyncAck): Promise<void>;
+    onBatchReceived(handler: BatchHandler): void;
+    onAckReceived(handler: AckHandler): void;
+    onForwardReceived(handler: ForwardHandler): void;
+    onSyncRequested(handler: SyncRequestHandler): void;
+    onSyncBatchReceived(handler: SyncBatchHandler): void;
+    onSyncCompleteReceived(handler: SyncCompleteHandler): void;
+    onSyncAckReceived(handler: SyncAckHandler): void;
+    onPeerConnected(handler: PeerConnectedHandler): void;
+    onPeerDisconnected(handler: PeerDisconnectedHandler): void;
+    peers(): ReadonlyMap<string, NodeInfo>;
+    extractTlsCN(call: {
+        getAuthContext(): unknown;
+    }): string | null;
+    validateTlsIdentity(call: {
+        getAuthContext(): unknown;
+    }, claimedNodeId: string): boolean;
+    resolveForwardPeerId(call: {
+        getPeer(): string;
+        getAuthContext(): unknown;
+    }): string | null;
+    private findPeerIdForStream;
+    private ensureConnected;
+    private getReplicateWriteStream;
+    private getSyncWriteStream;
+}
+
+export { type GrpcReplicationOptions, GrpcReplicationTransport, fromColumnValue, toColumnValue };