Create wrapper gem

.github/workflows/publish.yml

@@ -6,7 +6,7 @@ on:
     tags:
       - '*'
 jobs:
-  publish:
+  npm:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
@@ -18,3 +18,42 @@ jobs:
       - run: npm ci
       - run: npm run build
       - run: npm publish --tag latest
+
+  rubygems:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: gem
+    steps:
+      # Set up
+      - uses: actions/checkout@v5
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.4.7'
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version-file: ".tool-versions"
+      - uses: actions/setup-node@v6
+        with:
+          node-version: '24.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+        working-directory: .
+      - run: npm run build
+        working-directory: .
+      - run: npm ci
+        working-directory: entrypoint
+      - name: Install gems
+        run: bundle install
+      - name: Set version
+        run: sed -i "s/VERSION = '0.0.0'/VERSION = '${GITHUB_REF_NAME#v}'/" lib/triangulum/version.rb && bundle
+      - name: Package gems
+        run: bundle exec rake package
+
+      # Release
+      - uses: rubygems/configure-rubygems-credentials@v1.0.0
+      - name: Publish gem
+        run: bundle exec rake push:all
+      - name: Wait for release
+        run: gem exec rubygems-await pkg/*.gem

.github/workflows/test.yml

@@ -5,7 +5,7 @@ on:
       - 'main'
   pull_request:
 jobs:
-  test:
+  typescript:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
@@ -16,3 +16,40 @@ jobs:
       - run: npm ci
       - run: npm run build
       - run: npm run test
+
+  ruby:
+    runs-on: ubuntu-latest
+    name: ruby ${{ matrix.ruby }}
+    strategy:
+      matrix:
+        ruby:
+          - '3.4.7'
+    defaults:
+      run:
+        working-directory: gem
+
+    steps:
+      - uses: actions/checkout@v5
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version-file: ".tool-versions"
+      - uses: actions/setup-node@v6
+        with:
+          node-version: '24.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+        working-directory: .
+      - run: npm run build
+        working-directory: .
+      - run: npm ci
+        working-directory: entrypoint
+      - name: Install gems
+        run: bundle install
+      - name: Run the default task
+        run: bundle exec rake
+      - name: Build all gems
+        run: bundle exec rake package

.tool-versions

@@ -1 +1,3 @@
 nodejs 24.13.0
+ruby 3.4.7
+bun 1.3.11

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.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/readSingle.ts

@@ -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/single-validation.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/tsconfig.json

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