feat: added definition reader

Author: raphael-goetz

reader/ts/index.d.ts

@@ -0,0 +1,3 @@
+import {Definition} from './src/parser';
+
+export {Definition};

reader/ts/index.js

@@ -0,0 +1,60 @@
+import {Meta, MetaType, Reader} from './reader';
+import {DataType, FlowType, RuntimeFunctionDefinition} from "@code0-tech/sagittarius-graphql-types";
+
+export interface Feature {
+    name: string;
+    data_types: DataType[];
+    flow_types: FlowType[];
+    runtime_functions: RuntimeFunctionDefinition[];
+}
+
+export const Definition = (rootPath: string): Feature[] => {
+    const meta = Reader(rootPath);
+    if (!meta) return [];
+    const features: Feature[] = [];
+
+    for (const m of meta) {
+        let feature = features.find((f) => f.name === m.name);
+
+        if (feature) {
+            appendMeta(feature, m);
+        } else {
+            feature = {
+                name: m.name,
+                data_types: [],
+                flow_types: [],
+                runtime_functions: [],
+            };
+            appendMeta(feature, m);
+            features.push(feature);
+        }
+    }
+
+    return features;
+}
+
+function appendMeta(feature: Feature, meta: Meta): void {
+    for (const definition of meta.data) {
+        try {
+            switch (meta.type) {
+                case MetaType.DataType: {
+                    const parsed = JSON.parse(definition) as DataType;
+                    feature.data_types.push(parsed);
+                    break;
+                }
+                case MetaType.FlowType: {
+                    const parsed = JSON.parse(definition) as FlowType;
+                    feature.flow_types.push(parsed);
+                    break;
+                }
+                case MetaType.RuntimeFunction: {
+                    const parsed = JSON.parse(definition) as RuntimeFunctionDefinition;
+                    feature.runtime_functions.push(parsed);
+                    break;
+                }
+            }
+        } catch (err: any) {
+            console.error(`Error parsing ${meta.type} ${meta.name}:`, err);
+        }
+    }
+}

reader/ts/src/parser.ts

@@ -0,0 +1,112 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export enum MetaType {
+  FlowType = 'FlowType',
+  DataType = 'DataType',
+  RuntimeFunction = 'RuntimeFunction',
+}
+
+export interface Meta {
+  name: string;
+  type: MetaType;
+  data: string[];
+}
+
+export const Reader = (rootPath: string): Meta[] => {
+    const result: Meta[] = [];
+
+    try {
+      const features = fs.readdirSync(rootPath, { withFileTypes: true });
+
+      for (const featureDirent of features) {
+        if (!featureDirent.isDirectory()) continue;
+
+        const featurePath = path.join(rootPath, featureDirent.name);
+        const featureName = featureDirent.name;
+
+        const typeDirs = fs.readdirSync(featurePath, { withFileTypes: true });
+
+        for (const typeDirent of typeDirs) {
+          if (!typeDirent.isDirectory()) continue;
+
+          const metaType = matchMetaType(typeDirent.name);
+          if (!metaType) continue;
+
+          const typePath = path.join(featurePath, typeDirent.name);
+          const definitions = fs.readdirSync(typePath, { withFileTypes: true });
+
+          for (const def of definitions) {
+            const defPath = path.join(typePath, def.name);
+
+            if (def.isFile()) {
+              const meta = MetaReader(featureName, metaType, defPath);
+              if (meta) result.push(meta);
+            } else if (def.isDirectory()) {
+              const subDefinitions = fs.readdirSync(defPath, { withFileTypes: true });
+
+              for (const subDef of subDefinitions) {
+                const subPath = path.join(defPath, subDef.name);
+                if (!subDef.isFile()) continue;
+
+                const meta = MetaReader(featureName, metaType, subPath);
+                if (meta) result.push(meta);
+              }
+            }
+          }
+        }
+      }
+
+      return result
+    } catch (err) {
+      console.error(`Error reading path ${rootPath}:`, err);
+      return [];
+    }
+}
+
+const MetaReader = (name: string, type: MetaType, filePath: string): Meta | null => {
+    let content: string;
+
+    try {
+      content = fs.readFileSync(filePath, 'utf-8');
+    } catch (err) {
+      console.error(`Error reading file: ${filePath}`, err);
+      return null;
+    }
+
+    const lines = content.split('\n');
+    let insideCode = false;
+    const currentBlock: string[] = [];
+    const codeSnippets: string[] = [];
+
+    for (const line of lines) {
+      if (line.includes('```')) {
+        insideCode = !insideCode;
+
+        if (!insideCode) {
+          codeSnippets.push(currentBlock.join(' '));
+          currentBlock.length = 0;
+        }
+        continue;
+      }
+
+      if (insideCode) {
+        currentBlock.push(line);
+      }
+    }
+
+    return { name, type, data: codeSnippets };
+}
+
+function matchMetaType(name: string): MetaType | null {
+  switch (name) {
+    case 'flow_type':
+      return MetaType.FlowType;
+    case 'data_type':
+      return MetaType.DataType;
+    case 'runtime_definition':
+      return MetaType.RuntimeFunction;
+    default:
+      return null;
+  }
+}