Merge pull request #21 from code0-tech/15-ts-reader

TypeScript Reader

Author: raphael-goetz

.github/workflows/publish-reader.yml

@@ -0,0 +1,24 @@
+name: Publish Package to npmjs
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  publish:
+    defaults:
+      run:
+        working-directory: "./reader/ts"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm version from-git --git-tag-version=false
+      - run: npm ci
+      - run: npm run build
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_PUBLISH_TOKEN }}

.gitignore

@@ -1,3 +1,5 @@
 /target
 *.DS_Store
-.idea
+**/node_modules
+.idea
+reader/ts/src/*.js

README.md

@@ -1,33 +1,55 @@
-# Definition CLI
+# Definitions
 
-## Setup
-```bash
-cargo build --release
-```
+## Definition CLI
 
-## Usage
+### Setup
+[Install Cargo](https://doc.rust-lang.org/cargo/getting-started/installation.html)
 
+### Usage
+(Stay inside the root directory when running the command)
 ### General Report
 ```bash
-./cli report
-./cli report -p /path/to/definitions
+./cargo run report
+./cargo run report -p /path/to/definitions
 ```
 
 ### Feature Report
 ```bash
-./cli feature
-./cli feature -f feature_name
-./cli feature -f feature_name -p /path/to/definitions
+./cargo run feature
+./cargo run feature -p /path/to/definitions
+./cargo run feature -f feature_name
+./cargo run feature -f feature_name -p /path/to/definitions
 ```
 
 ### Watch for Changes
 ```bash
-./cli watch
-./cli watch -p /path/to/definitions
+./cargo run watch
+./cargo run watch -p /path/to/definitions
 ```
 
 ### Definition
 ```bash
-./cli definition -n definition_name
-./cli definition -n definition_name -p /path/to/definitions
+./cargo run definition -n definition_name
+./cargo run definition -n definition_name -p /path/to/definitions
+```
+
+## TypeScript Definition Package
+
+### Install Package
+```bash
+npm i @code0-tech/code0-definition-reader --save-dev
 ```
+
+### Usage
+
+```ts
+const features = Definition("./path/to/definitions")
+
+for (const feature in features) {
+    const name = feature.name; //name of the feature (e.g. rest)
+    const dataTypes = fearture.dataTypes; //dataTypes of this feature
+    const flowTypes = fearture.flowTypes; //flowTypes of this feature
+    const functions = fearture.runtimeFunctions; //runtimeFunctions of this feature
+}
+```
+

reader/ts/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[];
+}

reader/ts/index.js

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

reader/ts/package-lock.json

@@ -0,0 +1,31 @@
+{
+  "name": "@code0-tech/definition-reader",
+  "version": "0.0.0",
+  "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"
+  }
+}

reader/ts/package.json

@@ -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);
+        }
+    }
+}

reader/ts/src/parser.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;
+  }
+}