@valon-technologies/gestalt 0.0.1-alpha.18 → 0.0.1-alpha.20

package/src/workflow-manager.ts

@@ -1,4 +1,3 @@
-import type { MessageInitShape } from "@bufbuild/protobuf";
 import {
   createClient,
   type Client,
@@ -7,25 +6,34 @@ import {
 import { createGrpcTransport } from "@connectrpc/connect-node";
 
 import {
-  WorkflowManagerCreateScheduleRequestSchema,
-  WorkflowManagerCreateEventTriggerRequestSchema,
-  WorkflowManagerDeleteScheduleRequestSchema,
-  WorkflowManagerDeleteEventTriggerRequestSchema,
-  WorkflowManagerGetScheduleRequestSchema,
-  WorkflowManagerGetEventTriggerRequestSchema,
   WorkflowManagerHost as WorkflowManagerHostService,
-  WorkflowManagerPauseScheduleRequestSchema,
-  WorkflowManagerPauseEventTriggerRequestSchema,
-  WorkflowManagerPublishEventRequestSchema,
-  WorkflowManagerResumeScheduleRequestSchema,
-  WorkflowManagerResumeEventTriggerRequestSchema,
-  WorkflowManagerUpdateScheduleRequestSchema,
-  WorkflowManagerUpdateEventTriggerRequestSchema,
-  type ManagedWorkflowSchedule,
-  type ManagedWorkflowEventTrigger,
-  type WorkflowEvent,
 } from "./internal/gen/v1/workflow_pb.ts";
 import type { Request } from "./api.ts";
+import {
+  boundWorkflowTargetToProto,
+  managedWorkflowDefinitionFromProto,
+  managedWorkflowEventTriggerFromProto,
+  managedWorkflowRunFromProto,
+  managedWorkflowRunSignalFromProto,
+  managedWorkflowScheduleFromProto,
+  workflowEventFromProto,
+  workflowEventMatchToProto,
+  workflowEventToProto,
+  workflowSignalToProto,
+  type BoundWorkflowTarget,
+  type BoundWorkflowTargetInput,
+  type ManagedWorkflowDefinition,
+  type ManagedWorkflowEventTrigger,
+  type ManagedWorkflowRun,
+  type ManagedWorkflowRunSignal,
+  type ManagedWorkflowSchedule,
+  type WorkflowEvent,
+  type WorkflowEventInput,
+  type WorkflowEventMatch,
+  type WorkflowEventMatchInput,
+  type WorkflowSignal,
+  type WorkflowSignalInput,
+} from "./workflow.ts";
 
 /** Environment variable containing the workflow-manager host-service target. */
 export const ENV_WORKFLOW_MANAGER_SOCKET = "GESTALT_WORKFLOW_MANAGER_SOCKET";
@@ -35,64 +43,142 @@ export const ENV_WORKFLOW_MANAGER_SOCKET_TOKEN =
 const WORKFLOW_MANAGER_RELAY_TOKEN_HEADER =
   "x-gestalt-host-service-relay-token";
 
-/** Managed workflow schedule message returned by the host manager. */
-export type ManagedWorkflowScheduleMessage = ManagedWorkflowSchedule;
-/** Managed workflow event-trigger message returned by the host manager. */
-export type ManagedWorkflowEventTriggerMessage = ManagedWorkflowEventTrigger;
-/** Workflow event message returned after publishing an event. */
-export type WorkflowEventMessage = WorkflowEvent;
+/** Shape accepted when starting a workflow run. */
+export interface WorkflowManagerStartRunInput {
+  providerName: string;
+  target?: BoundWorkflowTarget | BoundWorkflowTargetInput | undefined;
+  idempotencyKey?: string | undefined;
+  workflowKey?: string | undefined;
+  definitionId?: string | undefined;
+}
+
+/** Shape accepted when signaling an existing workflow run. */
+export interface WorkflowManagerSignalRunInput {
+  runId: string;
+  signal?: WorkflowSignal | WorkflowSignalInput | undefined;
+}
+
+/** Shape accepted when signaling a run or starting it if missing. */
+export interface WorkflowManagerSignalOrStartRunInput {
+  providerName: string;
+  workflowKey: string;
+  target?: BoundWorkflowTarget | BoundWorkflowTargetInput | undefined;
+  idempotencyKey?: string | undefined;
+  signal?: WorkflowSignal | WorkflowSignalInput | undefined;
+  definitionId?: string | undefined;
+}
+
+/** Shape accepted when creating a workflow definition. */
+export interface WorkflowManagerCreateDefinitionInput {
+  providerName: string;
+  target?: BoundWorkflowTarget | BoundWorkflowTargetInput | undefined;
+  idempotencyKey?: string | undefined;
+}
+
+/** Shape accepted when fetching a workflow definition. */
+export interface WorkflowManagerGetDefinitionInput {
+  definitionId: string;
+}
+
+/** Shape accepted when updating a workflow definition. */
+export interface WorkflowManagerUpdateDefinitionInput {
+  definitionId: string;
+  providerName?: string | undefined;
+  target?: BoundWorkflowTarget | BoundWorkflowTargetInput | undefined;
+}
+
+/** Shape accepted when deleting a workflow definition. */
+export interface WorkflowManagerDeleteDefinitionInput {
+  definitionId: string;
+}
+
 /** Shape accepted when creating a workflow schedule. */
-export type WorkflowManagerCreateScheduleInput = MessageInitShape<
-  typeof WorkflowManagerCreateScheduleRequestSchema
->;
+export interface WorkflowManagerCreateScheduleInput {
+  providerName: string;
+  cron: string;
+  timezone?: string | undefined;
+  target?: BoundWorkflowTarget | BoundWorkflowTargetInput | undefined;
+  paused?: boolean | undefined;
+  idempotencyKey?: string | undefined;
+  definitionId?: string | undefined;
+}
+
 /** Shape accepted when creating an event trigger. */
-export type WorkflowManagerCreateTriggerInput = MessageInitShape<
-  typeof WorkflowManagerCreateEventTriggerRequestSchema
->;
+export interface WorkflowManagerCreateTriggerInput {
+  providerName: string;
+  match?: WorkflowEventMatch | WorkflowEventMatchInput | undefined;
+  target?: BoundWorkflowTarget | BoundWorkflowTargetInput | undefined;
+  paused?: boolean | undefined;
+  idempotencyKey?: string | undefined;
+  definitionId?: string | undefined;
+}
+
 /** Shape accepted when fetching a workflow schedule. */
-export type WorkflowManagerGetScheduleInput = MessageInitShape<
-  typeof WorkflowManagerGetScheduleRequestSchema
->;
+export interface WorkflowManagerGetScheduleInput {
+  scheduleId: string;
+}
+
 /** Shape accepted when fetching an event trigger. */
-export type WorkflowManagerGetTriggerInput = MessageInitShape<
-  typeof WorkflowManagerGetEventTriggerRequestSchema
->;
+export interface WorkflowManagerGetTriggerInput {
+  triggerId: string;
+}
+
 /** Shape accepted when updating a workflow schedule. */
-export type WorkflowManagerUpdateScheduleInput = MessageInitShape<
-  typeof WorkflowManagerUpdateScheduleRequestSchema
->;
+export interface WorkflowManagerUpdateScheduleInput {
+  scheduleId: string;
+  providerName?: string | undefined;
+  cron?: string | undefined;
+  timezone?: string | undefined;
+  target?: BoundWorkflowTarget | BoundWorkflowTargetInput | undefined;
+  paused?: boolean | undefined;
+  definitionId?: string | undefined;
+}
+
 /** Shape accepted when updating an event trigger. */
-export type WorkflowManagerUpdateTriggerInput = MessageInitShape<
-  typeof WorkflowManagerUpdateEventTriggerRequestSchema
->;
+export interface WorkflowManagerUpdateTriggerInput {
+  triggerId: string;
+  providerName?: string | undefined;
+  match?: WorkflowEventMatch | WorkflowEventMatchInput | undefined;
+  target?: BoundWorkflowTarget | BoundWorkflowTargetInput | undefined;
+  paused?: boolean | undefined;
+  definitionId?: string | undefined;
+}
+
 /** Shape accepted when deleting a workflow schedule. */
-export type WorkflowManagerDeleteScheduleInput = MessageInitShape<
-  typeof WorkflowManagerDeleteScheduleRequestSchema
->;
+export interface WorkflowManagerDeleteScheduleInput {
+  scheduleId: string;
+}
+
 /** Shape accepted when deleting an event trigger. */
-export type WorkflowManagerDeleteTriggerInput = MessageInitShape<
-  typeof WorkflowManagerDeleteEventTriggerRequestSchema
->;
+export interface WorkflowManagerDeleteTriggerInput {
+  triggerId: string;
+}
+
 /** Shape accepted when pausing a workflow schedule. */
-export type WorkflowManagerPauseScheduleInput = MessageInitShape<
-  typeof WorkflowManagerPauseScheduleRequestSchema
->;
+export interface WorkflowManagerPauseScheduleInput {
+  scheduleId: string;
+}
+
 /** Shape accepted when pausing an event trigger. */
-export type WorkflowManagerPauseTriggerInput = MessageInitShape<
-  typeof WorkflowManagerPauseEventTriggerRequestSchema
->;
+export interface WorkflowManagerPauseTriggerInput {
+  triggerId: string;
+}
+
 /** Shape accepted when resuming a workflow schedule. */
-export type WorkflowManagerResumeScheduleInput = MessageInitShape<
-  typeof WorkflowManagerResumeScheduleRequestSchema
->;
+export interface WorkflowManagerResumeScheduleInput {
+  scheduleId: string;
+}
+
 /** Shape accepted when resuming an event trigger. */
-export type WorkflowManagerResumeTriggerInput = MessageInitShape<
-  typeof WorkflowManagerResumeEventTriggerRequestSchema
->;
+export interface WorkflowManagerResumeTriggerInput {
+  triggerId: string;
+}
+
 /** Shape accepted when publishing a workflow event. */
-export type WorkflowManagerPublishEventInput = MessageInitShape<
-  typeof WorkflowManagerPublishEventRequestSchema
->;
+export interface WorkflowManagerPublishEventInput {
+  event?: WorkflowEvent | WorkflowEventInput | undefined;
+  providerName?: string | undefined;
+}
 
 /**
  * Client for creating and controlling workflow schedules and event triggers.
@@ -131,35 +217,148 @@ export class WorkflowManager {
     this.client = createClient(WorkflowManagerHostService, transport);
   }
 
+  /** Starts a workflow run immediately. */
+  async startRun(
+    request: WorkflowManagerStartRunInput,
+  ): Promise<ManagedWorkflowRun> {
+    return managedWorkflowRunFromProto(
+      await this.client.startRun({
+        providerName: request.providerName,
+        target: boundWorkflowTargetToProto(request.target),
+        idempotencyKey: request.idempotencyKey?.trim() || this.idempotencyKey,
+        workflowKey: request.workflowKey ?? "",
+        invocationToken: this.invocationToken,
+        definitionId: request.definitionId ?? "",
+      }),
+    );
+  }
+
+  /** Signals an existing workflow run. */
+  async signalRun(
+    request: WorkflowManagerSignalRunInput,
+  ): Promise<ManagedWorkflowRunSignal> {
+    return managedWorkflowRunSignalFromProto(
+      await this.client.signalRun({
+        runId: request.runId,
+        signal: workflowSignalToProto(request.signal),
+        invocationToken: this.invocationToken,
+      }),
+    );
+  }
+
+  /** Signals a workflow run, or starts it when no run exists for the key. */
+  async signalOrStartRun(
+    request: WorkflowManagerSignalOrStartRunInput,
+  ): Promise<ManagedWorkflowRunSignal> {
+    return managedWorkflowRunSignalFromProto(
+      await this.client.signalOrStartRun({
+        providerName: request.providerName,
+        workflowKey: request.workflowKey,
+        target: boundWorkflowTargetToProto(request.target),
+        idempotencyKey: request.idempotencyKey?.trim() || this.idempotencyKey,
+        signal: workflowSignalToProto(request.signal),
+        invocationToken: this.invocationToken,
+        definitionId: request.definitionId ?? "",
+      }),
+    );
+  }
+
+  /** Creates a reusable workflow definition. */
+  async createDefinition(
+    request: WorkflowManagerCreateDefinitionInput,
+  ): Promise<ManagedWorkflowDefinition> {
+    return managedWorkflowDefinitionFromProto(
+      await this.client.createDefinition({
+        providerName: request.providerName,
+        target: boundWorkflowTargetToProto(request.target),
+        invocationToken: this.invocationToken,
+        idempotencyKey: request.idempotencyKey?.trim() || this.idempotencyKey,
+      }),
+    );
+  }
+
+  /** Fetches one workflow definition. */
+  async getDefinition(
+    request: WorkflowManagerGetDefinitionInput,
+  ): Promise<ManagedWorkflowDefinition> {
+    return managedWorkflowDefinitionFromProto(
+      await this.client.getDefinition({
+        definitionId: request.definitionId,
+        invocationToken: this.invocationToken,
+      }),
+    );
+  }
+
+  /** Updates a workflow definition. */
+  async updateDefinition(
+    request: WorkflowManagerUpdateDefinitionInput,
+  ): Promise<ManagedWorkflowDefinition> {
+    return managedWorkflowDefinitionFromProto(
+      await this.client.updateDefinition({
+        definitionId: request.definitionId,
+        providerName: request.providerName ?? "",
+        target: boundWorkflowTargetToProto(request.target),
+        invocationToken: this.invocationToken,
+      }),
+    );
+  }
+
+  /** Deletes a workflow definition. */
+  async deleteDefinition(
+    request: WorkflowManagerDeleteDefinitionInput,
+  ): Promise<void> {
+    await this.client.deleteDefinition({
+      definitionId: request.definitionId,
+      invocationToken: this.invocationToken,
+    });
+  }
+
   /** Creates a workflow schedule. */
   async createSchedule(
     request: WorkflowManagerCreateScheduleInput,
-  ): Promise<ManagedWorkflowScheduleMessage> {
-    return await this.client.createSchedule({
-      ...request,
-      idempotencyKey: request.idempotencyKey?.trim() || this.idempotencyKey,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<ManagedWorkflowSchedule> {
+    return managedWorkflowScheduleFromProto(
+      await this.client.createSchedule({
+        providerName: request.providerName,
+        cron: request.cron,
+        timezone: request.timezone ?? "",
+        target: boundWorkflowTargetToProto(request.target),
+        paused: request.paused ?? false,
+        invocationToken: this.invocationToken,
+        idempotencyKey: request.idempotencyKey?.trim() || this.idempotencyKey,
+        definitionId: request.definitionId ?? "",
+      }),
+    );
   }
 
   /** Fetches one workflow schedule. */
   async getSchedule(
     request: WorkflowManagerGetScheduleInput,
-  ): Promise<ManagedWorkflowScheduleMessage> {
-    return await this.client.getSchedule({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<ManagedWorkflowSchedule> {
+    return managedWorkflowScheduleFromProto(
+      await this.client.getSchedule({
+        scheduleId: request.scheduleId,
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 
   /** Updates a workflow schedule. */
   async updateSchedule(
     request: WorkflowManagerUpdateScheduleInput,
-  ): Promise<ManagedWorkflowScheduleMessage> {
-    return await this.client.updateSchedule({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<ManagedWorkflowSchedule> {
+    return managedWorkflowScheduleFromProto(
+      await this.client.updateSchedule({
+        scheduleId: request.scheduleId,
+        providerName: request.providerName ?? "",
+        cron: request.cron ?? "",
+        timezone: request.timezone ?? "",
+        target: boundWorkflowTargetToProto(request.target),
+        paused: request.paused ?? false,
+        invocationToken: this.invocationToken,
+        definitionId: request.definitionId ?? "",
+      }),
+    );
   }
 
   /** Deletes a workflow schedule. */
@@ -167,7 +366,7 @@ export class WorkflowManager {
     request: WorkflowManagerDeleteScheduleInput,
   ): Promise<void> {
     await this.client.deleteSchedule({
-      ...request,
+      scheduleId: request.scheduleId,
       invocationToken: this.invocationToken,
     });
   }
@@ -175,52 +374,71 @@ export class WorkflowManager {
   /** Pauses a workflow schedule. */
   async pauseSchedule(
     request: WorkflowManagerPauseScheduleInput,
-  ): Promise<ManagedWorkflowScheduleMessage> {
-    return await this.client.pauseSchedule({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<ManagedWorkflowSchedule> {
+    return managedWorkflowScheduleFromProto(
+      await this.client.pauseSchedule({
+        scheduleId: request.scheduleId,
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 
   /** Resumes a workflow schedule. */
   async resumeSchedule(
     request: WorkflowManagerResumeScheduleInput,
-  ): Promise<ManagedWorkflowScheduleMessage> {
-    return await this.client.resumeSchedule({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<ManagedWorkflowSchedule> {
+    return managedWorkflowScheduleFromProto(
+      await this.client.resumeSchedule({
+        scheduleId: request.scheduleId,
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 
   /** Creates an event trigger. */
   async createTrigger(
     request: WorkflowManagerCreateTriggerInput,
-  ): Promise<ManagedWorkflowEventTriggerMessage> {
-    return await this.client.createEventTrigger({
-      ...request,
-      idempotencyKey: request.idempotencyKey?.trim() || this.idempotencyKey,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<ManagedWorkflowEventTrigger> {
+    return managedWorkflowEventTriggerFromProto(
+      await this.client.createEventTrigger({
+        providerName: request.providerName,
+        match: workflowEventMatchToProto(request.match),
+        target: boundWorkflowTargetToProto(request.target),
+        paused: request.paused ?? false,
+        invocationToken: this.invocationToken,
+        idempotencyKey: request.idempotencyKey?.trim() || this.idempotencyKey,
+        definitionId: request.definitionId ?? "",
+      }),
+    );
   }
 
   /** Fetches one event trigger. */
   async getTrigger(
     request: WorkflowManagerGetTriggerInput,
-  ): Promise<ManagedWorkflowEventTriggerMessage> {
-    return await this.client.getEventTrigger({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<ManagedWorkflowEventTrigger> {
+    return managedWorkflowEventTriggerFromProto(
+      await this.client.getEventTrigger({
+        triggerId: request.triggerId,
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 
   /** Updates an event trigger. */
   async updateTrigger(
     request: WorkflowManagerUpdateTriggerInput,
-  ): Promise<ManagedWorkflowEventTriggerMessage> {
-    return await this.client.updateEventTrigger({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<ManagedWorkflowEventTrigger> {
+    return managedWorkflowEventTriggerFromProto(
+      await this.client.updateEventTrigger({
+        triggerId: request.triggerId,
+        providerName: request.providerName ?? "",
+        match: workflowEventMatchToProto(request.match),
+        target: boundWorkflowTargetToProto(request.target),
+        paused: request.paused ?? false,
+        invocationToken: this.invocationToken,
+        definitionId: request.definitionId ?? "",
+      }),
+    );
   }
 
   /** Deletes an event trigger. */
@@ -228,7 +446,7 @@ export class WorkflowManager {
     request: WorkflowManagerDeleteTriggerInput,
   ): Promise<void> {
     await this.client.deleteEventTrigger({
-      ...request,
+      triggerId: request.triggerId,
       invocationToken: this.invocationToken,
     });
   }
@@ -236,31 +454,42 @@ export class WorkflowManager {
   /** Pauses an event trigger. */
   async pauseTrigger(
     request: WorkflowManagerPauseTriggerInput,
-  ): Promise<ManagedWorkflowEventTriggerMessage> {
-    return await this.client.pauseEventTrigger({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<ManagedWorkflowEventTrigger> {
+    return managedWorkflowEventTriggerFromProto(
+      await this.client.pauseEventTrigger({
+        triggerId: request.triggerId,
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 
   /** Resumes an event trigger. */
   async resumeTrigger(
     request: WorkflowManagerResumeTriggerInput,
-  ): Promise<ManagedWorkflowEventTriggerMessage> {
-    return await this.client.resumeEventTrigger({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<ManagedWorkflowEventTrigger> {
+    return managedWorkflowEventTriggerFromProto(
+      await this.client.resumeEventTrigger({
+        triggerId: request.triggerId,
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 
   /** Publishes an event into the workflow manager. */
   async publishEvent(
     request: WorkflowManagerPublishEventInput,
-  ): Promise<WorkflowEventMessage> {
-    return await this.client.publishEvent({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+  ): Promise<WorkflowEvent> {
+    const event = workflowEventFromProto(
+      await this.client.publishEvent({
+        event: workflowEventToProto(request.event),
+        invocationToken: this.invocationToken,
+        providerName: request.providerName ?? "",
+      }),
+    );
+    if (event === undefined) {
+      throw new Error("WorkflowManager.publishEvent returned no event");
+    }
+    return event;
   }
 }