@diagramers/cli 1.0.23 → 1.0.24

package/templates/api/src/services/account-service.ts

@@ -0,0 +1,243 @@
+import { ObjectId } from "bson";
+import * as uuid from 'uuid4';
+import dbcontext from "../helpers/dbcontext";
+import { EncryptionHelper } from "../helpers/encryptionHelper";
+import { AccountStatus, AuditMessageType, ResponseCode } from "../helpers/enums";
+import { Result } from "../helpers/result";
+import { UserEntity } from "../schemas/user";
+import { frameworkHelper } from "../helpers/FrameworkHelper";
+import { MailHelper } from "../helpers/mailer";
+import { Config } from "../config";
+import { AuthHelper } from "../helpers/auth";
+
+export class AccountService {
+    encryptionHelper: EncryptionHelper;
+    authHelper: AuthHelper;
+    result: Result;
+    className = 'AccountService';
+
+    constructor(result: Result) {
+        this.result = result;
+        this.encryptionHelper = new EncryptionHelper();
+        this.authHelper = new AuthHelper(result);
+    }
+
+    async seedUser(): Promise<Result> {
+        try {
+            this.result.addMessage(AuditMessageType.info, this.className, 'SeedUser', 'Started');
+            const existingAdmin = await dbcontext.UserEntity.findOne({ email: 'admin@tactic.com' });
+            if (existingAdmin) {
+                this.result.Data = existingAdmin._id;
+                this.result.Status = ResponseCode.Ok;
+                return this.result;
+            }
+            const userEntity = new UserEntity({
+                _id: new ObjectId(),
+                email: 'admin@diagrammers.com',
+                username: 'admin@diagrammers.com',
+                name: 'Admin User',
+                emailVerified: true,
+                status: AccountStatus.Active,
+                hashedPassword: this.encryptionHelper.encryptUserLogin('Admin123!'),
+                userType: 'ADMIN',
+                invitationCode: frameworkHelper.generateRandomString(6),
+                identity: uuid()
+            });
+            const createdUser = await dbcontext.UserEntity.create(userEntity);
+            if (createdUser) {
+                this.result.Data = createdUser._id;
+                this.result.Status = ResponseCode.Ok;
+            } else {
+                this.result.Status = ResponseCode.Error;
+                this.result.Errors.push('Failed to seed admin user');
+            }
+            return this.result;
+        } catch (ex) {
+            this.result.addException(this.className, 'SeedUser', ex);
+            return new Result(null, ResponseCode.Error, [ex], [ex.message]);
+        }
+    }
+
+    async register(userVM: any): Promise<Result> {
+        try {
+            const userEntity = new UserEntity({
+                email: userVM.email.toLowerCase(),
+                name: userVM.name,
+                username: userVM.email,
+                emailVerified: false,
+                invitationCode: frameworkHelper.generateRandomString(6),
+                status: AccountStatus.PendingConfirmation,
+                hashedPassword: this.encryptionHelper.encryptUserLogin(userVM.password),
+                userType: "NOR",
+                identity: uuid()
+            });
+            const createdUser = await dbcontext.UserEntity.create(userEntity);
+            if (createdUser) {
+                this.result.Data = createdUser._id;
+                const emailView = MailHelper.GetEmailConfirmationTemplate(
+                    userEntity.name,
+                    `${Config.props.base_site_url}/otp?oobCode=${this.encryptionHelper.encryptUserLogin(userEntity.invitationCode)}&inviteEmail=${this.encryptionHelper.encryptUserLogin(userEntity.email)}&usrStat=${this.encryptionHelper.encryptUserLogin(userEntity.status)}`,
+                    'Get Started'
+                );
+                await MailHelper.SendEmail(userVM.email, emailView, `Email Confirmation`);
+                this.result.Status = ResponseCode.Ok;
+            } else {
+                this.result.Status = ResponseCode.Error;
+                this.result.Errors.push('User could not be created');
+            }
+            return this.result;
+        } catch (ex) {
+            this.result.addException(this.className, 'Register', ex);
+            return new Result(null, ResponseCode.Error, [ex], [ex.message]);
+        }
+    }
+
+    async checkUserNameAvailability(username: string): Promise<Result> {
+        try {
+            const user = await dbcontext.UserEntity.findOne({ username });
+            if (!user) {
+                return new Result('', ResponseCode.NotExist);
+            } else {
+                return new Result(user._id, ResponseCode.Exist);
+            }
+        } catch (ex) {
+            return new Result(ex.message, ResponseCode.Error);
+        }
+    }
+
+    async confirmEmail(data: any): Promise<Result> {
+        try {
+            const email = this.encryptionHelper.decryptUserLogin(data.email);
+            const code = this.encryptionHelper.decryptUserLogin(data.code);
+            const user = await dbcontext.UserEntity.findOne({ email });
+            if (user && user.invitationCode === code) {
+                user.emailVerified = true;
+                user.status = AccountStatus.Active;
+                await user.save();
+                this.result.Data = user.email;
+                this.result.Status = ResponseCode.Ok;
+            } else {
+                this.result.Status = ResponseCode.Error;
+                this.result.Errors.push('Invalid email confirmation data');
+            }
+            return this.result;
+        } catch (ex) {
+            return new Result(null, ResponseCode.Error, [ex], [ex.message]);
+        }
+    }
+
+    async login(userLoginModel: any): Promise<Result> {
+        try {
+            const encryptedPassword = this.encryptionHelper.encryptUserLogin(userLoginModel.password);
+            const user = await dbcontext.UserEntity.findOne({ email: userLoginModel.email, hashedPassword: encryptedPassword });
+            if (user) {
+                this.result.Data = this.encryptionHelper.encryptUserLogin(JSON.stringify(user));
+                this.result.Status = ResponseCode.Ok;
+            } else {
+                this.result.Status = ResponseCode.Unauthorized;
+                this.result.Errors.push('Invalid login credentials');
+            }
+            return this.result;
+        } catch (ex) {
+            this.result.addException(this.className, 'Login', ex);
+            return this.result;
+        }
+    }
+
+    async getUserByEmail(email: string): Promise<Result> {
+        try {
+            const user = await dbcontext.UserEntity.findOne({ email });
+            if (user) {
+                this.result.Data = user;
+                this.result.Status = ResponseCode.Ok;
+            } else {
+                this.result.Status = ResponseCode.NotExist;
+            }
+            return this.result;
+        } catch (ex) {
+            this.result.addException(this.className, 'GetUserByEmail', ex);
+            return this.result;
+        }
+    }
+
+    // --- Added missing methods as skeletons ---
+
+    async VerifyToken(token: string): Promise<Result> {
+        try {
+            const verified = await this.authHelper.VerifyToken(token);
+            this.result.Data = verified;
+            this.result.Status = ResponseCode.Ok;
+            return this.result;
+        } catch (ex) {
+            this.result.addException(this.className, 'VerifyToken', ex);
+            return new Result(null, ResponseCode.Unauthorized, [ex], ['Invalid token']);
+        }
+    }
+
+    async VerifyMobileVerificationCode(data: any): Promise<Result> {
+        if (data.code === '123456') {
+            this.result.Data = true;
+            this.result.Status = ResponseCode.Ok;
+        } else {
+            this.result.Status = ResponseCode.Unauthorized;
+            this.result.Errors.push('Invalid code');
+        }
+        return this.result;
+    }
+
+    async resetUserPassword(data: any): Promise<Result> {
+        try {
+            const user = await dbcontext.UserEntity.findOne({ email: data.email });
+            if (user) {
+                user.hashedPassword = this.encryptionHelper.encryptUserLogin(data.password);
+                await user.save();
+                this.result.Data = true;
+                this.result.Status = ResponseCode.Ok;
+            } else {
+                this.result.Status = ResponseCode.NotExist;
+                this.result.Errors.push('User not found');
+            }
+            return this.result;
+        } catch (ex) {
+            this.result.addException(this.className, 'resetUserPassword', ex);
+            return new Result(null, ResponseCode.Error, [ex], [ex.message]);
+        }
+    }
+
+    async requestResettUserPassword(data: any): Promise<Result> {
+        try {
+            const user = await dbcontext.UserEntity.findOne({ email: data.email });
+            if (user) {
+                user.invitationCode = frameworkHelper.generateRandomString(6);
+                await user.save();
+                this.result.Data = true;
+                this.result.Status = ResponseCode.Ok;
+            } else {
+                this.result.Status = ResponseCode.NotExist;
+                this.result.Errors.push('User not found');
+            }
+            return this.result;
+        } catch (ex) {
+            this.result.addException(this.className, 'requestResettUserPassword', ex);
+            return new Result(null, ResponseCode.Error, [ex], [ex.message]);
+        }
+    }
+
+    async completeSignup(data: any): Promise<Result> {
+        this.result.Status = ResponseCode.Ok;
+        this.result.Data = true;
+        return this.result;
+    }
+
+    async checkEmailIsExistForBusiness(data: any): Promise<Result> {
+        this.result.Status = ResponseCode.NotExist;
+        this.result.Data = false;
+        return this.result;
+    }
+
+    async checkPhoneIsExistForBusiness(data: any): Promise<Result> {
+        this.result.Status = ResponseCode.NotExist;
+        this.result.Data = false;
+        return this.result;
+    }
+}

package/templates/api/src/services/audit-service.ts

@@ -0,0 +1,56 @@
+
+import { Config } from "../config";
+import { IAudit } from "../entities/audit";
+import dbcontext from "../helpers/dbcontext";
+import { AuditMessageType } from "../helpers/enums";
+export class AuditService {
+    async AddAuditBulk(messages: any, errors: any, additionalInfo: any) {
+        try {
+            var auditDocuments = [];
+            if (Config.props.isDev) {
+                messages.map((message: any) => {
+                    auditDocuments.push({
+                        type: message.type ? AuditMessageType[message.type] : AuditMessageType[AuditMessageType.unknown],
+                        className: message.className ? message.className : '-',
+                        methodName: message.methodName ? message.methodName : '-',
+                        requestIdentifier: message.requestIdentifier ? message.requestIdentifier : '-',
+                        message: message.message ? message.message : message,
+                        auditTime: message.auditTime ? message.auditTime : new Date(),
+                        additionalInfo: additionalInfo
+                    });
+                });
+            }
+            errors.map((error: any) => {
+                auditDocuments.push({
+                    type: AuditMessageType[AuditMessageType.exception],
+                    className: error.className ? error.className : '-',
+                    methodName: error.methodName ? error.methodName : '-',
+                    requestIdentifier: error.requestIdentifier ? error.requestIdentifier : '-',
+                    message: error.message ? error.message : error,
+                    auditTime: error.auditTime ? error.auditTime : new Date(),
+                    additionalInfo: additionalInfo
+                });
+            })
+            dbcontext.AuditEntity.insertMany(auditDocuments);
+        }
+        catch (ex) {
+            console.error(ex)
+        }
+    }
+    async AddAuditSingle(type: AuditMessageType, className, methodName, requestIdentifier, message, addInfo = undefined) {
+        try {
+            dbcontext.AuditEntity.create({
+                type: type ? AuditMessageType[type].toString() : AuditMessageType[AuditMessageType.unknown].toString(),
+                className: className,
+                methodName: methodName,
+                requestIdentifier: requestIdentifier,
+                message: message,
+                auditTime: new Date(),
+                additionalInfo: addInfo
+            })
+        }
+        catch (ex) {
+            console.error(ex)
+        }
+    }
+}

package/templates/api/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "module": "CommonJS",
+    "noImplicitReturns": false,
+    "noImplicitAny": false,
+    "moduleResolution": "node",
+    "noUnusedLocals": false,
+    "outDir": "lib",
+    "sourceMap": true,
+    "target": "ES2022",
+    "allowJs": true
+  },
+  "typeRoots": ["node_modules/@types"],
+  "compileOnSave": true,
+  "include": ["src", "src/*/*.hbs", "main.ts","scripts"]
+}

package/templates/api/webpack.config.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var nodeExternals = require("webpack-node-externals");
+var path = require("path");
+const CopyPlugin = require("copy-webpack-plugin");
+const CssMinimizerPlugin = require("css-minimizer-webpack-plugin");
+const MiniCssExtractPlugin = require("mini-css-extract-plugin");
+
+const { env } = require("process");
+
+module.exports = {
+  entry: "./main.ts",
+  mode: env.NODE_ENV || "development",
+  output: {
+    path: path.resolve(__dirname, "lib"),
+    filename: "[name].js",
+    libraryTarget: "this",
+  },
+  target: "electron-main",
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        loader: "ts-loader",
+        options: {
+          transpileOnly: false,
+          compilerOptions: {
+            declaration: true,
+            declarationDir: "./lib"
+          }
+        },
+      },
+      {
+        test: /\.s?css$/,
+        use: [MiniCssExtractPlugin.loader, "css-loader", "sass-loader"],
+      },
+    ],
+  },
+  resolve: {
+    extensions: [".ts", ".tsx", ".js"],
+    fallback: { crypto: false },
+  },
+  node: {
+    __dirname: true,
+    __filename: true,
+  },
+  externals: [nodeExternals()],
+  plugins: [
+    new CopyPlugin({
+      patterns: [
+        {
+          from: "src/assets",
+          to: "assets/",
+        },
+        {
+          from: "certs",
+          to: "certs/",
+        },
+      ],
+    }),
+  ],
+  optimization: {
+    minimizer: [new CssMinimizerPlugin()],
+    minimize: true,
+  },
+};

package/scripts/publish.sh

@@ -1,58 +0,0 @@
-#!/bin/bash
-
-# diagramers CLI Publishing Script
-echo "🚀 Publishing diagramers CLI..."
-
-# Check if user is logged into npm
-if ! npm whoami &> /dev/null; then
-    echo "❌ You need to be logged into npm. Run: npm login"
-    exit 1
-fi
-
-# Build the project first
-echo "🔧 Building CLI..."
-npm run build
-
-# Make sure the CLI binary is executable
-chmod +x dist/index.js
-
-# Check if package.json is properly configured
-if ! grep -q '"name": "@diagramers/cli"' package.json; then
-    echo "❌ Package name not set correctly in package.json"
-    exit 1
-fi
-
-# Check if version is set
-if ! grep -q '"version":' package.json; then
-    echo "❌ Version not set in package.json"
-    exit 1
-fi
-
-# Show what will be published
-echo "📦 Files that will be published:"
-npm pack --dry-run
-
-echo ""
-echo "⚠️  Review the files above. Continue with publishing? (y/N)"
-read -r response
-
-if [[ "$response" =~ ^([yY][eE][sS]|[yY])$ ]]; then
-    echo "🚀 Publishing to npm..."
-    npm publish --access public
-    
-    if [ $? -eq 0 ]; then
-        echo "✅ Successfully published to npm!"
-        echo ""
-        echo "🎉 Users can now install your CLI tool with:"
-        echo "   npm install -g @diagramers/cli"
-        echo ""
-        echo "📚 Or use it directly:"
-        echo "   npx @diagramers/cli init api my-project"
-    else
-        echo "❌ Failed to publish to npm"
-        exit 1
-    fi
-else
-    echo "❌ Publishing cancelled"
-    exit 1
-fi 

package/scripts/setup.sh

@@ -1,38 +0,0 @@
-#!/bin/bash
-
-# diagramers API Template Setup Script
-echo "🚀 Setting up diagramers API Template..."
-
-# Check if Node.js is installed
-if ! command -v node &> /dev/null; then
-    echo "❌ Node.js is not installed. Please install Node.js first."
-    exit 1
-fi
-
-# Check if npm is installed
-if ! command -v npm &> /dev/null; then
-    echo "❌ npm is not installed. Please install npm first."
-    exit 1
-fi
-
-echo "✅ Node.js and npm are installed"
-
-# Install dependencies for the main template
-echo "📦 Installing template dependencies..."
-npm install
-
-# Build and setup CLI
-echo "🔧 Setting up CLI tool..."
-cd cli
-npm install
-npm run build
-npm link
-cd ..
-
-echo "✅ Setup complete!"
-echo ""
-echo "🎉 You can now use the CLI to create new projects:"
-echo "   diagramers-api init my-new-project"
-echo ""
-echo "📚 For more information, see the README.md file"
-echo "🔧 To start development: npm run serve" 

package/scripts/version.sh

@@ -1,80 +0,0 @@
-#!/bin/bash
-
-# Version Management Script for diagramers API Template
-
-# Function to update version in package.json
-update_version() {
-    local new_version=$1
-    local file=$2
-    
-    if [[ "$OSTYPE" == "darwin"* ]]; then
-        # macOS
-        sed -i '' "s/\"version\": \"[^\"]*\"/\"version\": \"$new_version\"/" "$file"
-    else
-        # Linux
-        sed -i "s/\"version\": \"[^\"]*\"/\"version\": \"$new_version\"/" "$file"
-    fi
-}
-
-# Function to show current version
-show_version() {
-    echo "📦 Current versions:"
-    echo "Main package: $(grep '"version"' package.json | head -1 | sed 's/.*"version": "\([^"]*\)".*/\1/')"
-    echo "CLI package: $(grep '"version"' cli/package.json | head -1 | sed 's/.*"version": "\([^"]*\)".*/\1/')"
-}
-
-# Function to update both versions
-update_both_versions() {
-    local new_version=$1
-    echo "🔄 Updating version to $new_version..."
-    
-    update_version "$new_version" "package.json"
-    update_version "$new_version" "cli/package.json"
-    
-    echo "✅ Versions updated successfully!"
-    show_version
-}
-
-# Main script logic
-case "$1" in
-    "show")
-        show_version
-        ;;
-    "patch")
-        current_version=$(grep '"version"' package.json | head -1 | sed 's/.*"version": "\([^"]*\)".*/\1/')
-        new_version=$(echo "$current_version" | awk -F. '{print $1"."$2"."$3+1}')
-        update_both_versions "$new_version"
-        ;;
-    "minor")
-        current_version=$(grep '"version"' package.json | head -1 | sed 's/.*"version": "\([^"]*\)".*/\1/')
-        new_version=$(echo "$current_version" | awk -F. '{print $1"."$2+1".0"}')
-        update_both_versions "$new_version"
-        ;;
-    "major")
-        current_version=$(grep '"version"' package.json | head -1 | sed 's/.*"version": "\([^"]*\)".*/\1/')
-        new_version=$(echo "$current_version" | awk -F. '{print $1+1".0.0"}')
-        update_both_versions "$new_version"
-        ;;
-    "set")
-        if [ -z "$2" ]; then
-            echo "❌ Please provide a version number"
-            echo "Usage: ./version.sh set 1.2.3"
-            exit 1
-        fi
-        update_both_versions "$2"
-        ;;
-    *)
-        echo "📋 Version Management Script"
-        echo ""
-        echo "Usage:"
-        echo "  ./version.sh show          - Show current versions"
-        echo "  ./version.sh patch         - Increment patch version (1.0.0 -> 1.0.1)"
-        echo "  ./version.sh minor         - Increment minor version (1.0.0 -> 1.1.0)"
-        echo "  ./version.sh major         - Increment major version (1.0.0 -> 2.0.0)"
-        echo "  ./version.sh set <version> - Set specific version (e.g., 1.2.3)"
-        echo ""
-        echo "Examples:"
-        echo "  ./version.sh patch"
-        echo "  ./version.sh set 1.5.0"
-        ;;
-esac 

package/src/commands/api.ts

@@ -1,76 +0,0 @@
-import { Command } from 'commander';
-import { generateModule } from '../services/api-generator';
-import { generateTable } from '../services/table-generator';
-import { generateRelation } from '../services/relation-generator';
-import { processTemplate } from '../services/template-processor';
-import chalk from 'chalk';
-
-export function apiCommand(program: Command) {
-  const api = program
-    .command('api')
-    .description('API-specific commands for diagramers projects');
-
-  // Generate module command
-  api
-    .command('generate:module <name>')
-    .description('Generate a new module with entity, schema, service, controller, and routes')
-    .action(async (name: string) => {
-      try {
-        console.log(chalk.blue(`🚀 Generating module: ${name}`));
-        await generateModule(name);
-        console.log(chalk.green(`✅ Module '${name}' generated successfully!`));
-      } catch (error: any) {
-        console.error(chalk.red(`❌ Error generating module: ${error.message}`));
-        process.exit(1);
-      }
-    });
-
-  // Process template command
-  api
-    .command('process:template <name>')
-    .description('Process template files for a new project')
-    .action(async (name: string) => {
-      try {
-        console.log(chalk.blue(`🔧 Processing template for project: ${name}`));
-        await processTemplate(name);
-        console.log(chalk.green(`✅ Template processing completed for '${name}'!`));
-      } catch (error: any) {
-        console.error(chalk.red(`❌ Error processing template: ${error.message}`));
-        process.exit(1);
-      }
-    });
-
-  // Generate table command
-  api
-    .command('generate:table <name>')
-    .description('Generate a new database table with entity and schema only')
-    .action(async (name: string) => {
-      try {
-        console.log(chalk.blue(`🚀 Generating table: ${name}`));
-        await generateTable(name);
-        console.log(chalk.green(`✅ Table '${name}' generated successfully!`));
-      } catch (error: any) {
-        console.error(chalk.red(`❌ Error generating table: ${error.message}`));
-        process.exit(1);
-      }
-    });
-
-  // Generate relation command
-  api
-    .command('generate:relation <table1> <table2>')
-    .description('Generate a relationship between two existing tables')
-    .option('-t, --type <type>', 'Relationship type: one-to-one, one-to-many, many-to-many', 'one-to-one')
-    .action(async (table1: string, table2: string, options: any) => {
-      try {
-        const relationType = options?.type || 'one-to-one';
-        console.log(chalk.blue(`🔗 Creating ${relationType} relationship between ${table1} and ${table2}...`));
-        await generateRelation(table1, table2, relationType);
-        console.log(chalk.green(`✅ Relationship created successfully!`));
-      } catch (error: any) {
-        console.error(chalk.red(`❌ Error creating relationship: ${error.message}`));
-        process.exit(1);
-      }
-    });
-
-  return api;
-} 

package/src/commands/extend.ts

@@ -1,35 +0,0 @@
-import { Command } from 'commander';
-import { ProjectExtender } from '../services/project-extender';
-import chalk from 'chalk';
-
-export function extendCommand(program: Command) {
-  program
-    .command('extend')
-    .description('Extend project with additional features')
-    .option('-f, --feature <feature>', 'Feature to add (auth, email, socket, etc.)')
-    .option('-l, --list', 'List available features')
-    .action(async (options: any) => {
-      try {
-        if (options.list) {
-          const extender = new ProjectExtender();
-          await extender.listFeatures();
-          return;
-        }
-
-        if (!options.feature) {
-          console.log(chalk.red('❌ Please specify a feature to add or use --list to see available features'));
-          process.exit(1);
-        }
-
-        console.log(chalk.blue(`🔧 Adding feature: ${options.feature}`));
-        
-        const extender = new ProjectExtender();
-        await extender.addFeature(options.feature);
-        
-        console.log(chalk.green(`✅ Feature ${options.feature} added successfully!`));
-      } catch (error: any) {
-        console.error(chalk.red(`❌ Failed to add feature: ${error.message}`));
-        process.exit(1);
-      }
-    });
-}