@contractspec/example.workflow-system 3.7.5 → 3.7.7

package/dist/browser/entities/index.js

@@ -112,82 +112,160 @@ var ApprovalCommentEntity = defineEntity({
   indexes: [index.on(["approvalRequestId", "createdAt"])]
 });
 
-// src/entities/workflow.ts
+// src/entities/instance.ts
 import {
   defineEntity as defineEntity2,
   defineEntityEnum as defineEntityEnum2,
   field as field2,
   index as index2
 } from "@contractspec/lib.schema";
-var WorkflowStatusEnum = defineEntityEnum2({
-  name: "WorkflowStatus",
-  values: ["DRAFT", "ACTIVE", "DEPRECATED", "ARCHIVED"],
+var InstanceStatusEnum = defineEntityEnum2({
+  name: "InstanceStatus",
+  values: [
+    "PENDING",
+    "RUNNING",
+    "WAITING",
+    "PAUSED",
+    "COMPLETED",
+    "CANCELLED",
+    "FAILED",
+    "TIMEOUT"
+  ],
   schema: "workflow",
-  description: "Status of a workflow definition."
+  description: "Status of a workflow instance."
 });
-var WorkflowTriggerTypeEnum = defineEntityEnum2({
-  name: "WorkflowTriggerType",
-  values: ["MANUAL", "EVENT", "SCHEDULED", "API"],
+var StepExecutionStatusEnum = defineEntityEnum2({
+  name: "StepExecutionStatus",
+  values: [
+    "PENDING",
+    "ACTIVE",
+    "COMPLETED",
+    "SKIPPED",
+    "FAILED",
+    "TIMEOUT"
+  ],
   schema: "workflow",
-  description: "What triggers workflow instantiation."
+  description: "Status of a step execution."
 });
-var WorkflowDefinitionEntity = defineEntity2({
-  name: "WorkflowDefinition",
-  description: "A workflow blueprint that defines the process structure.",
+var WorkflowInstanceEntity = defineEntity2({
+  name: "WorkflowInstance",
+  description: "A running instance of a workflow definition.",
   schema: "workflow",
-  map: "workflow_definition",
+  map: "workflow_instance",
   fields: {
-    id: field2.id({ description: "Unique workflow definition ID" }),
-    name: field2.string({ description: "Human-readable workflow name" }),
-    key: field2.string({
-      description: 'Unique key for referencing (e.g., "purchase_approval")'
+    id: field2.id({ description: "Unique instance ID" }),
+    workflowDefinitionId: field2.foreignKey(),
+    referenceId: field2.string({
+      isOptional: true,
+      description: "External reference (e.g., order ID)"
     }),
-    description: field2.string({
+    referenceType: field2.string({
       isOptional: true,
-      description: "Detailed description"
+      description: 'Type of reference (e.g., "Order")'
     }),
-    version: field2.int({
-      default: 1,
-      description: "Version number for versioning definitions"
+    status: field2.enum("InstanceStatus", { default: "PENDING" }),
+    currentStepId: field2.string({
+      isOptional: true,
+      description: "Current step being executed"
+    }),
+    contextData: field2.json({ description: "Data context for this instance" }),
+    triggeredBy: field2.foreignKey({
+      description: "User who triggered the workflow"
     }),
-    status: field2.enum("WorkflowStatus", { default: "DRAFT" }),
-    triggerType: field2.enum("WorkflowTriggerType", { default: "MANUAL" }),
-    triggerConfig: field2.json({
+    triggerSource: field2.string({
       isOptional: true,
-      description: "Trigger-specific configuration"
+      description: 'Source of trigger (e.g., "api", "ui")'
+    }),
+    organizationId: field2.foreignKey(),
+    priority: field2.int({
+      default: 0,
+      description: "Processing priority (higher = more urgent)"
     }),
-    initialStepId: field2.string({
+    dueAt: field2.dateTime({
       isOptional: true,
-      description: "First step when workflow starts"
+      description: "When this instance should complete"
     }),
-    featureFlagKey: field2.string({
+    outcome: field2.string({
       isOptional: true,
-      description: "Feature flag to control availability"
+      description: 'Final outcome (e.g., "approved", "rejected")'
     }),
-    settings: field2.json({
+    resultData: field2.json({
       isOptional: true,
-      description: "Workflow-wide settings"
+      description: "Final result data"
     }),
-    metadata: field2.json({ isOptional: true, description: "Custom metadata" }),
-    organizationId: field2.foreignKey({ description: "Owning organization" }),
-    createdBy: field2.foreignKey({
-      description: "User who created this workflow"
+    errorMessage: field2.string({
+      isOptional: true,
+      description: "Error message if failed"
     }),
     createdAt: field2.createdAt(),
     updatedAt: field2.updatedAt(),
-    publishedAt: field2.dateTime({
+    startedAt: field2.dateTime({ isOptional: true }),
+    completedAt: field2.dateTime({ isOptional: true }),
+    workflowDefinition: field2.belongsTo("WorkflowDefinition", ["workflowDefinitionId"], ["id"]),
+    currentStep: field2.belongsTo("WorkflowStep", ["currentStepId"], ["id"]),
+    stepExecutions: field2.hasMany("StepExecution"),
+    approvalRequests: field2.hasMany("ApprovalRequest")
+  },
+  indexes: [
+    index2.on(["organizationId", "status"]),
+    index2.on(["workflowDefinitionId", "status"]),
+    index2.on(["referenceType", "referenceId"]),
+    index2.on(["triggeredBy", "status"]),
+    index2.on(["status", "dueAt"]),
+    index2.on(["createdAt"])
+  ],
+  enums: [InstanceStatusEnum]
+});
+var StepExecutionEntity = defineEntity2({
+  name: "StepExecution",
+  description: "Execution record of a step within a workflow instance.",
+  schema: "workflow",
+  map: "step_execution",
+  fields: {
+    id: field2.id({ description: "Unique execution ID" }),
+    workflowInstanceId: field2.foreignKey(),
+    workflowStepId: field2.foreignKey(),
+    status: field2.enum("StepExecutionStatus", { default: "PENDING" }),
+    executionOrder: field2.int({
+      default: 0,
+      description: "Order of execution within instance"
+    }),
+    inputData: field2.json({
       isOptional: true,
-      description: "When workflow was activated"
+      description: "Data when entering step"
+    }),
+    outputData: field2.json({
+      isOptional: true,
+      description: "Data when exiting step"
+    }),
+    actionTaken: field2.string({
+      isOptional: true,
+      description: 'Action that caused transition (e.g., "approve")'
     }),
-    steps: field2.hasMany("WorkflowStep"),
-    instances: field2.hasMany("WorkflowInstance")
+    transitionedTo: field2.string({
+      isOptional: true,
+      description: "Step key transitioned to"
+    }),
+    executedBy: field2.string({
+      isOptional: true,
+      description: "User who completed this step"
+    }),
+    errorMessage: field2.string({ isOptional: true }),
+    errorDetails: field2.json({ isOptional: true }),
+    retryCount: field2.int({ default: 0 }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    startedAt: field2.dateTime({ isOptional: true }),
+    completedAt: field2.dateTime({ isOptional: true }),
+    workflowInstance: field2.belongsTo("WorkflowInstance", ["workflowInstanceId"], ["id"], { onDelete: "Cascade" }),
+    workflowStep: field2.belongsTo("WorkflowStep", ["workflowStepId"], ["id"])
   },
   indexes: [
-    index2.unique(["organizationId", "key", "version"]),
-    index2.on(["organizationId", "status"]),
-    index2.on(["key", "version"])
+    index2.on(["workflowInstanceId", "executionOrder"]),
+    index2.on(["workflowInstanceId", "workflowStepId"]),
+    index2.on(["status"])
   ],
-  enums: [WorkflowStatusEnum, WorkflowTriggerTypeEnum]
+  enums: [StepExecutionStatusEnum]
 });
 
 // src/entities/step.ts
@@ -310,160 +388,82 @@ var WorkflowStepEntity = defineEntity3({
   enums: [StepTypeEnum, ApprovalModeEnum]
 });
 
-// src/entities/instance.ts
+// src/entities/workflow.ts
 import {
   defineEntity as defineEntity4,
   defineEntityEnum as defineEntityEnum4,
   field as field4,
   index as index4
 } from "@contractspec/lib.schema";
-var InstanceStatusEnum = defineEntityEnum4({
-  name: "InstanceStatus",
-  values: [
-    "PENDING",
-    "RUNNING",
-    "WAITING",
-    "PAUSED",
-    "COMPLETED",
-    "CANCELLED",
-    "FAILED",
-    "TIMEOUT"
-  ],
+var WorkflowStatusEnum = defineEntityEnum4({
+  name: "WorkflowStatus",
+  values: ["DRAFT", "ACTIVE", "DEPRECATED", "ARCHIVED"],
   schema: "workflow",
-  description: "Status of a workflow instance."
+  description: "Status of a workflow definition."
 });
-var StepExecutionStatusEnum = defineEntityEnum4({
-  name: "StepExecutionStatus",
-  values: [
-    "PENDING",
-    "ACTIVE",
-    "COMPLETED",
-    "SKIPPED",
-    "FAILED",
-    "TIMEOUT"
-  ],
+var WorkflowTriggerTypeEnum = defineEntityEnum4({
+  name: "WorkflowTriggerType",
+  values: ["MANUAL", "EVENT", "SCHEDULED", "API"],
   schema: "workflow",
-  description: "Status of a step execution."
+  description: "What triggers workflow instantiation."
 });
-var WorkflowInstanceEntity = defineEntity4({
-  name: "WorkflowInstance",
-  description: "A running instance of a workflow definition.",
+var WorkflowDefinitionEntity = defineEntity4({
+  name: "WorkflowDefinition",
+  description: "A workflow blueprint that defines the process structure.",
   schema: "workflow",
-  map: "workflow_instance",
+  map: "workflow_definition",
   fields: {
-    id: field4.id({ description: "Unique instance ID" }),
-    workflowDefinitionId: field4.foreignKey(),
-    referenceId: field4.string({
-      isOptional: true,
-      description: "External reference (e.g., order ID)"
-    }),
-    referenceType: field4.string({
-      isOptional: true,
-      description: 'Type of reference (e.g., "Order")'
+    id: field4.id({ description: "Unique workflow definition ID" }),
+    name: field4.string({ description: "Human-readable workflow name" }),
+    key: field4.string({
+      description: 'Unique key for referencing (e.g., "purchase_approval")'
     }),
-    status: field4.enum("InstanceStatus", { default: "PENDING" }),
-    currentStepId: field4.string({
+    description: field4.string({
       isOptional: true,
-      description: "Current step being executed"
+      description: "Detailed description"
     }),
-    contextData: field4.json({ description: "Data context for this instance" }),
-    triggeredBy: field4.foreignKey({
-      description: "User who triggered the workflow"
+    version: field4.int({
+      default: 1,
+      description: "Version number for versioning definitions"
     }),
-    triggerSource: field4.string({
+    status: field4.enum("WorkflowStatus", { default: "DRAFT" }),
+    triggerType: field4.enum("WorkflowTriggerType", { default: "MANUAL" }),
+    triggerConfig: field4.json({
       isOptional: true,
-      description: 'Source of trigger (e.g., "api", "ui")'
-    }),
-    organizationId: field4.foreignKey(),
-    priority: field4.int({
-      default: 0,
-      description: "Processing priority (higher = more urgent)"
+      description: "Trigger-specific configuration"
     }),
-    dueAt: field4.dateTime({
+    initialStepId: field4.string({
       isOptional: true,
-      description: "When this instance should complete"
+      description: "First step when workflow starts"
     }),
-    outcome: field4.string({
+    featureFlagKey: field4.string({
       isOptional: true,
-      description: 'Final outcome (e.g., "approved", "rejected")'
+      description: "Feature flag to control availability"
     }),
-    resultData: field4.json({
+    settings: field4.json({
       isOptional: true,
-      description: "Final result data"
+      description: "Workflow-wide settings"
     }),
-    errorMessage: field4.string({
-      isOptional: true,
-      description: "Error message if failed"
+    metadata: field4.json({ isOptional: true, description: "Custom metadata" }),
+    organizationId: field4.foreignKey({ description: "Owning organization" }),
+    createdBy: field4.foreignKey({
+      description: "User who created this workflow"
     }),
     createdAt: field4.createdAt(),
     updatedAt: field4.updatedAt(),
-    startedAt: field4.dateTime({ isOptional: true }),
-    completedAt: field4.dateTime({ isOptional: true }),
-    workflowDefinition: field4.belongsTo("WorkflowDefinition", ["workflowDefinitionId"], ["id"]),
-    currentStep: field4.belongsTo("WorkflowStep", ["currentStepId"], ["id"]),
-    stepExecutions: field4.hasMany("StepExecution"),
-    approvalRequests: field4.hasMany("ApprovalRequest")
-  },
-  indexes: [
-    index4.on(["organizationId", "status"]),
-    index4.on(["workflowDefinitionId", "status"]),
-    index4.on(["referenceType", "referenceId"]),
-    index4.on(["triggeredBy", "status"]),
-    index4.on(["status", "dueAt"]),
-    index4.on(["createdAt"])
-  ],
-  enums: [InstanceStatusEnum]
-});
-var StepExecutionEntity = defineEntity4({
-  name: "StepExecution",
-  description: "Execution record of a step within a workflow instance.",
-  schema: "workflow",
-  map: "step_execution",
-  fields: {
-    id: field4.id({ description: "Unique execution ID" }),
-    workflowInstanceId: field4.foreignKey(),
-    workflowStepId: field4.foreignKey(),
-    status: field4.enum("StepExecutionStatus", { default: "PENDING" }),
-    executionOrder: field4.int({
-      default: 0,
-      description: "Order of execution within instance"
-    }),
-    inputData: field4.json({
-      isOptional: true,
-      description: "Data when entering step"
-    }),
-    outputData: field4.json({
-      isOptional: true,
-      description: "Data when exiting step"
-    }),
-    actionTaken: field4.string({
+    publishedAt: field4.dateTime({
       isOptional: true,
-      description: 'Action that caused transition (e.g., "approve")'
-    }),
-    transitionedTo: field4.string({
-      isOptional: true,
-      description: "Step key transitioned to"
-    }),
-    executedBy: field4.string({
-      isOptional: true,
-      description: "User who completed this step"
+      description: "When workflow was activated"
     }),
-    errorMessage: field4.string({ isOptional: true }),
-    errorDetails: field4.json({ isOptional: true }),
-    retryCount: field4.int({ default: 0 }),
-    createdAt: field4.createdAt(),
-    updatedAt: field4.updatedAt(),
-    startedAt: field4.dateTime({ isOptional: true }),
-    completedAt: field4.dateTime({ isOptional: true }),
-    workflowInstance: field4.belongsTo("WorkflowInstance", ["workflowInstanceId"], ["id"], { onDelete: "Cascade" }),
-    workflowStep: field4.belongsTo("WorkflowStep", ["workflowStepId"], ["id"])
+    steps: field4.hasMany("WorkflowStep"),
+    instances: field4.hasMany("WorkflowInstance")
   },
   indexes: [
-    index4.on(["workflowInstanceId", "executionOrder"]),
-    index4.on(["workflowInstanceId", "workflowStepId"]),
-    index4.on(["status"])
+    index4.unique(["organizationId", "key", "version"]),
+    index4.on(["organizationId", "status"]),
+    index4.on(["key", "version"])
   ],
-  enums: [StepExecutionStatusEnum]
+  enums: [WorkflowStatusEnum, WorkflowTriggerTypeEnum]
 });
 // src/entities/index.ts
 var workflowSystemEntities = [