@contractspec/example.workflow-system 1.57.0 → 1.58.0

package/dist/browser/instance/index.js

@@ -0,0 +1,677 @@
+// src/instance/instance.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var InstanceStatusEnum = defineEnum("InstanceStatus", [
+  "PENDING",
+  "RUNNING",
+  "WAITING",
+  "PAUSED",
+  "COMPLETED",
+  "CANCELLED",
+  "FAILED",
+  "TIMEOUT"
+]);
+
+// src/instance/instance.schema.ts
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
+var WorkflowInstanceModel = defineSchemaModel({
+  name: "WorkflowInstanceModel",
+  description: "A running workflow instance",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    workflowDefinitionId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    referenceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    referenceType: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    status: { type: InstanceStatusEnum, isOptional: false },
+    currentStepId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    contextData: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    triggeredBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    priority: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    dueAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    outcome: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    resultData: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    errorMessage: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true }
+  }
+});
+var StartWorkflowInputModel = defineSchemaModel({
+  name: "StartWorkflowInput",
+  description: "Input for starting a workflow",
+  fields: {
+    workflowKey: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    contextData: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    referenceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    referenceType: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    priority: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    dueAt: { type: ScalarTypeEnum.DateTime(), isOptional: true }
+  }
+});
+var TransitionInputModel = defineSchemaModel({
+  name: "TransitionInput",
+  description: "Input for transitioning a workflow",
+  fields: {
+    instanceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    action: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    data: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    comment: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+var TransitionResultModel = defineSchemaModel({
+  name: "TransitionResult",
+  description: "Result of a workflow transition",
+  fields: {
+    success: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    instance: { type: WorkflowInstanceModel, isOptional: false },
+    previousStepKey: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    currentStepKey: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    message: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+
+// src/instance/instance.operations.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts/operations";
+import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
+var OWNERS = ["@example.workflow-system"];
+var StartWorkflowContract = defineCommand({
+  meta: {
+    key: "workflow.instance.start",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "instance", "start"],
+    description: "Start a new workflow instance.",
+    goal: "Initiate a workflow for a business process.",
+    context: "Order creation, request submission, etc."
+  },
+  io: {
+    input: StartWorkflowInputModel,
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.instance.started",
+        version: "1.0.0",
+        when: "Workflow starts",
+        payload: WorkflowInstanceModel
+      },
+      {
+        key: "workflow.step.entered",
+        version: "1.0.0",
+        when: "First step entered",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.started"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "start-workflow-happy-path",
+        given: ["Workflow definition exists"],
+        when: ["User starts workflow"],
+        then: ["Instance is created and started"]
+      }
+    ],
+    examples: [
+      {
+        key: "start-onboarding",
+        input: {
+          workflowKey: "onboarding-v1",
+          context: { employeeId: "emp-123" }
+        },
+        output: { id: "inst-456", status: "running" }
+      }
+    ]
+  }
+});
+var TransitionWorkflowContract = defineCommand({
+  meta: {
+    key: "workflow.instance.transition",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "instance", "transition", "state-machine"],
+    description: "Transition a workflow instance to the next step.",
+    goal: "Move workflow forward based on action.",
+    context: "Task completion, approval decisions."
+  },
+  io: {
+    input: TransitionInputModel,
+    output: TransitionResultModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.step.exited",
+        version: "1.0.0",
+        when: "Step is exited",
+        payload: WorkflowInstanceModel
+      },
+      {
+        key: "workflow.step.entered",
+        version: "1.0.0",
+        when: "New step is entered",
+        payload: WorkflowInstanceModel
+      },
+      {
+        key: "workflow.instance.completed",
+        version: "1.0.0",
+        when: "Workflow reaches end",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.transitioned"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "transition-workflow-happy-path",
+        given: ["Workflow instance is waiting at step"],
+        when: ["User provides input"],
+        then: ["Instance moves to next step"]
+      }
+    ],
+    examples: [
+      {
+        key: "complete-task",
+        input: {
+          instanceId: "inst-456",
+          action: "complete",
+          data: { approved: true }
+        },
+        output: { success: true, nextStep: "notify-hr" }
+      }
+    ]
+  }
+});
+var PauseWorkflowContract = defineCommand({
+  meta: {
+    key: "workflow.instance.pause",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "instance", "pause"],
+    description: "Pause a running workflow instance.",
+    goal: "Temporarily halt workflow execution.",
+    context: "Administrative action, emergency stop."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "PauseResumeInput",
+      fields: {
+        instanceId: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: false
+        },
+        reason: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true }
+      }
+    }),
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.instance.paused",
+        version: "1.0.0",
+        when: "Workflow is paused",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.paused"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "pause-workflow-happy-path",
+        given: ["Workflow is running"],
+        when: ["Admin pauses workflow"],
+        then: ["Instance status becomes PAUSED"]
+      }
+    ],
+    examples: [
+      {
+        key: "pause-maintenance",
+        input: { instanceId: "inst-456", reason: "System maintenance" },
+        output: { id: "inst-456", status: "paused" }
+      }
+    ]
+  }
+});
+var ResumeWorkflowContract = defineCommand({
+  meta: {
+    key: "workflow.instance.resume",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "instance", "resume"],
+    description: "Resume a paused workflow instance.",
+    goal: "Continue workflow execution.",
+    context: "Administrative action."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "PauseResumeInput",
+      fields: {
+        instanceId: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: false
+        },
+        reason: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true }
+      }
+    }),
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.instance.resumed",
+        version: "1.0.0",
+        when: "Workflow is resumed",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.resumed"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "resume-workflow-happy-path",
+        given: ["Workflow is paused"],
+        when: ["Admin resumes workflow"],
+        then: ["Instance status becomes RUNNING"]
+      }
+    ],
+    examples: [
+      {
+        key: "resume-normal",
+        input: { instanceId: "inst-456", reason: "Issue resolved" },
+        output: { id: "inst-456", status: "running" }
+      }
+    ]
+  }
+});
+var CancelWorkflowContract = defineCommand({
+  meta: {
+    key: "workflow.instance.cancel",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "instance", "cancel"],
+    description: "Cancel a workflow instance.",
+    goal: "Terminate workflow without completion.",
+    context: "User request, system cancellation."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "CancelWorkflowInput",
+      fields: {
+        instanceId: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: false
+        },
+        reason: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.instance.cancelled",
+        version: "1.0.0",
+        when: "Workflow is cancelled",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.cancelled"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "cancel-workflow-happy-path",
+        given: ["Workflow is running"],
+        when: ["User cancels workflow"],
+        then: ["Instance status becomes CANCELLED"]
+      }
+    ],
+    examples: [
+      {
+        key: "cancel-mistake",
+        input: { instanceId: "inst-456", reason: "Created by mistake" },
+        output: { id: "inst-456", status: "cancelled" }
+      }
+    ]
+  }
+});
+var ListInstancesContract = defineQuery({
+  meta: {
+    key: "workflow.instance.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "instance", "list"],
+    description: "List workflow instances with filtering.",
+    goal: "Browse and search running workflows.",
+    context: "Dashboard, monitoring."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "ListInstancesInput",
+      fields: {
+        workflowKey: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: true
+        },
+        status: { type: InstanceStatusEnum, isOptional: true },
+        referenceType: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: true
+        },
+        referenceId: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: true
+        },
+        triggeredBy: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: true
+        },
+        limit: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "ListInstancesOutput",
+      fields: {
+        instances: {
+          type: WorkflowInstanceModel,
+          isArray: true,
+          isOptional: false
+        },
+        total: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-instances-happy-path",
+        given: ["Workflow instances exist"],
+        when: ["User lists instances"],
+        then: ["List of instances is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-running",
+        input: { status: "running", limit: 10 },
+        output: { instances: [], total: 5 }
+      }
+    ]
+  }
+});
+var GetInstanceContract = defineQuery({
+  meta: {
+    key: "workflow.instance.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["workflow", "instance", "get"],
+    description: "Get a workflow instance with details.",
+    goal: "View workflow instance details.",
+    context: "Instance detail view."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "GetInstanceInput",
+      fields: {
+        instanceId: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-instance-happy-path",
+        given: ["Instance exists"],
+        when: ["User requests instance details"],
+        then: ["Instance details are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-details",
+        input: { instanceId: "inst-456" },
+        output: { id: "inst-456", workflowKey: "onboarding-v1" }
+      }
+    ]
+  }
+});
+
+// src/instance/instance.event.ts
+import { defineEvent, defineSchemaModel as defineSchemaModel3 } from "@contractspec/lib.contracts";
+import { ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
+var InstanceEventPayload = defineSchemaModel3({
+  name: "InstanceEventPayload",
+  description: "Base payload for instance events",
+  fields: {
+    instanceId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    workflowKey: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    status: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    referenceId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    referenceType: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: true
+    },
+    triggeredBy: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    timestamp: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var StepTransitionPayload = defineSchemaModel3({
+  name: "StepTransitionEventPayload",
+  description: "Payload for step transition events",
+  fields: {
+    instanceId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    fromStepKey: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    toStepKey: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    action: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    executedBy: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var InstanceCompletedPayload = defineSchemaModel3({
+  name: "InstanceCompletedEventPayload",
+  description: "Payload when instance completes",
+  fields: {
+    instanceId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    workflowKey: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    outcome: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    referenceId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    referenceType: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: true
+    },
+    duration: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var InstanceStartedEvent = defineEvent({
+  meta: {
+    key: "workflow.instance.started",
+    version: "1.0.0",
+    description: "A new workflow instance has been started.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "started"]
+  },
+  payload: InstanceEventPayload
+});
+var StepEnteredEvent = defineEvent({
+  meta: {
+    key: "workflow.step.entered",
+    version: "1.0.0",
+    description: "A workflow instance has entered a new step.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "step", "entered"]
+  },
+  payload: StepTransitionPayload
+});
+var StepExitedEvent = defineEvent({
+  meta: {
+    key: "workflow.step.exited",
+    version: "1.0.0",
+    description: "A workflow instance has exited a step.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "step", "exited"]
+  },
+  payload: StepTransitionPayload
+});
+var InstanceCompletedEvent = defineEvent({
+  meta: {
+    key: "workflow.instance.completed",
+    version: "1.0.0",
+    description: "A workflow instance has completed.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "completed"]
+  },
+  payload: InstanceCompletedPayload
+});
+var InstanceCancelledEvent = defineEvent({
+  meta: {
+    key: "workflow.instance.cancelled",
+    version: "1.0.0",
+    description: "A workflow instance has been cancelled.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "cancelled"]
+  },
+  payload: InstanceEventPayload
+});
+var InstancePausedEvent = defineEvent({
+  meta: {
+    key: "workflow.instance.paused",
+    version: "1.0.0",
+    description: "A workflow instance has been paused.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "paused"]
+  },
+  payload: InstanceEventPayload
+});
+var InstanceResumedEvent = defineEvent({
+  meta: {
+    key: "workflow.instance.resumed",
+    version: "1.0.0",
+    description: "A workflow instance has been resumed.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "resumed"]
+  },
+  payload: InstanceEventPayload
+});
+var InstanceFailedEvent = defineEvent({
+  meta: {
+    key: "workflow.instance.failed",
+    version: "1.0.0",
+    description: "A workflow instance has failed.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "failed"]
+  },
+  payload: InstanceEventPayload
+});
+var InstanceTimedOutEvent = defineEvent({
+  meta: {
+    key: "workflow.instance.timedOut",
+    version: "1.0.0",
+    description: "A workflow instance has timed out.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "timeout"]
+  },
+  payload: InstanceEventPayload
+});
+export {
+  WorkflowInstanceModel,
+  TransitionWorkflowContract,
+  TransitionResultModel,
+  TransitionInputModel,
+  StepExitedEvent,
+  StepEnteredEvent,
+  StartWorkflowInputModel,
+  StartWorkflowContract,
+  ResumeWorkflowContract,
+  PauseWorkflowContract,
+  ListInstancesContract,
+  InstanceTimedOutEvent,
+  InstanceStatusEnum,
+  InstanceStartedEvent,
+  InstanceResumedEvent,
+  InstancePausedEvent,
+  InstanceFailedEvent,
+  InstanceCompletedEvent,
+  InstanceCancelledEvent,
+  GetInstanceContract,
+  CancelWorkflowContract
+};

package/dist/browser/instance/instance.enum.js

@@ -0,0 +1,15 @@
+// src/instance/instance.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var InstanceStatusEnum = defineEnum("InstanceStatus", [
+  "PENDING",
+  "RUNNING",
+  "WAITING",
+  "PAUSED",
+  "COMPLETED",
+  "CANCELLED",
+  "FAILED",
+  "TIMEOUT"
+]);
+export {
+  InstanceStatusEnum
+};