@flowgram.ai/runtime-js 0.2.23 → 0.2.24

package/dist/esm/index.js

@@ -1,79 +1,78 @@
 // ../interface/dist/esm/index.js
+import z2 from "zod";
 import z from "zod";
 import z3 from "zod";
-import z2 from "zod";
 import z4 from "zod";
 import z5 from "zod";
 import z6 from "zod";
 import z7 from "zod";
+var WorkflowIOZodSchema = z.record(z.string(), z.any());
+var WorkflowSnapshotZodSchema = z.object({
+  id: z.string(),
+  nodeID: z.string(),
+  inputs: WorkflowIOZodSchema,
+  outputs: WorkflowIOZodSchema.optional(),
+  data: WorkflowIOZodSchema,
+  branch: z.string().optional()
+});
+var WorkflowStatusZodShape = {
+  status: z.string(),
+  terminated: z.boolean(),
+  startTime: z.number(),
+  endTime: z.number().optional(),
+  timeCost: z.number()
+};
+var WorkflowStatusZodSchema = z.object(WorkflowStatusZodShape);
+var WorkflowNodeReportZodSchema = z.object({
+  id: z.string(),
+  ...WorkflowStatusZodShape,
+  snapshots: z.array(WorkflowSnapshotZodSchema)
+});
+var WorkflowReportsZodSchema = z.record(z.string(), WorkflowNodeReportZodSchema);
+var WorkflowMessageZodSchema = z.object({
+  id: z.string(),
+  type: z.enum(["log", "info", "debug", "error", "warning"]),
+  message: z.string(),
+  nodeID: z.string().optional(),
+  timestamp: z.number()
+});
+var WorkflowMessagesZodSchema = z.record(
+  z.enum(["log", "info", "debug", "error", "warning"]),
+  z.array(WorkflowMessageZodSchema)
+);
+var WorkflowZodSchema = {
+  Inputs: WorkflowIOZodSchema,
+  Outputs: WorkflowIOZodSchema,
+  Status: WorkflowStatusZodSchema,
+  Snapshot: WorkflowSnapshotZodSchema,
+  Reports: WorkflowReportsZodSchema,
+  Messages: WorkflowMessagesZodSchema
+};
 var FlowGramAPIName = /* @__PURE__ */ ((FlowGramAPIName2) => {
   FlowGramAPIName2["ServerInfo"] = "ServerInfo";
   FlowGramAPIName2["TaskRun"] = "TaskRun";
   FlowGramAPIName2["TaskReport"] = "TaskReport";
   FlowGramAPIName2["TaskResult"] = "TaskResult";
   FlowGramAPIName2["TaskCancel"] = "TaskCancel";
-  FlowGramAPIName2["Validation"] = "Validation";
+  FlowGramAPIName2["TaskValidate"] = "TaskValidate";
   return FlowGramAPIName2;
 })(FlowGramAPIName || {});
-var ValidationDefine = {
-  name: "Validation",
+var TaskValidateDefine = {
+  name: "TaskValidate",
   method: "POST",
-  path: "/validation",
-  module: "Validation",
+  path: "/task/validate",
+  module: "Task",
   schema: {
-    input: z.object({
-      schema: z.string()
+    input: z2.object({
+      schema: z2.string(),
+      inputs: WorkflowZodSchema.Inputs
     }),
-    output: z.object({
-      valid: z.boolean(),
-      nodeErrors: z.array(
-        z.object({
-          message: z.string(),
-          nodeID: z.string()
-        })
-      ),
-      edgeErrors: z.array(
-        z.object({
-          message: z.string(),
-          edge: z.object({
-            sourceNodeID: z.string(),
-            targetNodeID: z.string(),
-            sourcePortID: z.string().optional(),
-            targetPortID: z.string().optional()
-          })
-        })
-      )
+    output: z2.object({
+      valid: z2.boolean(),
+      errors: z2.array(z2.string()).optional()
     })
   }
 };
-var WorkflowIOZodSchema = z2.record(z2.string(), z2.any());
-var WorkflowSnapshotZodSchema = z2.object({
-  id: z2.string(),
-  nodeID: z2.string(),
-  inputs: WorkflowIOZodSchema,
-  outputs: WorkflowIOZodSchema.optional(),
-  data: WorkflowIOZodSchema,
-  branch: z2.string().optional()
-});
-var WorkflowStatusZodShape = {
-  status: z2.string(),
-  terminated: z2.boolean(),
-  startTime: z2.number(),
-  endTime: z2.number().optional(),
-  timeCost: z2.number()
-};
-var WorkflowStatusZodSchema = z2.object(WorkflowStatusZodShape);
-var WorkflowZodSchema = {
-  Inputs: WorkflowIOZodSchema,
-  Outputs: WorkflowIOZodSchema,
-  Status: WorkflowStatusZodSchema,
-  Snapshot: WorkflowSnapshotZodSchema,
-  NodeReport: z2.object({
-    id: z2.string(),
-    ...WorkflowStatusZodShape,
-    snapshots: z2.array(WorkflowSnapshotZodSchema)
-  })
-};
 var TaskRunDefine = {
   name: "TaskRun",
   method: "POST",
@@ -115,7 +114,8 @@ var TaskReportDefine = {
       inputs: WorkflowZodSchema.Inputs,
       outputs: WorkflowZodSchema.Outputs,
       workflowStatus: WorkflowZodSchema.Status,
-      reports: z5.record(z5.string(), WorkflowZodSchema.NodeReport)
+      reports: WorkflowZodSchema.Reports,
+      messages: WorkflowZodSchema.Messages
     })
   }
 };
@@ -170,9 +170,9 @@ var FlowGramAPIs = {
     /* TaskCancel */
   ]: TaskCancelDefine,
   [
-    "Validation"
-    /* Validation */
-  ]: ValidationDefine
+    "TaskValidate"
+    /* TaskValidate */
+  ]: TaskValidateDefine
 };
 var FlowGramAPINames = Object.keys(FlowGramAPIs);
 var WorkflowPortType = /* @__PURE__ */ ((WorkflowPortType2) => {
@@ -362,6 +362,205 @@ function compareNodeGroups(groupA, groupB) {
   };
 }
 
+// src/infrastructure/utils/json-schema-validator.ts
+var ROOT_PATH = "root";
+var isRootPath = (path) => path === ROOT_PATH;
+var validateValue = (value, schema, path) => {
+  if (schema.$ref) {
+    return { result: true };
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    if (!schema.enum.includes(value)) {
+      return {
+        result: false,
+        errorMessage: `Value at ${path} must be one of: ${schema.enum.join(
+          ", "
+        )}, but got: ${JSON.stringify(value)}`
+      };
+    }
+  }
+  switch (schema.type) {
+    case "boolean":
+      return validateBoolean(value, path);
+    case "string":
+      return validateString(value, path);
+    case "integer":
+      return validateInteger(value, path);
+    case "number":
+      return validateNumber(value, path);
+    case "object":
+      return validateObject(value, schema, path);
+    case "array":
+      return validateArray(value, schema, path);
+    case "map":
+      return validateMap(value, schema, path);
+    default:
+      return {
+        result: false,
+        errorMessage: `Unknown type "${schema.type}" at ${path}`
+      };
+  }
+};
+var validateBoolean = (value, path) => {
+  if (typeof value !== "boolean") {
+    return {
+      result: false,
+      errorMessage: `Expected boolean at ${path}, but got: ${typeof value}`
+    };
+  }
+  return { result: true };
+};
+var validateString = (value, path) => {
+  if (typeof value !== "string") {
+    return {
+      result: false,
+      errorMessage: `Expected string at ${path}, but got: ${typeof value}`
+    };
+  }
+  return { result: true };
+};
+var validateInteger = (value, path) => {
+  if (!Number.isInteger(value)) {
+    return {
+      result: false,
+      errorMessage: `Expected integer at ${path}, but got: ${JSON.stringify(value)}`
+    };
+  }
+  return { result: true };
+};
+var validateNumber = (value, path) => {
+  if (typeof value !== "number" || isNaN(value)) {
+    return {
+      result: false,
+      errorMessage: `Expected number at ${path}, but got: ${JSON.stringify(value)}`
+    };
+  }
+  return { result: true };
+};
+var validateObject = (value, schema, path) => {
+  if (value === null || value === void 0) {
+    return {
+      result: false,
+      errorMessage: `Expected object at ${path}, but got: ${value}`
+    };
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return {
+      result: false,
+      errorMessage: `Expected object at ${path}, but got: ${Array.isArray(value) ? "array" : typeof value}`
+    };
+  }
+  const objectValue = value;
+  if (schema.required && schema.required.length > 0) {
+    for (const requiredProperty of schema.required) {
+      if (!(requiredProperty in objectValue)) {
+        return {
+          result: false,
+          errorMessage: `Missing required property "${requiredProperty}" at ${path}`
+        };
+      }
+    }
+  }
+  if (schema.properties) {
+    for (const [propertyName, propertySchema] of Object.entries(schema.properties)) {
+      const isRequired = propertySchema.isPropertyRequired === true;
+      if (isRequired && !(propertyName in objectValue)) {
+        return {
+          result: false,
+          errorMessage: `Missing required property "${propertyName}" at ${path}`
+        };
+      }
+    }
+  }
+  if (schema.properties) {
+    for (const [propertyName, propertySchema] of Object.entries(schema.properties)) {
+      if (propertyName in objectValue) {
+        const propertyPath = isRootPath(path) ? propertyName : `${path}.${propertyName}`;
+        const propertyResult = validateValue(
+          objectValue[propertyName],
+          propertySchema,
+          propertyPath
+        );
+        if (!propertyResult.result) {
+          return propertyResult;
+        }
+      }
+    }
+  }
+  if (schema.additionalProperties) {
+    const definedProperties = new Set(Object.keys(schema.properties || {}));
+    for (const [propertyName, propertyValue] of Object.entries(objectValue)) {
+      if (!definedProperties.has(propertyName)) {
+        const propertyPath = isRootPath(path) ? propertyName : `${path}.${propertyName}`;
+        const propertyResult = validateValue(
+          propertyValue,
+          schema.additionalProperties,
+          propertyPath
+        );
+        if (!propertyResult.result) {
+          return propertyResult;
+        }
+      }
+    }
+  }
+  return { result: true };
+};
+var validateArray = (value, schema, path) => {
+  if (!Array.isArray(value)) {
+    return {
+      result: false,
+      errorMessage: `Expected array at ${path}, but got: ${typeof value}`
+    };
+  }
+  if (schema.items) {
+    for (const [index, item] of value.entries()) {
+      const itemPath = `${path}[${index}]`;
+      const itemResult = validateValue(item, schema.items, itemPath);
+      if (!itemResult.result) {
+        return itemResult;
+      }
+    }
+  }
+  return { result: true };
+};
+var validateMap = (value, schema, path) => {
+  if (value === null || value === void 0) {
+    return {
+      result: false,
+      errorMessage: `Expected map at ${path}, but got: ${value}`
+    };
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return {
+      result: false,
+      errorMessage: `Expected map at ${path}, but got: ${Array.isArray(value) ? "array" : typeof value}`
+    };
+  }
+  const mapValue = value;
+  if (schema.additionalProperties) {
+    for (const [key, mapItemValue] of Object.entries(mapValue)) {
+      const keyPath = isRootPath(path) ? key : `${path}.${key}`;
+      const keyResult = validateValue(mapItemValue, schema.additionalProperties, keyPath);
+      if (!keyResult.result) {
+        return keyResult;
+      }
+    }
+  }
+  return { result: true };
+};
+var JSONSchemaValidator = (params) => {
+  const { schema, value } = params;
+  try {
+    const validationResult = validateValue(value, schema, ROOT_PATH);
+    return validationResult;
+  } catch (error) {
+    return {
+      result: false,
+      errorMessage: `Validation error: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+};
+
 // src/nodes/loop/index.ts
 var LoopExecutor = class {
   constructor() {
@@ -880,11 +1079,48 @@ var WorkflowRuntimeNodeExecutors = [
 
 // src/domain/validation/index.ts
 var WorkflowRuntimeValidation = class {
-  validate(schema) {
+  invoke(params) {
+    const { schema, inputs } = params;
+    const schemaValidationResult = this.schema(schema);
+    if (!schemaValidationResult.valid) {
+      return schemaValidationResult;
+    }
+    const inputsValidationResult = this.inputs(this.getWorkflowInputsDeclare(schema), inputs);
+    if (!inputsValidationResult.valid) {
+      return inputsValidationResult;
+    }
+    return {
+      valid: true
+    };
+  }
+  schema(schema) {
+    return {
+      valid: true
+    };
+  }
+  inputs(inputsSchema, inputs) {
+    const { result, errorMessage } = JSONSchemaValidator({
+      schema: inputsSchema,
+      value: inputs
+    });
+    if (!result) {
+      const error = `JSON Schema validation failed: ${errorMessage}`;
+      return {
+        valid: false,
+        errors: [error]
+      };
+    }
     return {
       valid: true
     };
   }
+  getWorkflowInputsDeclare(schema) {
+    const startNode = schema.nodes.find((node) => node.type === FlowGramNode.Start);
+    if (!startNode) {
+      throw new Error("Workflow schema must have a start node");
+    }
+    return startNode.data.outputs;
+  }
 };
 
 // src/domain/executor/index.ts
@@ -1892,11 +2128,19 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
 // src/domain/engine/index.ts
 var WorkflowRuntimeEngine = class {
   constructor(service) {
+    this.validation = service.Validation;
     this.executor = service.Executor;
   }
   invoke(params) {
     const context = WorkflowRuntimeContext.create();
     context.init(params);
+    const valid = this.validate(params, context);
+    if (!valid) {
+      return WorkflowRuntimeTask.create({
+        processing: Promise.resolve({}),
+        context
+      });
+    }
     const processing = this.process(context);
     processing.then(() => {
       context.dispose();
@@ -1963,6 +2207,19 @@ var WorkflowRuntimeEngine = class {
       return {};
     }
   }
+  validate(params, context) {
+    const { valid, errors } = this.validation.invoke(params);
+    if (valid) {
+      return true;
+    }
+    errors?.forEach((message) => {
+      context.messageCenter.error({
+        message
+      });
+    });
+    context.statusCenter.workflow.fail();
+    return false;
+  }
   canExecuteNode(params) {
     const { node, context } = params;
     const prevNodes = node.prev;
@@ -2031,6 +2288,7 @@ var WorkflowRuntimeContainer = class _WorkflowRuntimeContainer {
     const Validation = new WorkflowRuntimeValidation();
     const Executor = new WorkflowRuntimeExecutor(WorkflowRuntimeNodeExecutors);
     const Engine = new WorkflowRuntimeEngine({
+      Validation,
       Executor
     });
     return {
@@ -2087,6 +2345,12 @@ var WorkflowApplication = class _WorkflowApplication {
     }
     return task.context.ioCenter.outputs;
   }
+  validate(params) {
+    const validation = this.container.get(IValidation);
+    const result = validation.invoke(params);
+    console.log("> POST TaskValidate - valid: ", result.valid);
+    return result;
+  }
   static get instance() {
     if (this._instance) {
       return this._instance;
@@ -2096,6 +2360,19 @@ var WorkflowApplication = class _WorkflowApplication {
   }
 };
 
+// src/api/task-validate.ts
+var TaskValidateAPI = async (input) => {
+  const app = WorkflowApplication.instance;
+  const { schema: stringSchema, inputs } = input;
+  const schema = JSON.parse(stringSchema);
+  const result = app.validate({
+    schema,
+    inputs
+  });
+  const output = result;
+  return output;
+};
+
 // src/api/task-run.ts
 var TaskRunAPI = async (input) => {
   const app = WorkflowApplication.instance;
@@ -2146,22 +2423,21 @@ var TaskCancelAPI = async (input) => {
 
 // src/api/index.ts
 var WorkflowRuntimeAPIs = {
+  [FlowGramAPIName.ServerInfo]: () => {
+  },
+  // TODO
   [FlowGramAPIName.TaskRun]: TaskRunAPI,
   [FlowGramAPIName.TaskReport]: TaskReportAPI,
   [FlowGramAPIName.TaskResult]: TaskResultAPI,
   [FlowGramAPIName.TaskCancel]: TaskCancelAPI,
-  [FlowGramAPIName.ServerInfo]: () => {
-  },
-  // TODO
-  [FlowGramAPIName.Validation]: () => {
-  }
-  // TODO
+  [FlowGramAPIName.TaskValidate]: TaskValidateAPI
 };
 export {
   TaskCancelAPI,
   TaskReportAPI,
   TaskResultAPI,
   TaskRunAPI,
+  TaskValidateAPI,
   WorkflowRuntimeAPIs
 };
 //# sourceMappingURL=index.js.map