@hatchet-dev/typescript-sdk 1.27.0 → 1.28.0

package/clients/dispatcher/dispatcher-client.d.ts

@@ -1,5 +1,5 @@
 import { Channel, ClientFactory } from 'nice-grpc';
-import { DispatcherClient as PbDispatcherClient, StepActionEvent, GroupKeyActionEvent, OverridesData, DeepPartial, WorkerLabels as PbWorkerAffinityConfig, RuntimeInfo } from '../../protoc/dispatcher';
+import { DispatcherClient as PbDispatcherClient, StepActionEvent, BatchActionEvent, GroupKeyActionEvent, OverridesData, DeepPartial, WorkerLabels as PbWorkerAffinityConfig, RuntimeInfo } from '../../protoc/dispatcher';
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import { SlotConfig } from '../../v1/slot-types';
@@ -37,6 +37,11 @@ export declare class DispatcherClient {
      */
     getVersion(): Promise<string>;
     sendStepActionEvent(in_: StepActionEventInput): Promise<import("../../protoc/dispatcher").ActionEventResponse>;
+    /**
+     * Reports a lifecycle event (STARTED, COMPLETED, or FAILED) covering one or more
+     * members of a batch task's execution.
+     */
+    sendBatchActionEvent(in_: BatchActionEvent): Promise<import("../../protoc/dispatcher").ActionEventResponse>;
     sendGroupKeyActionEvent(in_: GroupKeyActionEvent): Promise<import("../../protoc/dispatcher").ActionEventResponse>;
     putOverridesData(in_: DeepPartial<OverridesData>): Promise<void | import("../../protoc/dispatcher").OverridesDataResponse>;
     refreshTimeout(incrementTimeoutBy: string, taskRunExternalId: string): Promise<import("../../protoc/dispatcher").RefreshTimeoutResponse>;

package/clients/dispatcher/dispatcher-client.js

@@ -83,6 +83,20 @@ class DispatcherClient {
             }
         });
     }
+    /**
+     * Reports a lifecycle event (STARTED, COMPLETED, or FAILED) covering one or more
+     * members of a batch task's execution.
+     */
+    sendBatchActionEvent(in_) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.sendBatchActionEvent(in_); }), this.logger);
+            }
+            catch (e) {
+                throw (0, hatchet_error_1.toHatchetError)(e);
+            }
+        });
+    }
     sendGroupKeyActionEvent(in_) {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/clients/rest/generated/Api.d.ts

@@ -1958,6 +1958,8 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
         limit?: number;
         /** Filter by worker status */
         statuses?: WorkerStatus[];
+        /** Filter by worker labels */
+        labels?: string[];
     }, params?: RequestParams) => Promise<import("axios").AxiosResponse<WorkerList, any, {}>>;
     /**
      * @description Update a worker

package/clients/rest/generated/data-contracts.d.ts

@@ -281,6 +281,8 @@ export declare enum V1TaskEventType {
     CREATED = "CREATED",
     QUEUED = "QUEUED",
     SKIPPED = "SKIPPED",
+    WAITING_FOR_BATCH = "WAITING_FOR_BATCH",
+    BATCH_FLUSHED = "BATCH_FLUSHED",
     COULD_NOT_SEND_TO_WORKER = "COULD_NOT_SEND_TO_WORKER",
     DURABLE_EVICTED = "DURABLE_EVICTED",
     DURABLE_RESTORING = "DURABLE_RESTORING"

package/clients/rest/generated/data-contracts.js

@@ -342,6 +342,8 @@ var V1TaskEventType;
     V1TaskEventType["CREATED"] = "CREATED";
     V1TaskEventType["QUEUED"] = "QUEUED";
     V1TaskEventType["SKIPPED"] = "SKIPPED";
+    V1TaskEventType["WAITING_FOR_BATCH"] = "WAITING_FOR_BATCH";
+    V1TaskEventType["BATCH_FLUSHED"] = "BATCH_FLUSHED";
     V1TaskEventType["COULD_NOT_SEND_TO_WORKER"] = "COULD_NOT_SEND_TO_WORKER";
     V1TaskEventType["DURABLE_EVICTED"] = "DURABLE_EVICTED";
     V1TaskEventType["DURABLE_RESTORING"] = "DURABLE_RESTORING";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/protoc/dispatcher/dispatcher.d.ts

@@ -15,6 +15,7 @@ export declare enum ActionType {
     START_STEP_RUN = 0,
     CANCEL_STEP_RUN = 1,
     START_GET_GROUP_KEY = 2,
+    START_BATCH = 3,
     UNRECOGNIZED = -1
 }
 export declare function actionTypeFromJSON(object: any): ActionType;
@@ -34,6 +35,7 @@ export declare enum StepActionEventType {
     STEP_EVENT_TYPE_COMPLETED = 2,
     STEP_EVENT_TYPE_FAILED = 3,
     STEP_EVENT_TYPE_ACKNOWLEDGED = 4,
+    STEP_EVENT_TYPE_CANCELLED = 5,
     UNRECOGNIZED = -1
 }
 export declare function stepActionEventTypeFromJSON(object: any): StepActionEventType;
@@ -182,6 +184,21 @@ export interface AssignedAction {
     triggeringEventExternalId?: string | undefined;
     /** (optional) the key of the event that triggered this workflow run (if any) */
     triggeringEventKey?: string | undefined;
+    /** (optional) the batch identifier if this task is part of a batch */
+    batchId?: string | undefined;
+    /** (optional) the total number of tasks in the batch */
+    batchSize?: number | undefined;
+    /** (optional) the index of the task within the batch */
+    batchIndex?: number | undefined;
+    /** (optional) payload for starting a batch execution */
+    batchStartPayload?: BatchStartPayload | undefined;
+    /** (optional) the partition key used for batching */
+    batchKey?: string | undefined;
+}
+export interface BatchStartPayload {
+    triggerReason: string;
+    triggerTime: Date | undefined;
+    expectedSize: number;
 }
 export interface WorkerListenRequest {
     /** the id of the worker */
@@ -234,6 +251,31 @@ export interface StepActionEvent {
     /** a flag indicating if the task should _not_ be retried */
     shouldNotRetry?: boolean | undefined;
 }
+export interface BatchActionEventItem {
+    /** the task external run id */
+    taskRunExternalId: string;
+    /** the event payload (e.g. serialized error for FAILED; unused for STARTED/CANCELLED) */
+    eventPayload: string;
+    /** the retry count (falls back to the task's current retry count if unset) */
+    retryCount?: number | undefined;
+    /** a flag indicating if the task should _not_ be retried (FAILED only) */
+    shouldNotRetry?: boolean | undefined;
+}
+export interface BatchActionEvent {
+    /** the id of the worker */
+    workerId: string;
+    /** the id of the job (shared across all items in the batch) */
+    jobId: string;
+    /** the action id (shared across all items in the batch) */
+    actionId: string;
+    /** (optional) the batch identifier, for observability */
+    batchId?: string | undefined;
+    eventTimestamp: Date | undefined;
+    /** the task event type -- applies uniformly to every item in this batch */
+    eventType: StepActionEventType;
+    /** the items in this batch */
+    items: BatchActionEventItem[];
+}
 export interface ActionEventResponse {
     /** the tenant id */
     tenantId: string;
@@ -341,11 +383,14 @@ export declare const UpsertWorkerLabelsRequest: MessageFns<UpsertWorkerLabelsReq
 export declare const UpsertWorkerLabelsRequest_LabelsEntry: MessageFns<UpsertWorkerLabelsRequest_LabelsEntry>;
 export declare const UpsertWorkerLabelsResponse: MessageFns<UpsertWorkerLabelsResponse>;
 export declare const AssignedAction: MessageFns<AssignedAction>;
+export declare const BatchStartPayload: MessageFns<BatchStartPayload>;
 export declare const WorkerListenRequest: MessageFns<WorkerListenRequest>;
 export declare const WorkerUnsubscribeRequest: MessageFns<WorkerUnsubscribeRequest>;
 export declare const WorkerUnsubscribeResponse: MessageFns<WorkerUnsubscribeResponse>;
 export declare const GroupKeyActionEvent: MessageFns<GroupKeyActionEvent>;
 export declare const StepActionEvent: MessageFns<StepActionEvent>;
+export declare const BatchActionEventItem: MessageFns<BatchActionEventItem>;
+export declare const BatchActionEvent: MessageFns<BatchActionEvent>;
 export declare const ActionEventResponse: MessageFns<ActionEventResponse>;
 export declare const SubscribeToWorkflowEventsRequest: MessageFns<SubscribeToWorkflowEventsRequest>;
 export declare const SubscribeToWorkflowRunsRequest: MessageFns<SubscribeToWorkflowRunsRequest>;
@@ -430,6 +475,18 @@ export declare const DispatcherDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        /**
+         * SendBatchActionEvent reports a single lifecycle event (STARTED, FAILED, or CANCELLED)
+         * for every task in a batch in one call, instead of one SendStepActionEvent call per task.
+         */
+        readonly sendBatchActionEvent: {
+            readonly name: "SendBatchActionEvent";
+            readonly requestType: typeof BatchActionEvent;
+            readonly requestStream: false;
+            readonly responseType: typeof ActionEventResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly sendGroupKeyActionEvent: {
             readonly name: "SendGroupKeyActionEvent";
             readonly requestType: typeof GroupKeyActionEvent;
@@ -514,6 +571,11 @@ export interface DispatcherServiceImplementation<CallContextExt = {}> {
     subscribeToWorkflowEvents(request: SubscribeToWorkflowEventsRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<WorkflowEvent>>;
     subscribeToWorkflowRuns(request: AsyncIterable<SubscribeToWorkflowRunsRequest>, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<WorkflowRunEvent>>;
     sendStepActionEvent(request: StepActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
+    /**
+     * SendBatchActionEvent reports a single lifecycle event (STARTED, FAILED, or CANCELLED)
+     * for every task in a batch in one call, instead of one SendStepActionEvent call per task.
+     */
+    sendBatchActionEvent(request: BatchActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
     sendGroupKeyActionEvent(request: GroupKeyActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
     putOverridesData(request: OverridesData, context: CallContext & CallContextExt): Promise<DeepPartial<OverridesDataResponse>>;
     unsubscribe(request: WorkerUnsubscribeRequest, context: CallContext & CallContextExt): Promise<DeepPartial<WorkerUnsubscribeResponse>>;
@@ -541,6 +603,11 @@ export interface DispatcherClient<CallOptionsExt = {}> {
     subscribeToWorkflowEvents(request: DeepPartial<SubscribeToWorkflowEventsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<WorkflowEvent>;
     subscribeToWorkflowRuns(request: AsyncIterable<DeepPartial<SubscribeToWorkflowRunsRequest>>, options?: CallOptions & CallOptionsExt): AsyncIterable<WorkflowRunEvent>;
     sendStepActionEvent(request: DeepPartial<StepActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;
+    /**
+     * SendBatchActionEvent reports a single lifecycle event (STARTED, FAILED, or CANCELLED)
+     * for every task in a batch in one call, instead of one SendStepActionEvent call per task.
+     */
+    sendBatchActionEvent(request: DeepPartial<BatchActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;
     sendGroupKeyActionEvent(request: DeepPartial<GroupKeyActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;
     putOverridesData(request: DeepPartial<OverridesData>, options?: CallOptions & CallOptionsExt): Promise<OverridesDataResponse>;
     unsubscribe(request: DeepPartial<WorkerUnsubscribeRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkerUnsubscribeResponse>;