feat: added correct feature export

Author: raphael-goetz

reader/ts/src/mapper/helper.ts renamed to reader/ts/src/mapper/dataTypeMapper.ts

@@ -15,6 +15,7 @@ import {
 } from "@code0-tech/tucana/pb/shared.data_type_pb.ts"
 import {GenericMapper as TucanaGenericMapper} from "@code0-tech/tucana/pb/shared.data_type_pb.ts"
 import {ConstructedDataTypes} from "../parser.js";
+import {getTranslationConnection} from "./translation.js";
 
 export enum GenericMapper_GenericCombinationStrategy {
     UNKNOWN = 0,
@@ -53,9 +54,7 @@ function getDataType(identifier: string, constructedDataTypes: ConstructedDataTy
     if (dataType == undefined) {
         const tucanaDataType = constructedDataTypes.scannedTucanaTypes.find(dt => dt.identifier === identifier)
         if (tucanaDataType == undefined) {
-            console.dir(constructedDataTypes, {depth: null})
-            console.log("just skipping identifier")
-            console.log(identifier)
+            console.error("Skipping Identifier because it can't be identified:" + identifier)
             return null
         }
         const constructed = {
@@ -252,11 +251,4 @@ function getDataTypeIdentifier(identifier: TucanaDataTypeIdentifier | undefined,
     return null;
 }
 
-function getTranslationConnection(translation: Translation[]): TranslationConnection {
-    return {
-        count: translation.length,
-        nodes: translation,
-    }
-}
-
-export {getDataType, getDataTypeIdentifier, getTranslationConnection}
+export {getDataType, getDataTypeIdentifier}

reader/ts/src/mapper/flowTypeMapper.ts

@@ -1,7 +1,8 @@
 import {FlowType as TucanaFlowType, FlowTypeSetting as TucanaFlowTypeSetting} from "@code0-tech/tucana/pb/shared.flow_definition_pb.ts"
 import {FlowType, FlowTypeSetting} from "@code0-tech/sagittarius-graphql-types";
-import {getDataType, getTranslationConnection} from "./helper.ts";
+import {getDataType} from "./dataTypeMapper.ts";
 import {ConstructedDataTypes} from "../parser.ts";
+import {getTranslationConnection} from "./translation.js";
 
 function mapFlowType(flowType: TucanaFlowType, constructed: ConstructedDataTypes): FlowType | null {
     return  {

reader/ts/src/mapper/functionMapper.ts

@@ -3,8 +3,9 @@ import {
     RuntimeFunctionDefinition as TucanaFunction,
     RuntimeParameterDefinition
 } from "@code0-tech/tucana/pb/shared.runtime_function_pb.ts";
-import {getDataTypeIdentifier, getTranslationConnection} from "./helper.ts";
+import {getDataTypeIdentifier} from "./dataTypeMapper.ts";
 import {ConstructedDataTypes} from "../parser.ts";
+import {getTranslationConnection} from "./translation.js";
 
 function mapFunction(func: TucanaFunction, constructed: ConstructedDataTypes): FunctionDefinition | null {
      return {

reader/ts/src/mapper/translation.ts

@@ -0,0 +1,9 @@
+import {Translation} from "@code0-tech/tucana/pb/shared.translation_pb.js";
+import {TranslationConnection} from "@code0-tech/sagittarius-graphql-types";
+
+export function getTranslationConnection(translation: Translation[]): TranslationConnection {
+    return {
+        count: translation.length,
+        nodes: translation,
+    }
+}

reader/ts/src/parser.ts

@@ -6,85 +6,118 @@ import {RuntimeFunctionDefinition as TucanaFunction} from "@code0-tech/tucana/pb
 import path from "node:path";
 import {mapFlowType} from "./mapper/flowTypeMapper.ts";
 import {mapFunction} from "./mapper/functionMapper.ts";
-import {DataType, FlowType, FunctionDefinition} from "@code0-tech/sagittarius-graphql-types";
+import {DataType} from "@code0-tech/sagittarius-graphql-types";
 import {DefinitionDataType} from "@code0-tech/tucana/pb/shared.data_type_pb.ts";
-import {getDataType} from "./mapper/helper.ts";
+import {getDataType} from "./mapper/dataTypeMapper.ts";
 
 export interface ConstructedDataTypes {
     scannedTucanaTypes: DefinitionDataType[]
     constructedDataTypes: DataType[]
 }
 
-export const Definition = (rootPath: string) => {
-    const dataTypes: TucanaDataType[] = []
-    const runtimeFunctions: TucanaFunction[] = [];
-    const flowTypes: TucanaFlowType[] = [];
-    console.log(rootPath)
-    path.join()
+export const Definition = (rootPath: string): Feature[] => {
+    const dataTypes: {feature: string, type: TucanaDataType}[] = []
+    const runtimeFunctions: {feature: string, func: TucanaFunction}[] = [];
+    const flowTypes: {feature: string, flow: TucanaFlowType}[] = [];
+
     readdirSync(rootPath, { withFileTypes: true }).forEach(file => {
-        console.log(file)
+        const featureName = file.name.split("_")[0]
+        if (featureName == null) {
+            throw new Error("Feature name is null")
+        }
+
         const filePath = path.join(file.parentPath, file.name)
-        console.log(filePath)
 
         const content = readFileSync(filePath);
         if (file.name.includes("data_type")) {
             const decoded = TucanaDataType.fromBinary(content);
-            dataTypes.push(decoded)
+            dataTypes.push(
+                {
+                    feature: featureName,
+                    type: decoded,
+                }
+            )
         }
 
         if (file.name.includes("function")) {
             const decoded = TucanaFunction.fromBinary(content);
-            runtimeFunctions.push(decoded)
+            runtimeFunctions.push(
+                {
+                    feature: featureName,
+                    func: decoded,
+                }
+            )
         }
 
         if (file.name.includes("flow_type")) {
             const decoded = TucanaFlowType.fromBinary(content);
-            flowTypes.push(decoded)
+            flowTypes.push(
+                {
+                    feature: featureName,
+                    flow: decoded,
+                }
+            )
         }
     })
+
+    const features: Feature[] = []
     const constructed: ConstructedDataTypes = {
-        scannedTucanaTypes: dataTypes,
+        scannedTucanaTypes: dataTypes.map(f => f.type),
         constructedDataTypes: []
     }
-    dataTypes.map(f => getDataType(f.identifier, constructed)).forEach((d: DataType | null) => console.dir(d, {depth: null}))
-    runtimeFunctions.map(f => mapFunction(f, constructed)).forEach((f: FunctionDefinition | null) => console.dir(f, {depth: null}))
-    flowTypes.map(f => mapFlowType(f, constructed)).forEach((f: FlowType | null) => console.dir(f, {depth: null}))
 
-    //throw new Error("Not implemented")
-    /*
-    const dt = meta.filter(m => m.type == MetaType.DataType).map(m => {
-     //   console.log(m.data)
-     //   return DefinitionDataType.fromJsonString(m.data)
-     //   console.dir(def, {depth: null})
-        return null;
-    });
-    for (const d of dt) {
-      //  console.dir(d, {depth: null})
-    }
-    const sortedDt = sortDataTypes(dt).map(d => mapDataType(d))
+    function getFeature(name:string): Feature {
+        const feature = features.find((f) => f.name === name);
+        if (feature != undefined) {
+            return feature;
+        }
+
+        const newFeature = {
+            name: name,
+            dataTypes: [],
+            flowTypes: [],
+            runtimeFunctions: [],
+        };
 
-    for (const dt of sortedDt) {
-        console.log(dt)
+        features.push(newFeature);
+        return newFeature;
     }
 
-    for (const m of meta) {
-        let feature = features.find((f) => f.name === m.name);
+    dataTypes.map(f => {
+        return {
+            name: f.feature,
+            type: getDataType(f.type.identifier, constructed)
+        }
+    }).forEach(dt => {
+        if (dt.type != null) {
+            const feature = getFeature(dt.name)
+            feature.dataTypes.push(dt.type)
+        }
+    })
+
+    runtimeFunctions.map(f => {
+        return {
+            name: f.feature,
+            type: mapFunction(f.func, constructed)
+        }
+    }).forEach(dt => {
+        if (dt.type != null) {
+            const feature = getFeature(dt.name)
+            feature.runtimeFunctions.push(dt.type)
+        }
+    })
 
-        if (feature) {
-            appendMeta(feature, m);
-        } else {
-            feature = {
-                name: m.name,
-                dataTypes: [],
-                flowTypes: [],
-                runtimeFunctions: [],
-            };
-            appendMeta(feature, m);
-            features.push(feature);
+    flowTypes.map(f => {
+        return {
+            name: f.feature,
+            type: mapFlowType(f.flow, constructed)
         }
-    }
+    }).forEach(dt => {
+        if (dt.type != null) {
+            const feature = getFeature(dt.name)
+            feature.flowTypes.push(dt.type)
+        }
+    })
 
     return features;
-
-     */
 }