@code0-tech/definition-reader 0.0.14 → 0.0.16

package/index.ts

@@ -0,0 +1,2 @@
+export { Definition } from './src/parser.ts';
+export type { Feature } from './src/types.ts';

package/package.json

@@ -1,15 +1,8 @@
 {
   "name": "@code0-tech/definition-reader",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Reader for Code0-Definitions",
-  "main": "./build/index.js",
-  "types": "./build/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./build/index.js",
-      "types": "./build/index.d.ts"
-    }
-  },
+  "main": "./dist/definition-reader.js",
   "type": "module",
   "scripts": {
     "build": "npx vite build && node dist/definition-reader.js"
@@ -26,7 +19,9 @@
     "url": "https://github.com/code0-tech/code0-definition"
   },
   "files": [
-    "build"
+    "dist",
+    "index.ts",
+    "src"
   ],
   "publishConfig": {
     "access": "public"

package/src/mapper/dataTypeMapper.ts

@@ -0,0 +1,227 @@
+import {
+    DataType,
+    DataTypeIdentifier, DataTypeRule,
+    DataTypeRuleConnection, DataTypeRulesContainsKeyConfig, DataTypeRulesContainsTypeConfig,
+    DataTypeRulesInputTypeConfig,
+    DataTypeRulesInputTypesConfig,
+    DataTypeRulesItemOfCollectionConfig, DataTypeRulesNumberRangeConfig,
+    DataTypeRulesParentTypeConfig, DataTypeRulesRegexConfig, DataTypeRulesVariant, DataTypeVariant,
+    GenericCombinationStrategyType,
+} from "@code0-tech/sagittarius-graphql-types";
+import {
+    DataTypeIdentifier as TucanaDataTypeIdentifier,
+    DefinitionDataType_Variant, DefinitionDataTypeRule, GenericMapper_GenericCombinationStrategy
+} 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, getID} from "../parser.ts";
+import {getTranslationConnection} from "./translation.ts";
+
+function getDataType(identifier: string, constructedDataTypes: ConstructedDataTypes): DataType | null {
+    const dataType = constructedDataTypes.constructedDataTypes.find(dt => dt.identifier === identifier)
+    if (dataType == undefined) {
+        const tucanaDataType = constructedDataTypes.scannedTucanaTypes.find(dt => dt.identifier === identifier)
+        if (tucanaDataType == undefined) {
+            console.error("Skipping Identifier because it can't be identified:" + identifier)
+            return null
+        }
+        const constructed: DataType = {
+            id: `gid://sagittarius/DataType/${getID(constructedDataTypes)}`,
+            genericKeys: tucanaDataType.genericKeys,
+            identifier: tucanaDataType.identifier,
+            name: getTranslationConnection(tucanaDataType.name),
+            rules: createRules(tucanaDataType.rules, constructedDataTypes),
+            variant: getDataTypeVariant(tucanaDataType.variant),
+        }
+
+        constructedDataTypes.constructedDataTypes.push(constructed)
+        return constructed;
+    }
+    return dataType;
+}
+
+function createRules(rule: DefinitionDataTypeRule[], constructedDataTypes: ConstructedDataTypes) : DataTypeRuleConnection {
+    return {
+        count: rule.length,
+        nodes: rule.map(r => {
+                switch (r.config.oneofKind) {
+                    case "containsType": {
+                        const ruleConfig: DataTypeRulesContainsTypeConfig = {
+                            dataTypeIdentifier: getDataTypeIdentifier(r.config.containsType.dataTypeIdentifier, constructedDataTypes),
+                        }
+                        const rule: DataTypeRule = {
+                            variant: DataTypeRulesVariant.ContainsType,
+                            config: ruleConfig
+                        }
+                        return rule;
+                    }
+                    case "containsKey": {
+                        const ruleConfig: DataTypeRulesContainsKeyConfig = {
+                            dataTypeIdentifier: getDataTypeIdentifier(r.config.containsKey.dataTypeIdentifier, constructedDataTypes),
+                            key: r.config.containsKey.key,
+                        }
+                        const rule: DataTypeRule = {
+                            variant: DataTypeRulesVariant.ContainsKey,
+                            config: ruleConfig
+                        }
+                        return rule;
+                    }
+                    case "itemOfCollection": {
+                        const ruleConfig: DataTypeRulesItemOfCollectionConfig = {
+                            items: r.config.itemOfCollection.items, //TODO: This needs to be checked
+                        }
+                        const rule: DataTypeRule = {
+                            variant: DataTypeRulesVariant.ItemOfCollection,
+                            config: ruleConfig
+                        }
+                        return rule;
+                    }
+                    case "numberRange": {
+                        const ruleConfig: DataTypeRulesNumberRangeConfig = {
+                            from: Number(r.config.numberRange.from),
+                            steps: r.config.numberRange.steps ? Number(r.config.numberRange.steps) : undefined,
+                            to: Number(r.config.numberRange.to),
+                        }
+                        const rule : DataTypeRule = {
+                            variant: DataTypeRulesVariant.NumberRange,
+                            config: ruleConfig
+                        }
+                        return rule;
+                    }
+                    case "regex": {
+                        const ruleConfig: DataTypeRulesRegexConfig = {
+                            pattern: r.config.regex.pattern,
+                        }
+                        const rule : DataTypeRule = {
+                            variant: DataTypeRulesVariant.Regex,
+                            config: ruleConfig
+                        }
+                        return rule;
+                    }
+                    case "inputTypes": {
+                        const ruleConfig: DataTypeRulesInputTypesConfig = {
+                            inputTypes: r.config.inputTypes.inputTypes.map(i => {
+                                console.log("AF: " + i.inputIdentifier)
+                                const input: DataTypeRulesInputTypeConfig = {
+                                    dataTypeIdentifier: getDataTypeIdentifier(i.dataTypeIdentifier, constructedDataTypes),
+                                    inputIdentifier: i.inputIdentifier,
+                                }
+                                return input;
+                            }),
+                        }
+                        const rule : DataTypeRule = {
+                            variant: DataTypeRulesVariant.InputType,
+                            config: ruleConfig
+                        }
+                        return rule;
+                    }
+
+                    case "returnType": {
+                        const ruleConfig: DataTypeRulesParentTypeConfig = {
+                            dataTypeIdentifier: getDataTypeIdentifier(r.config.returnType.dataTypeIdentifier, constructedDataTypes),
+                        }
+                        const rule : DataTypeRule = {
+                            variant: DataTypeRulesVariant.ReturnType,
+                            config: ruleConfig
+                        }
+                        return rule;
+                    }
+
+                    case "parentType": {
+                        const ruleConfig: DataTypeRulesParentTypeConfig = {
+                            dataTypeIdentifier: getDataTypeIdentifier(r.config.parentType.parentType, constructedDataTypes),
+                        }
+                        const rule : DataTypeRule = {
+                            variant: DataTypeRulesVariant.ParentType,
+                            config: ruleConfig
+                        }
+                        return rule;
+                    }
+                }
+                throw new Error(`Unknown rule: ${rule}`)
+            }
+        )
+    }
+}
+
+function getDataTypeVariant(variant: DefinitionDataType_Variant): DataTypeVariant {
+    switch (variant) {
+        case DefinitionDataType_Variant.ARRAY:
+            return DataTypeVariant.Array
+        case DefinitionDataType_Variant.DATATYPE:
+            return DataTypeVariant.DataType;
+        case DefinitionDataType_Variant.ERROR:
+            return DataTypeVariant.Error;
+        case DefinitionDataType_Variant.NODE:
+            return DataTypeVariant.Node;
+        case DefinitionDataType_Variant.OBJECT:
+            return DataTypeVariant.Object;
+        case DefinitionDataType_Variant.PRIMITIVE:
+            return DataTypeVariant.Primitive;
+        case DefinitionDataType_Variant.TYPE:
+            return DataTypeVariant.Type;
+        default:
+            throw new Error(`Unknown variant: ${variant}`);
+    }
+}
+
+function getDataTypeIdentifier(identifier: TucanaDataTypeIdentifier | undefined, constructedDataTypes: ConstructedDataTypes): DataTypeIdentifier | null {
+    if (identifier == undefined) {
+        return null
+    }
+
+    switch (identifier.type.oneofKind) {
+        case "genericType": {
+            return {
+                id: `gid://sagittarius/DataTypeIdentifier/${getID(constructedDataTypes)}`,
+                genericType: {
+                    id: `gid://sagittarius/GenericType/${getID(constructedDataTypes)}`,
+                    dataType: getDataType(identifier.type.genericType.dataTypeIdentifier, constructedDataTypes),
+                    genericMappers: identifier.type.genericType.genericMappers.map((mapper: TucanaGenericMapper) => {
+                        return {
+                            genericCombinationStrategies: mapper.genericCombinations.map(m => {
+                                let type = undefined
+                                switch (m) {
+                                    case GenericMapper_GenericCombinationStrategy.AND:
+                                        type = GenericCombinationStrategyType.And
+                                        break
+                                    case GenericMapper_GenericCombinationStrategy.OR:
+                                        type = GenericCombinationStrategyType.Or
+                                        break
+                                    default:
+                                        throw new Error("GenericCombinationStrategy was Unknown");
+                                }
+                                return {
+                                    id: `gid://sagittarius/GenericCombinationStrategy/${getID(constructedDataTypes)}`,
+                                    type: type
+                                }
+                            }),
+                            sources: mapper.source.map(id =>
+                                getDataTypeIdentifier(id, constructedDataTypes)
+                            ).filter(id => id != null),
+                            target: mapper.target,
+                            id: `gid://sagittarius/GenericMapper/${getID(constructedDataTypes)}`,
+                        }
+                    }),
+                }
+            }
+        }
+
+        case "dataTypeIdentifier": {
+            return {
+                id: `gid://sagittarius/DataTypeIdentifier/${getID(constructedDataTypes)}`,
+                dataType: getDataType(identifier.type.dataTypeIdentifier, constructedDataTypes)
+            }
+        }
+
+        case "genericKey": {
+            return {
+                id: `gid://sagittarius/DataTypeIdentifier/${getID(constructedDataTypes)}`,
+                genericKey: identifier.type.genericKey,
+            }
+        }
+    }
+
+    return null;
+}
+
+export {getDataType, getDataTypeIdentifier}

package/src/mapper/flowTypeMapper.ts

@@ -0,0 +1,35 @@
+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} from "./dataTypeMapper.ts";
+import {ConstructedDataTypes, getID} from "../parser.ts";
+import {getTranslationConnection} from "./translation.js";
+
+function mapFlowType(flowType: TucanaFlowType, constructed: ConstructedDataTypes): FlowType | null {
+    return  {
+        id: `gid://sagittarius/TypesFlowType/${getID(constructed)}`,
+        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[], constructed: ConstructedDataTypes): FlowTypeSetting[] {
+    return settings.map(setting => {
+        const flowSetting: FlowTypeSetting = {
+            id: `gid://sagittarius/FlowTypeSetting/${getID(constructed)}`,
+            names: getTranslationConnection(setting.name),
+            descriptions: getTranslationConnection(setting.description),
+            dataType: getDataType(setting.dataTypeIdentifier, constructed),
+            identifier: setting.identifier,
+            unique: setting.unique
+        }
+
+        return flowSetting;
+    })
+}
+
+export {mapFlowType}

package/src/mapper/functionMapper.ts

@@ -0,0 +1,39 @@
+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} from "./dataTypeMapper.ts";
+import {ConstructedDataTypes, getID} from "../parser.ts";
+import {getTranslationConnection} from "./translation.js";
+
+function mapFunction(func: TucanaFunction, constructed: ConstructedDataTypes): FunctionDefinition | null {
+     return {
+        id: `gid://sagittarius/FunctionDefinition/${getID(constructed)}`,
+        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[], constructed: ConstructedDataTypes): ParameterDefinitionConnection {
+    return {
+        count: def.length,
+        nodes: def.map(node => {
+            return {
+                id: `gid://sagittarius/ParameterDefinition/${getID(constructed)}`,
+                names: getTranslationConnection(node.name),
+                descriptions: getTranslationConnection(node.description),
+                documentations: getTranslationConnection(node.documentation),
+                dataType: getDataTypeIdentifier(node.dataTypeIdentifier, constructed)
+            }
+        })
+    }
+}
+
+export {mapFunction}

package/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,
+    }
+}

package/src/parser.ts

@@ -0,0 +1,131 @@
+import {DefinitionDataType as TucanaDataType} from "@code0-tech/tucana/pb/shared.data_type_pb.ts";
+import {Feature} from "./types.ts";
+import {readdirSync, readFileSync} from "node:fs";
+import {FlowType as TucanaFlowType} from "@code0-tech/tucana/pb/shared.flow_definition_pb.ts";
+import {RuntimeFunctionDefinition as TucanaFunction} from "@code0-tech/tucana/pb/shared.runtime_function_pb.ts";
+import path from "node:path";
+import {mapFlowType} from "./mapper/flowTypeMapper.ts";
+import {mapFunction} from "./mapper/functionMapper.ts";
+import {DataType} from "@code0-tech/sagittarius-graphql-types";
+import {DefinitionDataType} from "@code0-tech/tucana/pb/shared.data_type_pb.ts";
+import {getDataType} from "./mapper/dataTypeMapper.ts";
+
+export interface ConstructedDataTypes {
+    scannedTucanaTypes: DefinitionDataType[]
+    constructedDataTypes: DataType[]
+    id: number
+}
+
+export function getID(constructedDataTypes: ConstructedDataTypes) {
+    const last = constructedDataTypes.id
+    constructedDataTypes.id += 1
+    return last
+}
+
+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 => {
+        const featureName = file.name.split("_")[0]
+        if (featureName == null) {
+            throw new Error("Feature name is null")
+        }
+
+        const filePath = path.join(file.parentPath, file.name)
+
+        const content = readFileSync(filePath);
+        if (file.name.includes("data_type")) {
+            const decoded = TucanaDataType.fromBinary(content);
+            dataTypes.push(
+                {
+                    feature: featureName,
+                    type: decoded,
+                }
+            )
+        }
+
+        if (file.name.includes("function")) {
+            const decoded = TucanaFunction.fromBinary(content);
+            runtimeFunctions.push(
+                {
+                    feature: featureName,
+                    func: decoded,
+                }
+            )
+        }
+
+        if (file.name.includes("flow_type")) {
+            const decoded = TucanaFlowType.fromBinary(content);
+            flowTypes.push(
+                {
+                    feature: featureName,
+                    flow: decoded,
+                }
+            )
+        }
+    })
+
+    const features: Feature[] = []
+    const constructed: ConstructedDataTypes = {
+        scannedTucanaTypes: dataTypes.map(f => f.type),
+        constructedDataTypes: [],
+        id: 0
+    }
+
+    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: [],
+        };
+
+        features.push(newFeature);
+        return newFeature;
+    }
+
+    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)
+        }
+    })
+
+    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;
+}

package/src/types.ts

@@ -0,0 +1,8 @@
+import {DataType, FlowType, FunctionDefinition} from "@code0-tech/sagittarius-graphql-types";
+
+export interface Feature {
+    name: string;
+    dataTypes: DataType[];
+    flowTypes: FlowType[];
+    runtimeFunctions: FunctionDefinition[];
+}