Add process entrypoint

Author: Taucher2003

entrypoint/.gitignore

@@ -0,0 +1,2 @@
+*.iml
+node_modules/

entrypoint/mapper.ts

@@ -0,0 +1,126 @@
+import {SingleValidationInputData} from "./readSingle";
+import {
+    DataType,
+    Flow,
+    FunctionDefinition,
+    LiteralValue,
+    NodeFunction,
+    NodeParameter,
+    NodeParameterValue, ParameterDefinition,
+} from "@code0-tech/sagittarius-graphql-types";
+import {
+    DefinitionDataType,
+    NodeFunction as TucanaNodeFunction,
+    NodeParameter as TucanaNodeParameter, RuntimeFunctionDefinition, RuntimeParameterDefinition,
+    ValidationFlow,
+} from "@code0-tech/tucana/shared";
+import {toAllowedValue} from "@code0-tech/tucana/helpers";
+
+export type TriangulumFlowValidationInput = {
+    flow?: Flow,
+    functions?: FunctionDefinition[],
+    dataTypes?: DataType[]
+}
+
+export function mapToFlowValidation(data: SingleValidationInputData): TriangulumFlowValidationInput {
+    return {
+        flow: mapFlow(data.flow!),
+        functions: data.functions.map(mapFunctionDefinition),
+        dataTypes: data.dataTypes.map(mapDataType)
+    }
+}
+
+function gid(type: string, id: bigint | number) {
+    return `gid://sagittarius/${type}/${Number(id)}`;
+}
+
+function mapFlow(flow: ValidationFlow): Flow {
+    return {
+        __typename: "Flow",
+        id: gid('Flow', flow.flowId) as Flow['id'],
+        inputType: flow.inputType,
+        returnType: flow.returnType,
+        startingNodeId: gid('NodeFunction', flow.startingNodeId) as NodeFunction['id'],
+        nodes: {
+            nodes: flow.nodeFunctions.map(mapNodeFunction)
+        }
+    };
+}
+
+function mapNodeFunction(nodeFunction: TucanaNodeFunction): NodeFunction {
+    return {
+        id: gid('NodeFunction', nodeFunction.databaseId) as NodeFunction['id'],
+        functionDefinition: {
+            identifier: nodeFunction.runtimeFunctionId
+        },
+        nextNodeId: nodeFunction.nextNodeId ? gid('NodeFunction', nodeFunction.nextNodeId) as NodeFunction['id'] : undefined,
+        parameters: {
+            nodes: nodeFunction.parameters.map(mapNodeParameter)
+        }
+    }
+}
+
+function mapNodeParameter(nodeParameter: TucanaNodeParameter): NodeParameter {
+    let value: NodeParameterValue = {}
+    const nodeParameterValue = nodeParameter.value?.value
+
+    if (nodeParameterValue?.oneofKind === 'literalValue') {
+        value = {
+            __typename: 'LiteralValue',
+            value: toAllowedValue(nodeParameterValue.literalValue)
+        };
+    } else if (nodeParameterValue?.oneofKind === 'referenceValue') {
+        const target = nodeParameterValue.referenceValue.target;
+
+        value = {
+            __typename: 'ReferenceValue',
+            referencePath: nodeParameterValue.referenceValue.paths.map(p => ({
+                __typename: 'ReferencePath',
+                path: p.path,
+                arrayIndex: Number(p.arrayIndex)
+            }))
+        }
+
+        if (target.oneofKind === 'nodeId') {
+            value.nodeFunctionId = gid('NodeFunction', target.nodeId) as NodeFunction['id']
+        } else if (target.oneofKind === 'inputType') {
+            value.nodeFunctionId = gid('NodeFunction', target.inputType.nodeId) as NodeFunction['id']
+            value.parameterIndex = Number(target.inputType.parameterIndex)
+            value.inputIndex = Number(target.inputType.inputIndex)
+        }
+    } else if (nodeParameterValue?.oneofKind === 'nodeFunctionId') {
+        value = {
+            __typename: 'NodeFunctionIdWrapper',
+            id: gid('NodeFunction', nodeParameterValue.nodeFunctionId) as NodeFunction['id']
+        }
+    }
+
+    return {
+        id: gid('NodeParameter', nodeParameter.databaseId) as NodeParameter['id'],
+        value
+    }
+}
+
+function mapFunctionDefinition(functionDefinition: RuntimeFunctionDefinition): FunctionDefinition {
+    return {
+        identifier: functionDefinition.runtimeName,
+        signature: functionDefinition.signature,
+        parameterDefinitions: {
+            nodes: functionDefinition.runtimeParameterDefinitions.map(mapParameterDefinition)
+        }
+    }
+}
+
+function mapParameterDefinition(parameterDefinition: RuntimeParameterDefinition): ParameterDefinition {
+    return {
+        identifier: parameterDefinition.runtimeName,
+    }
+}
+
+function mapDataType(dataType: DefinitionDataType): DataType {
+    return {
+        identifier: dataType.identifier,
+        type: dataType.type,
+        genericKeys: dataType.genericKeys
+    };
+}

entrypoint/package-lock.json

@@ -0,0 +1,13 @@
+{
+  "name": "@code0-tech/triangulum-entrypoint",
+  "version": "0.0.0",
+  "private": true,
+  "dependencies": {
+    "@code0-tech/triangulum": "file:../",
+    "@code0-tech/tucana": "0.0.62",
+    "@protobuf-ts/runtime": "^2.11.1"
+  },
+  "devDependencies": {
+    "bun-types": "^1.3.11"
+  }
+}

entrypoint/package.json

@@ -0,0 +1,39 @@
+import {
+    DefinitionDataType,
+    RuntimeFunctionDefinition,
+    ValidationFlow
+} from "@code0-tech/tucana/shared";
+
+export type SingleValidationInputData = {
+    flow?: ValidationFlow,
+    functions: RuntimeFunctionDefinition[],
+    dataTypes: DefinitionDataType[]
+};
+
+export async function readSingleValidation(input: AsyncIterable<string>) {
+    const data: SingleValidationInputData = {
+        functions: [],
+        dataTypes: []
+    };
+
+    let parsingState = 0;
+
+    for await (const line of input) {
+        if(line === '') {
+            parsingState++;
+            continue;
+        }
+
+        const message = Uint8Array.fromBase64(line);
+        if(parsingState === 0) {
+            data.flow = ValidationFlow.fromBinary(message);
+        } else if(parsingState === 1) {
+            data.functions.push(RuntimeFunctionDefinition.fromBinary(message));
+        } else if(parsingState === 2) {
+            data.dataTypes.push(DefinitionDataType.fromBinary(message));
+        }
+    }
+
+    return data;
+}
+

entrypoint/readSingle.ts

@@ -0,0 +1,10 @@
+import {readSingleValidation} from "./readSingle";
+import {mapToFlowValidation} from "./mapper";
+import {getFlowValidation} from "@code0-tech/triangulum";
+
+const data = await readSingleValidation(console);
+const validationInput = mapToFlowValidation(data);
+
+const result = getFlowValidation(validationInput.flow, validationInput.functions, validationInput.dataTypes)
+
+console.info(JSON.stringify(result));

entrypoint/single-validation.ts

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "moduleResolution": "bundler",
+    "module": "esnext",
+    "target": "esnext",
+    "types": ["bun-types"]
+  }
+}