@superdurable/dex 0.2.0 → 0.2.2

package/dist/src/gen/dex.d.ts

@@ -298,8 +298,11 @@ export interface FlowConfig {
     continueAsNewPageSizeInBytes?: number | undefined;
     stepDurability?: StepDurability | undefined;
     workerTarget: WorkerTarget | undefined;
-    /** Present empty disables future synchronization; non-empty selects a Server-configured store. */
-    attributeSyncConfigName?: string | undefined;
+    /** Present empty disables future synchronization; non-empty selects Server-configured stores. */
+    attributeStoreNames?: AttributeStoreNames | undefined;
+}
+export interface AttributeStoreNames {
+    names: string[];
 }
 export interface WorkerTarget {
     /** Plaintext gRPC dial target, not an HTTP URL. */
@@ -329,6 +332,31 @@ export interface ChannelMessage {
     channelName: string;
     value: Value | undefined;
 }
+export interface WriteStreamRequest {
+    flowId: string;
+    flowType: string;
+    streamName: string;
+    maxEstimatedBytes: bigint;
+    value: Value | undefined;
+    /** Client keys must not contain "#"; Step SDKs use `<runID>#<stepExecutionID>`. */
+    idempotencyKey: string;
+}
+export interface ReadStreamRequest {
+    flowId: string;
+    flowType: string;
+    streamName: string;
+    resumeToken: string;
+    waitTimeSeconds: number;
+}
+export interface ReadStreamResponse {
+    message: StreamMessage | undefined;
+}
+export interface StreamMessage {
+    value: Value | undefined;
+    resumeToken: string;
+    createdTime: Date | undefined;
+    idempotencyKey: string;
+}
 export interface StopFlowRequest {
     flowId: string;
     runId: string;
@@ -1215,11 +1243,16 @@ export declare const StepOptions: MessageFns<StepOptions>;
 export declare const FlowAlreadyStartedOptions: MessageFns<FlowAlreadyStartedOptions>;
 export declare const FlowStartOptions: MessageFns<FlowStartOptions>;
 export declare const FlowConfig: MessageFns<FlowConfig>;
+export declare const AttributeStoreNames: MessageFns<AttributeStoreNames>;
 export declare const WorkerTarget: MessageFns<WorkerTarget>;
 export declare const StartFlowRequest: MessageFns<StartFlowRequest>;
 export declare const StartFlowResponse: MessageFns<StartFlowResponse>;
 export declare const PublishToChannelRequest: MessageFns<PublishToChannelRequest>;
 export declare const ChannelMessage: MessageFns<ChannelMessage>;
+export declare const WriteStreamRequest: MessageFns<WriteStreamRequest>;
+export declare const ReadStreamRequest: MessageFns<ReadStreamRequest>;
+export declare const ReadStreamResponse: MessageFns<ReadStreamResponse>;
+export declare const StreamMessage: MessageFns<StreamMessage>;
 export declare const StopFlowRequest: MessageFns<StopFlowRequest>;
 export declare const GetAttributesRequest: MessageFns<GetAttributesRequest>;
 export declare const GetAttributesResponse: MessageFns<GetAttributesResponse>;
@@ -1385,6 +1418,24 @@ export declare const FlowServiceService: {
         readonly responseSerialize: (value: Empty) => Buffer;
         readonly responseDeserialize: (value: Buffer) => Empty;
     };
+    readonly writeStream: {
+        readonly path: "/dex.FlowService/WriteStream";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: WriteStreamRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => WriteStreamRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly readStream: {
+        readonly path: "/dex.FlowService/ReadStream";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ReadStreamRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ReadStreamRequest;
+        readonly responseSerialize: (value: ReadStreamResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ReadStreamResponse;
+    };
     readonly stopFlow: {
         readonly path: "/dex.FlowService/StopFlow";
         readonly requestStream: false;
@@ -1560,6 +1611,8 @@ export declare const FlowServiceService: {
 export interface FlowServiceServer extends UntypedServiceImplementation {
     startFlow: handleUnaryCall<StartFlowRequest, StartFlowResponse>;
     publishToChannel: handleUnaryCall<PublishToChannelRequest, Empty>;
+    writeStream: handleUnaryCall<WriteStreamRequest, Empty>;
+    readStream: handleUnaryCall<ReadStreamRequest, ReadStreamResponse>;
     stopFlow: handleUnaryCall<StopFlowRequest, Empty>;
     getAttributes: handleUnaryCall<GetAttributesRequest, GetAttributesResponse>;
     setAttributes: handleUnaryCall<SetAttributesRequest, Empty>;
@@ -1587,6 +1640,12 @@ export interface FlowServiceClient extends Client {
     publishToChannel(request: PublishToChannelRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
     publishToChannel(request: PublishToChannelRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
     publishToChannel(request: PublishToChannelRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    writeStream(request: WriteStreamRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    writeStream(request: WriteStreamRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    writeStream(request: WriteStreamRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    readStream(request: ReadStreamRequest, callback: (error: ServiceError | null, response: ReadStreamResponse) => void): ClientUnaryCall;
+    readStream(request: ReadStreamRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ReadStreamResponse) => void): ClientUnaryCall;
+    readStream(request: ReadStreamRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ReadStreamResponse) => void): ClientUnaryCall;
     stopFlow(request: StopFlowRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
     stopFlow(request: StopFlowRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
     stopFlow(request: StopFlowRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;

package/dist/src/gen/dex.js

@@ -1377,7 +1377,7 @@ function createBaseFlowConfig() {
         continueAsNewPageSizeInBytes: undefined,
         stepDurability: undefined,
         workerTarget: undefined,
-        attributeSyncConfigName: undefined,
+        attributeStoreNames: undefined,
     };
 }
 export const FlowConfig = {
@@ -1397,8 +1397,8 @@ export const FlowConfig = {
         if (message.workerTarget !== undefined) {
             WorkerTarget.encode(message.workerTarget, writer.uint32(42).fork()).join();
         }
-        if (message.attributeSyncConfigName !== undefined) {
-            writer.uint32(50).string(message.attributeSyncConfigName);
+        if (message.attributeStoreNames !== undefined) {
+            AttributeStoreNames.encode(message.attributeStoreNames, writer.uint32(50).fork()).join();
         }
         return writer;
     },
@@ -1448,7 +1448,7 @@ export const FlowConfig = {
                     if (tag !== 50) {
                         break;
                     }
-                    message.attributeSyncConfigName = reader.string();
+                    message.attributeStoreNames = AttributeStoreNames.decode(reader, reader.uint32());
                     continue;
                 }
             }
@@ -1471,7 +1471,50 @@ export const FlowConfig = {
         message.workerTarget = (object.workerTarget !== undefined && object.workerTarget !== null)
             ? WorkerTarget.fromPartial(object.workerTarget)
             : undefined;
-        message.attributeSyncConfigName = object.attributeSyncConfigName ?? undefined;
+        message.attributeStoreNames = (object.attributeStoreNames !== undefined && object.attributeStoreNames !== null)
+            ? AttributeStoreNames.fromPartial(object.attributeStoreNames)
+            : undefined;
+        return message;
+    },
+};
+function createBaseAttributeStoreNames() {
+    return { names: [] };
+}
+export const AttributeStoreNames = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.names) {
+            writer.uint32(10).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAttributeStoreNames();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.names.push(reader.string());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return AttributeStoreNames.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAttributeStoreNames();
+        message.names = object.names?.map((e) => e) || [];
         return message;
     },
 };
@@ -1828,6 +1871,309 @@ export const ChannelMessage = {
         return message;
     },
 };
+function createBaseWriteStreamRequest() {
+    return { flowId: "", flowType: "", streamName: "", maxEstimatedBytes: 0n, value: undefined, idempotencyKey: "" };
+}
+export const WriteStreamRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.flowId !== "") {
+            writer.uint32(10).string(message.flowId);
+        }
+        if (message.flowType !== "") {
+            writer.uint32(18).string(message.flowType);
+        }
+        if (message.streamName !== "") {
+            writer.uint32(26).string(message.streamName);
+        }
+        if (message.maxEstimatedBytes !== 0n) {
+            if (BigInt.asIntN(64, message.maxEstimatedBytes) !== message.maxEstimatedBytes) {
+                throw new globalThis.Error("value provided for field message.maxEstimatedBytes of type int64 too large");
+            }
+            writer.uint32(32).int64(message.maxEstimatedBytes);
+        }
+        if (message.value !== undefined) {
+            Value.encode(message.value, writer.uint32(42).fork()).join();
+        }
+        if (message.idempotencyKey !== "") {
+            writer.uint32(50).string(message.idempotencyKey);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseWriteStreamRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.flowId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.flowType = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.streamName = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.maxEstimatedBytes = reader.int64();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.value = Value.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.idempotencyKey = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return WriteStreamRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWriteStreamRequest();
+        message.flowId = object.flowId ?? "";
+        message.flowType = object.flowType ?? "";
+        message.streamName = object.streamName ?? "";
+        message.maxEstimatedBytes = (object.maxEstimatedBytes !== undefined && object.maxEstimatedBytes !== null)
+            ? BigInt(object.maxEstimatedBytes)
+            : 0n;
+        message.value = (object.value !== undefined && object.value !== null) ? Value.fromPartial(object.value) : undefined;
+        message.idempotencyKey = object.idempotencyKey ?? "";
+        return message;
+    },
+};
+function createBaseReadStreamRequest() {
+    return { flowId: "", flowType: "", streamName: "", resumeToken: "", waitTimeSeconds: 0 };
+}
+export const ReadStreamRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.flowId !== "") {
+            writer.uint32(10).string(message.flowId);
+        }
+        if (message.flowType !== "") {
+            writer.uint32(18).string(message.flowType);
+        }
+        if (message.streamName !== "") {
+            writer.uint32(26).string(message.streamName);
+        }
+        if (message.resumeToken !== "") {
+            writer.uint32(34).string(message.resumeToken);
+        }
+        if (message.waitTimeSeconds !== 0) {
+            writer.uint32(40).int32(message.waitTimeSeconds);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseReadStreamRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.flowId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.flowType = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.streamName = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.resumeToken = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.waitTimeSeconds = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return ReadStreamRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseReadStreamRequest();
+        message.flowId = object.flowId ?? "";
+        message.flowType = object.flowType ?? "";
+        message.streamName = object.streamName ?? "";
+        message.resumeToken = object.resumeToken ?? "";
+        message.waitTimeSeconds = object.waitTimeSeconds ?? 0;
+        return message;
+    },
+};
+function createBaseReadStreamResponse() {
+    return { message: undefined };
+}
+export const ReadStreamResponse = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.message !== undefined) {
+            StreamMessage.encode(message.message, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseReadStreamResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.message = StreamMessage.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return ReadStreamResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseReadStreamResponse();
+        message.message = (object.message !== undefined && object.message !== null)
+            ? StreamMessage.fromPartial(object.message)
+            : undefined;
+        return message;
+    },
+};
+function createBaseStreamMessage() {
+    return { value: undefined, resumeToken: "", createdTime: undefined, idempotencyKey: "" };
+}
+export const StreamMessage = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.value !== undefined) {
+            Value.encode(message.value, writer.uint32(10).fork()).join();
+        }
+        if (message.resumeToken !== "") {
+            writer.uint32(18).string(message.resumeToken);
+        }
+        if (message.createdTime !== undefined) {
+            Timestamp.encode(toTimestamp(message.createdTime), writer.uint32(26).fork()).join();
+        }
+        if (message.idempotencyKey !== "") {
+            writer.uint32(34).string(message.idempotencyKey);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStreamMessage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.value = Value.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.resumeToken = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.createdTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.idempotencyKey = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return StreamMessage.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseStreamMessage();
+        message.value = (object.value !== undefined && object.value !== null) ? Value.fromPartial(object.value) : undefined;
+        message.resumeToken = object.resumeToken ?? "";
+        message.createdTime = object.createdTime ?? undefined;
+        message.idempotencyKey = object.idempotencyKey ?? "";
+        return message;
+    },
+};
 function createBaseStopFlowRequest() {
     return { flowId: "", runId: "", reason: "", stopType: 0 };
 }
@@ -12189,6 +12535,24 @@ export const FlowServiceService = {
         responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
         responseDeserialize: (value) => Empty.decode(value),
     },
+    writeStream: {
+        path: "/dex.FlowService/WriteStream",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(WriteStreamRequest.encode(value).finish()),
+        requestDeserialize: (value) => WriteStreamRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
+        responseDeserialize: (value) => Empty.decode(value),
+    },
+    readStream: {
+        path: "/dex.FlowService/ReadStream",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(ReadStreamRequest.encode(value).finish()),
+        requestDeserialize: (value) => ReadStreamRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(ReadStreamResponse.encode(value).finish()),
+        responseDeserialize: (value) => ReadStreamResponse.decode(value),
+    },
     stopFlow: {
         path: "/dex.FlowService/StopFlow",
         requestStream: false,