blend-kit 1.0.1

package/dist/helper/ReactHelper.js

@@ -0,0 +1,524 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fileHelper_1 = require("./fileHelper");
+const path_1 = __importDefault(require("path"));
+const BlendReactGrammarHelper_1 = __importDefault(require("./grammarHelper/BlendReactGrammarHelper"));
+const { execSync } = require('child_process');
+const runCommand = (command, cwd = process.cwd()) => {
+    try {
+        execSync(command, { stdio: 'inherit', cwd });
+    }
+    catch (error) {
+        console.error(`Failed to execute command: ${command}`);
+        process.exit(1);
+    }
+};
+class ReactHelper {
+    constructor() {
+        this.folderPath = path_1.default.join(process.cwd());
+        this.folderName = path_1.default.basename(this.folderPath);
+        this.basicFilePath = path_1.default.join(this.folderPath, `${this.folderName}.basic`);
+        this.configPath = path_1.default.join(this.folderPath, '.basicConfig');
+        this.basicProjectContent = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/basicConfig.json`) || "{}");
+    }
+    doReactOperations() {
+        this.createReactSpec();
+        this.parseSpec();
+    }
+    doReactGenerations() {
+        this.buildComponents();
+        this.buildScreens();
+    }
+    createReactSpec() {
+        this.basicProjectContent.sectionList.forEach(section => {
+            const sectionName = section.name.trim();
+            const sectionFolderPath = path_1.default.join(this.folderPath, 'spec', sectionName);
+            const reactFolderPath = path_1.default.join(sectionFolderPath, 'frontend');
+            section.reactModuleList.forEach(reactModule => {
+                const dataFilePath = path_1.default.join(reactFolderPath, `${reactModule.name}.react`);
+                if (!fileHelper_1.FileHelper.exists(dataFilePath)) {
+                    fileHelper_1.FileHelper.writeFile(dataFilePath, `module ${reactModule.name}`);
+                }
+            });
+        });
+    }
+    parseSpec() {
+        const sectionReactList = [];
+        this.basicProjectContent.sectionList.forEach(section => {
+            const sectionName = section.name.trim();
+            const sectionObj = {
+                name: sectionName,
+                reactModuleList: [],
+            };
+            section.reactModuleList.forEach(reactModule => {
+                const rnFilePath = path_1.default.join(this.folderPath, `spec/${sectionName}/frontend/${reactModule.name}.react`);
+                const specCode = fileHelper_1.FileHelper.readFile(rnFilePath);
+                const reactHelper = new BlendReactGrammarHelper_1.default();
+                const json = reactHelper.parseBlendReact(specCode);
+                if (!json.valid) {
+                    throw new Error("Error while parsing the react native screens");
+                }
+                else {
+                    sectionObj.reactModuleList.push(json.json);
+                }
+            });
+            sectionReactList.push(sectionObj);
+        });
+        // Write the generated configuration to a file
+        fileHelper_1.FileHelper.writeFile(`${this.configPath}/reactConfig.json`, JSON.stringify(sectionReactList, null, 4));
+    }
+    generateMDPCode(component) {
+        return `module ${component.name}\nprops {}`;
+    }
+    //Generate
+    buildScreens() {
+        const reactSectionList = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/reactConfig.json`));
+        reactSectionList.forEach(reactSection => {
+            const reactFolderPath = path_1.default.join(this.folderPath, `module/${reactSection.name}/react`);
+            reactSection.reactModuleList.forEach(reactModule => {
+                this.buildLayouts(reactSection, reactModule);
+                const rnProjectPath = path_1.default.join(reactFolderPath, reactModule.name);
+                reactModule.screenList.forEach(screen => {
+                    const screenPath = `${rnProjectPath}/src/view/${screen.path}/`;
+                    const screenCode = this.generateScreenCode(screen);
+                    fileHelper_1.FileHelper.createFile(`${screenPath}${screen.name}.tsx`, screenCode);
+                });
+            });
+        });
+    }
+    buildComponents() {
+        const reactSectionList = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/reactConfig.json`));
+        reactSectionList.forEach(reactSection => {
+            const reactFolderPath = path_1.default.join(this.folderPath, `module/${reactSection.name}/react`);
+            reactSection.reactModuleList.forEach(reactModule => {
+                this.buildLayouts(reactSection, reactModule);
+                const rnProjectPath = path_1.default.join(reactFolderPath, reactModule.name);
+                const mdpHookComponentPath = `${rnProjectPath}/src/src-gen/component/mdpHook.ts`;
+                const mdpPath = `${rnProjectPath}/src/src-gen/component/MDP.ts`;
+                const mdpHookCode = this.generateMDPHookCode(reactModule.componentList);
+                fileHelper_1.FileHelper.writeFile(`${mdpHookComponentPath}`, mdpHookCode);
+                fileHelper_1.FileHelper.writeFile(`${mdpPath}`, `export interface MDP {getMetaData:() => any;}\nexport interface IBasicComponent {value?: any;onInput?:(val: any) => any;}`);
+                reactModule.componentList.forEach(component => {
+                    const componentPath = `${rnProjectPath}/src/component/${component.path}/`;
+                    const componentCode = this.generateComponentCode(component);
+                    const mdpCode = this.generateComponentMDPCode(component);
+                    fileHelper_1.FileHelper.createFile(`${componentPath}/${component.name}/${component.name}.tsx`, componentCode);
+                    fileHelper_1.FileHelper.createFile(`${componentPath}/${component.name}/${component.name}MDP.ts`, mdpCode);
+                    fileHelper_1.FileHelper.createFile(`${componentPath}/${component.name}/index.ts`, `export {default} from './${component.name}';\nexport * from "./${component.name}MDP";`);
+                });
+            });
+        });
+    }
+    generateMDPHookCode(componentList) {
+        const importsCode = `
+        ${componentList.reduce((acc, component) => {
+            acc = acc + `import ${component.name} from '../../component/${component.path}/${component.name}';\n`;
+            return acc;
+        }, "")}`;
+        return `
+        import React, { useCallback, useRef, useState } from "react";
+        import { MDP } from "./MDP";
+        ${importsCode}
+        
+
+export const useMetaData = (props: { 
+    mdpClass: MDP; 
+    defaultInput?: any; 
+    onInput?: (val: any) => void; 
+    extraProps?: any;
+    memoize?: boolean;
+}): [React.ReactElement, any, React.Dispatch<any>] => {
+    
+    console.log(props.defaultInput, props.mdpClass, "defaultInput");
+
+    const [input, setInput] = useState(props.defaultInput);
+    const componentRef: any = useRef<React.ReactElement | null>(null);
+
+    // useEffect(() => {
+    //     setInput(props.defaultInput);
+    // }, [props.defaultInput]);
+
+    const handleInputChange = useCallback((val: any) => {
+        setInput(val);
+        props.onInput?.(val);
+    }, [props.onInput]);
+
+    
+    if (!componentRef.current || props.mdpClass !== componentRef.current.props.mdpClass || props.extraProps !== componentRef.current.props.extraProps) {
+        componentRef.current = generateElementFromMetaData({
+            componentClassMetaData: props.mdpClass.getMetaData(),
+            onInput: handleInputChange,
+            value: input,
+            extraProps: props.extraProps
+        });
+    }
+
+    return [componentRef.current, input, setInput];
+};
+
+export const generateElementFromMetaData = ({ componentClassMetaData, value, onInput, extraProps }: {
+    componentClassMetaData: any;
+    value?: any;
+    onInput?: any;
+    extraProps?: object;
+}) => {
+    return React.createElement((ComponentNameMap[componentClassMetaData.componentName] as any), {
+        ...componentClassMetaData.props,
+        value: value,
+        onInput: onInput,
+        ...extraProps
+    })
+}
+
+
+
+const ComponentNameMap: any = {
+    ${componentList.reduce((acc, component) => {
+            acc = acc + `"${component.name}": ${component.name},\n`;
+            return acc;
+        }, "")}
+}
+
+export interface IMetaDataHook {
+    element: React.ReactElement,
+    input?: any;
+}
+        
+        `;
+    }
+    checkForFolderAndCreateReactApp() {
+        return new Promise((checkRes) => __awaiter(this, void 0, void 0, function* () {
+            const reactSectionList = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/reactConfig.json`));
+            const promises = [];
+            reactSectionList.forEach(reactSection => {
+                const reactFolderPath = path_1.default.join(this.folderPath, `module/${reactSection.name}/react`);
+                fileHelper_1.FileHelper.ensureDir(reactFolderPath);
+                reactSection.reactModuleList.forEach(rnModule => {
+                    const modulePath = path_1.default.join(reactFolderPath, rnModule.name);
+                    if (!fileHelper_1.FileHelper.exists(modulePath)) {
+                        promises.push(new Promise(res => {
+                            runCommand(`npm create vite@6.2.0 ${rnModule.name} -- --template react-ts `, reactFolderPath);
+                            // runCommand(`npm install -D typescript @types/node @types/react @types/react-dom @types/jest`, modulePath);
+                            const dependencies = [
+                                '@reduxjs/toolkit@2.6.0',
+                                'react-redux@9.2.0',
+                                'redux-saga@1.3.0',
+                                "axios@1.8.1",
+                                "react-router-dom@7.2.0",
+                                "tailwindcss@4.0.9",
+                                "tailwindcss@4.0.9",
+                                "@tailwindcss/vite@4.0.9"
+                            ];
+                            runCommand(`npm install ${dependencies.join(' ')}`, modulePath);
+                            fileHelper_1.FileHelper.writeFile(`${modulePath}/src/App.tsx`, mainAppcode);
+                            fileHelper_1.FileHelper.writeFile(`${modulePath}/src/index.css`, `@import "tailwindcss";`);
+                            fileHelper_1.FileHelper.writeFile(`${modulePath}/tsconfig.json`, tsConfigJsonCode);
+                            fileHelper_1.FileHelper.writeFile(`${modulePath}/tsconfig.app.json`, tsConfigAppJsonCode);
+                            fileHelper_1.FileHelper.writeFile(`${modulePath}/src/index.css`, `@import "tailwindcss";`);
+                            runCommand(`npm install -D @types/node`, modulePath);
+                            fileHelper_1.FileHelper.writeFile(`${modulePath}/vite.config.ts`, viteConfigCode);
+                            runCommand(`npx shadcn@latest init`, modulePath);
+                        }));
+                    }
+                });
+            });
+            yield Promise.all(promises);
+            checkRes(true);
+        }));
+    }
+    buildLayouts(rnSection, reactModule) {
+        const reactFolderPath = path_1.default.join(this.folderPath, `module/${rnSection.name}/react`);
+        const rnLayoutPath = path_1.default.join(reactFolderPath, reactModule.name);
+        const lo = {
+            name: "BlendGenerated",
+            route: "/",
+            children: reactModule.layout,
+        };
+        const routerCode = this.generateRouterCode(lo, reactModule);
+        fileHelper_1.FileHelper.writeFile(`${rnLayoutPath}/src/src-gen/router/blend-router.tsx`, routerCode);
+        this.traverseChildrenAndCreateLayout(rnLayoutPath, lo, reactModule);
+        fileHelper_1.FileHelper.createFile(`${rnLayoutPath}/src/layout/${lo.name}Layout.tsx`, `
+${this.generateLayoutCode(lo, reactModule)}
+`);
+    }
+    traverseChildrenAndCreateLayout(reactLayoutPath, lo, frontEnd) {
+        lo.children.forEach(loChild => {
+            if (loChild.children) {
+                fileHelper_1.FileHelper.createFile(`${reactLayoutPath}/src/layout/${loChild.name}Layout.tsx`, `
+    ${this.generateLayoutCode(loChild, frontEnd)}
+    `);
+                this.traverseChildrenAndCreateLayout(reactLayoutPath, loChild, frontEnd);
+            }
+        });
+    }
+    findScreenPath(screenList, screenName) {
+        const index = screenList.findIndex(screen => screen.name === screenName);
+        if (screenList[index]) {
+            return screenList[index].path;
+        }
+        else {
+        }
+    }
+    generateFlattenedArray(children) {
+        let uniqueElements = [];
+        let flatenedArray = [];
+        generateFlattenedArrayFun(children);
+        function generateFlattenedArrayFun(children) {
+            return children.forEach((child) => {
+                flatenedArray.push(child);
+                if (child.children) {
+                    generateFlattenedArrayFun(child.children);
+                }
+                else {
+                    if (!uniqueElements.includes(child.element)) {
+                        uniqueElements.push(child.element);
+                    }
+                    else {
+                        flatenedArray.pop();
+                    }
+                }
+            });
+        }
+        return flatenedArray;
+    }
+    generateRouterCode(mainLayout, frontEnd) {
+        const defaultImportCode = `
+        import { createBrowserRouter } from 'react-router-dom';\n
+        import React from 'react';\n
+        import BlendGeneratedLayout from '../../layout/BlendGeneratedLayout';
+        `;
+        console.log([mainLayout], JSON.stringify([mainLayout]), "Main layout///////////////");
+        const routerJsonCode = `const router = createBrowserRouter([${this.generateLayoutRouterJSONCode([mainLayout])}])\nexport default router;`;
+        console.log(this.generateFlattenedArray(mainLayout.children), "this.generateFlattenedArray(mainLayout.children)");
+        const importCode = `${this.generateFlattenedArray(mainLayout.children).reduce((acc, item) => {
+            const importCode = `   ${item.children ? `
+                    import ${item.name}Layout from '../../layout/${item.name}Layout';\n
+                    ` : `
+                    import ${item.element} from '../../view/${this.findScreenPath(frontEnd.screenList, ((item === null || item === void 0 ? void 0 : item.element) || ""))}/${item.element}';\n
+                    `}`;
+            acc = acc + importCode;
+            return acc;
+        }, "")}`;
+        return importCode + defaultImportCode + routerJsonCode;
+    }
+    generateLayoutRouterJSONCode(layoutList) {
+        return layoutList.reduce((acc, layout) => {
+            acc = acc + `{element: ${layout.children ? `<${layout.name}Layout/>,` : `<${layout.element} />,`}
+            path: "${layout.route}",
+            ${layout.children ? `children: [${this.generateLayoutRouterJSONCode(layout.children)}],` : ``}
+            },
+            `;
+            return acc;
+        }, '');
+    }
+    generateRouterConstant(children) {
+        let path = '';
+        const routeObj = generateRouterConstantObj(children);
+        function generateRouterConstantObj(children) {
+            return children.reduce((acc, child, index) => {
+                if (child.children) {
+                    path = child.route && child.route != "" && child.route != "/" ? path + "/" + child.route : path;
+                    acc[child.name] = generateRouterConstantObj(child.children);
+                    console.log(child.name, index, children.length, "Path With layout After");
+                    if (index == children.length - 1) {
+                        path = path.split("/").slice(0, -1).join('/').toString();
+                        // const pathNumToBeRemoved = child.route.split("/").length;
+                        // path = path.split("/").slice(0,-pathNumToBeRemoved).join('/').toString();
+                    }
+                }
+                else {
+                    path = child.route && child.route != "" && child.route != "/" ? path + "/" + child.route : path;
+                    acc[child.name] = path;
+                    console.log(path, "Path Without layout");
+                    const pathNumToBeRemoved = child.route.split("/").length;
+                    console.log(pathNumToBeRemoved, index, children.length, "pathNumToBeRemoved..............");
+                    path = path.split("/").slice(0, -pathNumToBeRemoved).join('/').toString();
+                    if (index == children.length - 1) {
+                        path = path.split("/").slice(0, -1).join('/').toString();
+                        // const pathNumToBeRemoved = child.route.split("/").length;
+                        // path = path.split("/").slice(0,-pathNumToBeRemoved).join('/').toString();
+                    }
+                }
+                return acc;
+            }, {});
+        }
+        return JSON.stringify(routeObj);
+    }
+    generateLayoutCode(lo, frontEnd) {
+        return (`
+import { Outlet } from "react-router-dom"
+const ${lo.name}Layout = () => {
+        return (
+        <div>
+            ${lo.name}Layout
+            <Outlet />
+        </div>
+        )
+}
+
+export default ${lo.name}Layout;
+`);
+    }
+    generateScreenCode(screen) {
+        return `
+        import React from "react";
+        const ${screen.name} = () => {
+        return(
+            <div>
+            ${screen.name}
+            </div>
+        )
+        }
+        
+        export default ${screen.name};
+        `;
+    }
+    generateComponentCode(component) {
+        return `
+        import React from "react";
+        import {I${component.name}Props} from './${component.name}MDP';
+        const ${component.name} = (props: I${component.name}Props) => {
+        return(
+            <div>
+            ${component.name}
+            </div>
+        )
+        }
+        
+        export default ${component.name};
+        `;
+    }
+    generateComponentMDPCode(component) {
+        const pathCode = '../../' + component.path.split("/").reduce((acc, curVal) => {
+            acc = acc + '../';
+            return acc;
+        }, "");
+        return `
+        import { MDP,IBasicComponent } from "${pathCode}src-gen/component/MDP";
+        
+export class ${component.name}MDP implements I${component.name}MDP {
+    componentName: string = "${component.name}";
+    
+    getMetaData() {
+        return {
+            componentName: this.componentName,
+            props: {
+            }
+
+        }
+    }
+}
+
+export interface I${component.name}Props extends IBasicComponent {
+}
+export interface I${component.name}MDP extends MDP {
+getMetaData: () => {componentName: string, props: I${component.name}Props}
+}
+        `;
+    }
+}
+exports.default = ReactHelper;
+const mainAppcode = `
+
+import { Provider } from 'react-redux';
+import './App.css';
+import { store } from './redux/store/store';
+import { RouterProvider } from 'react-router-dom';
+import router from './src-gen/router/blend-router'
+function App() {
+  
+  return (
+    <div className="App">
+     <Provider store={store}>
+     <RouterProvider router={router}/>
+     </Provider>
+    </div>
+  );
+}
+
+export default App;
+`;
+const tsConfigJsonCode = `
+{
+  "files": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    },
+    {
+      "path": "./tsconfig.node.json"
+    }
+  ],
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}
+
+`;
+const tsConfigAppJsonCode = `
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": ["src"]
+}
+
+
+`;
+const viteConfigCode = `
+import path from "path"
+import tailwindcss from "@tailwindcss/vite"
+import react from "@vitejs/plugin-react"
+import { defineConfig } from "vite"
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+})
+`;

package/dist/helper/SectionHelper.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fileHelper_1 = require("./fileHelper");
+class SectionHelper {
+    static createProject(basicFileContent) {
+        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_1.default.join(folderPath, 'module', sectionName);
+            const packageFilePath = path_1.default.join(sectionFolderPath, "package.json");
+            const tsConfigFilePath = path_1.default.join(sectionFolderPath, "tsconfig.json");
+            const appTsPath = path_1.default.join(sectionFolderPath, "src/app.ts");
+            const envPath = path_1.default.join(sectionFolderPath, ".env.dev");
+            const routesPath = path_1.default.join(sectionFolderPath, "src/routes/common/common.routes.config.ts");
+            const packageFileCode = packageJSON;
+            packageFileCode.name = sectionName;
+            fileHelper_1.FileHelper.createFile(packageFilePath, JSON.stringify(packageFileCode));
+            fileHelper_1.FileHelper.createFile(tsConfigFilePath, JSON.stringify(tsconfigJson));
+            fileHelper_1.FileHelper.createFile(appTsPath, appTsCode);
+            fileHelper_1.FileHelper.createFile(envPath, envFileCode);
+            fileHelper_1.FileHelper.createFile(routesPath, routesCode);
+        }
+    }
+}
+exports.default = SectionHelper;
+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;
+}
+  `;