@diagramers/cli 1.0.23 → 1.0.24

package/templates/api/src/schemas/otp.ts

@@ -0,0 +1,52 @@
+import * as mongoose from 'mongoose';
+import { OTPCode } from '../entities/user';
+import { AuthProvider } from '../helpers/enums';
+
+export const otpSchema = new mongoose.Schema({
+    code: {
+        type: String,
+        required: true
+    },
+    user_id: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'user',
+        required: true
+    },
+    auth_provider: {
+        type: String,
+        enum: Object.values(AuthProvider),
+        required: true
+    },
+    purpose: {
+        type: String,
+        enum: ['email_verification', 'phone_verification', 'password_reset', 'login'],
+        required: true
+    },
+    expires_at: {
+        type: Date,
+        required: true
+    },
+    attempts: {
+        type: Number,
+        default: 0
+    },
+    max_attempts: {
+        type: Number,
+        default: 3
+    },
+    is_used: {
+        type: Boolean,
+        default: false
+    },
+    created_at: {
+        type: Date,
+        default: Date.now
+    }
+}, { timestamps: true, suppressReservedKeysWarning: true });
+
+// Index for performance
+otpSchema.index({ user_id: 1, purpose: 1, is_used: 1 });
+otpSchema.index({ code: 1, user_id: 1 });
+otpSchema.index({ expires_at: 1 }, { expireAfterSeconds: 0 }); // TTL index
+
+export const OTPEntity = mongoose.model<OTPCode>('otp', otpSchema); 

package/templates/api/src/schemas/session.ts

@@ -0,0 +1,57 @@
+import * as mongoose from 'mongoose';
+import { UserSession } from '../entities/user';
+import { AuthProvider, AuthMethod } from '../helpers/enums';
+
+export const sessionSchema = new mongoose.Schema({
+    session_id: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    user_id: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'user',
+        required: true
+    },
+    auth_provider: {
+        type: String,
+        enum: Object.values(AuthProvider),
+        required: true
+    },
+    auth_method: {
+        type: String,
+        enum: Object.values(AuthMethod),
+        required: true
+    },
+    ip_address: {
+        type: String,
+        required: true
+    },
+    user_agent: {
+        type: String,
+        required: true
+    },
+    is_active: {
+        type: Boolean,
+        default: true
+    },
+    expires_at: {
+        type: Date,
+        required: true
+    },
+    created_at: {
+        type: Date,
+        default: Date.now
+    },
+    last_activity: {
+        type: Date,
+        default: Date.now
+    }
+}, { timestamps: true, suppressReservedKeysWarning: true });
+
+// Index for performance
+sessionSchema.index({ user_id: 1, is_active: 1 });
+sessionSchema.index({ session_id: 1 });
+sessionSchema.index({ expires_at: 1 }, { expireAfterSeconds: 0 }); // TTL index
+
+export const SessionEntity = mongoose.model<UserSession>('session', sessionSchema); 

package/templates/api/src/schemas/user.ts

@@ -0,0 +1,125 @@
+import * as mongoose from 'mongoose';
+import { IUser } from '../entities/user';
+import { AuthProvider } from '../helpers/enums';
+import { v4 as uuidv4 } from 'uuid';
+
+// Auth Provider Info Schema
+const authProviderInfoSchema = new mongoose.Schema({
+    provider: {
+        type: String,
+        enum: Object.values(AuthProvider),
+        required: true
+    },
+    provider_user_id: {
+        type: String,
+        required: false
+    },
+    provider_access_token: {
+        type: String,
+        required: false
+    },
+    provider_refresh_token: {
+        type: String,
+        required: false
+    },
+    provider_metadata: {
+        type: mongoose.Schema.Types.Mixed,
+        required: false
+    },
+    is_verified: {
+        type: Boolean,
+        default: false
+    },
+    last_used: {
+        type: Date,
+        default: Date.now
+    },
+    created_at: {
+        type: Date,
+        default: Date.now
+    }
+}, { _id: false });
+
+export const userSchema = new mongoose.Schema(
+    {
+        name: {
+            type: mongoose.SchemaTypes.String,
+            required: true,
+        },
+        username: {
+            type: mongoose.SchemaTypes.String,
+            required: false,
+            length: 150,
+            unique: true
+        },
+        email: {
+            type: mongoose.SchemaTypes.String,
+            unique: true,
+            required: true,
+        },
+        emailVerified: {
+            type: mongoose.SchemaTypes.Boolean,
+            default: false,
+        },
+        
+        // New authentication fields
+        auth_providers: {
+            type: [authProviderInfoSchema],
+            default: []
+        },
+        primary_auth_provider: {
+            type: String,
+            enum: Object.values(AuthProvider),
+            default: AuthProvider.INTERNAL
+        },
+        
+        // Legacy fields (for backward compatibility)
+        hashedPassword: {
+            type: mongoose.SchemaTypes.String,
+            required: false
+        },
+        firebaseUID: {
+            type: mongoose.SchemaTypes.String,
+            required: false
+        },
+        
+        // Contact information
+        phone: {
+            type: mongoose.SchemaTypes.String,
+            required: false
+        },
+        phoneVerified: {
+            type: mongoose.SchemaTypes.Boolean,
+            default: false,
+        },
+        
+        // Profile information
+        identity: {
+            type: String,
+            default: () => uuidv4()
+        },
+        address: {
+            type: mongoose.Schema.Types.Mixed,
+            required: false
+        },
+        invitationCode: {
+            type: String,
+            required: false
+        },
+        registerationStatus: {
+            type: mongoose.SchemaTypes.Boolean,
+            default: false
+        },
+        userType: {
+            type: String,
+            default: 'NOR'
+        },
+        status: {
+            type: Number,
+            default: 1
+        }
+    },
+    { timestamps: true, suppressReservedKeysWarning: true },
+);
+
+export const UserEntity = mongoose.model<IUser>('user', userSchema);

package/templates/api/src/server/index.ts

@@ -0,0 +1,86 @@
+import * as express from "express";
+import * as bodyParser from "body-parser";
+import { Routes } from "../routes"
+import { SocketServerProvider } from "./socket-server-provider";
+const path = require("path");
+import { IConfig } from "../config/config-interface";
+import { connectDb } from "../helpers/dbcontext";
+import { Server as socketServer } from "socket.io";
+import { Result } from "../helpers/result";
+import { ResponseCode } from "../helpers/enums";
+const cors = require('cors');
+export var SocketServer: socketServer = null;
+export class Server {
+    app: express.Application;
+
+    constructor() {
+        this.app = express();
+        // this.config();
+    }
+
+    Create(config: IConfig) {
+        process.setMaxListeners(0);
+
+        this.app.set('env', config.variables.NODE_ENV);
+        this.app.set('port', config.props.port);
+        this.app.set('hostname', config.props.host_name);
+        this.app.use(bodyParser.json({ limit:'100mb'}));
+        // Increase body parser limit to accommodate larger payloads
+        this.app.use(express.json({ limit: '100mb' })); // Set JSON body parser limit
+        this.app.use(express.urlencoded({ limit: '100mb', extended: true })); // Set URL-encoded body parser limit
+        this.app.use((req, res, next) => {
+            res.header('Access-Control-Allow-Origin', '*');
+            res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Content-Length, Accept, p-request-identifier');
+            res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            next();
+          });
+        this.app.use(bodyParser.urlencoded({
+            extended: true
+        }));
+        // this.app.use(express.static(__dirname));
+        this.app.options('*', cors());
+        // this.app.use(cors)
+        const assetsPath = path.join(__dirname + '/assets');
+        // this.app.engine('hbs', engines.handlebars);
+        this.app.set('views', path.join(__dirname, '/views'));
+        console.log('***ASSETS PATH *** ', assetsPath);
+        this.app.use(express.static(assetsPath));
+        this.app.set('view engine', 'hbs');
+        var routeConfigs = new Routes();
+        routeConfigs.init(this.app);
+        var socketServerProvider = new SocketServerProvider(this.app, config);
+        SocketServer = socketServerProvider.io;
+    }
+
+    Start(config: IConfig) {
+        // let hostname = config.props.host_name,
+        //     port = config.props.port;
+        // this.app.listen(config.props.port, function () {
+        //     console.log('Express server listening on - http://' + hostname + ':' + port);
+        // });
+        connectDb().then(async () => {
+            let hostname = this.app.get('hostname'),
+                port = this.app.get('port');
+            // this.app.listen(port, function () {
+            //     console.log('Express server listening on - http://' + hostname + ':' + port);
+            // // });
+            // var taskService = new TaskService(new Result(null, ResponseCode.Incompelete))
+            // await taskService.LoadScheduledTasks();
+        }).catch((ex) => {
+            console.error(ex);
+        });
+        console.log('started')
+    }
+    // private config(): void {
+    //     //add support for application/json type for data
+    //     this.app.use(bodyParser.json());
+
+    //     //support application/x-www-form-urlencoded post data
+    //     this.app.use(bodyParser.urlencoded({ extended: false }));
+
+    //     this.app.get("/", (req, res) => {
+    //         res.send("Welcome to HELLO!");
+    //     });
+    // }
+
+}

package/templates/api/src/server/socket-server-provider.ts

@@ -0,0 +1,209 @@
+import * as express from "express";
+import { Server, Socket } from 'socket.io';
+import { IConfig } from "../config/config-interface";
+import { RequestInit } from 'node-fetch'
+import { AuditMessageType, ResponseCode, SocketEventCode, SocketIdentifierType } from "../helpers/enums";
+import { AuditService } from "../services/audit-service";
+import { Result } from "../helpers/result";
+import { UUID } from "bson";
+import { handleSocketResponse } from "../helpers/handle-response";
+import { EncryptionHelper } from "../helpers/encryptionHelper";
+import { AuthHelper } from "../helpers/auth";
+import { readFileSync } from 'fs';
+import * as https from 'https'
+import * as path from 'path';
+import { SocketServer } from "./index";
+
+const http = require('http');
+
+export class SocketServerProvider {
+    /**
+     *
+     */
+    io: Server = null;
+    config: IConfig = null;
+    sockets: any[] = [];
+    expressApp: express.Application;
+    className = 'SocketServerProvider'
+    constructor(app: express.Application, config: IConfig) {
+        var socketServer = http.createServer(app);
+
+        this.expressApp = app
+        socketServer.listen(app.get('port'), () => {
+            console.log(`Express & Socket Server listening to ${app.get('port')} - ${new Date().toString()}`)
+        });
+        const cors = require('cors');
+        const allowList = ['https://app.sendifier.com', 'https://humble-macaw-separately.ngrok-free.app', 'https://www.sendifier.com', 'http://localhost:3000', 'http://127.0.0.1:3000', 'localhost:4000', 'http://127.0.0.1:4000'];
+        const allowUserAgents = ['facebookexternalua', 'PostmanRuntime/7.33.0', 'PostmanRuntime/7.35.0',
+            'PostmanRuntime/7.36.0', 'socket-io-postman-agent', 'curl/7.74.0'];
+        var corsOptionsDelegate = function (origin, callback) {
+            console.log('validating cors', JSON.stringify(origin))
+
+            var corsOptions: any = {}
+            var allowed = false;
+            if (allowList.indexOf(origin) !== -1) {
+                allowed = true;
+            } else {
+                if (allowUserAgents.indexOf(origin) !== -1) {
+                    allowed = true;
+                }
+                else {
+                    allowed = false;
+                }
+            }
+            corsOptions.origin = allowed;
+            corsOptions.methods = "GET,HEAD,PUT,PATCH,POST,DELETE";
+            corsOptions.headers = ['Authorization', 'Origin', 'X-Requested-With', 'Content-Type', 'Accept', 'Access-Control-Request-Method', 'Access-Control-Request-Headers', 'Cache-Control'];
+            if (allowed || !origin) {
+                callback(null, corsOptions)
+            }
+            else
+                callback('Not allowed source', corsOptions) // callback expects two parameters: error and options
+        }
+
+        this.io = new Server(socketServer, {
+            cors: {
+                origin: corsOptionsDelegate,
+                methods: '*',
+                allowedHeaders: '*',
+
+                'preflightContinue': true
+            },
+            maxHttpBufferSize: 1e8, // Set maximum HTTP buffer size (default is 1e6 bytes)
+        });
+        this.registerEvents();
+    }
+    async registerEvents() {
+        var auditService = new AuditService();
+        this.io.setMaxListeners(0);
+        this.io.sockets.on(SocketEventCode.Connect, async (socket) => {
+            console.log(`user connected with socket id ${socket.id} - ${new Date().toString()}`);
+            const query = socket.request['_query'];
+            if (query) {
+                const tabid = query.tabid;
+                if (tabid != null && tabid != undefined && tabid != 'null' && tabid != 'undefined') {
+                    auditService.AddAuditSingle(AuditMessageType.socket, this.className, SocketEventCode.Connect, tabid, 'Socket connected', this.getRequestAdditionalInfo(tabid));
+                    if (!this.sockets[tabid]) {
+                        this.sockets[tabid] = {};
+                    }
+                    // else {
+                    //     this.sockets[tabid] = { socketId: socket.id, tabid: tabid, tkn: query.currentContact };
+                    //     console.info(`Tab {${tabid}} added with socket {${socket.id}} - ${new Date().toString()}`);
+                    //     auditService.AddAuditSingle(AuditMessageType.socket, this.className, SocketEventCode.Connect, tabid, `Tab {${tabid}} added with socket {${socket.id}}`, this.getRequestAdditionalInfo(tabid));
+                    // }
+                    this.sockets[tabid].socketId = socket.id;
+                    this.sockets[tabid].tabid = tabid;
+                    this.sockets[tabid].tkn = query.currentUser;
+                    if (query.currentUser && query.currentUser != 'null') {
+                        this.sockets[tabid].user = JSON.parse(new EncryptionHelper().decryptUserLogin(query.currentUser));
+                    }
+                    auditService.AddAuditSingle(AuditMessageType.socket, this.className, SocketEventCode.Connect, tabid, `Socket {${socket.id}} registered for tab {${tabid}}`, this.getRequestAdditionalInfo(tabid));
+
+                }
+                else {
+                    this.io.emit(SocketEventCode.ReloadClient);
+                    auditService.AddAuditSingle(AuditMessageType.socket, this.className, SocketEventCode.ReloadClient, tabid, `Connection doesn't have tabid, reloaded`, this.getRequestAdditionalInfo(tabid));
+                }
+            }
+
+
+
+            socket.on(SocketEventCode.Error, (error) => {
+                console.error('Server error:', error);
+            });
+            socket.on(SocketEventCode.UserLoggedIn, async (payload, callback) => {
+                try {
+                    var data = payload.data;
+                    var tabid = payload.tabid;
+                    console.log(`User {${data.email}} is logged in from Tab {${tabid}} with socket {${socket.id}} - ${new Date().toString()}`);
+                    auditService.AddAuditSingle(AuditMessageType.socket, this.className, SocketEventCode.UserLoggedIn, tabid, `User logged in`, this.getRequestAdditionalInfo(tabid));
+                    this.sockets[tabid].tkn = payload.currentUser;
+                    var userProfile = new EncryptionHelper().decryptUserLogin(payload.currentUser);
+                    this.sockets[tabid].user = userProfile
+                    socket.join(`${userProfile._defaultCompanyId}`);
+                    socket.join(`${userProfile._defaultCompanyId}_${userProfile._id}`);
+                    auditService.AddAuditSingle(AuditMessageType.socket, this.className, SocketEventCode.UserLoggedIn, tabid, `User joined default company room`, this.getRequestAdditionalInfo(tabid));
+                }
+                catch (ex) {
+                    callback(new Result(null, ResponseCode.Unauthorized, [ex], ['unauthenticated request'], new UUID().toString()));
+                }
+            });
+            socket.on(SocketEventCode.UserLoggedOut, (payload) => {
+                const tabid = payload.tabid;
+                auditService.AddAuditSingle(AuditMessageType.socket, this.className, SocketEventCode.UserLoggedOut, tabid, `User logged out`, this.getRequestAdditionalInfo(tabid));
+                delete this.sockets[tabid].user;
+            });
+            socket.on(SocketEventCode.Close, (data) => {
+                socket.disconnect(true);
+                var socketToBeDisconnected = this.sockets[data.tabid];
+                auditService.AddAuditSingle(AuditMessageType.socket, this.className, SocketEventCode.UserLoggedOut, data.tabid, `User disonnected`, this.getRequestAdditionalInfo(data.tabid));
+                delete this.sockets[data.tabid]
+            });
+            socket.on(SocketEventCode.RespondWhatsappMessage, async (payload) => {
+                var requestIdentifier = new UUID().toString();
+                var senderSocket = this.sockets[payload.tabid];
+                var result = new Result(null, ResponseCode.Incompelete, [], [], requestIdentifier, this.getRequestAdditionalInfo(payload.tabid), senderSocket.user);
+                result.addMessage(AuditMessageType.socket, this.className, SocketEventCode.RespondWhatsappMessage, 'Send whatsapp message')
+                const data = payload.data;
+                var whatsappProviderService = null;//new WhatsappProviderService(result);
+                await whatsappProviderService.SendWhatsappMessage(data, senderSocket);
+                handleSocketResponse(result);
+            });
+            socket.on(SocketEventCode.VerifyToken, async (payload, callback) => {
+                var tabid = payload.tabid;
+                var userSoket = this.sockets[tabid];
+                if (userSoket && userSoket.user) {
+                    var authHelper = new AuthHelper(new Result(null, ResponseCode.Ok, [], [], payload.tabid, {}, userSoket.user));
+                    var verifyTokenResult = await authHelper.VerifyToken(userSoket.user.token);
+                    if (verifyTokenResult.Status == ResponseCode.Ok) {
+                        callback(true)
+                    }
+                    else {
+                        callback(false)
+                    }
+                }
+                else {
+                    socket.emit(SocketEventCode.ReloadClient);
+                }
+            });
+            socket.on(SocketEventCode.RefreshToken, async (payload, callback) => {
+                var tabid = payload.tabid;
+                var data = payload.data;
+                var encryptionHelper = new EncryptionHelper();
+                var userSoket = this.sockets[tabid];
+                if (userSoket && userSoket.user) {
+                    this.sockets[tabid].user.token = data;
+                    var response = this.sockets[tabid].user;
+                    this.sockets[tabid].tkn = response;
+                    callback(response);
+                }
+                else {
+                    socket.emit(SocketEventCode.ReloadClient);
+                }
+            });
+        });
+    }
+
+    getRequestAdditionalInfo(tabid) {
+        var requestedSocket = this.sockets[tabid];
+        var result: any = { tabId: tabid };
+        if (requestedSocket) {
+            result.socketId = requestedSocket.socketId;
+            if (requestedSocket.user) {
+                result.userProfile = {
+                    id: requestedSocket.user.id,
+                    name: requestedSocket.user.name,
+                    phone: requestedSocket.user.phone,
+                    email: requestedSocket.user.email,
+                    defaultCompany: requestedSocket.user._defaultCompanyId,
+                    requestIdentifier: requestedSocket.requestIdentifier
+                }
+            }
+        }
+        return result;
+    }
+}
+export const emitEvent = async (groupId, eventCode: SocketEventCode, payload) => {
+    SocketServer.to(String(groupId)).emit(eventCode, payload);
+
+}