@code0-tech/definition-reader 0.0.2

package/index.d.ts

@@ -0,0 +1,20 @@
+import {DataType, FlowType, RuntimeFunctionDefinition} from "@code0-tech/sagittarius-graphql-types";
+
+export enum MetaType {
+    FlowType = 'FlowType',
+    DataType = 'DataType',
+    RuntimeFunction = 'RuntimeFunction',
+}
+
+export interface Meta {
+    name: string;
+    type: MetaType;
+    data: string[];
+}
+
+export interface Feature {
+    name: string;
+    dataTypes: DataType[];
+    flowTypes: FlowType[];
+    runtimeFunctions: RuntimeFunctionDefinition[];
+}

package/index.js

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

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@code0-tech/definition-reader",
+  "version": "0.0.2",
+  "description": "Reader for Code0-Definitions",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc"
+  },
+  "author": "",
+  "license": "",
+  "devDependencies": {
+    "@code0-tech/sagittarius-graphql-types": "^0.0.0-f91466f0f343596ad170e7e5c5316a70b072594d",
+    "@types/node": "^24.1.0",
+    "typescript": "^5.8.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/code0-tech/code0-definitions.git"
+  },
+  "files": [
+    "src",
+    "index.d.ts",
+    "index.js",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/parser.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Definition = void 0;
+const reader_1 = require("./reader");
+const index_1 = require("../index");
+const Definition = (rootPath) => {
+    const meta = (0, reader_1.Reader)(rootPath);
+    if (!meta)
+        return [];
+    const features = [];
+    for (const m of meta) {
+        let feature = features.find((f) => f.name === m.name);
+        if (feature) {
+            appendMeta(feature, m);
+        }
+        else {
+            feature = {
+                name: m.name,
+                dataTypes: [],
+                flowTypes: [],
+                runtimeFunctions: [],
+            };
+            appendMeta(feature, m);
+            features.push(feature);
+        }
+    }
+    return features;
+};
+exports.Definition = Definition;
+function appendMeta(feature, meta) {
+    for (const definition of meta.data) {
+        try {
+            switch (meta.type) {
+                case index_1.MetaType.DataType: {
+                    const parsed = JSON.parse(definition);
+                    feature.dataTypes.push(parsed);
+                    break;
+                }
+                case index_1.MetaType.FlowType: {
+                    const parsed = JSON.parse(definition);
+                    feature.flowTypes.push(parsed);
+                    break;
+                }
+                case index_1.MetaType.RuntimeFunction: {
+                    const parsed = JSON.parse(definition);
+                    feature.runtimeFunctions.push(parsed);
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Error parsing ${meta.type} ${meta.name}:`, err);
+        }
+    }
+}

package/src/parser.ts

@@ -0,0 +1,54 @@
+import {Reader} from './reader';
+import {DataType, FlowType, RuntimeFunctionDefinition} from "@code0-tech/sagittarius-graphql-types";
+import {Feature, Meta, MetaType} from "../index";
+
+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,
+                dataTypes: [],
+                flowTypes: [],
+                runtimeFunctions: [],
+            };
+            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.dataTypes.push(parsed);
+                    break;
+                }
+                case MetaType.FlowType: {
+                    const parsed = JSON.parse(definition) as FlowType;
+                    feature.flowTypes.push(parsed);
+                    break;
+                }
+                case MetaType.RuntimeFunction: {
+                    const parsed = JSON.parse(definition) as RuntimeFunctionDefinition;
+                    feature.runtimeFunctions.push(parsed);
+                    break;
+                }
+            }
+        } catch (err: any) {
+            console.error(`Error parsing ${meta.type} ${meta.name}:`, err);
+        }
+    }
+}

package/src/reader.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reader = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_1 = require("../index");
+const Reader = (rootPath) => {
+    const result = [];
+    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 [];
+    }
+};
+exports.Reader = Reader;
+const MetaReader = (name, type, filePath) => {
+    let content;
+    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 = [];
+    const codeSnippets = [];
+    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) {
+    switch (name) {
+        case 'flow_type':
+            return index_1.MetaType.FlowType;
+        case 'data_type':
+            return index_1.MetaType.DataType;
+        case 'runtime_definition':
+            return index_1.MetaType.RuntimeFunction;
+        default:
+            return null;
+    }
+}

package/src/reader.ts

@@ -0,0 +1,101 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {Meta, MetaType} from "../index";
+
+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;
+  }
+}