@graph-compose/core 1.0.0

package/dist/types/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/types/workflow.ts"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,CAAC;AAE5B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6I5B,CAAC;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/types/workflow.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowGraphSchema = void 0;
+require("zod-openapi/extend");
+const zod_1 = require("zod");
+const config_1 = require("./config");
+const nodes_1 = require("./nodes");
+exports.WorkflowGraphSchema = zod_1.z
+    .object({
+    nodes: zod_1.z.array(nodes_1.NodeSchema),
+    tools: zod_1.z
+        .array(nodes_1.ToolNodeSchema)
+        .optional()
+        .openapi({
+        description: "The tools available to the workflow. This is only used in flows where agents are used.",
+    })
+        .default([]),
+    webhookUrl: zod_1.z.string().url().optional().openapi({
+        description: "Optional webhook URL to notify when the workflow completes",
+    }),
+    context: zod_1.z.record(zod_1.z.any()).optional().openapi({
+        description: "An optional object providing initial data to the workflow execution. This data is globally accessible throughout the workflow using handlebars expressions prefixed with `context.`, like `{{ context.apiKey }}`. You can leverage the full power of the [JSONata](https://jsonata.org/) query and transformation language within these expressions when accessing context data.\n\nUse this for static configuration or any data needed by multiple nodes at the start of the workflow. For sensitive values like API keys, it is recommended to use Graph Compose's dedicated secrets management features rather than including them directly in the context.",
+    }),
+    workflowConfig: config_1.WorkflowConfigSchema.optional().openapi({
+        description: "Configuration for the workflow",
+    }),
+    meta: zod_1.z.record(zod_1.z.any()).optional().openapi({
+        description: "Any additional information about the workflow. This pretty much doesn't do anything",
+    }),
+})
+    .superRefine((data, ctx) => {
+    // Get all agent nodes that have tools configured
+    const agentNodes = data.nodes.filter((node) => node.type === "agent" && node.tools && node.tools.length > 0);
+    // Get set of all available tool IDs
+    const availableTools = new Set(data.tools?.map(tool => tool.id) || []);
+    // Helper function to check for circular dependencies in a graph
+    const hasCircularDependencies = (nodes) => {
+        const graph = new Map();
+        nodes.forEach(node => {
+            graph.set(node.id, node.dependencies || []);
+        });
+        const visited = new Set();
+        const recursionStack = new Set();
+        const hasCycle = (nodeId) => {
+            if (!visited.has(nodeId)) {
+                visited.add(nodeId);
+                recursionStack.add(nodeId);
+                const dependencies = graph.get(nodeId) || [];
+                for (const depId of dependencies) {
+                    if (!visited.has(depId) && hasCycle(depId)) {
+                        return true;
+                    }
+                    else if (recursionStack.has(depId)) {
+                        return true;
+                    }
+                }
+            }
+            recursionStack.delete(nodeId);
+            return false;
+        };
+        for (const nodeId of graph.keys()) {
+            if (!visited.has(nodeId) && hasCycle(nodeId)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    // Helper function to validate graph tool dependencies
+    const validateGraphToolDependencies = (tool) => {
+        const nodeIds = new Set(tool.graph.nodes.map((n) => n.id));
+        for (const node of tool.graph.nodes) {
+            if (!node.dependencies)
+                continue;
+            for (const depId of node.dependencies) {
+                if (!nodeIds.has(depId)) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: `Tool "${tool.id}" contains node "${node.id}" that references non-existent dependency: ${depId}`,
+                        path: [
+                            "tools",
+                            tool.id,
+                            "graph",
+                            "nodes",
+                            node.id,
+                            "dependencies",
+                        ],
+                    });
+                }
+            }
+        }
+        if (hasCircularDependencies(tool.graph.nodes)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Tool "${tool.id}" contains circular dependencies in its graph`,
+                path: ["tools", tool.id, "graph", "nodes"],
+            });
+        }
+    };
+    for (const node of agentNodes) {
+        // Check max_iterations
+        if (!node.http.config?.max_iterations ||
+            node.http.config.max_iterations <= 1) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Agent node '${node.id}' has tools configured but max_iterations <= 1. Tools require at least 2 iterations to complete.`,
+                path: ["nodes", node.id, "http", "config", "max_iterations"],
+            });
+        }
+        // Check each tool exists and validate graph tools
+        for (const toolId of node.tools) {
+            if (!availableTools.has(toolId)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Agent node '${node.id}' references undefined tool '${toolId}'`,
+                    path: ["nodes", node.id, "tools"],
+                });
+            }
+            else {
+                // If tool exists and is a graph type, validate its dependencies
+                const tool = data.tools?.find(t => t.id === toolId);
+                if (tool && tool.type === "graph") {
+                    validateGraphToolDependencies(tool);
+                }
+            }
+        }
+    }
+})
+    .openapi({
+    ref: "WorkflowGraph",
+    description: "A workflow graph is a collection of nodes that are connected to each other. It is the main object that defines the structure of a workflow.",
+});
+//# sourceMappingURL=workflow.js.map

package/dist/types/workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.js","sourceRoot":"","sources":["../../src/types/workflow.ts"],"names":[],"mappings":"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"}

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./template";
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./template"), exports);
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B"}

package/dist/utils/template/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Extracts JSONata expression from a template string if it matches {{ expr }} format
+ * Returns null if the string is not a template expression
+ */
+export declare function extractJsonataExpression(template: string): string | null;
+/**
+ * Normalizes template strings by removing newlines within {{ }} expressions
+ */
+export declare function normalizeTemplate(template: string): string;
+/**
+ * Validates a single JSONata expression
+ */
+export declare function validateJsonataExpression(expression: string): boolean;
+/**
+ * Validates a template string that may contain multiple JSONata expressions
+ */
+export declare function validateTemplateExpression(template: string): boolean;
+/**
+ * Collects validation errors for all JSONata expressions in an object
+ */
+export declare function validateNestedExpressions(obj: any, path?: string[]): Array<{
+    path: string[];
+    expression: string;
+    error: string;
+}>;
+/**
+ * Type guard to check if a string contains template expressions
+ */
+export declare function hasTemplateExpressions(value: string): boolean;
+/**
+ * Extracts all template expressions from a string
+ */
+export declare function extractAllExpressions(template: string): string[];
+/**
+ * Validates that a JSONata expression returns a boolean
+ * Throws an error if the expression is invalid or doesn't return a boolean
+ */
+export declare function validateBooleanExpression(expression: string): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/template/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/template/index.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMxE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAI1D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAOrE;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CASpE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,GAAG,EACR,IAAI,GAAE,MAAM,EAAO,GAClB,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CA0C9D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAGhE;AA4BD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAQrE"}

package/dist/utils/template/index.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJsonataExpression = extractJsonataExpression;
+exports.normalizeTemplate = normalizeTemplate;
+exports.validateJsonataExpression = validateJsonataExpression;
+exports.validateTemplateExpression = validateTemplateExpression;
+exports.validateNestedExpressions = validateNestedExpressions;
+exports.hasTemplateExpressions = hasTemplateExpressions;
+exports.extractAllExpressions = extractAllExpressions;
+exports.validateBooleanExpression = validateBooleanExpression;
+const jsonata_1 = __importDefault(require("jsonata"));
+/**
+ * Extracts JSONata expression from a template string if it matches {{ expr }} format
+ * Returns null if the string is not a template expression
+ */
+function extractJsonataExpression(template) {
+    const match = template.match(/^\{\{([\s\S]*?)\}\}$/);
+    if (match) {
+        return match[1].trim();
+    }
+    return null;
+}
+/**
+ * Normalizes template strings by removing newlines within {{ }} expressions
+ */
+function normalizeTemplate(template) {
+    return template.replace(/\{\{([\s\S]*?)\}\}/g, (match, content) => {
+        return `{{${content.replace(/\s*\n\s*/g, " ")}}}`;
+    });
+}
+/**
+ * Validates a single JSONata expression
+ */
+function validateJsonataExpression(expression) {
+    try {
+        (0, jsonata_1.default)(expression.trim());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validates a template string that may contain multiple JSONata expressions
+ */
+function validateTemplateExpression(template) {
+    const expressions = template.match(/\{\{([^}]+)\}\}/g);
+    if (!expressions)
+        return false; // No expressions to validate
+    return expressions.every(expr => {
+        const innerExpr = expr.slice(2, -2).trim();
+        return validateJsonataExpression(innerExpr);
+    });
+}
+/**
+ * Collects validation errors for all JSONata expressions in an object
+ */
+function validateNestedExpressions(obj, path = []) {
+    const errors = [];
+    if (typeof obj === "string") {
+        // Check for full template string
+        const fullMatch = obj.match(/^\{\{\s*([^}]+)\s*\}\}$/);
+        if (fullMatch) {
+            try {
+                (0, jsonata_1.default)(fullMatch[1].trim());
+            }
+            catch (e) {
+                errors.push({
+                    path,
+                    expression: fullMatch[1].trim(),
+                    error: e instanceof Error ? e.message : "Unknown error",
+                });
+            }
+        }
+        else {
+            // Check for embedded expressions
+            const expressions = obj.match(/\{\{([^}]+)\}\}/g);
+            if (expressions) {
+                expressions.forEach(expr => {
+                    try {
+                        const expression = expr.slice(2, -2).trim();
+                        (0, jsonata_1.default)(expression);
+                    }
+                    catch (e) {
+                        errors.push({
+                            path,
+                            expression: expr.slice(2, -2).trim(),
+                            error: e instanceof Error ? e.message : "Unknown error",
+                        });
+                    }
+                });
+            }
+        }
+    }
+    else if (typeof obj === "object" && obj !== null) {
+        Object.entries(obj).forEach(([key, value]) => {
+            errors.push(...validateNestedExpressions(value, [...path, key]));
+        });
+    }
+    return errors;
+}
+/**
+ * Type guard to check if a string contains template expressions
+ */
+function hasTemplateExpressions(value) {
+    return /\{\{([^}]+)\}\}/.test(value);
+}
+/**
+ * Extracts all template expressions from a string
+ */
+function extractAllExpressions(template) {
+    const matches = template.match(/\{\{([^}]+)\}\}/g) || [];
+    return matches.map(match => match.slice(2, -2).trim());
+}
+/**
+ * Infers the return type of a JSONata expression
+ */
+function inferExpressionType(ast) {
+    // Handle basic types
+    if (ast.type === "boolean" ||
+        ast.type === "comparison" ||
+        ast.type === "condition" ||
+        ast.type === "regex") {
+        return { type: "boolean" };
+    }
+    // Handle binary operations that result in boolean
+    if (ast.type === "binary" &&
+        ["=", "!=", "<", "<=", ">", ">=", "in"].includes(ast.value)) {
+        return { type: "boolean" };
+    }
+    // For other types, return their type directly
+    return { type: ast.type };
+}
+/**
+ * Validates that a JSONata expression returns a boolean
+ * Throws an error if the expression is invalid or doesn't return a boolean
+ */
+function validateBooleanExpression(expression) {
+    try {
+        const ast = (0, jsonata_1.default)(expression).ast();
+        const inferredType = inferExpressionType(ast);
+        return inferredType.type === "boolean";
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/utils/template/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/template/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@graph-compose/core",
+  "version": "1.0.0",
+  "description": "Core functionality for Graph Compose",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "graph",
+    "compose",
+    "core"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/graph-compose/graph-compose.git",
+    "directory": "packages/core"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "uuid": "^11.0.5",
+    "zod": "^3.24.3",
+    "zod-openapi": "^4.2.4",
+    "zod-to-json-schema": "^3.24.1"
+  },
+  "devDependencies": {
+    "@tsconfig/node18": "^1.0.3",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^18.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.7.3",
+    "@typescript-eslint/parser": "^6.7.3",
+    "eslint": "^7.32.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.0.4"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testRegex": "src/__tests__/.*\\.test\\.ts$",
+    "moduleFileExtensions": [
+      "ts",
+      "js",
+      "json"
+    ],
+    "transform": {
+      "^.+\\.ts$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.json"
+        }
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "watch": "tsc --build --watch",
+    "dev": "tsc --build --watch",
+    "format": "prettier --write .",
+    "lint": "eslint src",
+    "test": "jest --verbose --runInBand"
+  }
+}