@ldsg/workflow 0.3.8 → 0.3.10

package/dist/utils/evaluate-variables/utils/get-data-with-json-schema-and-input/resolve-json-schema.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveJsonSchema = void 0;
+const jsonata_1 = __importDefault(require("jsonata"));
+const lodash_1 = __importDefault(require("lodash"));
+const resolveJsonSchema = async (params) => {
+    var _a;
+    const { input, jsonSchema, source } = params;
+    const { type: jsonSchemaType, 'x-expression': jsonSchemaExpression, const: jsonSchemaConst } = jsonSchema;
+    let data;
+    /**
+     * 若常量值存在，则直接返回
+     */
+    if (jsonSchemaConst) {
+        data = jsonSchemaConst;
+    }
+    else {
+        data = source;
+        /**
+         * 若表达式存在，则尝试获取表达式值
+         */
+        if (jsonSchemaExpression) {
+            const expression = (0, jsonata_1.default)(jsonSchemaExpression);
+            data = await expression.evaluate(input);
+        }
+        switch (jsonSchemaType) {
+            case 'object': {
+                data = data !== null && data !== void 0 ? data : {};
+                const jsonSchemaProperties = (_a = jsonSchema.properties) !== null && _a !== void 0 ? _a : {};
+                const keys = lodash_1.default.keys(jsonSchemaProperties);
+                const keysMapResPromises = keys.map(async (key) => {
+                    const source = lodash_1.default.get(data, key);
+                    const resolveJsonSchemaRes = await (0, exports.resolveJsonSchema)({
+                        jsonSchema: jsonSchemaProperties[key],
+                        input,
+                        source
+                    });
+                    const res = {
+                        key,
+                        resolveJsonSchemaRes
+                    };
+                    return res;
+                });
+                const keysMapRes = await Promise.all(keysMapResPromises);
+                lodash_1.default.each(keysMapRes, ({ key, resolveJsonSchemaRes }) => {
+                    lodash_1.default.set(data, key, resolveJsonSchemaRes.data);
+                });
+                break;
+            }
+            case 'array': {
+                throw new Error('unsupported array type');
+            }
+            case 'boolean':
+            case 'integer':
+            case 'number':
+            case 'string': {
+                break;
+            }
+            case 'null': {
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+    }
+    const res = { data };
+    return res;
+};
+exports.resolveJsonSchema = resolveJsonSchema;

package/dist/utils/evaluate-variables/utils/get-field-path-by-field-type-key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-field-path-by-field-type-key.d.ts","sourceRoot":"","sources":["../../../../src/utils/evaluate-variables/utils/get-field-path-by-field-type-key.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,GAAI,cAAc,MAAM,KAAG,MAiBjE,CAAC"}
+{"version":3,"file":"get-field-path-by-field-type-key.d.ts","sourceRoot":"","sources":["../../../../src/utils/evaluate-variables/utils/get-field-path-by-field-type-key.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,GAAI,cAAc,MAAM,KAAG,MAejE,CAAC"}

package/dist/utils/evaluate-variables/utils/get-field-path-by-field-type-key.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFieldPathByFieldTypeKey = void 0;
 const getFieldPathByFieldTypeKey = (fieldTypeKey) => {
     // 将字符串按点分割成数组
-    const splitRes = fieldTypeKey.split(".");
+    const splitRes = fieldTypeKey.split('.');
     // 过滤数组：除了索引为复数且值为 properties ，其他所有元素均保留
     const filterRes = splitRes.filter((value, index) => {
-        const res = !(value === "properties" && index % 2 === 0);
+        const res = !(value === 'properties' && index % 2 === 0);
         return res;
     });
     // 将过滤后的数组重新用点连接成字符串
-    const res = filterRes.join(".");
+    const res = filterRes.join('.');
     return res;
 };
 exports.getFieldPathByFieldTypeKey = getFieldPathByFieldTypeKey;

package/dist/utils/get-execution-levels.d.ts

@@ -0,0 +1,17 @@
+import { WorkflowData, WorkflowNodeInfo } from '../types';
+interface GetExecutionLevelsParams {
+    workflowData: WorkflowData;
+    startNode: WorkflowNodeInfo;
+    endNode: WorkflowNodeInfo;
+}
+interface GetExecutionLevelsRes {
+    executionLevels: WorkflowNodeInfo[][];
+}
+/**
+ * 获取执行层级列表，用于并行执行
+ * 根据节点依赖关系构建执行层级，同一层级的节点可以并行执行
+ * 例如：连线如 1-2、1-3、2-4、3-4、4-5 时，需要 2、3 均执行完成后才执行 4
+ */
+export declare const getExecutionLevels: (params: GetExecutionLevelsParams) => GetExecutionLevelsRes;
+export {};
+//# sourceMappingURL=get-execution-levels.d.ts.map

package/dist/utils/get-execution-levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-execution-levels.d.ts","sourceRoot":"","sources":["../../src/utils/get-execution-levels.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE1D,UAAU,wBAAwB;IAChC,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,OAAO,EAAE,gBAAgB,CAAC;CAC3B;AAED,UAAU,qBAAqB;IAC7B,eAAe,EAAE,gBAAgB,EAAE,EAAE,CAAC;CACvC;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,wBAAwB,KAAG,qBAuJrE,CAAC"}

package/dist/utils/get-execution-levels.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExecutionLevels = void 0;
+/**
+ * 获取执行层级列表，用于并行执行
+ * 根据节点依赖关系构建执行层级，同一层级的节点可以并行执行
+ * 例如：连线如 1-2、1-3、2-4、3-4、4-5 时，需要 2、3 均执行完成后才执行 4
+ */
+const getExecutionLevels = (params) => {
+    const { workflowData, startNode, endNode } = params;
+    const { edges, nodes } = workflowData;
+    // 构建节点映射
+    const nodeMap = new Map();
+    nodes.forEach((node) => {
+        nodeMap.set(node.id, node);
+    });
+    // 构建依赖关系图
+    const dependencies = new Map(); // 节点 -> 依赖的节点集合
+    const dependents = new Map(); // 节点 -> 被依赖的节点集合
+    // 初始化所有节点的依赖和被依赖集合
+    nodes.forEach((node) => {
+        dependencies.set(node.id, new Set());
+        dependents.set(node.id, new Set());
+    });
+    // 根据边构建依赖关系
+    edges.forEach((edge) => {
+        var _a, _b;
+        const { sourceWorkflowNodeResourceId, targetWorkflowNodeResourceId } = edge;
+        // target 依赖于 source
+        (_a = dependencies.get(targetWorkflowNodeResourceId)) === null || _a === void 0 ? void 0 : _a.add(sourceWorkflowNodeResourceId);
+        // source 被 target 依赖
+        (_b = dependents.get(sourceWorkflowNodeResourceId)) === null || _b === void 0 ? void 0 : _b.add(targetWorkflowNodeResourceId);
+    });
+    // 使用拓扑排序构建执行层级
+    const executionLevels = [];
+    const completedNodes = new Set();
+    const remainingDependencies = new Map();
+    // 首先进行循环依赖检测
+    const visited = new Set();
+    const recursionStack = new Set();
+    function hasCycle(nodeId) {
+        if (recursionStack.has(nodeId)) {
+            return true; // 发现循环依赖
+        }
+        if (visited.has(nodeId)) {
+            return false; // 已经检查过，没有循环
+        }
+        visited.add(nodeId);
+        recursionStack.add(nodeId);
+        const deps = dependencies.get(nodeId);
+        if (deps) {
+            for (const dep of deps) {
+                if (hasCycle(dep)) {
+                    return true;
+                }
+            }
+        }
+        recursionStack.delete(nodeId);
+        return false;
+    }
+    // 检查所有节点是否存在循环依赖
+    for (const nodeId of dependencies.keys()) {
+        if (hasCycle(nodeId)) {
+            throw new Error('Circular dependency detected in workflow');
+        }
+    }
+    // 复制依赖关系到剩余依赖映射
+    dependencies.forEach((deps, nodeId) => {
+        remainingDependencies.set(nodeId, new Set(deps));
+    });
+    // 开始节点必须在第一层
+    const firstLevel = [startNode];
+    executionLevels.push(firstLevel);
+    completedNodes.add(startNode.id);
+    // 更新剩余依赖
+    remainingDependencies.delete(startNode.id);
+    remainingDependencies.forEach((deps) => {
+        deps.delete(startNode.id);
+    });
+    // 构建后续层级
+    while (remainingDependencies.size > 0) {
+        const currentLevel = [];
+        const nodesToProcess = [];
+        // 找到所有依赖已满足的节点
+        remainingDependencies.forEach((deps, nodeId) => {
+            if (deps.size === 0) {
+                nodesToProcess.push(nodeId);
+                const node = nodeMap.get(nodeId);
+                if (node) {
+                    currentLevel.push(node);
+                }
+            }
+        });
+        // 如果没有找到可以执行的节点，说明存在循环依赖
+        if (currentLevel.length === 0) {
+            throw new Error('Circular dependency detected in workflow');
+        }
+        executionLevels.push(currentLevel);
+        // 标记当前层级的节点为已完成
+        nodesToProcess.forEach((nodeId) => {
+            completedNodes.add(nodeId);
+            remainingDependencies.delete(nodeId);
+        });
+        // 更新剩余依赖
+        const remainingDepsArray = Array.from(remainingDependencies.entries());
+        remainingDepsArray.forEach(([nodeId, deps]) => {
+            nodesToProcess.forEach((processedNodeId) => {
+                deps.delete(processedNodeId);
+            });
+            remainingDependencies.set(nodeId, deps);
+        });
+    }
+    // 确保结束节点在最后一层
+    if (executionLevels.length > 0) {
+        const lastLevel = executionLevels[executionLevels.length - 1];
+        const endNodeInLastLevel = lastLevel.some((node) => node.id === endNode.id);
+        if (!endNodeInLastLevel) {
+            // 如果结束节点不在最后一层，需要检查是否已经在某一层中
+            let endNodeFound = false;
+            for (const level of executionLevels) {
+                if (level.some((node) => node.id === endNode.id)) {
+                    endNodeFound = true;
+                    break;
+                }
+            }
+            if (!endNodeFound) {
+                // 如果结束节点不在任何层级中，添加到最后一层
+                executionLevels.push([endNode]);
+            }
+        }
+    }
+    return {
+        executionLevels
+    };
+};
+exports.getExecutionLevels = getExecutionLevels;

package/dist/utils/get-execution-levels.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-execution-levels.test.d.ts.map

package/dist/utils/get-execution-levels.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-execution-levels.test.d.ts","sourceRoot":"","sources":["../../src/utils/get-execution-levels.test.ts"],"names":[],"mappings":""}

package/dist/utils/get-execution-levels.test.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_execution_levels_1 = require("./get-execution-levels");
+// 创建测试节点
+const createTestNode = (id) => ({
+    id,
+    propertiesSchema: {
+        type: 'object',
+        properties: {
+            input: { type: 'object' },
+            output: { type: 'object' }
+        }
+    },
+    execute: async () => ({ variables: {} })
+});
+describe('getExecutionLevels', () => {
+    test('should create correct execution levels for parallel workflow', () => {
+        // 测试场景：1-2, 1-3, 2-4, 3-4, 4-5
+        // 期望的层级：
+        // Level 0: [1]
+        // Level 1: [2, 3] (并行)
+        // Level 2: [4] (需要2,3都完成)
+        // Level 3: [5]
+        const nodes = [
+            createTestNode('node-1'),
+            createTestNode('node-2'),
+            createTestNode('node-3'),
+            createTestNode('node-4'),
+            createTestNode('node-5')
+        ];
+        const workflowData = {
+            edges: [
+                {
+                    sourceWorkflowNodeResourceId: 'node-1',
+                    targetWorkflowNodeResourceId: 'node-2'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-1',
+                    targetWorkflowNodeResourceId: 'node-3'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-2',
+                    targetWorkflowNodeResourceId: 'node-4'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-3',
+                    targetWorkflowNodeResourceId: 'node-4'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-4',
+                    targetWorkflowNodeResourceId: 'node-5'
+                }
+            ],
+            nodes
+        };
+        const startNode = nodes[0]; // node-1
+        const endNode = nodes[4]; // node-5
+        const { executionLevels } = (0, get_execution_levels_1.getExecutionLevels)({
+            workflowData,
+            startNode,
+            endNode
+        });
+        // 验证层级数量
+        expect(executionLevels.length).toBe(4);
+        // 验证第一层（只有node-1）
+        expect(executionLevels[0]).toHaveLength(1);
+        expect(executionLevels[0][0].id).toBe('node-1');
+        // 验证第二层（node-2和node-3，可以并行）
+        expect(executionLevels[1]).toHaveLength(2);
+        const level2NodeIds = executionLevels[1].map((node) => node.id).sort();
+        expect(level2NodeIds).toEqual(['node-2', 'node-3']);
+        // 验证第三层（只有node-4，需要2,3都完成）
+        expect(executionLevels[2]).toHaveLength(1);
+        expect(executionLevels[2][0].id).toBe('node-4');
+        // 验证第四层（只有node-5）
+        expect(executionLevels[3]).toHaveLength(1);
+        expect(executionLevels[3][0].id).toBe('node-5');
+    });
+    test('should handle simple sequential workflow', () => {
+        // 测试简单的顺序工作流：1-2-3
+        const nodes = [
+            createTestNode('node-1'),
+            createTestNode('node-2'),
+            createTestNode('node-3')
+        ];
+        const workflowData = {
+            edges: [
+                {
+                    sourceWorkflowNodeResourceId: 'node-1',
+                    targetWorkflowNodeResourceId: 'node-2'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-2',
+                    targetWorkflowNodeResourceId: 'node-3'
+                }
+            ],
+            nodes
+        };
+        const startNode = nodes[0]; // node-1
+        const endNode = nodes[2]; // node-3
+        const { executionLevels } = (0, get_execution_levels_1.getExecutionLevels)({
+            workflowData,
+            startNode,
+            endNode
+        });
+        // 验证层级数量
+        expect(executionLevels.length).toBe(3);
+        // 每层只有一个节点
+        executionLevels.forEach((level, index) => {
+            expect(level).toHaveLength(1);
+            expect(level[0].id).toBe(`node-${index + 1}`);
+        });
+    });
+    test('should handle complex parallel workflow', () => {
+        // 测试更复杂的并行工作流：1-2, 1-3, 1-4, 2-5, 3-5, 4-6, 5-6, 6-7
+        // 期望的层级：
+        // Level 0: [1]
+        // Level 1: [2, 3, 4] (并行)
+        // Level 2: [5] (需要2,3完成)
+        // Level 3: [6] (需要4,5完成)
+        // Level 4: [7]
+        const nodes = [
+            createTestNode('node-1'),
+            createTestNode('node-2'),
+            createTestNode('node-3'),
+            createTestNode('node-4'),
+            createTestNode('node-5'),
+            createTestNode('node-6'),
+            createTestNode('node-7')
+        ];
+        const workflowData = {
+            edges: [
+                {
+                    sourceWorkflowNodeResourceId: 'node-1',
+                    targetWorkflowNodeResourceId: 'node-2'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-1',
+                    targetWorkflowNodeResourceId: 'node-3'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-1',
+                    targetWorkflowNodeResourceId: 'node-4'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-2',
+                    targetWorkflowNodeResourceId: 'node-5'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-3',
+                    targetWorkflowNodeResourceId: 'node-5'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-4',
+                    targetWorkflowNodeResourceId: 'node-6'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-5',
+                    targetWorkflowNodeResourceId: 'node-6'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-6',
+                    targetWorkflowNodeResourceId: 'node-7'
+                }
+            ],
+            nodes
+        };
+        const startNode = nodes[0]; // node-1
+        const endNode = nodes[6]; // node-7
+        const { executionLevels } = (0, get_execution_levels_1.getExecutionLevels)({
+            workflowData,
+            startNode,
+            endNode
+        });
+        // 验证层级数量
+        expect(executionLevels.length).toBe(5);
+        // 验证第一层（只有node-1）
+        expect(executionLevels[0]).toHaveLength(1);
+        expect(executionLevels[0][0].id).toBe('node-1');
+        // 验证第二层（node-2, node-3, node-4，可以并行）
+        expect(executionLevels[1]).toHaveLength(3);
+        const level2NodeIds = executionLevels[1].map((node) => node.id).sort();
+        expect(level2NodeIds).toEqual(['node-2', 'node-3', 'node-4']);
+        // 验证第三层（只有node-5，需要2,3完成）
+        expect(executionLevels[2]).toHaveLength(1);
+        expect(executionLevels[2][0].id).toBe('node-5');
+        // 验证第四层（只有node-6，需要4,5完成）
+        expect(executionLevels[3]).toHaveLength(1);
+        expect(executionLevels[3][0].id).toBe('node-6');
+        // 验证第五层（只有node-7）
+        expect(executionLevels[4]).toHaveLength(1);
+        expect(executionLevels[4][0].id).toBe('node-7');
+    });
+    test('should throw error for circular dependency', () => {
+        // 测试循环依赖：1-2, 2-3, 3-1
+        const nodes = [
+            createTestNode('node-1'),
+            createTestNode('node-2'),
+            createTestNode('node-3')
+        ];
+        const workflowData = {
+            edges: [
+                {
+                    sourceWorkflowNodeResourceId: 'node-1',
+                    targetWorkflowNodeResourceId: 'node-2'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-2',
+                    targetWorkflowNodeResourceId: 'node-3'
+                },
+                {
+                    sourceWorkflowNodeResourceId: 'node-3',
+                    targetWorkflowNodeResourceId: 'node-1'
+                }
+            ],
+            nodes
+        };
+        const startNode = nodes[0]; // node-1
+        const endNode = nodes[2]; // node-3
+        expect(() => {
+            (0, get_execution_levels_1.getExecutionLevels)({
+                workflowData,
+                startNode,
+                endNode
+            });
+        }).toThrow('Circular dependency detected in workflow');
+    });
+});

package/package.json

@@ -1,31 +1,40 @@
 {
   "name": "@ldsg/workflow",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "",
+  "keywords": [],
+  "license": "MIT",
+  "author": "wanxger",
   "main": "dist/index.js",
+  "types": "dist",
   "files": [
     "dist/"
   ],
-  "types": "dist",
-  "keywords": [],
-  "author": "wanxger",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
     "json-schema": "0.4.0",
     "json-schema-default": "^1.0.2",
+    "jsonata": "^2.0.6",
     "lodash": "^4.17.21",
-    "@ldsg/handler": "0.3.8",
-    "@ldsg/resource": "0.3.8",
-    "@ldsg/resource-definition": "0.3.8"
+    "@ldsg/resource": "0.3.10",
+    "@ldsg/resource-definition": "0.3.10",
+    "@ldsg/constants": "0.3.10",
+    "@ldsg/handler": "0.3.10"
   },
   "devDependencies": {
-    "@types/flat": "^5.0.5",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.5.2",
     "@types/json-schema": "^7.0.15",
     "@types/lodash": "^4.14.202",
-    "@ldsg/types": "0.3.8"
+    "fs-extra": "^11.3.0",
+    "jest": "^29.5.0",
+    "supertest": "^6.3.4",
+    "ts-jest": "^29.1.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "@ldsg/types": "0.3.10"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",

package/dist/utils/evaluate-variables/utils/resolve-json-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-json-schema.d.ts","sourceRoot":"","sources":["../../../../src/utils/evaluate-variables/utils/resolve-json-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAuB,MAAM,aAAa,CAAC;AAO/D,UAAU,uBAAuB;IAC/B,UAAU,EAAE,WAAW,CAAC;IAExB;;OAEG;IACH,KAAK,EAAE,GAAG,CAAC;IAEX;;OAEG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,UAAU,oBAAoB;IAC5B,KAAK,CAAC,EAAE,GAAG,CAAC;IAEZ,IAAI,CAAC,EAAE,GAAG,CAAC;IAEX,OAAO,CAAC,EAAE,GAAG,CAAC;IAEd,UAAU,CAAC,EAAE,GAAG,CAAC;CAClB;AAED,KAAK,iBAAiB,GAAG,CACvB,MAAM,EAAE,uBAAuB,KAC5B,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAEnC,eAAO,MAAM,iBAAiB,EAAE,iBAkK/B,CAAC"}

package/dist/utils/evaluate-variables/utils/resolve-json-schema.js

@@ -1,112 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveJsonSchema = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const constants_1 = require("../constants");
-const resolveJsonSchema = async (params) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    const { input, jsonSchema, returnExpressionAsData } = params;
-    const { type } = jsonSchema;
-    const res = {};
-    switch (type) {
-        case "object": {
-            const properties = lodash_1.default.get(jsonSchema, "properties");
-            const promises = lodash_1.default.keys(properties).map(async (propertyKey) => {
-                const propertyValue = lodash_1.default.get(properties, propertyKey);
-                if (!lodash_1.default.isObject(propertyValue)) {
-                    return;
-                }
-                const resolveJsonSchemaRes = await (0, exports.resolveJsonSchema)({
-                    jsonSchema: propertyValue,
-                    input,
-                    returnExpressionAsData,
-                });
-                lodash_1.default.set(res, `data.${propertyKey}`, resolveJsonSchemaRes.data);
-                lodash_1.default.set(res, `const.${propertyKey}`, resolveJsonSchemaRes.const);
-                lodash_1.default.set(res, `default.${propertyKey}`, resolveJsonSchemaRes.default);
-                lodash_1.default.set(res, `expression.${propertyKey}`, resolveJsonSchemaRes.expression);
-            });
-            await Promise.all(promises);
-            break;
-        }
-        case "array": {
-            const itemsType = (_a = jsonSchema.items) === null || _a === void 0 ? void 0 : _a.type;
-            let objectExpression;
-            if (itemsType === "object") {
-                const resolveJsonSchemaRes = await (0, exports.resolveJsonSchema)({
-                    jsonSchema: jsonSchema.items,
-                    input,
-                    returnExpressionAsData: true,
-                });
-                const expressionSubstrings = [];
-                lodash_1.default.each(resolveJsonSchemaRes.expression, (value, key) => {
-                    if (value) {
-                        expressionSubstrings.push(`"${key}": ${value}`);
-                    }
-                });
-                objectExpression = `{${expressionSubstrings.join(",")}}`;
-            }
-            const promises = constants_1.FIELD_VALUE_RETRIEVAL_METHODS.map(async (fieldValueRetrievalMethod) => {
-                const { name, handle } = fieldValueRetrievalMethod;
-                /**
-                 * 字段的真实 path 是 key 去除类型
-                 */
-                const value = lodash_1.default.get(jsonSchema, name);
-                let res;
-                if (!lodash_1.default.isNil(value)) {
-                    res = await handle({
-                        input,
-                        retrievalMethodValue: value,
-                        objectExpression,
-                        returnExpressionAsData,
-                    });
-                }
-                return res;
-            });
-            const fieldValues = await Promise.all(promises);
-            res.const = (_b = fieldValues.find((value) => !lodash_1.default.isNil(value === null || value === void 0 ? void 0 : value.const))) === null || _b === void 0 ? void 0 : _b.const;
-            res.data = (_c = fieldValues.find((value) => !lodash_1.default.isNil(value === null || value === void 0 ? void 0 : value.data))) === null || _c === void 0 ? void 0 : _c.data;
-            res.default = (_d = fieldValues.find((value) => !lodash_1.default.isNil(value === null || value === void 0 ? void 0 : value.default))) === null || _d === void 0 ? void 0 : _d.default;
-            res.expression = (_e = fieldValues.find((value) => !lodash_1.default.isNil(value === null || value === void 0 ? void 0 : value.expression))) === null || _e === void 0 ? void 0 : _e.expression;
-            break;
-        }
-        case "boolean":
-        case "integer":
-        case "number":
-        case "string": {
-            const promises = constants_1.FIELD_VALUE_RETRIEVAL_METHODS.map(async (fieldValueRetrievalMethod) => {
-                const { name, handle } = fieldValueRetrievalMethod;
-                /**
-                 * 字段的真实 path 是 key 去除类型
-                 */
-                const value = lodash_1.default.get(jsonSchema, name);
-                let res;
-                if (!lodash_1.default.isNil(value)) {
-                    res = await handle({
-                        input,
-                        retrievalMethodValue: value,
-                        returnExpressionAsData,
-                    });
-                }
-                return res;
-            });
-            const fieldValues = await Promise.all(promises);
-            res.const = (_f = fieldValues.find((value) => !lodash_1.default.isNil(value === null || value === void 0 ? void 0 : value.const))) === null || _f === void 0 ? void 0 : _f.const;
-            res.data = (_g = fieldValues.find((value) => !lodash_1.default.isNil(value === null || value === void 0 ? void 0 : value.data))) === null || _g === void 0 ? void 0 : _g.data;
-            res.default = (_h = fieldValues.find((value) => !lodash_1.default.isNil(value === null || value === void 0 ? void 0 : value.default))) === null || _h === void 0 ? void 0 : _h.default;
-            res.expression = (_j = fieldValues.find((value) => !lodash_1.default.isNil(value === null || value === void 0 ? void 0 : value.expression))) === null || _j === void 0 ? void 0 : _j.expression;
-            break;
-        }
-        case "null": {
-            break;
-        }
-        default: {
-            throw new Error("invalid field type");
-        }
-    }
-    return res;
-};
-exports.resolveJsonSchema = resolveJsonSchema;

package/dist/utils/evaluate-variables.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=evaluate-variables.test.d.ts.map

package/dist/utils/evaluate-variables.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evaluate-variables.test.d.ts","sourceRoot":"","sources":["../../src/utils/evaluate-variables.test.ts"],"names":[],"mappings":""}