@appxdigital/appx-core-cli 1.0.11 → 1.0.13

package/cli.js

@@ -0,0 +1,578 @@
+#!/usr/bin/env node
+
+// Ensure node 20 at least
+const [major] = process.versions.node.split('.').map(Number);
+if (major < 20) {
+    console.error('❌ Node.js version 20 or higher is required to run this script.');
+    process.exit(1);
+}
+
+// Dependencies
+import {program} from 'commander';
+import inquirer from 'inquirer';
+import fs from 'fs-extra';
+import fsCore from 'fs';
+import {execSync} from 'child_process';
+import path from 'path';
+import {fileURLToPath} from 'url';
+import cliProgress from 'cli-progress';
+import crypto from 'crypto';
+import pg from "pg";
+import mysql from "mysql2/promise";
+
+// Utils and data
+import {gatherFileUploadSettings, insertFileUploadConfiguration} from './utils/fileUploadConfig.js';
+import packageJson from './package.json' with {type: 'json'};
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const CORE_VERSION = '0.1.115';
+
+const phaseDurations = {
+    installDependencies: 30,
+    setupProjectStructure: 5,
+    createPrismaMigration: 5,
+    generateCoreModels: 10,
+    gitInit: 1,
+    migrateDatabase: 5,
+    fileUploadSetup: 5
+};
+
+const calculateTotalETA = () => {
+    return Object.values(phaseDurations).reduce((acc, curr) => acc + curr, 0);
+};
+
+const logo = `\x1b[36m
+      _       _______  _______  ____  ____
+     / \\     |_   __ \\|_   __ \\|_  _||_  _|
+    / _ \\      | |__) | | |__) | \\ \\  / /
+   / ___ \\     |  ___/  |  ___/   > \`' <
+ _/ /   \\ \\_  _| |_    _| |_    _/ /'\\ \\_
+|____| |____||_____|  |_____|  |____||____|
+\x1b[0m
+CLI Version: ${packageJson.version}
+`;
+
+console.log(logo);
+program.version(packageJson.version).description('AppX Core Project Initialization Wizard');
+let progressBar;
+let remainingETA = 0;
+program
+    .command('create')
+    .description('Create a new AppX Core project')
+    .action(() => {
+        console.log('Starting AppX Core...');
+        promptUser();
+    });
+
+function coreGenerate(showOutput) {
+    // run file inside node_modules/appx-core/dist/config/generate-all.js
+    const generatePath = path.join(process.cwd(), 'node_modules', '@appxdigital/appx-core', 'dist', 'config', 'generate-all.js');
+    if (!fsCore.existsSync(generatePath)) {
+        console.error('❌ Not inside a valid AppX Core project directory. Please run this command inside your project directory.');
+        process.exit(1);
+    }
+    // Execute the script
+    try {
+        executeCommand(`node ${generatePath}`, showOutput);
+        console.log('✅ Prisma client and GraphQL schema generated successfully.');
+    } catch (error) {
+        console.error('❌ An error occurred while generating Prisma client and GraphQL schema:', error.message);
+        process.exit(1);
+    }
+}
+
+program.command('generate')
+    .description('Updates Prisma client and generates the GraphQL schema')
+    .action(() => {
+        coreGenerate(true);
+    });
+
+program.command('setup:fileupload')
+    .description('Add file upload configuration to the project')
+    .action(() => {
+        // run file inside node_modules/appx-core/dist/config/setup-fileupload.js
+        const generatePath = path.join(process.cwd(), 'node_modules', '@appxdigital/appx-core', 'dist', 'config', 'setup-fileupload.js');
+        if (!fsCore.existsSync(generatePath)) {
+            console.error('❌ Not inside a valid AppX Core project directory. Please run this command inside your project directory.');
+            process.exit(1);
+        }
+        // Execute the script
+        try {
+            execSync(`node ${generatePath}`, {stdio: 'inherit'});
+            console.log('✅ File upload configuration added successfully.');
+        } catch (error) {
+            console.error('❌ An error occurred while adding file upload configuration:', error.message);
+            process.exit(1);
+        }
+    });
+
+async function checkDb(config) {
+    const {dbProvider, dbHost, dbPort, dbUser, dbPassword, dbName} = config;
+
+    if (dbProvider === "mysql") {
+        const conn = await mysql.createConnection({
+            host: dbHost,
+            port: Number(dbPort),
+            user: dbUser,
+            password: dbPassword,
+            // Important: don't set database here yet; we first check it exists
+            connectTimeout: 5000,
+        });
+
+        try {
+            // 1) DB exists?
+            const [dbRows] = await conn.query(
+                "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = ?",
+                [dbName]
+            );
+
+            if (dbRows.length === 0) {
+                return {ok: false, reason: `Database "${dbName}" does not exist.`};
+            }
+
+            // 2) Any tables?
+            const [tableRows] = await conn.query(
+                "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ? LIMIT 1",
+                [dbName]
+            );
+
+            if (tableRows.length > 0) {
+                return {ok: false, reason: `Database "${dbName}" is not empty (has tables).`};
+            }
+
+            return {ok: true};
+        } finally {
+            await conn.end();
+        }
+    }
+
+    if (dbProvider === "postgresql") {
+        const client = new pg.Client({
+            host: dbHost,
+            port: Number(dbPort),
+            user: dbUser,
+            password: dbPassword,
+            database: "postgres", // connect to a known db first to check existence
+            connectionTimeoutMillis: 5000,
+        });
+
+        await client.connect();
+        try {
+            // 1) DB exists?
+            const dbRes = await client.query(
+                "SELECT 1 FROM pg_database WHERE datname = $1",
+                [dbName]
+            );
+            if (dbRes.rowCount === 0) {
+                return {ok: false, reason: `Database "${dbName}" does not exist.`};
+            }
+
+            // 2) Connect to target db and check tables in public schema (and others if you want)
+            const client2 = new pg.Client({
+                host: dbHost,
+                port: Number(dbPort),
+                user: dbUser,
+                password: dbPassword,
+                database: dbName,
+                connectionTimeoutMillis: 5000,
+            });
+
+            await client2.connect();
+            try {
+                const tableRes = await client2.query(
+                    `
+                        SELECT 1
+                        FROM information_schema.tables
+                        WHERE table_type = 'BASE TABLE'
+                          AND table_schema NOT IN ('pg_catalog', 'information_schema') LIMIT 1
+                    `
+                );
+
+                if (tableRes.rowCount > 0) {
+                    return {ok: false, reason: `Database "${dbName}" is not empty (has tables).`};
+                }
+
+                return {ok: true};
+            } finally {
+                await client2.end();
+            }
+        } finally {
+            await client.end();
+        }
+    }
+
+    return {ok: false, reason: "Unsupported dbProvider."};
+}
+
+async function promptDbConfig() {
+    return inquirer.prompt([
+        {
+            type: "list",
+            name: "dbProvider",
+            message: "Database provider:",
+            choices: ["mysql", "postgresql"],
+            default: "mysql",
+        },
+        {
+            type: "input",
+            name: "dbHost",
+            message: "Database Host:",
+            default: "127.0.0.1",
+        },
+        {
+            type: "input",
+            name: "dbPort",
+            message: "Database Port:",
+            default: (answers) => (answers.dbProvider === "mysql" ? "3306" : "5432"),
+            validate: (v) => (!Number.isNaN(Number(v)) ? true : "Port must be a number"),
+        },
+        {
+            type: "input",
+            name: "dbUser",
+            message: "Database User:",
+            default: "root",
+        },
+        {
+            type: "password",
+            name: "dbPassword",
+            message: "Database Password:",
+            mask: "*",
+        },
+        {
+            type: "input",
+            name: "dbName",
+            message: "Database Name:",
+            default: "generic",
+        },
+    ]);
+}
+
+async function promptDbUntilValid() {
+    while (true) {
+        const dbConfig = await promptDbConfig();
+
+        try {
+            const result = await checkDb(dbConfig);
+
+            if (result.ok) {
+                return dbConfig;
+            }
+
+            process.stdout.write(`❌ Database check failed: ${result.reason}\n`);
+        } catch (err) {
+            process.stdout.write(`❌ Database check failed: ${err.message}\n`);
+        }
+
+        const {retry} = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "retry",
+                message: "Re-enter all database settings?",
+                default: true,
+            },
+        ]);
+
+        if (!retry) {
+            throw new Error("User aborted database configuration.");
+        }
+    }
+}
+
+async function promptUser() {
+    let fileUploadConfigData = {};
+    try {
+        const baseAnswers = await inquirer.prompt([
+            {
+                type: "input",
+                name: "projectName",
+                message: "Project name:",
+                default: "nestjs-project",
+            },
+        ]);
+
+        const dbAnswers = await promptDbUntilValid();
+
+        const rest = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "showOutput",
+                message: "Show installation output?",
+                default: false,
+            },
+            {
+                type: "confirm",
+                name: "configureFileUpload",
+                message: "Configure file upload?",
+                default: false,
+            },
+        ]);
+
+        const answers = {...baseAnswers, ...dbAnswers, ...rest};
+
+        if (answers.configureFileUpload) {
+            fileUploadConfigData = await gatherFileUploadSettings();
+        }
+
+        remainingETA = calculateTotalETA();
+        createProject(answers, fileUploadConfigData);
+    } catch (error) {
+        console.error('Error prompting user:', error);
+    }
+}
+
+async function createProject(answers, fileUploadConfigData) {
+    const {projectName, showOutput, backoffice} = answers;
+
+    console.log(`Creating project: ${projectName}`);
+
+    // If current directory is empty, use it as project directory
+    let projectPath = process.cwd();
+
+    // Ignore DS_STORE files when checking if directory is empty
+    if (fs.readdirSync(projectPath).filter(f => f.toLowerCase() !== '.DS_STORE').length > 0) {
+        projectPath += `/${projectName.replace(/\s+/g, '_').toLowerCase()}`;
+    }
+
+    console.log(`Project path: ${projectPath}`);
+
+    const project_config = {
+        DB_PROVIDER: answers.dbProvider === 'mysql' ? 'mysql' : 'postgresql',
+        DB_HOST: answers.dbHost,
+        DB_PORT: answers.dbPort,
+        DB_USER: answers.dbUser,
+        DB_PASSWORD: answers.dbPassword,
+        DB_NAME: answers.dbName,
+        SESSION_SECRET: crypto.randomBytes(32).toString('hex'),
+        SESSION_COOKIE_NAME: 'session_' + projectName.replace(/\s+/g, '_').toLowerCase(),
+        JWT_SECRET: crypto.randomBytes(32).toString('hex'),
+        JWT_REFRESH_SECRET: crypto.randomBytes(32).toString('hex'),
+    }
+
+    if (!showOutput) {
+        const phases = backoffice ? 8 : 7;
+        progressBar = new cliProgress.SingleBar(
+            {
+                format: `\x1b[36m{bar}\x1b[0m {percentage}% | ETA: {remainingETA}s | {value}/{total}`,
+                barCompleteChar: '\u2588',
+                barIncompleteChar: '\u2591'
+            },
+            cliProgress.Presets.shades_classic
+        );
+        progressBar.update(0, {remainingETA});
+        progressBar.start(phases, 0);
+    }
+
+    try {
+        fs.ensureDirSync(projectPath);
+
+        // Directory must be empty
+        if (fs.readdirSync(projectPath).filter(f => f.toLowerCase() !== '.DS_STORE').length > 0) {
+            console.error('🚫 The target directory is not empty. Please choose an empty directory or remove existing files. Check for hidden files as well.');
+            process.exit(1);
+        }
+
+        process.chdir(projectPath);
+
+        // TODO test database connection here and exit if it fails
+
+
+        // Install dependencies
+        createPackageJson(projectPath, projectName);
+        executeCommand('npm --logevel=error install', answers.showOutput);
+        incrementProgress(answers?.showOutput, "installDependencies");
+
+        // Update PATH to include local node_modules/.bin
+        const localBinPath = path.join(projectPath, 'node_modules', '.bin');
+        process.env.PATH = `${localBinPath}${path.delimiter}${process.env.PATH}`;
+
+        // Create Core project structure
+        setupProjectStructure(projectPath, project_config);
+
+        // Create .gitignore
+        await createGitignore(projectPath);
+
+        // Create tsconfig.json and tsconfig.build.json
+        createTsConfig(projectPath);
+
+        incrementProgress(answers?.showOutput, "setupProjectStructure");
+
+        // Create prisma migration file
+        executeCommand(`prisma migrate dev --name init --create-only`, answers?.showOutput);
+        incrementProgress(answers?.showOutput, "createPrismaMigration");
+
+        // Generate Core Models
+        coreGenerate(answers?.showOutput);
+        incrementProgress(answers?.showOutput, "generateCoreModels");
+
+        // Format code
+        executeCommand('npx --yes prettier --write .', answers?.showOutput);
+
+        // Initialize git repo
+        initializeGitRepo(projectPath, answers?.showOutput);
+        incrementProgress(answers?.showOutput, "gitInit");
+
+        // Migrate database
+        executeCommand(`prisma migrate dev`, answers?.showOutput);
+
+        incrementProgress(answers?.showOutput, "migrateDatabase");
+
+        if (fileUploadConfigData.provider) {
+            await insertFileUploadConfiguration(fileUploadConfigData, projectPath);
+            incrementProgress(showOutput, "fileUploadSetup");
+        }
+
+        if (!showOutput) {
+            progressBar.stop();
+        }
+        console.log('Project created successfully!');
+
+    } catch (error) {
+        console.error('❌ An error occurred during project creation:', error.message);
+        if (fs.existsSync(projectPath)) {
+            //console.log('🧹 Cleaning up incomplete project files...');
+            //fs.removeSync(projectPath);
+        }
+        console.error('🚫 Project creation aborted due to the above error.');
+        if (!showOutput && progressBar) {
+            progressBar.stop();
+        }
+        process.exit(1);
+    }
+}
+
+function createPackageJson(projectPath, projectName) {
+    const packageJsonContent = {
+        name: projectName,
+        version: "0.0.1",
+        description: "",
+        author: "Powered by AppX Digital",
+        private: true,
+        license: "UNLICENSED",
+        scripts: {
+            "build": "nest build",
+            "start": "nest start",
+            "start:dev": "cross-env NODE_ENV=development nest start --watch",
+            "start:prod": "cross-env NODE_ENV=production node dist/main",
+            "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+            "db-pull": "npm run db-pull --prefix ./node_modules/appx-core"
+        },
+        dependencies: {
+            "@appxdigital/appx-core": CORE_VERSION,
+        },
+        devDependencies: {
+            "@nestjs/cli": "~11.0.0",
+            "cross-env": "~10.1.0",
+        },
+        engines: {
+            "node": ">=20.0.0"
+        }
+    };
+
+    fs.writeJsonSync(path.join(projectPath, 'package.json'), packageJsonContent, {spaces: 2});
+}
+
+function setupProjectStructure(projectPath, project_config) {
+    // Create scaffold files from scaffold directory recursively, replacing placeholders from *.template files
+    const scaffoldDir = path.join(__dirname, 'scaffold');
+
+    function copyAndReplaceTemplates(srcDir, destDir) {
+        fs.readdirSync(srcDir).forEach((item) => {
+            const srcPath = path.join(srcDir, item);
+            let destPath = path.join(destDir, item.replace('.template', ''));
+            const stats = fs.statSync(srcPath);
+            if (stats.isDirectory()) {
+                fs.ensureDirSync(destPath);
+                copyAndReplaceTemplates(srcPath, destPath);
+            } else {
+                let content = fs.readFileSync(srcPath, 'utf-8');
+
+                // Replace placeholders
+                for (const [key, value] of Object.entries(project_config)) {
+                    const placeholder = `{{${key}}}`;
+                    content = content.replace(new RegExp(placeholder, 'g'), value);
+                }
+                fs.writeFileSync(destPath, content, 'utf-8');
+            }
+        });
+    }
+
+    copyAndReplaceTemplates(scaffoldDir, projectPath);
+}
+
+function initializeGitRepo(projectPath, showOutput = false) {
+    // If git is installed in the system, initialize a git repository and make the initial commit
+    let installed = true;
+    try {
+        execSync('git --version', {stdio: 'ignore'});
+    } catch (error) {
+        console.log('Git is not installed. Skipping git initialization.');
+        return;
+    }
+
+    try {
+        executeCommand('git init', showOutput);
+        executeCommand('git add .', showOutput);
+        executeCommand('git commit -m "Project init"', showOutput);
+    } catch (error) {
+        console.error("Failed to initialize git repository or make the initial commit:", error);
+        throw error;
+    }
+}
+
+async function createGitignore(projectPath) {
+    const envFilesToAdd = ['.env', '.env.production'];
+
+    const {defaultGitIgnore} = await import(path.join(projectPath, 'node_modules', '@nestjs/cli/lib/configuration/defaults.js'));
+    const existingLines = defaultGitIgnore.split('\n');
+    const updatedLines = new Set(existingLines);
+    envFilesToAdd.forEach((file) => {
+        if (!existingLines.includes(file)) {
+            updatedLines.add(file);
+        }
+    });
+    const finalContent = Array.from(updatedLines).join('\n').trim() + '\n';
+
+    const gitignorePath = path.join(projectPath, '.gitignore');
+    fs.writeFileSync(gitignorePath, finalContent, 'utf-8');
+}
+
+function createTsConfig(projectPath) {
+    let tsConfig = fs.readFileSync(path.join(projectPath, 'node_modules/@nestjs/schematics/dist/lib/application/files/ts/tsconfig.json'), 'utf-8');
+    // Replace '<%= strict %>' with 'false'
+    tsConfig = tsConfig.replaceAll("<%= strict %>", 'false');
+
+    let tsConfigBuild = fs.readFileSync(path.join(projectPath, 'node_modules/@nestjs/schematics/dist/lib/application/files/ts/tsconfig.build.json'), 'utf-8');
+
+    // Ensure target is ES2017
+    tsConfig = JSON.parse(tsConfig);
+    if (!tsConfig.compilerOptions) {
+        tsConfig.compilerOptions = {};
+    }
+    tsConfig.compilerOptions.target = 'ES2017';
+    tsConfig = JSON.stringify(tsConfig, null, 2);
+
+    fs.writeFileSync(path.join(projectPath, 'tsconfig.json'), tsConfig);
+    fs.writeFileSync(path.join(projectPath, 'tsconfig.build.json'), tsConfigBuild);
+}
+
+
+function incrementProgress(showOutput, phase) {
+    if (!showOutput) {
+        remainingETA -= phaseDurations[phase];
+        progressBar.update(progressBar.value + phase === 'end' ? 0 : 1, {remainingETA});
+    }
+}
+
+function executeCommand(command, showOutput = answers?.showOutput) {
+    const options = showOutput ? {stdio: 'inherit'} : {stdio: 'ignore'};
+    try {
+        execSync(command, options);
+    } catch (error) {
+        console.error(`Failed to execute command: ${command}`, error);
+        throw error;
+    }
+}
+
+program.parse(process.argv);

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "@appxdigital/appx-core-cli",
-    "version": "1.0.11",
+    "version": "1.0.13",
     "main": "index.js",
     "scripts": {
         "npm:publish": "npm publish --access public",
@@ -11,16 +11,17 @@
     "author": "",
     "license": "ISC",
     "bin": {
-        "appx-core": "./wizard.js"
+        "appx-core": "./cli.js"
     },
     "dependencies": {
         "@inquirer/prompts": "^7.0.0",
-        "@nestjs/cli": "^11.0.6",
         "cli-progress": "^3.12.0",
         "commander": "^12.1.0",
         "fs-extra": "^11.2.0",
         "handlebars": "^4.7.8",
-        "inquirer": "^12.0.0"
+        "inquirer": "^12.0.0",
+        "mysql2": "^3.16.1",
+        "pg": "^8.17.1"
     },
     "description": ""
 }

package/scaffold/.env.template

@@ -0,0 +1,33 @@
+##DataBase Configurations##
+DB_HOST={{DB_HOST}}
+DB_PORT={{DB_PORT}}
+DB_USER={{DB_USER}}
+DB_PASSWORD={{DB_PASSWORD}}
+DB_NAME={{DB_NAME}}
+DB_PROVIDER={{DB_PROVIDER}}
+DB_URL="${DB_PROVIDER}://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}"
+
+##Project configurations##
+
+#Port
+APP_PORT=3000
+
+#Default behaviour for use of transactions
+USE_TRANSACTION=true
+
+#Session secret
+SESSION_SECRET="{{SESSION_SECRET}}"
+
+#Cookie name for the session token
+SESSION_COOKIE_NAME="{{SESSION_COOKIE_NAME}}"
+
+#Expiration time for the session token in seconds
+SESSION_TTL=86400
+
+# JWT expiration times
+JWT_EXPIRES_IN=10d
+JWT_REFRESH_EXPIRES_IN=1y
+
+# JWT
+JWT_SECRET="{{JWT_SECRET}}"
+JWT_REFRESH_SECRET="{{JWT_REFRESH_SECRET}}"

package/scaffold/.eslintrc.js

@@ -0,0 +1,26 @@
+module.exports = {
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+        project: 'tsconfig.json',
+        tsconfigRootDir: __dirname,
+        sourceType: 'module',
+    },
+    plugins: ['@typescript-eslint/eslint-plugin'],
+    extends: [
+        'plugin:@typescript-eslint/recommended',
+        'plugin:prettier/recommended',
+    ],
+    root: true,
+    env: {
+        node: true,
+        jest: true,
+    },
+    ignorePatterns: ['.eslintrc.js'],
+    rules: {
+        '@typescript-eslint/interface-name-prefix': 'off',
+        '@typescript-eslint/explicit-function-return-type': 'off',
+        '@typescript-eslint/explicit-module-boundary-types': 'off',
+        '@typescript-eslint/no-explicit-any': 'off',
+        'prettier/prettier': ['error', {endOfLine: 'lf'}],
+    },
+};

package/scaffold/.gitattributes

@@ -0,0 +1,2 @@
+
+* text=auto eol=lf

package/scaffold/.prettierrc

@@ -0,0 +1,9 @@
+{
+    "singleQuote": true,
+    "trailingComma": "all",
+    "endOfLine": "lf",
+    "tabWidth": 2,
+    "semi": true,
+    "bracketSpacing": true,
+    "jsxBracketSameLine": true
+}