@common-stack/generate-plugin 8.0.1-alpha.5 → 8.0.2-alpha.0

package/src/generators/add-fullstack/schema.d.ts

@@ -1,5 +1,5 @@
 export interface AddFullstackGeneratorSchema {
     name: string;
     config?: string;
-    path?: string;  // Optional path property for specifying the base path
-}
+    path?: string; // Optional path property for specifying the base path
+}

package/src/generators/add-fullstack/schema.ts

@@ -0,0 +1,10 @@
+export interface AddFullstackGeneratorSchema {
+    name?: string;
+    path?: string;
+    skipGit?: boolean;
+    skipGitCrypt?: boolean;
+    skipHusky?: boolean;
+    skipNxConfig?: boolean;
+    template?: string;
+    config?: any;
+}

package/src/generators/add-fullstack/updates/gitAttributesSetup.ts

@@ -0,0 +1,60 @@
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+import * as fs from 'fs';
+
+/**
+ * Renames _gitattributes to .gitattributes during the Tree modification phase
+ */
+export function prepareGitAttributes(tree: Tree, projectRoot: string) {
+    const gitattributesSrc = path.join(projectRoot, '_gitattributes');
+    const gitattributesDest = path.join(projectRoot, '.gitattributes');
+    
+    if (tree.exists(gitattributesSrc)) {
+        // Read content and write to destination
+        const content = tree.read(gitattributesSrc).toString();
+        tree.write(gitattributesDest, content);
+        // Remove the source file
+        tree.delete(gitattributesSrc);
+        console.log(`Renamed ${gitattributesSrc} to ${gitattributesDest}`);
+        return true;
+    }
+    
+    return false;
+}
+
+/**
+ * Updates .gitattributes with additional patterns if needed after files are on disk
+ */
+export function updateGitAttributes(projectRoot: string, attributesToAdd: Record<string, string>) {
+    try {
+        const gitattributesPath = path.join(projectRoot, '.gitattributes');
+        
+        if (!fs.existsSync(gitattributesPath)) {
+            console.log('.gitattributes file not found, skipping update');
+            return false;
+        }
+        
+        let gitattributesContent = fs.readFileSync(gitattributesPath, 'utf8');
+        let contentUpdated = false;
+        
+        // Add each attribute if not already present
+        Object.entries(attributesToAdd).forEach(([pattern, attribute]) => {
+            const attributeLine = `${pattern} ${attribute}`;
+            if (!gitattributesContent.includes(attributeLine)) {
+                contentUpdated = true;
+                gitattributesContent += `\n${attributeLine}`;
+            }
+        });
+        
+        // Write the file if we made changes
+        if (contentUpdated) {
+            fs.writeFileSync(gitattributesPath, gitattributesContent, 'utf8');
+            console.log('Updated .gitattributes file with additional patterns');
+        }
+        
+        return contentUpdated;
+    } catch (error) {
+        console.error('Error updating .gitattributes:', error);
+        return false;
+    }
+} 

package/src/generators/add-fullstack/updates/gitCryptSetup.ts

@@ -0,0 +1,77 @@
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+
+/**
+ * Set up git-crypt for encrypting sensitive files
+ */
+export function setupGitCrypt(tree: Tree, projectRoot: string) {
+    try {
+        // Navigate to the project directory
+        const originalDir = process.cwd();
+        process.chdir(projectRoot);
+        
+        console.log('Setting up git-crypt in:', projectRoot);
+        
+        // Check if git-crypt is installed
+        try {
+            execSync('git-crypt --version', { stdio: 'ignore' });
+        } catch (error) {
+            console.log('git-crypt not found. Please install git-crypt to encrypt sensitive files.');
+            console.log('Continuing without git-crypt setup.');
+            process.chdir(originalDir);
+            return;
+        }
+        
+        // Check if git-crypt is already initialized
+        const gitCryptDir = path.join(projectRoot, '.git-crypt');
+        const gitCryptConfigExists = fs.existsSync(gitCryptDir);
+        
+        if (gitCryptConfigExists) {
+            console.log('git-crypt is already initialized for this repository');
+        } else {
+            // Initialize git-crypt
+            try {
+                execSync('git-crypt init', { stdio: 'inherit' });
+                console.log('git-crypt initialized');
+            } catch (error) {
+                console.error('Error initializing git-crypt:', error);
+                process.chdir(originalDir);
+                return;
+            }
+        }
+        
+        // Create keys directory if it doesn't exist
+        const keysDir = path.join(projectRoot, '.git-crypt', 'keys');
+        if (!fs.existsSync(keysDir)) {
+            fs.mkdirSync(keysDir, { recursive: true });
+        }
+        
+        // Generate and export a key for sharing only if it doesn't exist
+        const keyFile = path.join(keysDir, 'default-git-crypt-key');
+        if (!fs.existsSync(keyFile)) {
+            try {
+                execSync(`git-crypt export-key ${keyFile}`, { stdio: 'inherit' });
+                console.log(`Generated git-crypt key at: ${keyFile}`);
+                console.log('Keep this key secure and share it with team members who need access to encrypted files.');
+            } catch (error) {
+                console.error('Error exporting git-crypt key:', error);
+            }
+        } else {
+            console.log(`git-crypt key already exists at: ${keyFile}`);
+        }
+        
+        console.log('Git-crypt setup completed - sensitive files will be encrypted');
+        
+        // Return to original directory
+        process.chdir(originalDir);
+    } catch (error) {
+        console.error('Error setting up git-crypt:', error);
+        // Continue even if there's an error to not block the overall process
+        const originalDir = process.cwd();
+        if (originalDir !== projectRoot) {
+            process.chdir(originalDir);
+        }
+    }
+}

package/src/generators/add-fullstack/updates/gitSetup.ts

@@ -0,0 +1,63 @@
+import { Tree } from '@nx/devkit';
+import { execSync } from 'child_process';
+
+/**
+ * Sets up git repository in the project
+ */
+export function setupGit(tree: Tree, projectRoot: string) {
+    try {
+        // Navigate to the project directory
+        const originalDir = process.cwd();
+        process.chdir(projectRoot);
+        
+        console.log('Setting up git in:', projectRoot);
+        
+        // Initialize git repository
+        execSync('git init', { stdio: 'inherit' });
+        console.log('Git repository initialized');
+        
+        // Return to original directory
+        process.chdir(originalDir);
+    } catch (error) {
+        console.error('Error setting up git:', error);
+        // Continue even if there's an error to not block the overall process
+        const originalDir = process.cwd();
+        if (originalDir !== projectRoot) {
+            process.chdir(originalDir);
+        }
+    }
+}
+
+/**
+ * Commit all initial files to git
+ */
+export function commitInitialFiles(projectRoot: string) {
+    try {
+        // Navigate to the project directory
+        const originalDir = process.cwd();
+        process.chdir(projectRoot);
+        
+        console.log('Staging initial files...');
+        
+        try {
+            // Add all files
+            execSync('git add .', { stdio: 'inherit' });
+            
+            // Commit with --no-verify to bypass husky hooks
+            execSync('git commit -m "Initial commit from @common-stack/generate-plugin" --no-verify', { stdio: 'inherit' });
+            console.log('Initial commit created (bypassing pre-commit hooks)');
+        } catch (error) {
+            console.error('Error committing files:', error);
+        }
+        
+        // Return to original directory
+        process.chdir(originalDir);
+    } catch (error) {
+        console.error('Error during git commit process:', error);
+        // Continue even if there's an error to not block the overall process
+        const originalDir = process.cwd();
+        if (originalDir !== projectRoot) {
+            process.chdir(originalDir);
+        }
+    }
+}

package/src/generators/add-fullstack/updates/htmlPluginUpdate.ts

@@ -1,5 +1,6 @@
 import { Tree } from '@nx/devkit';
 import * as path from 'path';
+import * as fs from 'fs';
 
 export function updateHtmlPlugin(tree: Tree, projectRoot: string) {
     const filePath = path.join(projectRoot, 'tools', 'html-plugin-template.ejs');
@@ -9,3 +10,33 @@ export function updateHtmlPlugin(tree: Tree, projectRoot: string) {
         tree.write(filePath, newContents);
     }
 }
+
+export function renameDotFiles(tree: Tree, projectRoot: string) {
+    // List of files that need to be renamed from _name to .name
+    const dotFiles = [
+        { src: '_gitignore', dest: '.gitignore' },
+        { src: '_browserslistrc', dest: '.browserslistrc' },
+        { src: '_eslintignore', dest: '.eslintignore' },
+        { src: '_eslintrc.js', dest: '.eslintrc.js' },
+        { src: '_nxignore', dest: '.nxignore' },
+        { src: '_markdownlint.json', dest: '.markdownlint.json' },
+        { src: '_markdownlintignore', dest: '.markdownlintignore' },
+        { src: '_npmrc', dest: '.npmrc' },
+    ];
+
+    // Process each file
+    dotFiles.forEach(({ src, dest }) => {
+        const srcPath = path.join(projectRoot, src);
+        const destPath = path.join(projectRoot, dest);
+        
+        // Check if the source file exists
+        if (tree.exists(srcPath)) {
+            // Read content and write to destination
+            const content = tree.read(srcPath).toString();
+            tree.write(destPath, content);
+            // Remove the source file
+            tree.delete(srcPath);
+            console.log(`Renamed ${srcPath} to ${destPath}`);
+        }
+    });
+}

package/src/generators/add-fullstack/updates/huskySetup.ts

@@ -0,0 +1,84 @@
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+
+export function setupHusky(tree: Tree, projectRoot: string) {
+    try {
+        // Navigate to the project directory
+        const originalDir = process.cwd();
+        process.chdir(projectRoot);
+        
+        console.log('Setting up husky in:', projectRoot);
+        
+        try {
+            // Initialize husky (creates .husky directory and prepares hooks)
+            execSync('npx husky init', { stdio: 'inherit' });
+            console.log('Husky initialized successfully');
+            
+            // Copy the husky hook files from _husky/ to .husky/
+            const sourceDir = path.join(projectRoot, '_husky');
+            const targetDir = path.join(projectRoot, '.husky');
+            
+            if (fs.existsSync(sourceDir) && fs.existsSync(targetDir)) {
+                // Read all files from _husky directory
+                const files = fs.readdirSync(sourceDir);
+                
+                // Copy each file to .husky directory
+                files.forEach(file => {
+                    const sourcePath = path.join(sourceDir, file);
+                    const targetPath = path.join(targetDir, file);
+                    
+                    if (fs.statSync(sourcePath).isFile()) {
+                        // Read content from our hook template
+                        const content = fs.readFileSync(sourcePath, 'utf8');
+                        
+                        // Remove any old shebang lines to avoid deprecation warnings
+                        const cleanContent = content
+                            .replace(/^#!\/usr\/bin\/env sh\n/, '')
+                            .replace(/^\. "\$\(dirname -- "\$0"\)\/\_\/husky\.sh"\n/, '')
+                            .trim();
+                        
+                        // Write the hook content
+                        fs.writeFileSync(targetPath, cleanContent, 'utf8');
+                        
+                        try {
+                            // Make the hook executable
+                            fs.chmodSync(targetPath, '755');
+                            console.log(`Made executable: ${file}`);
+                        } catch (error) {
+                            console.log(`Note: Could not set executable permissions for ${file}. This is normal on Windows.`);
+                        }
+                        
+                        console.log(`Copied: ${file} to .husky directory`);
+                    }
+                });
+                
+                // Remove the _husky directory after copying
+                try {
+                    fs.rmdirSync(sourceDir, { recursive: true });
+                    console.log('Removed _husky directory after copying');
+                } catch (error) {
+                    console.log('Could not remove _husky directory, but continuing...');
+                }
+            } else {
+                console.log('Source or target directory not found, skipping hook setup');
+            }
+            
+            console.log('Husky setup completed successfully');
+        } catch (error) {
+            console.error('Error running husky commands:', error);
+            console.log('Continuing despite husky setup failure');
+        }
+        
+        // Return to original directory
+        process.chdir(originalDir);
+    } catch (error) {
+        console.error('Error setting up husky:', error);
+        // Continue even if there's an error to not block the overall process
+        const originalDir = process.cwd();
+        if (originalDir !== projectRoot) {
+            process.chdir(originalDir);
+        }
+    }
+}

package/src/generators/add-fullstack/updates/index.ts

@@ -1,6 +1,13 @@
-export * from './jenkinsfileUpdate';
-export * from './packageJsonUpdate';
-export * from './lernaJsonUpdate';
-export * from './htmlPluginUpdate';
-export * from './licenseUpdate';
-export * from './ignoreUpdate';
+export { updateJenkinsFile } from './jenkinsUpdate';
+export { updatePackageJson } from './packageJsonUpdate';
+export { backupLernaJson, restoreLernaJson } from './lernaUpdate';
+export { updateLicense } from './licenseUpdate';
+export { backupFiles, restoreFiles } from './fileBackup';
+export { updateRepository } from './repositoryUpdate';
+export { updateHtmlPlugin, renameDotFiles } from './htmlPluginUpdate';
+export { setupGit, commitInitialFiles } from './gitSetup';
+export { setupGitCrypt } from './gitCryptSetup';
+export { setupHusky } from './huskySetup';
+export { prepareGitAttributes, updateGitAttributes } from './gitAttributesSetup';
+export { setupNpmAuth } from './npmAuthSetup';
+export * from './nxSetup';

package/src/generators/add-fullstack/updates/jenkinsUpdate.ts

@@ -0,0 +1,53 @@
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+
+export function updateJenkinsFile(tree: Tree, projectRoot: string, name: string) {
+    const filePath = path.join(projectRoot, 'Jenkinsfile');
+    const paramsToUpdate = {
+        BASE_NAMESPACE: name,
+        CONNECTION_ID: name,
+        WORKSPACE_ID: name,
+        UNIQUE_NAME: name,
+    };
+
+    if (tree.exists(filePath)) {
+        const jenkinsFileContent = tree.read(filePath).toString();
+        let labelExists = false;
+
+        const updatedContent = jenkinsFileContent.split('\n').map(line => {
+            // Check if the label is already defined and skip modifying it
+            if (line.includes('label') && line.includes('kubernetes')) {
+                labelExists = true;
+            }
+
+            // Update only the specified parameters
+            for (const param in paramsToUpdate) {
+                if (line.includes(`string(name: '${param}'`)) {
+                    return line.replace(/defaultValue: '.*'/, `defaultValue: '${paramsToUpdate[param]}'`);
+                }
+            }
+            return line;
+        }).join('\n');
+
+        let finalContent = updatedContent;
+        
+        // Add missing parameters if they don't exist
+        Object.keys(paramsToUpdate).forEach(param => {
+            if (!finalContent.includes(`string(name: '${param}'`)) {
+                finalContent = finalContent.concat(
+                    `string(name: '${param}', defaultValue: '${paramsToUpdate[param]}', description: '${param.replace(/_/g, ' ').toLowerCase()}')\n`
+                );
+            }
+        });
+
+        // Only write back to the file if we have made changes
+        if (!labelExists || Object.keys(paramsToUpdate).some(param => !finalContent.includes(`string(name: '${param}'`))) {
+            tree.write(filePath, finalContent);
+            console.log(`Updated Jenkinsfile with parameters for: ${name}`);
+        } else {
+            console.log('No changes needed in Jenkinsfile');
+        }
+    } else {
+        console.log('Jenkinsfile not found, skipping update');
+    }
+} 

package/src/generators/add-fullstack/updates/{lernaJsonUpdate.ts → lernaUpdate.ts}

@@ -19,15 +19,14 @@ export function backupLernaJson(tree: Tree, projectRoot: string) {
                     backup[param] = paramValue;
                     exists = true;
                 }
-            } else {
-                if (lernaJson[param]) {
-                    backup[param] = lernaJson[param];
-                    exists = true;
-                }
+            } else if (lernaJson[param]) {
+                backup[param] = lernaJson[param];
+                exists = true;
             }
         }
 
         if (exists) {
+            console.log('Backed up important values from lerna.json');
             return backup;
         }
     }
@@ -39,7 +38,7 @@ export function restoreLernaJson(tree: Tree, projectRoot: string, backup: any) {
     const lernaJsonPath = path.join(projectRoot, 'lerna.json');
     if (backup && fs.existsSync(lernaJsonPath)) {
         updateJson(tree, lernaJsonPath, (lernaJson: any) => {
-            Object.keys(backup).forEach(param => {
+            Object.keys(backup).forEach((param) => {
                 if (param.includes(':')) {
                     lernaJson = set(lernaJson, param.split(':'), backup[param]);
                 } else {
@@ -50,4 +49,4 @@ export function restoreLernaJson(tree: Tree, projectRoot: string, backup: any) {
         });
         console.log('Restored old values in lerna.json');
     }
-}
+}

package/src/generators/add-fullstack/updates/licenseUpdate.ts

@@ -5,11 +5,11 @@ export function updateLicense(tree: Tree, projectRoot: string) {
     const files = ['LICENSE-GNU', 'LICENSE-IST', 'LICENSE-MIT'];
     const packageJsonPath = path.join(projectRoot, 'package.json');
     const packageJson = readJson(tree, packageJsonPath);
-    
+
     if (packageJson.license) {
         const fileName = `LICENSE-${packageJson.license.toUpperCase()}`;
-        
-        files.forEach(file => {
+
+        files.forEach((file) => {
             const filePath = path.join(projectRoot, file);
             if (file === fileName) {
                 if (tree.exists(filePath)) {

package/src/generators/add-fullstack/updates/npmAuthSetup.ts

@@ -0,0 +1,76 @@
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as readline from 'readline';
+
+/**
+ * Prompts the user for npm auth token and updates the .npmrc file
+ */
+export async function setupNpmAuth(tree: Tree, projectRoot: string): Promise<void> {
+    try {
+        const npmrcPath = path.join(projectRoot, '.npmrc');
+        
+        // Check if .npmrc exists after rename from _npmrc
+        if (!fs.existsSync(npmrcPath)) {
+            console.log('.npmrc file not found. It may not have been properly renamed from _npmrc.');
+            return;
+        }
+        
+        // Create readline interface for user input
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        
+        console.log('\nNPM Authentication Setup');
+        console.log('========================');
+        console.log('This project requires an npm authentication token.');
+        console.log('You can generate a token from https://www.npmjs.com/settings/[username]/tokens');
+        console.log('Press Enter to skip if you do not have a token yet.');
+        
+        // Prompt for the auth token and wait for the user to complete their input
+        const token = await new Promise<string>((resolve) => {
+            rl.question('Enter your npm auth token: ', (answer) => {
+                console.log(''); // Add a line break after input
+                resolve(answer.trim());
+            });
+        });
+        
+        // Explicitly close the readline interface
+        rl.close();
+        
+        // Wait for the close event to ensure we don't proceed before input is complete
+        await new Promise(resolve => rl.on('close', resolve));
+        
+        if (!token) {
+            console.log('No token provided, keeping existing .npmrc configuration');
+            return;
+        }
+        
+        // Read current .npmrc content
+        let npmrcContent = fs.readFileSync(npmrcPath, 'utf8');
+        
+        // Check if token is already set
+        if (npmrcContent.includes('//registry.npmjs.org/:_authToken=')) {
+            // Replace existing token
+            npmrcContent = npmrcContent.replace(
+                /\/\/registry\.npmjs\.org\/:_authToken=.*/,
+                `//registry.npmjs.org/:_authToken=${token}`
+            );
+        } else {
+            // Add token if it doesn't exist
+            npmrcContent += `\n//registry.npmjs.org/:_authToken=${token}\n`;
+        }
+        
+        // Write updated content
+        fs.writeFileSync(npmrcPath, npmrcContent);
+        console.log('Updated .npmrc with authentication token');
+        
+        // Inform about git-crypt encryption
+        console.log('Note: The .npmrc file is configured to be encrypted by git-crypt');
+        console.log('      The token will be encrypted when committed to the repository');
+        
+    } catch (error) {
+        console.error('Error setting up npm authentication:', error);
+    }
+}