@common-stack/generate-plugin 7.0.4-alpha.0 → 7.0.4-alpha.10

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);
+    }
+} 

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

@@ -0,0 +1,145 @@
+import { Tree, updateJson } from '@nx/devkit';
+import * as path from 'path';
+import * as readline from 'readline';
+
+/**
+ * Sets up Nx configuration with optional AWS credentials
+ */
+export async function setupNxConfig(tree: Tree, projectRoot: string) {
+    console.log('\nAWS Configuration for Nx Cache');
+    console.log('=============================');
+    console.log('This project uses AWS S3 for remote caching with Nx.');
+    console.log('Please provide your AWS credentials or press Enter to skip for now.');
+
+    // Basic configuration without AWS credentials
+    const basicConfig = {
+        tasksRunnerOptions: {
+            default: {
+                runner: 'nx/tasks-runners/default',
+                options: {
+                    cacheableOperations: ['build', 'test', 'lint'],
+                    accessibleHosts: ['https://registry.npmjs.org'],
+                    useDaemonProcess: false,
+                    parallel: 3,
+                },
+            },
+        },
+    };
+
+    const nxJsonPath = path.join(projectRoot, 'nx.json');
+
+    // Safe prompt function with timeout that returns a string
+    const askWithTimeout = (rl: readline.Interface, question: string, timeoutMs = 10000): Promise<string> => {
+        return new Promise<string>((resolve) => {
+            let resolved = false;
+
+            const timeout = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    console.log(`\nTimeout waiting for input. Skipping.`);
+                    resolve('');
+                }
+            }, timeoutMs);
+
+            rl.question(question, (answer: string) => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    resolve(answer);
+                }
+            });
+        });
+    };
+
+    let rl: readline.Interface | undefined;
+    try {
+        rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+
+        // Ask for AWS credentials with timeouts
+        const accessKeyId = await askWithTimeout(rl, 'AWS Access Key ID (press Enter to skip): ');
+
+        // If user skips, create basic config
+        if (!accessKeyId || accessKeyId === '') {
+            console.log('Skipping AWS configuration. Creating basic nx.json.');
+            // Check if nx.json exists and update or create
+            if (tree.exists(nxJsonPath)) {
+                updateJson(tree, nxJsonPath, (json) => {
+                    if (!json.tasksRunnerOptions) {
+                        json.tasksRunnerOptions = basicConfig.tasksRunnerOptions;
+                    }
+                    return json;
+                });
+            } else {
+                tree.write(nxJsonPath, JSON.stringify(basicConfig, null, 2));
+            }
+        } else {
+            // Get remaining AWS info
+            const secretAccessKey = await askWithTimeout(rl, 'AWS Secret Access Key: ');
+            const region = (await askWithTimeout(rl, 'AWS Region (default: us-east-1): ')) || 'us-east-1';
+            const bucketName = await askWithTimeout(rl, 'AWS S3 Bucket Name: ');
+
+            // Only add AWS config if all fields are provided
+            if (secretAccessKey && bucketName) {
+                // Use type assertion to avoid TypeScript errors
+                const awsConfig = { ...basicConfig };
+                // Use "as any" to bypass type checking
+                (awsConfig.tasksRunnerOptions.default.options as any) = {
+                    ...awsConfig.tasksRunnerOptions.default.options,
+                    cacheDirectory: '.nx/cache',
+                    remoteCache: {
+                        s3: {
+                            accessKeyId,
+                            secretAccessKey,
+                            region,
+                            bucketName,
+                        },
+                    },
+                };
+
+                // Update or create nx.json with AWS config
+                if (tree.exists(nxJsonPath)) {
+                    updateJson(tree, nxJsonPath, () => awsConfig);
+                    console.log('Updated nx.json with AWS configuration.');
+                } else {
+                    tree.write(nxJsonPath, JSON.stringify(awsConfig, null, 2));
+                    console.log('Created nx.json with AWS configuration.');
+                }
+            } else {
+                console.log('Incomplete AWS information. Creating basic nx.json.');
+                // Create basic config without AWS
+                if (tree.exists(nxJsonPath)) {
+                    updateJson(tree, nxJsonPath, (json) => {
+                        if (!json.tasksRunnerOptions) {
+                            json.tasksRunnerOptions = basicConfig.tasksRunnerOptions;
+                        }
+                        return json;
+                    });
+                } else {
+                    tree.write(nxJsonPath, JSON.stringify(basicConfig, null, 2));
+                }
+            }
+        }
+    } catch (error) {
+        console.error('Error setting up Nx configuration:', error);
+        // Fallback to basic config
+        if (tree.exists(nxJsonPath)) {
+            updateJson(tree, nxJsonPath, (json) => {
+                if (!json.tasksRunnerOptions) {
+                    json.tasksRunnerOptions = basicConfig.tasksRunnerOptions;
+                }
+                return json;
+            });
+        } else {
+            tree.write(nxJsonPath, JSON.stringify(basicConfig, null, 2));
+        }
+    } finally {
+        // Ensure readline interface is closed
+        if (rl) {
+            rl.close();
+        }
+        console.log('Nx configuration setup complete.');
+    }
+}

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

@@ -1,52 +1,14 @@
 import { Tree, updateJson } from '@nx/devkit';
 import * as path from 'path';
-import { convertHttpsToSsh } from '../../../utils';
 
 export function updatePackageJson(tree: Tree, projectRoot: string, json: any) {
     const packageJsonPath = path.join(projectRoot, 'package.json');
-    
+
     updateJson(tree, packageJsonPath, (packageJson: any) => {
-        Object.entries(json).reduce((acc, [key, value]) => { 
-            acc[key] = value; 
-            return acc; 
+        Object.entries(json).reduce((acc, [key, value]) => {
+            acc[key] = value;
+            return acc;
         }, packageJson);
         return packageJson;
     });
 }
-
-export function updateRepository(tree: Tree, projectRoot: string, repository: string) {
-    if (repository.startsWith('http://')) {
-        repository = repository.replace('http://', 'https://');
-    }
-
-    // update in package.json
-    updatePackageJson(tree, projectRoot, {
-        "homepage": `${repository}#readme`,
-        "bugs": {
-            "url": `${repository}/issues`
-        },
-        "repository": {
-            "type": "git",
-            "url": `git+${repository}.git`
-        },
-    });
-    
-    // update in Jenkinsfile
-    const filePath = path.join(projectRoot, 'Jenkinsfile');
-    
-    if (tree.exists(filePath)) {
-        const jenkinsFileContent = tree.read(filePath).toString();
-        let paramExists = false;
-        const updatedContent = jenkinsFileContent.split('\n').map(line => {
-            if (line.includes(`string(name: 'REPOSITORY_SSH_URL'`)) {
-                paramExists = true;
-                return line.replace(/defaultValue: '.*'/, `defaultValue: '${convertHttpsToSsh(repository)}'`);
-            }
-            return line;
-        }).join('\n');
-
-        if (paramExists) {
-            tree.write(filePath, updatedContent);
-        }
-    }
-}

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

@@ -0,0 +1,45 @@
+/* eslint-disable no-param-reassign */
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+import { updatePackageJson } from './packageJsonUpdate';
+import { convertHttpsToSsh } from '../../../utils';
+
+export function updateRepository(tree: Tree, projectRoot: string, repository: string) {
+    if (repository.startsWith('http://')) {
+        repository = repository.replace('http://', 'https://');
+    }
+
+    // update in package.json
+    updatePackageJson(tree, projectRoot, {
+        homepage: `${repository}#readme`,
+        bugs: {
+            url: `${repository}/issues`,
+        },
+        repository: {
+            type: 'git',
+            url: `git+${repository}.git`,
+        },
+    });
+
+    // update in Jenkinsfile
+    const filePath = path.join(projectRoot, 'Jenkinsfile');
+
+    if (tree.exists(filePath)) {
+        const jenkinsFileContent = tree.read(filePath).toString();
+        let paramExists = false;
+        const updatedContent = jenkinsFileContent
+            .split('\n')
+            .map((line) => {
+                if (line.includes(`string(name: 'REPOSITORY_SSH_URL'`)) {
+                    paramExists = true;
+                    return line.replace(/defaultValue: '.*'/, `defaultValue: '${convertHttpsToSsh(repository)}'`);
+                }
+                return line;
+            })
+            .join('\n');
+
+        if (paramExists) {
+            tree.write(filePath, updatedContent);
+        }
+    }
+}

package/src/generators/add-moleculer/files/_dockerignore

@@ -0,0 +1,6 @@
+*
+!dist/
+!*.js
+!*.json
+!.npmrc
+!common/

package/src/generators/add-moleculer/files/_draftignore

@@ -0,0 +1,4 @@
+*.swp
+*.tmp
+*.temp
+.git*

package/src/generators/add-moleculer/files/_gitignore

@@ -0,0 +1,2 @@
+src/modules/module.ts
+common/

package/src/generators/add-moleculer/files/package.json

@@ -29,11 +29,11 @@
         "common": "link:./common"
     },
     "dependencies": {
-        "@common-stack/client-core": "6.0.8-alpha.31",
-        "@common-stack/core": "6.0.8-alpha.31",
-        "@common-stack/server-core": "6.0.8-alpha.31",
-        "@common-stack/server-stack": "6.0.8-alpha.66",
-        "@common-stack/store-mongo": "6.0.8-alpha.66",
+        "@common-stack/client-core": "7.0.4-alpha.6",
+        "@common-stack/core": "7.0.4-alpha.6",
+        "@common-stack/server-core": "7.0.4-alpha.9",
+        "@common-stack/server-stack": "7.0.4-alpha.9",
+        "@common-stack/store-mongo": "7.0.4-alpha.6",
         "@container-stack/mailing-api": "5.2.1-alpha.1",
         "helmet": "^3.21.2",
         "react": "18.2.0",

package/src/generators/add-moleculer/generator.ts

@@ -1,29 +1,53 @@
-import { addProjectConfiguration, updateJson, formatFiles, generateFiles, Tree } from '@nx/devkit';
+/* eslint-disable import/no-extraneous-dependencies */
+// eslint-disable-next-line jsonc/indent
+import { generateFiles, names, offsetFromRoot, Tree, stripIndents } from '@nx/devkit';
 import * as path from 'path';
+import { libraryGenerator } from '@nx/js';
 import { AddMoleculerGeneratorSchema } from './schema';
-import { isValid, getValid } from '../../utils';
-
-const DEFAULT_SERVER_NAME = 'moleculer-server';
+import { copyNpmrc, renameDotFiles } from '../../utils/copyDotfiles';
 
 export async function addMoleculerGenerator(tree: Tree, options: AddMoleculerGeneratorSchema) {
-    const projectName = isValid(options.name) ? `${getValid(options.name)}-server` : DEFAULT_SERVER_NAME;
-    const configs: any = {...options, name: projectName};
-
-    return await generateMoleculer(tree, configs);
-}
+    const libsDir = options.directory || 'servers';
+    const fullLibsDir = path.join(options.projectRoot || '', libsDir);
 
-export const generateMoleculer = async (tree: Tree, options: any) => {
-    let projectName = getValid(options.name) ?? DEFAULT_SERVER_NAME;
-    const projectRoot = isValid(options.directory) ? `${getValid(options.directory)}/${projectName}` : projectName;
-    projectName = isValid(options.ns) ? `${getValid(options.ns)}-${projectName}` : projectName;
+    const name = options.name || 'moleculer-server';
+    const normalizedName = names(name).fileName;
+    const fullName = path.join(fullLibsDir, normalizedName);
 
-    generateFiles(tree, path.join(__dirname, 'files'), projectRoot, options);
-    updateJson(tree, `${projectRoot}/package.json`, (packageJson) => {
-        packageJson['name'] = projectName;
-        return packageJson;
+    // Run the Nx library generator to create the basic structure
+    await libraryGenerator(tree, {
+        name: normalizedName,
+        directory: fullLibsDir,
+        unitTestRunner: 'jest',
+        tags: `scope:moleculer,type:app`,
     });
 
-    await formatFiles(tree);
+    // Generate the custom files
+    const templateOptions = {
+        ...options,
+        ...names(name),
+        dot: '.',
+        offsetFromRoot: offsetFromRoot(fullName),
+        template: '',
+    };
+
+    generateFiles(tree, path.join(__dirname, 'files'), fullName, templateOptions);
+
+    // Rename underscore files to dotfiles
+    renameDotFiles(tree, fullName);
+
+    // Copy .npmrc from the project root
+    const projectRoot = options.projectRoot || '';
+    copyNpmrc(tree, projectRoot, fullName);
+
+    console.log(stripIndents`
+    Thank you for using the @common-stack moleculer-server generator!
+    
+    Next steps:
+    
+    - Run \`yarn\` to install dependencies
+    - Start application with \`yarn start\`
+  `);
 }
 
 export default addMoleculerGenerator;

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

@@ -0,0 +1,6 @@
+export interface AddMoleculerGeneratorSchema {
+    name?: string;
+    directory?: string;
+    ns?: string;
+    projectRoot?: string;
+}