@statelyai/graph 0.11.1 → 0.13.0

package/dist/schemas.mjs

@@ -9,7 +9,7 @@ const PortDirectionSchema = z.enum([
 ]);
 const PortSchema = z.object({
 	name: z.string(),
-	direction: PortDirectionSchema.optional(),
+	direction: PortDirectionSchema,
 	label: z.string().optional(),
 	data: z.any(),
 	x: z.number().optional(),
@@ -66,6 +66,162 @@ const GraphSchema = z.object({
 	]).optional(),
 	style: StyleSchema.optional()
 });
+function getValidationIssues(schema, value) {
+	const result = schema.safeParse(value);
+	if (result.success) return [];
+	return result.error.issues.map((issue) => ({
+		code: issue.code,
+		message: issue.message,
+		path: issue.path.map((segment) => typeof segment === "symbol" ? String(segment) : segment)
+	}));
+}
+function isGraphPort(value) {
+	return PortSchema.safeParse(value).success;
+}
+function isGraphNode(value) {
+	return NodeSchema.safeParse(value).success;
+}
+function isGraphEdge(value) {
+	return EdgeSchema.safeParse(value).success;
+}
+function isGraph(value) {
+	return validateGraph(value).length === 0;
+}
+function getGraphPortIssues(value) {
+	return getValidationIssues(PortSchema, value);
+}
+function getGraphNodeIssues(value) {
+	return getValidationIssues(NodeSchema, value);
+}
+function getGraphEdgeIssues(value) {
+	return getValidationIssues(EdgeSchema, value);
+}
+function getGraphIssues(value) {
+	return validateGraph(value);
+}
+function createIssue(code, message, path) {
+	return {
+		code,
+		message,
+		path
+	};
+}
+function getDuplicateIndexes(items, getKey) {
+	const indexesByKey = /* @__PURE__ */ new Map();
+	items.forEach((item, index) => {
+		const key = getKey(item);
+		if (key == null) return;
+		const indexes = indexesByKey.get(key) ?? [];
+		indexes.push(index);
+		indexesByKey.set(key, indexes);
+	});
+	for (const [key, indexes] of indexesByKey) if (indexes.length < 2) indexesByKey.delete(key);
+	return indexesByKey;
+}
+function getGraphInvariantIssues(graph) {
+	const issues = [];
+	const nodeIndexes = /* @__PURE__ */ new Map();
+	const nodesById = /* @__PURE__ */ new Map();
+	for (const [id, indexes] of getDuplicateIndexes(graph.nodes, (node) => node.id)) for (const index of indexes) issues.push(createIssue("duplicate_node_id", `Duplicate node id "${id}"`, [
+		"nodes",
+		index,
+		"id"
+	]));
+	for (const [id, indexes] of getDuplicateIndexes(graph.edges, (edge) => edge.id)) for (const index of indexes) issues.push(createIssue("duplicate_edge_id", `Duplicate edge id "${id}"`, [
+		"edges",
+		index,
+		"id"
+	]));
+	graph.nodes.forEach((node, index) => {
+		nodeIndexes.set(node.id, index);
+		nodesById.set(node.id, node);
+	});
+	if (graph.initialNodeId && !nodeIndexes.has(graph.initialNodeId)) issues.push(createIssue("missing_initial_node", `Initial node "${graph.initialNodeId}" does not exist`, ["initialNodeId"]));
+	graph.nodes.forEach((node, index) => {
+		if (node.id === "") issues.push(createIssue("empty_node_id", "Node id must be a non-empty string", [
+			"nodes",
+			index,
+			"id"
+		]));
+		if (node.parentId === "") issues.push(createIssue("empty_parent_id", "Node parentId must be a non-empty string", [
+			"nodes",
+			index,
+			"parentId"
+		]));
+		else if (node.parentId != null && !nodeIndexes.has(node.parentId)) issues.push(createIssue("missing_parent", `Parent node "${node.parentId}" does not exist`, [
+			"nodes",
+			index,
+			"parentId"
+		]));
+		if (node.initialNodeId && !nodeIndexes.has(node.initialNodeId)) issues.push(createIssue("missing_node_initial", `Initial node "${node.initialNodeId}" does not exist`, [
+			"nodes",
+			index,
+			"initialNodeId"
+		]));
+		for (const [name, indexes] of getDuplicateIndexes(node.ports ?? [], (port) => port.name)) for (const portIndex of indexes) issues.push(createIssue("duplicate_port_name", `Duplicate port name "${name}" on node "${node.id}"`, [
+			"nodes",
+			index,
+			"ports",
+			portIndex,
+			"name"
+		]));
+	});
+	for (const node of graph.nodes) {
+		const seen = /* @__PURE__ */ new Set();
+		let current = node.parentId;
+		while (current != null) {
+			if (current === node.id || seen.has(current)) {
+				issues.push(createIssue("parent_cycle", `Node "${node.id}" is part of a parent cycle`, [
+					"nodes",
+					nodeIndexes.get(node.id) ?? 0,
+					"parentId"
+				]));
+				break;
+			}
+			seen.add(current);
+			current = nodesById.get(current)?.parentId;
+		}
+	}
+	graph.edges.forEach((edge, index) => {
+		if (edge.id === "") issues.push(createIssue("empty_edge_id", "Edge id must be a non-empty string", [
+			"edges",
+			index,
+			"id"
+		]));
+		const source = nodesById.get(edge.sourceId);
+		const target = nodesById.get(edge.targetId);
+		if (!source) issues.push(createIssue("missing_source_node", `Source node "${edge.sourceId}" does not exist`, [
+			"edges",
+			index,
+			"sourceId"
+		]));
+		if (!target) issues.push(createIssue("missing_target_node", `Target node "${edge.targetId}" does not exist`, [
+			"edges",
+			index,
+			"targetId"
+		]));
+		if (source && edge.sourcePort !== void 0 && !source.ports?.some((port) => port.name === edge.sourcePort)) issues.push(createIssue("missing_source_port", `Port "${edge.sourcePort}" does not exist on source node "${edge.sourceId}"`, [
+			"edges",
+			index,
+			"sourcePort"
+		]));
+		if (target && edge.targetPort !== void 0 && !target.ports?.some((port) => port.name === edge.targetPort)) issues.push(createIssue("missing_target_port", `Port "${edge.targetPort}" does not exist on target node "${edge.targetId}"`, [
+			"edges",
+			index,
+			"targetPort"
+		]));
+	});
+	return issues;
+}
+function validateGraph(value) {
+	const shapeResult = GraphSchema.safeParse(value);
+	if (!shapeResult.success) return shapeResult.error.issues.map((issue) => ({
+		code: issue.code,
+		message: issue.message,
+		path: issue.path.map((segment) => typeof segment === "symbol" ? String(segment) : segment)
+	}));
+	return getGraphInvariantIssues(shapeResult.data);
+}
 
 //#endregion
-export { EdgeSchema, GraphSchema, NodeSchema, PortSchema };
+export { EdgeSchema, GraphSchema, NodeSchema, PortSchema, getGraphEdgeIssues, getGraphIssues, getGraphNodeIssues, getGraphPortIssues, isGraph, isGraphEdge, isGraphNode, isGraphPort, validateGraph };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@statelyai/graph",
   "type": "module",
-  "version": "0.11.1",
+  "version": "0.13.0",
   "description": "A TypeScript-first graph library with plain JSON-serializable objects",
   "author": "David Khourshid <david@stately.ai>",
   "license": "MIT",

package/schemas/graph.schema.json

@@ -150,6 +150,7 @@
               },
               "required": [
                 "name",
+                "direction",
                 "data"
               ],
               "additionalProperties": false

package/schemas/node.schema.json

@@ -125,6 +125,7 @@
         },
         "required": [
           "name",
+          "direction",
           "data"
         ],
         "additionalProperties": false