feat: finished reader impl

Author: raphael-goetz

.gitignore

@@ -3,4 +3,6 @@
 **/node_modules
 .idea
 reader/ts/src/*.js
-reader/ts/build
+reader/ts/build
+bundles
+reader/**/*.js

reader/ts/index.ts

@@ -1,6 +1,5 @@
 import {Definition} from "./src/parser.ts";
 
 export { Definition } from './src/parser.ts';
-export type { Feature, MetaType, Meta } from './src/types.ts';
-
-const def = Definition("../../definitions/")
+export type { Feature } from './src/types.ts';
+Definition("../../cli/bundles")

reader/ts/src/mapper/dataTypeMapper.ts

@@ -48,7 +48,6 @@ function resolveDataTypeIdentifier(dataTypeIdentifier: DataTypeIdentifier | unde
     if (dataTypeIdentifier == undefined) {
         return result
     }
-
     const dataType: any = dataTypeIdentifier!
 
     if (dataType.type.GenericType) {

reader/ts/src/mapper/dataTypeSorter.ts

@@ -1,32 +1,26 @@
 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 {Meta, MetaType} from "../types.ts";
+import {ConstructedDataTypes} from "../parser.ts";
 
-function mapFlowType(meta: Meta): FlowType | null {
-    if (meta.type != MetaType.FlowType) {
-        console.error(`Expected FlowType, got ${meta.type}`);
-        return null;
-    }
-
-    const parsed = JSON.parse(meta.data) as TucanaFlowType;
+function mapFlowType(flowType: TucanaFlowType, constructed: ConstructedDataTypes): FlowType | null {
     return  {
-        identifier: parsed.identifier,
-        inputType: getDataType(parsed.inputTypeIdentifier),
-        returnType: getDataType(parsed.returnTypeIdentifier),
-        flowTypeSettings: createFlowTypeSetting(parsed.settings),
-        names: getTranslationConnection(parsed.name),
-        descriptions: getTranslationConnection(parsed.description),
-        editable: parsed.editable
+        identifier: flowType.identifier,
+        inputType: getDataType(flowType.inputTypeIdentifier!!, constructed),
+        returnType: getDataType(flowType.returnTypeIdentifier!!, constructed),
+        flowTypeSettings: createFlowTypeSetting(flowType.settings, constructed),
+        names: getTranslationConnection(flowType.name),
+        descriptions: getTranslationConnection(flowType.description),
+        editable: flowType.editable
     }
 }
 
-function createFlowTypeSetting(settings: TucanaFlowTypeSetting[]): FlowTypeSetting[] {
+function createFlowTypeSetting(settings: TucanaFlowTypeSetting[], constructed: ConstructedDataTypes): FlowTypeSetting[] {
     return settings.map(setting => {
         return {
             names: getTranslationConnection(setting.name),
             descriptions: getTranslationConnection(setting.description),
-            dataType: getDataType(setting.dataTypeIdentifier),
+            dataType: getDataType(setting.dataTypeIdentifier, constructed),
             identifier: setting.identifier,
             unique: setting.unique
         }

reader/ts/src/mapper/flowTypeMapper.ts

@@ -1,39 +1,33 @@
-import {Meta, MetaType} from "../types.ts";
 import {FunctionDefinition, ParameterDefinitionConnection} from "@code0-tech/sagittarius-graphql-types";
 import {
     RuntimeFunctionDefinition as TucanaFunction,
     RuntimeParameterDefinition
 } from "@code0-tech/tucana/pb/shared.runtime_function_pb.ts";
 import {getDataTypeIdentifier, getTranslationConnection} from "./helper.ts";
+import {ConstructedDataTypes} from "../parser.ts";
 
-function mapFunction(meta:Meta): FunctionDefinition | null {
-    if (meta.type != MetaType.RuntimeFunction) {
-        console.error(`Expected RuntimeFunction, got ${meta.type}`);
-        return null;
-    }
-
-    const parsed = JSON.parse(meta.data) as TucanaFunction;
+function mapFunction(func: TucanaFunction, constructed: ConstructedDataTypes): FunctionDefinition | null {
      return {
-        genericKeys: parsed.genericKeys,
-        names: getTranslationConnection(parsed.name),
-        descriptions: getTranslationConnection(parsed.description),
-        documentations: getTranslationConnection(parsed.documentation),
-        deprecationMessages: getTranslationConnection(parsed.deprecationMessage),
-        throwsError: parsed.throwsError,
-        returnType: getDataTypeIdentifier(parsed.returnTypeIdentifier),
-        parameterDefinitions: getParameterDefinitionConnection(parsed.runtimeParameterDefinitions),
+        genericKeys: func.genericKeys,
+        names: getTranslationConnection(func.name),
+        descriptions: getTranslationConnection(func.description),
+        documentations: getTranslationConnection(func.documentation),
+        deprecationMessages: getTranslationConnection(func.deprecationMessage),
+        throwsError: func.throwsError,
+        returnType: getDataTypeIdentifier(func.returnTypeIdentifier, constructed),
+        parameterDefinitions: getParameterDefinitionConnection(func.runtimeParameterDefinitions, constructed),
     }
 }
 
-function getParameterDefinitionConnection(def: RuntimeParameterDefinition[]): ParameterDefinitionConnection {
+function getParameterDefinitionConnection(def: RuntimeParameterDefinition[], constructed: ConstructedDataTypes): ParameterDefinitionConnection {
     return {
         count: def.length,
         nodes: def.map(node => {
             return {
                 names: getTranslationConnection(node.name),
                 descriptions: getTranslationConnection(node.description),
                 documentations: getTranslationConnection(node.documentation),
-                dataType: getDataTypeIdentifier(node.dataTypeIdentifier)
+                dataType: getDataTypeIdentifier(node.dataTypeIdentifier, constructed)
             }
         })
     }