@moamc/rn-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MOAMC Engineering Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,154 @@
+# @moamc/rn-cli
+
+Enterprise-grade Code Generation CLI for React Native Applications
+
+## 🚀 Features
+
+- ✅ Generate complete feature modules with screens, hooks, and API integration
+- ✅ Add screens to existing features with form support
+- ✅ Create API services with GET/POST methods
+- ✅ Generate React Query hooks with validation
+- ✅ Support for multiple field types (text, number, email, date, dropdown, etc.)
+- ✅ Automatic validation generation
+- ✅ TypeScript-ready templates
+
+## 📦 Installation
+
+### Global Installation (Recommended)
+
+```bash
+npm install -g @moamc/rn-cli
+```
+
+### Project-specific Installation
+
+```bash
+npm install --save-dev @moamc/rn-cli
+```
+
+## 🎯 Usage
+
+After installation, run the CLI from your React Native project root:
+
+```bash
+rn-cli
+```
+
+### Available Commands
+
+#### Generate Feature
+```bash
+rn-cli generate:feature
+# or
+rn-cli g:f
+```
+Creates a complete feature module with screen, API service, and hooks.
+
+#### Generate Screen
+```bash
+rn-cli generate:screen
+# or
+rn-cli g:s
+```
+Adds a new screen to an existing feature with optional form support.
+
+#### Generate API
+```bash
+rn-cli generate:api
+# or
+rn-cli g:a
+```
+Creates API service methods with React Query integration.
+
+#### Generate Hook
+```bash
+rn-cli generate:hook
+# or
+rn-cli g:h
+```
+Generates data-fetching hooks with validation.
+
+## 📁 Project Structure Requirements
+
+Your React Native project should follow this structure:
+
+```
+project-root/
+├── screens/
+│   └── FeatureName/
+│       └── ScreenName/
+│           ├── ScreenName.js
+│           ├── hooks/
+│           ├── components/
+│           ├── validation.js
+│           ├── constants.js
+│           └── helpers.js
+├── services/
+├── queries/
+└── navigations/
+```
+
+## 🎨 Form Field Types
+
+- **Text** - Standard text input
+- **Number** - Numeric input
+- **Email** - Email address with validation
+- **Date** - Date picker
+- **Dropdown** - Select from options
+- **Radio** - Single choice
+- **Checkbox** - Multiple choices
+- **File** - File upload
+
+## 🔌 API Integration
+
+The CLI supports both GET and POST APIs:
+
+1. **GET API** - Fetch data with React Query
+2. **POST API** - Submit forms with useMutation
+3. **Automatic cache invalidation** after successful POST
+
+## ✨ Features
+
+### Automatic Validation
+- Real-time field validation
+- Submit-time validation
+- Custom validation rules per field type
+
+### React Query Integration
+- Automatic query key generation
+- Cache management
+- Error handling
+- Loading states
+
+### Form Support
+- Multiple field types
+- Field width control (full/half)
+- Required field validation
+- Dropdown options
+
+## 🛠️ Development
+
+To use in development mode:
+
+```bash
+cd cli-tool
+npm link
+```
+
+Then in your project:
+
+```bash
+rn-cli
+```
+
+## 📝 License
+
+MIT
+
+## 👥 Author
+
+MOAMC Engineering Team
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/generators/api.js

@@ -0,0 +1,155 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const {
+  getProjectPath,
+  readFile,
+  writeFile,
+  logSuccess,
+  logInfo,
+  logWarning,
+  toCamelCase,
+} = require('../utils/fileUtils');
+
+const generateAPI = async () => {
+  console.log(chalk.cyan.bold('\n╭────────────────────────────────────────────────────────────╮'));
+  console.log(chalk.cyan.bold('│') + chalk.white.bold('              🔌  API METHOD GENERATOR                     ') + chalk.cyan.bold('│'));
+  console.log(chalk.cyan.bold('╰────────────────────────────────────────────────────────────╯'));
+  console.log(chalk.gray('  Create a new API service method\n'));
+
+  const servicesPath = getProjectPath('services');
+  const services = fs.readdirSync(servicesPath).filter(file => {
+    const fullPath = path.join(servicesPath, file);
+    return fs.statSync(fullPath).isDirectory() && !['common'].includes(file);
+  });
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'serviceName',
+      message: chalk.yellow('❓ Select the target service:'),
+      choices: [...services, chalk.green('+ Create new service')],
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'input',
+      name: 'newServiceName',
+      message: chalk.yellow('❓ Enter new service name:'),
+      when: (answers) => answers.serviceName.includes('Create new service'),
+      validate: (input) => input.trim() !== '' || chalk.red('⚠️  Service name is required'),
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'input',
+      name: 'methodName',
+      message: chalk.yellow('❓ Enter method name') + chalk.gray(' (e.g., getUserProfile, saveBankDetails):'),
+      validate: (input) => input.trim() !== '' || chalk.red('⚠️  Method name is required'),
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'input',
+      name: 'endpoint',
+      message: chalk.yellow('❓ Enter API endpoint') + chalk.gray(' (e.g., /api/user/profile):'),
+      validate: (input) => input.trim() !== '' || chalk.red('⚠️  Endpoint is required'),
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'list',
+      name: 'methodType',
+      message: chalk.yellow('❓ Select HTTP method:'),
+      choices: [
+        { name: chalk.green('POST') + chalk.gray('   - Create or update data'), value: 'POST' },
+        { name: chalk.blue('GET') + chalk.gray('    - Retrieve data'), value: 'GET' },
+        { name: chalk.yellow('PUT') + chalk.gray('    - Update existing data'), value: 'PUT' },
+        { name: chalk.red('DELETE') + chalk.gray(' - Remove data'), value: 'DELETE' },
+      ],
+      default: 'POST',
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'confirm',
+      name: 'requiresAuth',
+      message: chalk.yellow('❓ Requires authentication?'),
+      default: true,
+      prefix: chalk.green('✓'),
+    },
+  ]);
+
+  const serviceName = answers.serviceName.includes('Create new service') 
+    ? answers.newServiceName.toLowerCase() 
+    : answers.serviceName;
+  
+  const serviceFile = getProjectPath('services', serviceName, `${serviceName}.js`);
+  const methodName = toCamelCase(answers.methodName);
+
+  let newMethod = '';
+  if (answers.methodType === 'GET') {
+    newMethod = `
+function ${methodName}(data) {
+\tconst response = coreAPI.makeAuthenticatedGetCall(
+\t\t'${answers.endpoint}',
+\t\t${answers.requiresAuth}
+\t);
+\treturn handleResponse(response);
+}`;
+  } else {
+    newMethod = `
+function ${methodName}(data) {
+\tconst response = coreAPI.makeAuthenticatedPostCall(
+\t\t'${answers.endpoint}',
+\t\tdata,
+\t\t${answers.requiresAuth}
+\t);
+\treturn handleResponse(response);
+}`;
+  }
+
+  if (fs.existsSync(serviceFile)) {
+    let content = readFile(serviceFile);
+    
+    // Find the export statement
+    const exportMatch = content.match(/export const \w+Service = \{([^}]*)\};/s);
+    
+    if (exportMatch) {
+      const exportContent = exportMatch[1].trim();
+      const methods = exportContent.split(',').map(m => m.trim()).filter(m => m);
+      
+      // Add new method before the export
+      const insertPosition = content.lastIndexOf('export const');
+      content = content.slice(0, insertPosition) + newMethod + '\n\n' + content.slice(insertPosition);
+      
+      // Update export
+      methods.push(methodName);
+      const newExport = `export const ${serviceName}Service = {\n\t${methods.join(',\n\t')}\n};`;
+      content = content.replace(/export const \w+Service = \{[^}]*\};/s, newExport);
+      
+      writeFile(serviceFile, content);
+      logSuccess(`Added method "${methodName}" to ${serviceName} service`);
+    } else {
+      logWarning('Could not find export statement. Please add the method manually.');
+    }
+  } else {
+    // Create new service file
+    const content = `import { coreAPI } from '../common/baseConfig';
+import handleResponse from '../handler';
+${newMethod}
+
+export const ${serviceName}Service = {
+\t${methodName}
+};
+`;
+    writeFile(serviceFile, content);
+    logSuccess(`Created new service: ${serviceName}`);
+  }
+
+  logSuccess(`\n✨ API method "${methodName}" added successfully!`);
+  console.log(chalk.cyan('\n╭────────────────────────────────────────────────────────────╮'));
+  console.log(chalk.cyan('│') + chalk.white.bold('                    📝  NEXT STEPS                         ') + chalk.cyan('│'));
+  console.log(chalk.cyan('╰────────────────────────────────────────────────────────────╯'));
+  console.log(chalk.white('  1. ') + chalk.green('✓') + chalk.gray(' Create query options in /queries if using React Query'));
+  console.log(chalk.white('  2. ') + chalk.green('✓') + chalk.gray(' Use the method in your custom hook'));
+  console.log(chalk.cyan('\n' + '─'.repeat(65) + '\n'));
+};
+
+module.exports = { generateAPI };

package/generators/feature.js

@@ -0,0 +1,155 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const path = require('path');
+const {
+  getProjectPath,
+  writeFile,
+  logSuccess,
+  logInfo,
+  toPascalCase,
+  confirmOverwrite,
+  fileExists,
+} = require('../utils/fileUtils');
+const { generateScreenTemplate } = require('../templates/screenTemplate');
+const { generateHookTemplate } = require('../templates/hookTemplate');
+const { generateValidationTemplate } = require('../templates/validationTemplate');
+const { generateStylesTemplate } = require('../templates/stylesTemplate');
+const { generateConstantsTemplate } = require('../templates/constantsTemplate');
+const { generateHelpersTemplate } = require('../templates/helpersTemplate');
+const { generateAPIServiceTemplate } = require('../templates/apiTemplate');
+
+const generateFeature = async () => {
+  console.log(chalk.cyan.bold('\n╭────────────────────────────────────────────────────────────╮'));
+  console.log(chalk.cyan.bold('│') + chalk.white.bold('              🎯  FEATURE CREATION WIZARD                    ') + chalk.cyan.bold('│'));
+  console.log(chalk.cyan.bold('╰────────────────────────────────────────────────────────────╯'));
+  console.log(chalk.gray('  Let\'s build a new feature module for your application\n'));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'featureName',
+      message: chalk.yellow('❓ Enter feature name') + chalk.gray(' (e.g., UserProfile, BankManagement):'),
+      validate: (input) => input.trim() !== '' || chalk.red('⚠️  Feature name is required'),
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'input',
+      name: 'screenName',
+      message: chalk.yellow('❓ Enter main screen name') + chalk.gray(' (e.g., ProfileDetails, AddBank):'),
+      validate: (input) => input.trim() !== '' || chalk.red('⚠️  Screen name is required'),
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'confirm',
+      name: 'hasForm',
+      message: chalk.yellow('❓ Does this screen include a form?'),
+      default: false,
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'confirm',
+      name: 'createAPI',
+      message: chalk.yellow('❓ Would you like to create an API service?'),
+      default: true,
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'input',
+      name: 'apiMethodName',
+      message: chalk.yellow('❓ Enter API method name') + chalk.gray(' (e.g., getUserProfile, saveBankDetails):'),
+      when: (answers) => answers.createAPI,
+      validate: (input) => input.trim() !== '' || chalk.red('⚠️  API method name is required'),
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'input',
+      name: 'apiEndpoint',
+      message: chalk.yellow('❓ Enter API endpoint') + chalk.gray(' (e.g., /api/user/profile):'),
+      when: (answers) => answers.createAPI,
+      validate: (input) => input.trim() !== '' || chalk.red('⚠️  API endpoint is required'),
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'list',
+      name: 'apiType',
+      message: chalk.yellow('❓ Select API method type:'),
+      choices: [
+        { name: chalk.green('POST') + chalk.gray(' - Create or update data'), value: 'POST' },
+        { name: chalk.blue('GET') + chalk.gray('  - Retrieve data'), value: 'GET' },
+      ],
+      when: (answers) => answers.createAPI,
+      default: 'POST',
+      prefix: chalk.green('✓'),
+    },
+  ]);
+
+  const featureName = toPascalCase(answers.featureName);
+  const screenName = toPascalCase(answers.screenName);
+  const screenPath = getProjectPath('screens', featureName, screenName);
+
+  // Create screen files
+  const screenFile = path.join(screenPath, `${screenName}.js`);
+  const hookFile = path.join(screenPath, `use${screenName}.js`);
+  const stylesFile = path.join(screenPath, 'styles.js');
+  const constantsFile = path.join(screenPath, 'constants.js');
+  const helpersFile = path.join(screenPath, 'helpers.js');
+
+  const files = [
+    { path: screenFile, content: generateScreenTemplate(screenName, featureName, answers.hasForm, formFields) },
+    { path: hookFile, content: generateHookTemplate(screenName, answers.hasForm, formFields) },
+    { path: stylesFile, content: generateStylesTemplate() },
+    { path: constantsFile, content: generateConstantsTemplate(formFields) },
+    { path: helpersFile, content: generateHelpersTemplate() },
+  ];
+
+  if (answers.hasForm) {
+    const validationFile = path.join(screenPath, 'validation.js');
+    files.push({ path: validationFile, content: generateValidationTemplate(formFields) });
+  }
+
+  for (const file of files) {
+    if (fileExists(file.path)) {
+      const shouldOverwrite = await confirmOverwrite(inquirer, file.path);
+      if (!shouldOverwrite) {
+        logInfo(`Skipped: ${path.basename(file.path)}`);
+        continue;
+      }
+    }
+    writeFile(file.path, file.content);
+    logSuccess(`Created: ${path.relative(getProjectPath(), file.path)}`);
+  }
+
+  // Create API service if requested
+  if (answers.createAPI) {
+    const serviceName = featureName.toLowerCase();
+    const servicePath = getProjectPath('services', serviceName);
+    const serviceFile = path.join(servicePath, `${serviceName}.js`);
+
+    const methods = [{
+      name: answers.apiMethodName,
+      endpoint: answers.apiEndpoint,
+      type: answers.apiType,
+    }];
+
+    const serviceContent = generateAPIServiceTemplate(featureName, methods);
+    
+    if (fileExists(serviceFile)) {
+      logInfo(`Service file already exists: ${serviceFile}`);
+      logInfo('Please manually add the new method to the existing service file.');
+    } else {
+      writeFile(serviceFile, serviceContent);
+      logSuccess(`Created: ${path.relative(getProjectPath(), serviceFile)}`);
+    }
+  }
+
+  logSuccess(`\n✨ Feature "${featureName}" created successfully!`);
+  console.log(chalk.cyan('\n╭────────────────────────────────────────────────────────────╮'));
+  console.log(chalk.cyan('│') + chalk.white.bold('                    📝  NEXT STEPS                         ') + chalk.cyan('│'));
+  console.log(chalk.cyan('╰────────────────────────────────────────────────────────────╯'));
+  console.log(chalk.white('  1. ') + chalk.green('✓') + chalk.gray(' Add the screen to Navigation.js'));
+  console.log(chalk.white('  2. ') + chalk.green('✓') + chalk.gray(' Update the API service if needed'));
+  console.log(chalk.white('  3. ') + chalk.green('✓') + chalk.gray(' Create query options in /queries if using React Query'));
+  console.log(chalk.cyan('\n' + '─'.repeat(65) + '\n'));
+};
+
+module.exports = { generateFeature };

package/generators/hook.js

@@ -0,0 +1,115 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const {
+  getProjectPath,
+  writeFile,
+  logSuccess,
+  logInfo,
+  toPascalCase,
+  confirmOverwrite,
+  fileExists,
+} = require('../utils/fileUtils');
+const { generateHookTemplate } = require('../templates/hookTemplate');
+
+const generateHook = async () => {
+  console.log(chalk.cyan.bold('\n╭────────────────────────────────────────────────────────────╮'));
+  console.log(chalk.cyan.bold('│') + chalk.white.bold('              🪝  CUSTOM HOOK GENERATOR                    ') + chalk.cyan.bold('│'));
+  console.log(chalk.cyan.bold('╰────────────────────────────────────────────────────────────╯'));
+  console.log(chalk.gray('  Generate a reusable React hook\n'));
+
+  const screensPath = getProjectPath('screens');
+  const features = fs.readdirSync(screensPath).filter(file => {
+    const fullPath = path.join(screensPath, file);
+    return fs.statSync(fullPath).isDirectory();
+  });
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'location',
+      message: chalk.yellow('❓ Where should the hook be created?'),
+      choices: [
+        { name: chalk.blue('📱 In a screen folder'), value: 'In a screen folder' },
+        { name: chalk.blue('📦 In helpers folder'), value: 'In helpers folder' },
+        { name: chalk.blue('📁 Custom path'), value: 'Custom path' },
+      ],
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'list',
+      name: 'featureName',
+      message: chalk.yellow('❓ Select the feature:'),
+      choices: features,
+      when: (answers) => answers.location === 'In a screen folder',
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'input',
+      name: 'customPath',
+      message: chalk.yellow('❓ Enter custom path') + chalk.gray(' (relative to project root):'),
+      when: (answers) => answers.location === 'Custom path',
+      validate: (input) => input.trim() !== '' || chalk.red('⚠️  Path is required'),
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'input',
+      name: 'hookName',
+      message: chalk.yellow('❓ Enter hook name') + chalk.gray(' (e.g., useFetchUserData, useFormSubmit):'),
+      validate: (input) => {
+        if (input.trim() === '') return chalk.red('⚠️  Hook name is required');
+        if (!input.startsWith('use')) return chalk.red('⚠️  Hook name should start with "use"');
+        return true;
+      },
+      prefix: chalk.green('✓'),
+    },
+    {
+      type: 'list',
+      name: 'hookType',
+      message: chalk.yellow('❓ Select hook type:'),
+      choices: [
+        { name: chalk.blue('📊 Data fetching (useQuery)'), value: 'query' },
+        { name: chalk.blue('📋 Form handling (Formik)'), value: 'form' },
+        { name: chalk.blue('⚙️ Custom logic'), value: 'custom' },
+      ],
+      prefix: chalk.green('✓'),
+    },
+  ]);
+
+  let hookPath;
+  if (answers.location === 'In a screen folder') {
+    hookPath = getProjectPath('screens', answers.featureName);
+  } else if (answers.location === 'In helpers folder') {
+    hookPath = getProjectPath('helpers');
+  } else {
+    hookPath = getProjectPath(answers.customPath);
+  }
+
+  const hookName = toPascalCase(answers.hookName.replace(/^use/, ''));
+  const hookFile = path.join(hookPath, `use${hookName}.js`);
+
+  if (fileExists(hookFile)) {
+    const shouldOverwrite = await confirmOverwrite(inquirer, hookFile);
+    if (!shouldOverwrite) {
+      logInfo('Operation cancelled');
+      return;
+    }
+  }
+
+  const hasForm = answers.hookType === 'form';
+  const content = generateHookTemplate(hookName, hasForm);
+
+  writeFile(hookFile, content);
+  logSuccess(`Created: ${path.relative(getProjectPath(), hookFile)}`);
+
+  logSuccess(`\n✨ Hook "use${hookName}" created successfully!`);
+  console.log(chalk.cyan('\n╭────────────────────────────────────────────────────────────╮'));
+  console.log(chalk.cyan('│') + chalk.white.bold('                    📝  NEXT STEPS                         ') + chalk.cyan('│'));
+  console.log(chalk.cyan('╰────────────────────────────────────────────────────────────╯'));
+  console.log(chalk.white('  1. ') + chalk.green('✓') + chalk.gray(' Implement the hook logic'));
+  console.log(chalk.white('  2. ') + chalk.green('✓') + chalk.gray(' Import and use in your component'));
+  console.log(chalk.cyan('\n' + '─'.repeat(65) + '\n'));
+};
+
+module.exports = { generateHook };