@diagramers/cli 1.0.24 → 1.0.26

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

@@ -1,52 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

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