blend-kit 1.0.1

package/src/helper/SectionHelper.ts

@@ -0,0 +1,154 @@
+import path from 'path';
+import { FileHelper } from "./fileHelper";
+
+export default class SectionHelper {
+    static createProject(basicFileContent: string)  {
+        const folderPath = process.cwd(); // Current working directory
+                const sectionRegex = /section\s+([a-zA-Z0-9_]+)\s*{\s*data-module\s+([a-zA-Z0-9,]+)\s*}/g;
+        
+                let match;
+                while ((match = sectionRegex.exec(basicFileContent)) !== null) {
+                    const sectionName = match[1];
+                    // Path for the section folder inside `spec`
+                    const sectionFolderPath = path.join(folderPath, 'module', sectionName);
+                    const packageFilePath = path.join(sectionFolderPath,"package.json");
+                    const tsConfigFilePath = path.join(sectionFolderPath,"tsconfig.json");
+                    const appTsPath = path.join(sectionFolderPath,"src/app.ts");
+                    const envPath = path.join(sectionFolderPath,".env.dev");
+                    const routesPath = path.join(sectionFolderPath,"src/routes/common/common.routes.config.ts");
+                    const packageFileCode = packageJSON;
+                    packageFileCode.name = sectionName;
+                    FileHelper.createFile(packageFilePath,JSON.stringify(packageFileCode));
+                    FileHelper.createFile(tsConfigFilePath,JSON.stringify(tsconfigJson));
+                    FileHelper.createFile(appTsPath,appTsCode);
+                    FileHelper.createFile(envPath,envFileCode);
+                    FileHelper.createFile(routesPath,routesCode);
+                    
+                }
+    }
+}
+
+const tsconfigJson = {
+    "compilerOptions": {
+      "target": "es2016",
+      "module": "commonjs",
+      "outDir": "./dist",
+      "strict": true,
+      "esModuleInterop": true,
+      "inlineSourceMap": true
+    }
+  }
+
+  const packageJSON = {
+    "name": "",
+    "version": "1.0.0",
+    "description": "",
+    "main": "index.js",
+    "scripts": {
+      "start": "tsc && NODE_ENV=dev node ./dist/app.js",
+      "debug": "export DEBUG=* && npm run start",
+      "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "Govind",
+    "license": "ISC",
+    "dependencies": {
+      "bcrypt": "^5.1.0",
+      "body-parser": "^1.20.1",
+      "cors": "^2.8.5",
+      "crypto": "^1.0.1",
+      "debug": "^4.3.4",
+      "express": "^4.18.2",
+      "express-jwt": "^8.4.1",
+      "express-winston": "^4.2.0",
+      "jsonwebtoken": "^9.0.0",
+      "mongoose": "^6.8.1",
+      "winston": "^3.8.2",
+      "dotenv": "^16.3.1"
+    },
+    "devDependencies": {
+      "@types/bcrypt": "^5.0.0",
+      "@types/cors": "^2.8.13",
+      "@types/debug": "^4.1.7",
+      "@types/express": "^4.17.15",
+      "source-map-support": "^0.5.21",
+      "tslint": "^6.1.3",
+      "typescript": "^4.9.4"
+    }
+  }
+
+  const envFileCode = "";
+
+  const appTsCode = `
+  import express from 'express';
+import * as http from 'http';
+
+import * as winston from 'winston';
+import * as expressWinston from 'express-winston';
+import cors from 'cors';
+import debug from 'debug';
+
+import bodyParser, {json, urlencoded} from 'body-parser';
+import mongoose from 'mongoose';
+import { CommonRoutesConfig } from './routes/common/common.routes.config';
+import dotenv from "dotenv";
+
+const app: express.Application = express();
+
+const port = 3000;
+const routes: Array<CommonRoutesConfig> = [];
+const debugLog: debug.IDebugger = debug('app');
+app.use((err: any, req:express.Request, res:express.Response, next:any) => {
+    console.error(err.stack)
+    res.status(500).send('Something broke!')
+  });
+app.use(express.json());
+
+app.use(cors());
+app.use(urlencoded());
+app.use(json());
+dotenv.config({ path: ".env.\${process.env.NODE_ENV}" });
+mongoose.set('strictQuery', false);
+
+const runningMessage = "Server running ats http://localhost:\${port}";
+app.get('/', (req: express.Request, res: express.Response) => {
+    
+    res.send("Hello World")
+});
+
+
+const server: http.Server = http.createServer(app);
+
+
+server.listen(port, () => {
+    if(process.env.MONGO_DB_URL) {
+    mongoose.connect(process.env.MONGO_DB_URL).then(mongoConnection => {
+        console.log("Succesfully connected to the data base",routes)
+    })
+    }
+    console.log(runningMessage);
+    routes.forEach((route: CommonRoutesConfig) => {
+        
+    });
+    // our only exception to avoiding console.log(), because we
+    // always want to know when the server is done starting up
+    
+});
+  `
+  
+  const routesCode = `
+  import express from 'express';
+export abstract class CommonRoutesConfig {
+    app: express.Application;
+    name: string;
+
+    constructor(app: express.Application, name: string) {
+        this.app = app;
+        this.name = name;
+        this.configureRoutes();
+    }
+    getName() {
+        return this.name;
+    }
+    abstract configureRoutes(): express.Application;
+}
+  `

package/src/helper/fileHelper.ts

@@ -0,0 +1,111 @@
+// fileHelper.ts
+import fs from 'fs-extra';
+import path from 'path';
+
+export class FileHelper {
+  // Ensure a directory exists, create it if it doesn't
+  static ensureDir(folderPath: string): void {
+    try {
+      fs.ensureDirSync(folderPath);
+    } catch (error) {
+      console.error(`Error ensuring directory: ${error.message}`);
+      throw error;
+    }
+  }
+
+  static writeFile(filePath: string, content: string): void {
+    try {
+      // Ensure the folder exists
+      const folderPath = path.dirname(filePath);
+      this.ensureDir(folderPath);
+
+      // Write the file
+      fs.writeFileSync(filePath, content);
+    } catch (error) {
+      console.error(`Error writing file at ${filePath}: ${error.message}`);
+      throw error;
+    }
+  }
+
+  static createFile(filePath: string, content: string): void {
+    try {
+      // Ensure the folder exists
+      const folderPath = path.dirname(filePath);
+      this.ensureDir(folderPath);
+      if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, content);
+      }
+      // Write the file
+      
+    } catch (error) {
+      console.error(`Error writing file at ${filePath}: ${error.message}`);
+      throw error;
+    }
+  }
+
+ // Read content from a file
+ static readFile(filePath: string): string {
+    try {
+      return fs.readFileSync(filePath, 'utf-8');
+    } catch (error) {
+      console.error(`Error reading file at ${filePath}: ${error.message}`);
+      throw error;
+    }
+  }
+  // Write a JSON object to a file, ensuring the folder exists
+  static writeJson(filePath: string, jsonContent: object): void {
+    try {
+      // Ensure the folder exists
+      const folderPath = path.dirname(filePath);
+      this.ensureDir(folderPath);
+
+      // Write the JSON file
+      fs.writeJsonSync(filePath, jsonContent, { spaces: 2 });
+    } catch (error) {
+      console.error(`Error writing JSON to ${filePath}: ${error.message}`);
+      throw error;
+    }
+  }
+ 
+  // Check if a file or directory exists
+  static exists(filePath: string): boolean {
+    try {
+      return fs.existsSync(filePath);
+    } catch (error) {
+      console.error(`Error checking existence of ${filePath}: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Copy a file from source to destination, ensuring the destination folder exists
+  static async copyFile(srcPath: string, destPath: string): Promise<void> {
+    try {
+      // Ensure the destination folder exists
+      await fs.ensureDir(path.dirname(destPath));
+
+      // Copy the file
+      await fs.copyFile(srcPath, destPath);
+      console.log(`File copied from ${srcPath} to ${destPath}`);
+    } catch (error) {
+      console.error(`Error copying file from ${srcPath} to ${destPath}: ${error.message}`);
+      throw error;
+    }
+  }
+
+
+/**
+ * Copies an entire folder from source to destination, including its contents.
+ * @param srcFolder The path to the source folder.
+ * @param destFolder The path to the destination folder.
+ */
+static async copyFolder(srcFolder: string, destFolder: string): Promise<void> {
+    try {
+      // Copy the folder recursively
+      await fs.copy(srcFolder, destFolder, { overwrite: true });
+      console.log(`Folder copied from ${srcFolder} to ${destFolder}`);
+    } catch (error) {
+      console.error(`Error copying folder from ${srcFolder} to ${destFolder}: ${error.message}`);
+      throw error;
+    }
+  }
+}

package/src/helper/grammarHelper/BlendApiGrammarHelper.ts

@@ -0,0 +1,45 @@
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import { BlendApiLexer } from "../../parser/blendApi/src/grammar/BlendApiLexer";
+import { BlendApiParser } from "../../parser/blendApi/src/grammar/BlendApiParser";
+import { IApiMainSection, IApiSection, IApiSpec, IExpressSection } from "../../types/apiOperationTypes";
+
+export default class BlendApiGrammarHelper {
+    parseBlendApi(code: string) {
+        const inputStream = CharStreams.fromString(code);
+        const lexer = new BlendApiLexer(inputStream);
+        const tokenStream = new CommonTokenStream(lexer);
+        const parser = new BlendApiParser(tokenStream);
+
+        const mainModule = parser.program();
+        const json: IExpressSection = {
+            name: mainModule.moduleDefinition().CAPITAL_IDENTIFIER().text,
+            apiSectionList: mainModule.sectionDefinition().map(item => {
+                const apiSection: IApiSection = {
+                    name: item.CAPITAL_IDENTIFIER().text, apiList: item.apiDefinition().map(api => {
+                        const apiSpec: IApiSpec = {
+                            input: {},
+                            output: {},
+                            name: api.IDENTIFIER().text,
+                            type: api.HTTP_METHOD().text,
+                            directOutput: api.outputDefinition()?.directOutputDefenition()?.type()? {
+                                required: !api.outputDefinition()?.directOutputDefenition()?.type().text.includes("?"),
+                                name: api.outputDefinition()?.directOutputDefenition()?.type().text?.replace("?", ""),
+                            }:{},
+                            authenticated: api?.authenticated()?.text=="authenticated"
+                        }
+                        api.inputDefinition()?.field()?.forEach(field => {
+                            apiSpec.input[field.IDENTIFIER().text] = { type: field.type().text?.replace("?", ""), required: !field?.type().text.includes("?") };
+                        })
+                        api.outputDefinition()?.field()?.forEach(field => {
+                            apiSpec.output[field.IDENTIFIER().text] = { type: field.type().text?.replace("?", ""), required: !field?.type().text.includes("?") };
+                        })
+                        return apiSpec;
+                    })
+                }
+                return apiSection;
+            }),
+            includedDataModuleList: []
+        }
+        return { isValid: parser.numberOfSyntaxErrors === 0, json };
+    }
+}

package/src/helper/grammarHelper/BlendBasicGrammarHelper.ts

@@ -0,0 +1,101 @@
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import { BlendBasicLexer } from "../../parser/blendbasic/src/grammar/BlendBasicLexer";
+import { BlendBasicParser, SectionContext, ModuleContext, DataModuleContext, ExpressModuleContext, RnModuleContext, MongoModuleContext, ReactModuleContext } from "../../parser/blendbasic/src/grammar/BlendBasicParser";
+import { AbstractParseTreeVisitor } from "antlr4ts/tree/AbstractParseTreeVisitor";
+import GrammarErrorHelper from "./GrammarErrorHelper";
+
+export default class BlendBasicGrammarHelper extends AbstractParseTreeVisitor<any> {
+    protected defaultResult() {
+        return {}; // Avoid errors if visitChildren returns nothing
+    }
+
+    parseBlendBasic(code: string) {
+        const inputStream = CharStreams.fromString(code);
+        const lexer = new BlendBasicLexer(inputStream);
+        const tokenStream = new CommonTokenStream(lexer);
+        const parser = new BlendBasicParser(tokenStream);
+        const sectionsList = parser.sections(); // Assuming the root rule is "program" that contains multiple sections
+        const sections = sectionsList.section().map(section => this.visitSection(section));
+        const basicJson = {
+            name: "BlendBasicConfig",
+            description: "Basic config for swing",
+            createdAt: new Date().toISOString(),
+            sectionList: sections
+        };
+        return {valid: parser.numberOfSyntaxErrors===0,basicJson};
+    }
+
+    visitSection(ctx: SectionContext): any {
+        const sectionName = ctx.IDENTIFIER().text;
+
+        // Lists for categorized modules
+        const dataModuleList: string[] = [];
+        const expressModuleList: any[] = [];
+        const rnModuleList: any[] = [];
+        const mongoModuleList: any[] = [];
+        const reactModuleList: any[] = [];
+
+        ctx.module().forEach(mod => {
+            const resultList = this.visitModule(mod);
+            console.log(resultList,"resultList")
+            if (!resultList) return;
+            resultList.map(result => {
+                if (result.type === "data-module") {
+                    dataModuleList.push(result.name);
+                } else if (result.type === "express-module") {
+                    expressModuleList.push({ name: result.name });
+                } else if (result.type === "rn-module") {
+                    rnModuleList.push({ name: result.name });
+                } else if (result.type === "mongo-module") {
+                    mongoModuleList.push({ name: result.name });
+                }
+                else if (result.type === "react-module") {
+                    reactModuleList.push({ name: result.name });
+                }
+            })
+
+            
+        });
+
+        return {
+            name: sectionName,
+            dataModuleList,
+            expressModuleList,
+            rnModuleList,
+            mongoModuleList,
+            reactModuleList
+        };
+    }
+
+    visitModule(ctx: ModuleContext): any {
+        // Handle multiple identifiers
+        const moduleType = ctx.children?.[0].text; // First token is the type (e.g., data-module)
+        console.log(moduleType,"moduleType")
+        if(ctx.dataModule()) return this.visitDataModule(ctx.dataModule())
+        if(ctx.expressModule()) return this.visitExpressModule(ctx.expressModule())
+        if(ctx.rnModule()) return this.visitRnModule(ctx.rnModule())
+        if(ctx.mongoModule()) return this.visitMongoModule(ctx.mongoModule())
+        if(ctx.reactModule()) return this.visitReactModule(ctx.reactModule())
+    }
+
+    visitDataModule(ctx: DataModuleContext): any {
+        return ctx.IDENTIFIER().map(id => ({ type: "data-module", name: id.text }));
+    }
+    
+    visitExpressModule(ctx: ExpressModuleContext): any {
+        return ctx.IDENTIFIER().map(id => ({ type: "express-module", name: id.text }));
+    }
+    
+    visitRnModule(ctx: RnModuleContext): any {
+        return ctx.IDENTIFIER().map(id => ({ type: "rn-module", name: id.text }));
+    }
+    
+    visitMongoModule(ctx: MongoModuleContext): any {
+        return ctx.IDENTIFIER().map(id => ({ type: "mongo-module", name: id.text }));
+    }
+
+    visitReactModule(ctx: ReactModuleContext): any {
+        return ctx.IDENTIFIER().map(id => ({ type: "react-module", name: id.text }));
+    }
+    
+}

package/src/helper/grammarHelper/BlendDataGrammarHelper.ts

@@ -0,0 +1,49 @@
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import { BlendDataLexer } from "../../parser/blendData/src/grammar/BlendDataLexer";
+import { BlendDataParser, DataDefinitionContext, FieldContext } from "../../parser/blendData/src/grammar/BlendDataParser";
+
+export default class BlendDataGrammarHelper {
+       parseBlendData(code: string) {
+            const inputStream = CharStreams.fromString(code);
+            const lexer = new BlendDataLexer(inputStream);
+            const tokenStream = new CommonTokenStream(lexer);
+            const parser = new BlendDataParser(tokenStream);
+            const mainSection = parser.program(); // Assuming the root rule is "program" that contains multiple sections
+            const dataDefenitionList = mainSection.dataDefinition();
+            let hasError = false;
+          
+            const dataSet = new Set();
+            const moduleDataObject = {
+                name: mainSection.moduleDefinition().CAPITAL_IDENTIFIER().text,
+                dataList:   dataDefenitionList.map((dataDefinition: DataDefinitionContext) => {
+                    const dataName = dataDefinition.CAPITAL_IDENTIFIER().text;
+                    if(dataSet.has(dataName)) {
+                        hasError = true;
+                        console.log(`Duplicate Data ${dataName} found`)
+                    }
+                    dataSet.add(dataDefinition.CAPITAL_IDENTIFIER().text)
+                    const fieldSet = new Set();
+                    return {
+                        name: dataDefinition.CAPITAL_IDENTIFIER().text,
+                        fields: dataDefinition.field().map((field: FieldContext) => {
+                            const fieldName = field.IDENTIFIER().text;
+                                if(fieldSet.has(fieldName)) {
+                                    hasError = true;
+                                    console.log(`Field Data ${fieldName} found in ${dataName}`)
+                                }
+                                fieldSet.add(fieldName);
+                            return {
+                                name: fieldName,
+                                requred: !field.type().text.includes("?"),
+                                type: field.type().text.replace("?",""),
+                            }
+                        })
+                    }
+                    
+                    
+                })
+            }
+            
+            return {valid: parser.numberOfSyntaxErrors===0&&!hasError,moduleDataObject};
+        }
+}

package/src/helper/grammarHelper/BlendMDPGrammarHelper.ts

@@ -0,0 +1,33 @@
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import {  } from "../../parser/blendbasic/src/grammar/BlendBasicLexer";
+import {  SectionContext, ModuleContext, DataModuleContext, ExpressModuleContext, RnModuleContext, MongoModuleContext, ReactModuleContext } from "../../parser/blendbasic/src/grammar/BlendBasicParser";
+import { AbstractParseTreeVisitor } from "antlr4ts/tree/AbstractParseTreeVisitor";
+import { BlendMDPLexer } from "../../parser/blendMDP/src/grammar/BlendMDPLexer";
+import { BlendMDPParser } from "../../parser/blendMDP/src/grammar/BlendMDPParser";
+
+export default class BlendMDPGrammarHelper extends AbstractParseTreeVisitor<any> {
+    protected defaultResult() {
+        return {}; // Avoid errors if visitChildren returns nothing
+    }
+
+    parseBlendMDP(code: string) {
+        const inputStream = CharStreams.fromString(code);
+        const lexer = new BlendMDPLexer(inputStream);
+        const tokenStream = new CommonTokenStream(lexer);
+        const parser = new BlendMDPParser(tokenStream);
+        const program = parser.program(); 
+        
+        const mdpJson = {
+            name: program.moduleDefinition().CAPITAL_IDENTIFIER().text,
+            propsList: program.propsDefinition().propsBodyDefinition().map(propsBody => {
+                return {
+                    name: propsBody.IDENTIFIER().text,
+                    type: propsBody.CAPITAL_IDENTIFIER().text
+                }
+            })
+        };
+        return {valid: parser.numberOfSyntaxErrors===0,mdpJson};
+    }
+
+    
+}

package/src/helper/grammarHelper/BlendMongoGrammarHelper.ts

@@ -0,0 +1,50 @@
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import { BlendMongoLexer } from "../../parser/blendMongo/src/grammar/BlendMongoLexer";
+import { BlendMongoParser } from "../../parser/blendMongo/src/grammar/BlendMongoParser";
+import { IDataBase } from "../../types/mongoOperationTypes";
+
+export default class BlendMongoGrammarHelper {
+    parseBlendMongo(code: string){
+        const inputStream = CharStreams.fromString(code);
+        const lexer = new BlendMongoLexer(inputStream);
+        const tokenStream = new CommonTokenStream(lexer);
+        const parser = new BlendMongoParser(tokenStream);
+        const program = parser.program();
+        const moduleDefinition = program.moduleDefinition();
+        const collectionDefinitionList = program.collectionDefinition();
+        const json: IDataBase = {
+            dbName: moduleDefinition.CAPITAL_IDENTIFIER().text,
+            collectionList: collectionDefinitionList.map(collectionDefinition => {
+                const propertyFields = collectionDefinition.property().map(property => {
+                    return {
+                        name: property.IDENTIFIER().text,
+                        type: property.type().text,
+                        unique: property.propertyChars()?.mongoChars()?property.propertyChars()?.mongoChars()?.findIndex(item => item.text === "unique") !=-1: undefined,
+                        index: property.propertyChars()?.mongoChars()?property.propertyChars()?.mongoChars()?.findIndex(item => item.text === "index") !=-1: undefined,
+                        // ref: collectionDefinition.reference()?collectionDefinition.reference()?.CAPITAL_IDENTIFIER().text:undefined,
+                    }
+                });
+
+                const referenceFields = collectionDefinition.reference()?.map(reference => {
+                    return {
+                        name: reference.IDENTIFIER().text,
+                        type: 'Types.ObjectId',
+                        unique: reference.propertyChars()?.mongoChars()?reference.propertyChars()?.mongoChars()?.findIndex(item => item.text === "unique") !=-1: undefined,
+                        index: reference.propertyChars()?.mongoChars()?reference.propertyChars()?.mongoChars()?.findIndex(item => item.text === "index") !=-1: undefined,
+                        ref: reference?.CAPITAL_IDENTIFIER().text,
+                    }
+                });
+                return {
+                    name: collectionDefinition.CAPITAL_IDENTIFIER().text,
+                    fields: [...propertyFields,...referenceFields]
+                }
+            })
+            
+        }
+
+        return {
+            isValid: parser.numberOfSyntaxErrors>0,
+            json: json
+        }
+    }
+}

package/src/helper/grammarHelper/BlendRNGrammarHelper.ts

@@ -0,0 +1,65 @@
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import { BlendMongoLexer } from "../../parser/blendMongo/src/grammar/BlendMongoLexer";
+import { BlendMongoParser } from "../../parser/blendMongo/src/grammar/BlendMongoParser";
+import { IDataBase } from "../../types/mongoOperationTypes";
+import { BlendRNLexer } from "../../parser/blendRN/src/grammar/BlendRNLexer";
+import { BlendRNParser, LayoutDefinitionContext, ProgramContext } from "../../parser/blendRN/src/grammar/BlendRNParser";
+import path from "path";
+import { IRNComponent, IRNLayout, IRNModule, IRNScreen } from "../../types/frontendOperationTypes";
+
+export default class BlendRNGrammarHelper {
+    parseBlendRN(code: string){
+        const inputStream = CharStreams.fromString(code);
+        const lexer = new BlendRNLexer(inputStream);
+        const tokenStream = new CommonTokenStream(lexer);
+        const parser = new BlendRNParser(tokenStream);
+        const program = parser.program();
+        let screenList: IRNScreen[] = [];
+        let componentList: IRNComponent[] = [];
+        program.screenDefenition().forEach(screen => {
+            screen.CAPITAL_IDENTIFIER().forEach(screenName => {
+                screenList.push({name: screenName.text,path: screen.PATH_IDENTIFIER().text.replace(/"/g, '')});
+            })
+        });
+
+        program.componentDefenition().forEach(component => {
+            component.CAPITAL_IDENTIFIER().forEach(componentName => {
+                componentList.push({name: componentName.text,path: component.PATH_IDENTIFIER().text.replace(/"/g, '')});
+            })
+        });
+        const layout: IRNLayout[] = parseAndCreateLayoutAndScreen(program);
+        function parseAndCreateLayoutAndScreen(prgrm: ProgramContext|LayoutDefinitionContext): IRNLayout[] {
+            return prgrm.layoutDefinition().map(layout => {
+                const layoutList = parseAndCreateLayoutAndScreen(layout);
+                const pageList: IRNLayout[] = layout.pageDefinition().map(page => {
+                    return {
+                        name: page.CAPITAL_IDENTIFIER()[0].text,
+                        route: page.PATH_IDENTIFIER().text.replace(/"/g, ''),
+                        element: page.CAPITAL_IDENTIFIER()[1].text
+                    }
+                })
+                return {
+                    name: layout.CAPITAL_IDENTIFIER().text,
+                    route: layout.PATH_IDENTIFIER().text.replace(/"/g, ''),
+                    children: [...layoutList,...pageList],
+                    type: layout.LAYOUT_TYPE().text
+                }
+            });
+        }
+        
+        const json:IRNModule = {
+            componentList,
+            screenList,
+            layout,
+            name: program.moduleDefinition().CAPITAL_IDENTIFIER().text
+        }
+
+        return {
+            valid: parser.numberOfSyntaxErrors==0,
+            json
+        }
+        
+    }
+
+    
+}

package/src/helper/grammarHelper/BlendReactGrammarHelper.ts

@@ -0,0 +1,65 @@
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import { BlendMongoLexer } from "../../parser/blendMongo/src/grammar/BlendMongoLexer";
+import { BlendMongoParser } from "../../parser/blendMongo/src/grammar/BlendMongoParser";
+import { IDataBase } from "../../types/mongoOperationTypes";
+import { BlendRNLexer } from "../../parser/blendRN/src/grammar/BlendRNLexer";
+import { LayoutDefinitionContext, ProgramContext } from "../../parser/blendReact/src/grammar/BlendReactParser";
+import path from "path";
+import { BlendReactLexer } from "../../parser/blendReact/src/grammar/BlendReactLexer";
+import { BlendReactParser } from "../../parser/blendReact/src/grammar/BlendReactParser";
+import { IReactLayout, IReactModule, IReactScreen } from "../../types/frontendOperationTypes";
+
+export default class BlendReactGrammarHelper {
+    parseBlendReact(code: string){
+        const inputStream = CharStreams.fromString(code);
+        const lexer = new BlendReactLexer(inputStream);
+        const tokenStream = new CommonTokenStream(lexer);
+        const parser = new BlendReactParser(tokenStream);
+        const program = parser.program();
+        let screenList: IReactScreen[] = [];
+        let componentList: IReactScreen[] = [];
+        program.screenDefenition().forEach(screen => {
+            screen.CAPITAL_IDENTIFIER().forEach(screenName => {
+                screenList.push({name: screenName.text,path: screen.PATH_IDENTIFIER().text.replace(/"/g, '')});
+            })
+        });
+        program.componentDefenition().forEach(screen => {
+            screen.CAPITAL_IDENTIFIER().forEach(screenName => {
+                componentList.push({name: screenName.text,path: screen.PATH_IDENTIFIER().text.replace(/"/g, '')});
+            })
+        });
+        const layout: IReactLayout[] = parseAndCreateLayoutAndScreen(program);
+        function parseAndCreateLayoutAndScreen(prgrm: ProgramContext|LayoutDefinitionContext): IReactLayout[] {
+            return prgrm.layoutDefinition().map(layout => {
+                const layoutList = parseAndCreateLayoutAndScreen(layout);
+                const pageList: IReactLayout[] = layout.pageDefinition().map(page => {
+                    return {
+                        name: page.CAPITAL_IDENTIFIER()[0].text,
+                        route: page.PATH_IDENTIFIER().text.replace(/"/g, ''),
+                        element: page.CAPITAL_IDENTIFIER()[1].text
+                    }
+                })
+                return {
+                    name: layout.CAPITAL_IDENTIFIER().text,
+                    route: layout.PATH_IDENTIFIER().text.replace(/"/g, ''),
+                    children: [...layoutList,...pageList],
+                }
+            });
+        }
+        
+        const json:IReactModule = {
+            componentList,
+            screenList,
+            layout,
+            name: program.moduleDefinition().CAPITAL_IDENTIFIER().text.toLocaleLowerCase()
+        }
+
+        return {
+            valid: parser.numberOfSyntaxErrors==0,
+            json
+        }
+        
+    }
+
+    
+}