blend-kit 1.0.1

package/src/types/apiOperationTypes.ts

@@ -0,0 +1,43 @@
+export type IApiSpec = {
+    name: string;
+    type: string;
+    input: any;
+    output: any;
+    authenticated?: boolean;
+    directOutput?: IApiDataField;
+};
+
+export type IApiMainSection = {
+    name: string;
+    expressSectionList: IExpressSection[];
+};
+
+export type IExpressSection = {
+    name: string;
+    apiSectionList: IApiSection[];
+    includedDataModuleList: string[];
+};
+
+export type IApiSection = {
+    name: string,
+    apiList: IApiSpec[]
+}
+
+export interface IApiDataField {
+    name?: string,
+    type?: string,
+    required?: boolean
+}
+
+
+
+// export type IApiModule = {
+//     name: string;
+//     apiList: IApiSpec[];
+// }
+
+export enum ApiType {
+    Get="GET",
+    Post="POST",
+    Put="PUT"
+}

package/src/types/basicOperationTypes.ts

@@ -0,0 +1,15 @@
+export type IBasicSection = {
+    name: string;
+    dataModuleList: string[];
+    expressModuleList: { name: string; includedDataModuleList: string[] }[];
+    rnModuleList?: {name: string}[];
+    reactModuleList?: {name: string}[];
+    mongoModuleList?: {name: string}[];
+  };
+  
+  export type IBasicProject = {
+    name: string;
+    description: string;
+    createdAt: string;
+    sectionList: IBasicSection[];
+  };

package/src/types/dataOperationTypes.ts

@@ -0,0 +1,20 @@
+export interface IDataSection {
+    name: string,
+    sectionDataList: IDataModule[]
+}
+
+export interface IDataModule {
+    name: string,
+    dataList: IData[]
+}
+
+export interface IData {
+name: string,
+fields: IDataField[]
+}
+
+export interface IDataField {
+    name: string,
+    type: string,
+    required?: boolean
+}

package/src/types/frontendOperationTypes.ts

@@ -0,0 +1,92 @@
+export interface IFrontEndScreen{
+    name: string;
+    path: string;
+    parentLayout?: string;
+};
+
+export interface IRNLayout {
+    name: string;
+    route: string;
+    type?: string;
+    element?: any;
+    children?: Array<{
+        element?: string;
+        name: string;
+        route: string;
+        type?: string;
+        children?: IRNLayout["children"];
+        parentLayout?:string;
+    }>;
+};
+export interface IRNScreen{
+    name: string,
+    path: string
+}
+
+export interface IRNComponent{
+    name: string,
+    path: string
+}
+export interface IRNModule {
+    componentList: IRNComponent[],
+    screenList: IRNScreen[],
+   layout: IRNLayout[],
+   name: string,
+}
+
+
+export interface IRNSection {
+    name: string,
+    rnModuleList: IRNModule[];
+}
+export interface SpecJSON {
+    screenList: IFrontEndScreen[];
+    layout: IRNLayout[];
+}
+
+
+
+//React
+
+
+export interface IReactSection {
+    name: string,
+    reactModuleList: IReactModule[];
+}
+
+export interface IReactModule {
+    
+    componentList: IReactComponent[],
+    screenList: IReactScreen[],
+   layout: IReactLayout[],
+   name: string,
+}
+
+
+
+export interface IReactScreen {
+    name:string,
+    path:string
+}
+
+export interface IReactComponent {
+    name:string,
+    path:string,
+    props?: any,
+    parent?: string
+}
+
+
+export interface IReactLayout {
+    name:string,
+    route:string,
+    children?: IReactLayout[],
+    element?: string;
+    // type?: string;
+}
+
+export interface IReactElement {
+    element: string;
+    route: string;
+    name: string;
+}

package/src/types/mongoOperationTypes.ts

@@ -0,0 +1,36 @@
+
+
+export interface IMongoSection {
+    name: string,
+    sectionDbList: IDataBase[]
+}
+
+export interface IDataBase {
+    dbName: string;
+    collectionList: ICollection[];
+}
+
+export interface ICollection {
+    name: string,
+    fields: Field[]
+}
+
+
+export interface Field {
+    name: string,
+    required?: boolean,
+    type: any,
+    index?: boolean,
+    unique?: boolean,
+    ref?: string
+}
+
+export enum FieldType {
+    String="String",
+    Number="Number",
+    Date="Date",
+    Object="Object",
+    StringArray="[String]",
+    Boolean="Boolean"
+}
+

package/template/.env.dev

@@ -0,0 +1 @@
+JWT_SECRET_KEY=vachavadhyan

package/template/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "vaishnavam",
+  "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"
+  }
+}

package/template/src/app.js

@@ -0,0 +1,76 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const http = __importStar(require("http"));
+const cors_1 = __importDefault(require("cors"));
+const debug_1 = __importDefault(require("debug"));
+const body_parser_1 = require("body-parser");
+const mongoose_1 = __importDefault(require("mongoose"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const app = (0, express_1.default)();
+const port = 3000;
+const routes = [];
+const debugLog = (0, debug_1.default)('app');
+app.use((err, req, res, next) => {
+    console.error(err.stack);
+    res.status(500).send('Something broke!');
+});
+app.use(express_1.default.json());
+app.use((0, cors_1.default)());
+app.use((0, body_parser_1.urlencoded)());
+app.use((0, body_parser_1.json)());
+dotenv_1.default.config({ path: `.env.${process.env.NODE_ENV}` });
+mongoose_1.default.set('strictQuery', false);
+const runningMessage = `Server running ats http://localhost:${port}`;
+app.get('/', (req, res) => {
+    res.send("Hello World");
+});
+const server = http.createServer(app);
+server.listen(port, () => {
+    if (process.env.MONGO_DB_URL) {
+        mongoose_1.default.connect(process.env.MONGO_DB_URL).then(mongoConnection => {
+            console.log("Succesfully connected to the data base", routes);
+        });
+    }
+    console.log(runningMessage);
+    routes.forEach((route) => {
+    });
+    // our only exception to avoiding console.log(), because we
+    // always want to know when the server is done starting up
+});

package/template/src/app.ts

@@ -0,0 +1,54 @@
+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
+    
+});

package/template/src/config/database.config.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const databaseConfig = {
+    url: 'mongodb://127.0.0.1/vaishnavam'
+};
+exports.default = databaseConfig;

package/template/src/config/database.config.ts

@@ -0,0 +1,4 @@
+const databaseConfig =  {
+url: 'mongodb://127.0.0.1/vaishnavam'
+}
+export default databaseConfig;

package/template/src/data/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/template/src/data/interfaces.ts

@@ -0,0 +1,23 @@
+
+        export interface IUser_User {
+            userName: String,
+			emailId: String,
+			password: String,
+			mobile: String,
+			firstName: String,
+			lastName: String,
+			
+        }
+        
+        export interface IRole_User {
+            name: String,
+			description: String,
+			
+        }
+        
+        export interface IPermission_User {
+            name: String,
+			description: String,
+			
+        }
+        

package/template/src/middlewares/auth.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const verifyToken = (req, res, next) => {
+    const token = req.body.token || req.query.token || req.headers["authorization"];
+    if (!token) {
+        return res.status(403).send("A token is required for authentication");
+    }
+    try {
+        const secretKey = process.env.JWT_SECRET_KEY || "";
+        const decoded = jsonwebtoken_1.default.verify(token, secretKey);
+        req.user = decoded;
+    }
+    catch (err) {
+        return res.status(401).send("Invalid Token");
+    }
+    return next();
+};
+exports.default = verifyToken;

package/template/src/middlewares/auth.ts

@@ -0,0 +1,21 @@
+
+import jwt from 'jsonwebtoken';
+
+const verifyToken = (req: any, res: any, next: any) => {
+  const token =
+    req.body.token || req.query.token || req.headers["authorization"];
+
+  if (!token) {
+    return res.status(403).send("A token is required for authentication");
+  }
+  try {
+    const secretKey = process.env.JWT_SECRET_KEY || "";
+    const decoded = jwt.verify(token, secretKey);
+    req.user = decoded;
+  } catch (err) {
+    return res.status(401).send("Invalid Token");
+  }
+  return next();
+};
+
+export default verifyToken;

package/template/src/models/Database.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+class Database {
+}
+Database.UserDb = mongoose_1.default.connection.useDb('user');
+exports.default = Database;

package/template/src/models/Database.ts

@@ -0,0 +1,8 @@
+
+import mongoose from "mongoose";
+
+export default class Database {
+static UserDb = mongoose.connection.useDb('user'); 
+
+}
+        

package/template/src/models/User/Permission.model.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Database_1 = __importDefault(require("../Database"));
+const mongoose_1 = require("mongoose");
+const PermissionSchema = new mongoose_1.Schema({
+    name: { type: String, },
+    description: { type: String, },
+});
+const Permission = Database_1.default.UserDb.model('Permission', PermissionSchema);
+exports.default = Permission;

package/template/src/models/User/Permission.model.ts

@@ -0,0 +1,14 @@
+
+import Database from '../Database';
+import { Schema, model, connect, ObjectId } from 'mongoose';
+
+import {IPermission_User} from '../../data/interfaces';
+const PermissionSchema = new Schema<IPermission_User>({
+    name: {type: String,},
+	description: {type: String,},
+	
+});
+
+const Permission = Database.UserDb.model<IPermission_User>('Permission', PermissionSchema);
+
+export default Permission;

package/template/src/models/User/Role.model.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Database_1 = __importDefault(require("../Database"));
+const mongoose_1 = require("mongoose");
+const RoleSchema = new mongoose_1.Schema({
+    name: { type: String, },
+    description: { type: String, },
+});
+const Role = Database_1.default.UserDb.model('Role', RoleSchema);
+exports.default = Role;

package/template/src/models/User/Role.model.ts

@@ -0,0 +1,14 @@
+
+import Database from '../Database';
+import { Schema, model, connect, ObjectId } from 'mongoose';
+
+import {IRole_User} from '../../data/interfaces';
+const RoleSchema = new Schema<IRole_User>({
+    name: {type: String,},
+	description: {type: String,},
+	
+});
+
+const Role = Database.UserDb.model<IRole_User>('Role', RoleSchema);
+
+export default Role;

package/template/src/models/User/User.model.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Database_1 = __importDefault(require("../Database"));
+const mongoose_1 = require("mongoose");
+const UserSchema = new mongoose_1.Schema({
+    userName: { type: String, },
+    emailId: { type: String, },
+    password: { type: String, },
+    mobile: { type: String, },
+    firstName: { type: String, },
+    lastName: { type: String, },
+});
+const User = Database_1.default.UserDb.model('User', UserSchema);
+exports.default = User;

package/template/src/models/User/User.model.ts

@@ -0,0 +1,18 @@
+
+import Database from '../Database';
+import { Schema, model, connect, ObjectId } from 'mongoose';
+
+import {IUser_User} from '../../data/interfaces';
+const UserSchema = new Schema<IUser_User>({
+    userName: {type: String,},
+	emailId: {type: String,},
+	password: {type: String,},
+	mobile: {type: String,},
+	firstName: {type: String,},
+	lastName: {type: String,},
+	
+});
+
+const User = Database.UserDb.model<IUser_User>('User', UserSchema);
+
+export default User;

package/template/src/routes/User.routes.js

@@ -0,0 +1,47 @@
+"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 common_routes_config_1 = require("./common/common.routes.config");
+const User_service_1 = __importDefault(require("../services/User/User.service"));
+const api_data_1 = require("../services/User/api.data");
+class UserRoutes extends common_routes_config_1.CommonRoutesConfig {
+    constructor(app) {
+        super(app, 'UserRoutes');
+        this.UserService = new User_service_1.default();
+    }
+    configureRoutes() {
+        this.app.route('/user/signup').post((req, res) => __awaiter(this, void 0, void 0, function* () {
+            const input = api_data_1.USER_SIGNUP_INPUT.fromJSON(req.body);
+            const defaultPreCondition = input.checkDefaultPreCondition();
+            if (defaultPreCondition.isValid) {
+                this.UserService.Signup(input, res);
+            }
+            else {
+                res.status(412).send(defaultPreCondition.errorBody);
+            }
+        }));
+        this.app.route('/user/login').post((req, res) => __awaiter(this, void 0, void 0, function* () {
+            const input = api_data_1.USER_LOGIN_INPUT.fromJSON(req.body);
+            const defaultPreCondition = input.checkDefaultPreCondition();
+            if (defaultPreCondition.isValid) {
+                this.UserService.Login(input, res);
+            }
+            else {
+                res.status(412).send(defaultPreCondition.errorBody);
+            }
+        }));
+        return this.app;
+    }
+}
+exports.default = UserRoutes;