@appxdigital/appx-core-cli 1.0.10 → 1.0.12

package/wizard.js

@@ -1,43 +1,46 @@
 #!/usr/bin/env node
 
-import { program } from 'commander';
+// 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 {execSync} from 'child_process';
 import path from 'path';
-import { fileURLToPath } from 'url';
+import {fileURLToPath} from 'url';
 import cliProgress from 'cli-progress';
-import { gatherFileUploadSettings, insertFileUploadConfiguration } from './utils/fileUploadConfig.js';
-import packageJson from './package.json' assert { type: 'json' };
 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 dependencyVersions = JSON.parse(
-    fsCore.readFileSync(path.join(__dirname, 'utils', 'dependency-versions.json'), 'utf-8')
-);
+const CORE_VERSION = '0.1.115';
 
 const phaseDurations = {
-    nestjs: 20,
-    appmodule: 5,
-    installDependencies: 80,
-    installCore: 120,
-    prismaSetup: 10,
-    setupConcluded: 5,
-    end: 5
+    installDependencies: 30,
+    setupProjectStructure: 5,
+    createPrismaMigration: 5,
+    generateCoreModels: 10,
+    gitInit: 1,
+    migrateDatabase: 5,
+    fileUploadSetup: 5
 };
 
-const calculateTotalETA = (includeBackoffice) => {
-    let totalTime = phaseDurations.nestjs +
-        phaseDurations.appmodule +
-        phaseDurations.installDependencies +
-        phaseDurations.installCore +
-        phaseDurations.prismaSetup +
-        phaseDurations.setupConcluded
-        + phaseDurations.end;
-    return totalTime;
+const calculateTotalETA = () => {
+    return Object.values(phaseDurations).reduce((acc, curr) => acc + curr, 0);
 };
 
 const logo = `\x1b[36m
@@ -52,34 +55,38 @@ CLI Version: ${packageJson.version}
 `;
 
 console.log(logo);
-program.version(packageJson.version).description('NestJS Project Initialization Wizard');
+program.version(packageJson.version).description('AppX Core Project Initialization Wizard');
 let progressBar;
 let remainingETA = 0;
 program
     .command('create')
-    .description('Create a new NestJS project')
+    .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(() => {
-        // 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 {
-            execSync(`node ${generatePath}`, { stdio: 'inherit' });
-            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);
-        }
+        coreGenerate(true);
     });
 
 program.command('setup:fileupload')
@@ -93,7 +100,7 @@ program.command('setup:fileupload')
         }
         // Execute the script
         try {
-            execSync(`node ${generatePath}`, { stdio: 'inherit' });
+            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);
@@ -101,82 +108,248 @@ program.command('setup:fileupload')
         }
     });
 
-async function promptUser() {
-    let fileUploadConfigData = {};
-    try {
-        const answers = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'projectName',
-                message: 'Project name:',
-                default: 'nestjs-project'
-            },
-            {
-                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'
-            },
+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: 'input',
-                name: 'dbUser',
-                message: 'Database User:',
-                default: 'root'
+                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: 'password',
-                name: 'dbPassword',
-                message: 'Database Password:',
-                mask: '*'
+                type: "input",
+                name: "projectName",
+                message: "Project name:",
+                default: "nestjs-project",
             },
+        ]);
+
+        const dbAnswers = await promptDbUntilValid();
+
+        const rest = await inquirer.prompt([
             {
-                type: 'input',
-                name: 'dbName',
-                message: 'Database Name:',
-                default: 'generic'
+                type: "confirm",
+                name: "showOutput",
+                message: "Show installation output?",
+                default: false,
             },
             {
-                type: 'confirm',
-                name: 'showOutput',
-                message: 'Show installation output?',
-                default: false
+                type: "confirm",
+                name: "configureFileUpload",
+                message: "Configure file upload?",
+                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(answers.backoffice);
+        remainingETA = calculateTotalETA();
         createProject(answers, fileUploadConfigData);
     } catch (error) {
         console.error('Error prompting user:', error);
     }
 }
 
-async function createProject(answers, fileUploadConfigData) {
-    const { projectName, dbProvider, dbHost, dbPort, dbUser, dbPassword, dbName, showOutput, backoffice, configureFileUpload } = answers;
+async function createProject (answers, fileUploadConfigData) {
+    const {projectName, showOutput, backoffice} = answers;
+
     console.log(`Creating project: ${projectName}`);
-    const projectPath = `${process.cwd()}/${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(
@@ -187,69 +360,79 @@ async function createProject(answers, fileUploadConfigData) {
             },
             cliProgress.Presets.shades_classic
         );
-        progressBar.update(0, { remainingETA });
+        progressBar.update(0, {remainingETA});
         progressBar.start(phases, 0);
     }
 
     try {
         fs.ensureDirSync(projectPath);
-        fs.emptyDirSync(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);
 
-        setupProjectStructure(projectPath, answers);
-        incrementProgress(answers?.showOutput, "setupConcluded");
-        const envContent = `
-##DataBase Configurations##  
-DB_HOST=${dbHost}
-DB_PORT=${dbPort}
-DB_USER=${dbUser}
-DB_PASSWORD=${dbPassword}
-DB_NAME=${dbName}
-DB_PROVIDER=${dbProvider}
-DB_URL="\${DB_PROVIDER}://\${DB_USER}:\${DB_PASSWORD}@\${DB_HOST}:\${DB_PORT}/\${DB_NAME}"
+        // TODO test database connection here and exit if it fails
 
 
-##Project configurations##
+        // Install dependencies
+        createPackageJson(projectPath, projectName);
+        executeCommand('npm --logevel=error install', answers.showOutput);
+        incrementProgress(answers?.showOutput, "installDependencies");
 
-#Port
-APP_PORT=3000
+        // 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}`;
 
-#Default behaviour for use of transactions
-USE_TRANSACTION=true
+        // Create Core project structure
+        setupProjectStructure(projectPath, project_config);
 
-#Session secret
-SESSION_SECRET="${crypto.randomBytes(32).toString('hex')}"
+        // Create .gitignore
+        await createGitignore(projectPath);
 
-#Cookie name for the session token
-SESSION_COOKIE_NAME="APPXCORE"
+        // Create tsconfig.json and tsconfig.build.json
+        createTsConfig(projectPath);
 
-#Expiration time for the session token in seconds
-SESSION_TTL=86400
+        incrementProgress(answers?.showOutput, "setupProjectStructure");
 
-# JWT
-JWT_SECRET="${crypto.randomBytes(32).toString('hex')}"
-JWT_REFRESH_SECRET="${crypto.randomBytes(32).toString('hex')}"
-`;
+        // 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");
 
-        fs.writeFileSync(`${projectPath}/.env`, envContent);
         if (fileUploadConfigData.provider) {
             await insertFileUploadConfiguration(fileUploadConfigData, projectPath);
             incrementProgress(showOutput, "fileUploadSetup");
         }
-        updateGitignore(projectPath);
-        configureProjectSettings(projectPath);
-        executeCommand('npx prettier --write .', answers?.showOutput);
-        initializeGitRepo(projectPath);
-        incrementProgress(answers?.showOutput, "end");
+
         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.log('🧹 Cleaning up incomplete project files...');
+            //fs.removeSync(projectPath);
         }
         console.error('🚫 Project creation aborted due to the above error.');
         if (!showOutput && progressBar) {
@@ -259,297 +442,87 @@ JWT_REFRESH_SECRET="${crypto.randomBytes(32).toString('hex')}"
     }
 }
 
-function setupProjectStructure(projectPath, answers) {
-    ensureAndRunNestCli(projectPath, answers?.showOutput);
-    incrementProgress(answers?.showOutput, "nestjs");
-
-    // Copy main README.md
-    const readmePath = path.join(__dirname, 'README.md');
-    fs.copyFileSync(readmePath, `${projectPath}/README.md`);
-
-    const bootstrapContent = getBootstrapContent();
-    fs.writeFileSync(`${projectPath}/src/main.ts`, bootstrapContent);
-
-    const tsConfigPath = path.join(projectPath, 'tsconfig.json');
-    if (fs.existsSync(tsConfigPath)) {
-        const tsConfig = fs.readJsonSync(tsConfigPath);
-
-        if (!tsConfig.compilerOptions) {
-            tsConfig.compilerOptions = {};
+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",
         }
-        tsConfig.compilerOptions.target = 'ES2017';
-        fs.writeJsonSync(tsConfigPath, tsConfig, { spaces: 2 });
-    } else {
-        console.warn('Could not find generated tsconfig.json to modify.');
-    }
+    };
 
-    const appModuleContent = getAppModuleTemplate();
-    fs.writeFileSync(`${projectPath}/src/app.module.ts`, appModuleContent);
-    incrementProgress(answers?.showOutput, "appmodule");
-    installDependenciesFromManifest(answers?.showOutput);
-    executeCommand('npm install --save-dev @types/multer @types/express cross-env', answers?.showOutput);
-    incrementProgress(answers?.showOutput, "installDependencies");
-
-    // const tgzPath = path.resolve('D:/Projects/core/appx-core', fs.readdirSync('D:/Projects/core/appx-core').find(f => f.startsWith('appx-core-package') && f.endsWith('.tgz')));
-    // executeCommand(`npm install "${tgzPath}"`, answers?.showOutput);
-    executeCommand('npm install @appxdigital/appx-core@latest', answers?.showOutput);
-    incrementProgress(answers?.showOutput, "installCore");
-
-    //Prisma setup
-    const prismaVersion = dependencyVersions.devDependencies?.prisma;
-    if (!prismaVersion) {
-        console.error('Prisma version not found in dependency-versions.json devDependencies. Cannot run prisma init.');
-        process.exit(1);
-    }
-    executeCommand(`npx prisma@${prismaVersion} init`, answers?.showOutput);
-    customizePrismaSchema(projectPath, answers);
-    incrementProgress(answers?.showOutput, "prismaSetup");
-    createPrismaModule(projectPath);
-    createPermissionsConfig(projectPath);
-    setupAdminJS(projectPath);
-    createAdminConfig(projectPath);
-    addScriptsToPackageJson(projectPath);
+    fs.writeJsonSync(path.join(projectPath, 'package.json'), packageJsonContent, {spaces: 2});
 }
 
-function ensureAndRunNestCli(projectPath, showOutput = false) {
-    const options = showOutput ? { stdio: 'inherit' } : { stdio: 'ignore' };
-    const command = 'npx --yes @nestjs/cli new . --skip-install --package-manager npm';
-    try {
-        execSync('npx --no-install @nestjs/cli --version', options);
-    } catch {
-        try {
-            execSync('npx @nestjs/cli --version', options);
-        } catch (fetchError) {
-            console.error('❌ Failed to fetch @nestjs/cli via npx. Please check your internet connection.');
-            process.exit(1);
-        }
-    }
-    try {
-        execSync(command, { cwd: projectPath, ...options });
-    } catch (creationError) {
-        console.error(`❌ Failed to create the project: ${creationError.message}`);
-        process.exit(1);
+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');
+            }
+        });
     }
-}
-
-function getBootstrapContent() {
-    const bootstrapFilePath = path.join(__dirname, 'templates', 'bootstrap.template.js');
-    return fs.readFileSync(bootstrapFilePath, 'utf8');
-}
-
-function getAppModuleTemplate() {
-    const appModuleTemplatePath = path.join(__dirname, 'templates', 'app.module.template.js');
-    return fs.readFileSync(appModuleTemplatePath, 'utf8');
-}
-
-function setupAdminJS(projectPath) {
-    const backoffice = path.join(projectPath, 'src/backoffice');
-    fs.ensureDirSync(backoffice);
-
-    const backofficeComponents = path.join(backoffice, 'components');
-    fs.ensureDirSync(backofficeComponents);
-
-    const dashboardContent = getDashboardTemplate();
-    fs.writeFileSync(path.join(backofficeComponents, 'dashboard.tsx'), dashboardContent);
-}
-
-function getComponentLoaderTemplate() {
-    const template = path.join(__dirname, 'templates', 'adminjs', 'component-loader.template.js');
-    return fs.readFileSync(template, 'utf8');
-}
-
-function getDashboardTemplate() {
-    const template = path.join(__dirname, 'templates', 'adminjs', 'dashboard.template.js');
-    return fs.readFileSync(template, 'utf8');
-}
-
-function getUtilsTemplate() {
-    const template = path.join(__dirname, 'templates', 'adminjs', 'utils.template.js');
-    return fs.readFileSync(template, 'utf8');
-}
-
-function getAdminTemplate() {
-    const template = path.join(__dirname, 'templates', 'adminjs', 'admin.template.js');
-    return fs.readFileSync(template, 'utf8');
-}
-
-function getAdminAppModuleTemplate() {
-    const appModuleTemplatePath = path.join(__dirname, 'templates', 'adminjs', 'adminjs-app.module.template.js');
-    return fs.readFileSync(appModuleTemplatePath, 'utf8');
-}
-
-function createPermissionsConfig(projectPath) {
-    const configDir = path.join(projectPath, 'src/config');
-    fs.ensureDirSync(configDir);
-
-    const templatePath = path.join(__dirname, 'templates', 'permissions.config.template.js');
-    const permissionsConfigContent = fs.readFileSync(templatePath, 'utf-8');
-
-    fs.writeFileSync(path.join(configDir, 'permissions.config.ts'), permissionsConfigContent);
-}
-
-function createAdminConfig (projectPath) {
-    const configDir = path.join(projectPath, 'src/config');
-    fs.ensureDirSync(configDir);
-
-    const templatePath = path.join(__dirname, 'templates', 'admin.config.template.js');
-    const permissionsConfigContent = fs.readFileSync(templatePath, 'utf-8');
-
-    fs.writeFileSync(path.join(configDir, 'admin.config.ts'), permissionsConfigContent);
-}
-
-function customizePrismaSchema(projectPath, answers) {
-    const prismaDir = `${projectPath}/prisma`;
-    const schemaFile = `${prismaDir}/schema.prisma`;
-
-    fs.ensureDirSync(prismaDir);
-
-    const schemaContent = `
-datasource db {
-  provider = "${answers.dbProvider}"
-  url      = env("DB_URL")
-}
-
-generator client {
-  provider = "prisma-client-js"
-}
-
-generator nestgraphql {
-  provider = "node node_modules/prisma-nestjs-graphql"
-  output   = "../src/generated/"
-}
-
-model User {
-  id             Int                 @id @default(autoincrement())
-  email          String              @unique
-  name           String?
-  password       String?             /// @Role(none)
-  role           Role                @default(GUEST)
-  refreshTokens  UserRefreshToken[]
-}
 
-model Session {
-  id        String   @id
-  sid       String   @unique
-  data      String
-  expiresAt DateTime
-  userId    Int?
+    copyAndReplaceTemplates(scaffoldDir, projectPath);
 }
 
-model UserRefreshToken {
-  id        String    @id @default(cuid())
-  token     String    @unique @db.VarChar(255)
-  userId    Int
-  user      User      @relation(fields: [userId], references: [id], onDelete: Cascade)
-  expiresAt DateTime
-  createdAt DateTime  @default(now())
-  revokedAt DateTime?
-
-  @@index([userId])
-}
-
-enum Role {
-  ADMIN
-  GUEST
-}
-`;
-
-    fs.writeFileSync(schemaFile, schemaContent);
-}
-
-function createPrismaModule(projectPath) {
-    const prismaDir = path.join(projectPath, 'src/prisma');
-    fs.ensureDirSync(prismaDir);
-
-    const templatePath = path.join(__dirname, 'templates', 'prisma.module.template.js');
-    const prismaModuleContent = fs.readFileSync(templatePath, 'utf-8');
-
-    fs.writeFileSync(path.join(prismaDir, 'prisma.module.ts'), prismaModuleContent);
-}
-
-function addScriptsToPackageJson(projectPath) {
-    const packageJsonPath = path.join(projectPath, 'package.json');
-    const packageJson = fs.readJsonSync(packageJsonPath);
-
-    packageJson.scripts = packageJson.scripts || {};
-    packageJson.scripts["start:dev"] = "cross-env NODE_ENV=development nest start --watch";
-    packageJson.scripts["start:prod"] = "cross-env NODE_ENV=production node dist/main";
-    packageJson.scripts["db-pull"] = "npm run db-pull --prefix ./node_modules/appx-core";
-
-    fs.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
-}
+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;
+    }
 
-function initializeGitRepo(projectPath) {
     try {
-        execSync('git add .', { cwd: projectPath, stdio: 'ignore' });
-        execSync('git commit -m "Project init"', { cwd: projectPath, stdio: 'ignore' });
+        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;
     }
 }
 
-
-function configureProjectSettings(projectPath) {
-    const prettierConfig = {
-        singleQuote: true,
-        trailingComma: 'all',
-        endOfLine: 'lf',
-        tabWidth: 2,
-        semi: true,
-        bracketSpacing: true,
-        jsxBracketSameLine: true
-    };
-
-    fs.writeFileSync(
-        path.join(projectPath, '.prettierrc'),
-        JSON.stringify(prettierConfig, null, 2)
-    );
-
-    const eslintConfig = `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' }],
-        },
-    };`;
-
-    fs.writeFileSync(path.join(projectPath, '.eslintrc.js'), eslintConfig);
-
-    const gitattributesContent = `
-* text=auto eol=lf
-`;
-    fs.writeFileSync(path.join(projectPath, '.gitattributes'), gitattributesContent);
-}
-
-function updateGitignore(projectPath) {
-    const gitignorePath = path.join(projectPath, '.gitignore');
+async function createGitignore (projectPath) {
     const envFilesToAdd = ['.env', '.env.production'];
-    let gitignoreContent = '';
-    if (fs.existsSync(gitignorePath)) {
-        gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8');
-    } else {
-        console.log(`.gitignore file not found. Creating a new one.`);
-    }
-    const existingLines = gitignoreContent.split('\n');
+
+    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)) {
@@ -557,42 +530,45 @@ function updateGitignore(projectPath) {
         }
     });
     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');
 
-function incrementProgress(showOutput, phase) {
+    // 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 });
+        progressBar.update(progressBar.value + phase === 'end' ? 0 : 1, {remainingETA});
     }
 }
 
-function executeCommand(command, showOutput = answers?.showOutput) {
-    const options = showOutput ? { stdio: 'inherit' } : { stdio: 'ignore' };
+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);
-    }
-}
-
-function installDependenciesFromManifest(showOutput = true) {
-    const { dependencies, devDependencies } = dependencyVersions;
-    const depList = Object.entries(dependencies)
-        .map(([pkg, version]) => `${pkg}@${version}`)
-        .join(' ');
-
-    const devDepList = Object.entries(devDependencies)
-        .map(([pkg, version]) => `${pkg}@${version}`)
-        .join(' ');
-
-    if (depList) {
-        executeCommand(`npm install ${depList}`, showOutput);
-    }
-
-    if (devDepList) {
-        executeCommand(`npm install -D ${devDepList}`, showOutput);
+        throw error;
     }
 }