@idealyst/cli 1.0.28 → 1.0.30

package/dist/index.js

@@ -2,8 +2,8 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import fs from 'fs-extra';
+import { fileURLToPath } from 'url';
 import { spawn } from 'child_process';
 import ora from 'ora';
 import validatePackageName from 'validate-npm-package-name';
@@ -119,12 +119,23 @@ async function installDependencies(projectPath, skipInstall = false) {
 }
 function runCommand(command, args, options) {
     return new Promise((resolve, reject) => {
+        const timeoutMs = options.timeout || 300000; // 5 minutes default timeout
         const process = spawn(command, args, {
             cwd: options.cwd,
-            stdio: 'inherit',
+            stdio: ['pipe', 'inherit', 'inherit'], // Pipe stdin to prevent hanging on prompts
             shell: true
         });
+        // Set up timeout
+        const timeoutId = setTimeout(() => {
+            process.kill('SIGTERM');
+            reject(new Error(`Command timed out after ${timeoutMs / 1000} seconds`));
+        }, timeoutMs);
+        // Close stdin immediately to prevent hanging on interactive prompts
+        if (process.stdin) {
+            process.stdin.end();
+        }
         process.on('close', (code) => {
+            clearTimeout(timeoutId);
             if (code === 0) {
                 resolve();
             }
@@ -133,6 +144,7 @@ function runCommand(command, args, options) {
             }
         });
         process.on('error', (error) => {
+            clearTimeout(timeoutId);
             reject(error);
         });
     });
@@ -210,9 +222,15 @@ async function resolveProjectPath(projectName, directory) {
 async function initializeReactNativeProject(projectName, directory, displayName, skipInstall) {
     const spinner = ora('Initializing React Native project...').start();
     try {
-        // Use the correct React Native CLI command format with specific version and yarn
+        // Use create-react-native-app for a more reliable setup
         const cliCommand = 'npx';
-        const args = ['@react-native-community/cli@latest', 'init', projectName, '--version', '0.80.1', '--pm', 'yarn', '--skip-git-init'];
+        const args = [
+            'react-native@latest',
+            'init',
+            projectName,
+            '--pm', 'yarn',
+            '--skip-git-init'
+        ];
         // Add title if displayName is provided
         if (displayName) {
             args.push('--title', displayName);
@@ -221,19 +239,31 @@ async function initializeReactNativeProject(projectName, directory, displayName,
         if (skipInstall) {
             args.push('--skip-install');
         }
-        // Run React Native initialization in the target directory
-        await runCommand(cliCommand, args, { cwd: directory });
+        spinner.text = 'Initializing React Native project (this may take a few minutes)...';
+        // Run React Native initialization with timeout
+        await runCommand(cliCommand, args, {
+            cwd: directory,
+            timeout: 600000 // 10 minutes timeout for React Native init
+        });
         spinner.succeed('React Native project initialized successfully');
     }
     catch (error) {
         spinner.fail('Failed to initialize React Native project');
-        console.log(chalk.yellow('Make sure you have the React Native CLI and yarn available:'));
-        console.log(chalk.white('  npx @react-native-community/cli@latest init ProjectName --version 0.80.1 --pm yarn --skip-git-init'));
-        console.log(chalk.yellow('If you encounter issues, try:'));
-        console.log(chalk.white('  npm install -g @react-native-community/cli'));
-        console.log(chalk.white('  npm install -g yarn'));
-        console.log(chalk.white('  # or'));
-        console.log(chalk.white('  yarn global add @react-native-community/cli'));
+        if (error instanceof Error && error.message.includes('timed out')) {
+            console.log(chalk.red('❌ React Native initialization timed out'));
+            console.log(chalk.yellow('This can happen due to:'));
+            console.log(chalk.white('  • Slow internet connection'));
+            console.log(chalk.white('  • Network issues downloading dependencies'));
+            console.log(chalk.white('  • React Native CLI hanging on prompts'));
+        }
+        console.log(chalk.yellow('\n💡 Alternative approaches:'));
+        console.log(chalk.white('1. Try manually creating the project:'));
+        console.log(chalk.white(`   npx react-native@latest init ${projectName} --pm yarn --skip-git-init`));
+        console.log(chalk.white('\n2. Use Expo (faster alternative):'));
+        console.log(chalk.white(`   npx create-expo-app@latest ${projectName} --template blank-typescript`));
+        console.log(chalk.white('\n3. Ensure prerequisites:'));
+        console.log(chalk.white('   npm install -g react-native-cli'));
+        console.log(chalk.white('   npm install -g @react-native-community/cli'));
         throw error;
     }
 }
@@ -506,43 +536,70 @@ async function generateNativeProject(options) {
     const templatePath = path.join(__dirname$4, '..', 'templates', 'native');
     const templateData = getTemplateData(name, `React Native app built with Idealyst Framework`, displayName, workspaceScope || undefined);
     try {
-        // Step 1: Update workspace configuration FIRST (before React Native CLI)
+        // Step 1: Update workspace configuration FIRST
         await updateWorkspacePackageJson(workspacePath, directory);
-        // Step 2: Initialize React Native project using CLI with --skip-install
-        // Note: For React Native CLI, we need to run it in the parent directory and specify the project name
-        const projectDir = path.dirname(projectPath);
-        const projectName = path.basename(projectPath);
-        await initializeReactNativeProject(projectName, projectDir, displayName, true);
-        // Step 3: Overlay Idealyst-specific files
-        await overlayIdealystFiles(templatePath, projectPath, templateData);
+        // Step 2: Try React Native CLI initialization, with fallback to template-only
+        const useRnCli = process.env.IDEALYST_USE_RN_CLI !== 'false';
+        if (useRnCli) {
+            try {
+                console.log(chalk.blue('🚀 Attempting React Native CLI initialization...'));
+                console.log(chalk.gray('   (This creates proper Android/iOS native directories)'));
+                // Initialize React Native project using CLI with --skip-install
+                const projectDir = path.dirname(projectPath);
+                const projectName = path.basename(projectPath);
+                await initializeReactNativeProject(projectName, projectDir, displayName, true);
+                // Step 3: Overlay Idealyst-specific files
+                await overlayIdealystFiles(templatePath, projectPath, templateData);
+                console.log(chalk.green('✅ React Native project created with native platform support'));
+            }
+            catch (rnError) {
+                console.log(chalk.yellow('⚠️  React Native CLI failed, falling back to template-only approach...'));
+                await createNativeProjectFromTemplate(templatePath, projectPath, templateData);
+                console.log(chalk.yellow('📝 Template-only project created. You may need to run "npx react-native init" later for native platforms.'));
+            }
+        }
+        else {
+            console.log(chalk.blue('��️  Creating project from template only (IDEALYST_USE_RN_CLI=false)'));
+            await createNativeProjectFromTemplate(templatePath, projectPath, templateData);
+        }
         // Step 4: Handle tRPC setup
         if (withTrpc) {
             await copyTrpcFiles(templatePath, projectPath, templateData);
             await copyTrpcAppComponent(templatePath, projectPath, templateData);
         }
-        // Step 5: Configure Android vector icons
-        await configureAndroidVectorIcons(projectPath);
-        // Step 6: Remove tRPC dependencies if not requested (after merge but before install)
+        // Step 5: Configure Android vector icons (only if we have Android directory)
+        const hasAndroid = await fs.pathExists(path.join(projectPath, 'android'));
+        if (hasAndroid) {
+            await configureAndroidVectorIcons(projectPath);
+        }
+        // Step 6: Remove tRPC dependencies if not requested
         if (!withTrpc) {
             await removeTrpcDependencies(projectPath);
         }
-        // Step 7: Install dependencies (including Idealyst packages) after workspace config is updated
+        // Step 7: Install dependencies
         await installDependencies(projectPath, skipInstall);
         console.log(chalk.green('✅ React Native project created successfully!'));
         console.log(chalk.blue('📋 Project includes:'));
-        console.log(chalk.white('  • React Native with proper Android/iOS setup'));
-        console.log(chalk.white('  • Idealyst Components'));
-        console.log(chalk.white('  • Idealyst Navigation'));
-        console.log(chalk.white('  • Idealyst Theme'));
-        console.log(chalk.white('  • React Native Vector Icons (configured)'));
-        console.log(chalk.white('  • TypeScript configuration'));
-        console.log(chalk.white('  • Metro configuration'));
-        console.log(chalk.white('  • Babel configuration'));
-        console.log(chalk.white('  • Native platform directories (android/, ios/)'));
+        console.log(chalk.white('  • React Native with TypeScript'));
+        console.log(chalk.white('  • Idealyst Components & Navigation'));
+        console.log(chalk.white('  • Idealyst Theme & Styling'));
+        console.log(chalk.white('  • Jest testing configuration'));
+        console.log(chalk.white('  • Metro & Babel configuration'));
+        if (hasAndroid) {
+            console.log(chalk.white('  • Android native platform setup'));
+            console.log(chalk.white('  • React Native Vector Icons (configured)'));
+        }
+        const hasIos = await fs.pathExists(path.join(projectPath, 'ios'));
+        if (hasIos) {
+            console.log(chalk.white('  • iOS native platform setup'));
+        }
+        if (!hasAndroid && !hasIos) {
+            console.log(chalk.yellow('  ⚠️  No native platforms detected'));
+            console.log(chalk.yellow('     Run "npx react-native init" in project directory for native support'));
+        }
         if (withTrpc) {
             console.log(chalk.white('  • tRPC client setup and utilities'));
             console.log(chalk.white('  • React Query integration'));
-            console.log(chalk.white('  • Pre-configured tRPC provider'));
         }
     }
     catch (error) {
@@ -551,6 +608,10 @@ async function generateNativeProject(options) {
         throw error;
     }
 }
+// Helper function to create project from template only (fallback when RN CLI fails)
+async function createNativeProjectFromTemplate(templatePath, projectPath, templateData) {
+    await copyTemplate(templatePath, projectPath, templateData);
+}
 
 const __filename$3 = fileURLToPath(import.meta.url);
 const __dirname$3 = path.dirname(__filename$3);

package/dist/types/generators/utils.d.ts

@@ -8,6 +8,7 @@ export declare function processTemplateFile(filePath: string, data: TemplateData
 export declare function installDependencies(projectPath: string, skipInstall?: boolean): Promise<void>;
 export declare function runCommand(command: string, args: string[], options: {
     cwd: string;
+    timeout?: number;
 }): Promise<void>;
 export declare function getTemplateData(projectName: string, description?: string, appName?: string, workspaceScope?: string): TemplateData;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idealyst/cli",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "CLI tool for generating Idealyst Framework projects",
   "type": "module",
   "main": "dist/index.js",
@@ -19,10 +19,11 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rollup -c",
-    "dev": "rollup -c -w",
-    "prepublishOnly": "yarn build",
-    "publish:npm": "npm publish"
+    "build": "tsc",
+    "test": "jest",
+    "test:integration": "jest __tests__/integration.test.ts",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist"
   },
   "dependencies": {
     "chalk": "^5.0.0",
@@ -35,13 +36,16 @@
   "devDependencies": {
     "@types/fs-extra": "^11.0.0",
     "@types/inquirer": "^9.0.0",
+    "@types/jest": "^29.5.0",
     "@types/node": "^20.0.0",
     "@types/validate-npm-package-name": "^4.0.0",
+    "jest": "^29.7.0",
     "rollup": "^3.20.0",
     "rollup-plugin-commonjs": "^10.1.0",
     "rollup-plugin-json": "^4.0.0",
     "rollup-plugin-node-resolve": "^5.2.0",
     "rollup-plugin-typescript2": "^0.34.0",
+    "ts-jest": "^29.1.0",
     "typescript": "^5.0.0"
   },
   "files": [

package/templates/api/__tests__/api.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from '@jest/globals';
+import { appRouter } from '../src/router/index.js';
+
+describe('API Router', () => {
+  it('should have a valid router configuration', () => {
+    expect(appRouter).toBeDefined();
+    expect(typeof appRouter).toBe('object');
+  });
+
+  it('should export the expected router structure', () => {
+    // Test that the router has the expected structure
+    expect(appRouter._def).toBeDefined();
+    expect(appRouter._def.router).toBe(true);
+  });
+});
+
+describe('Sample API Test', () => {
+  it('should pass a basic test', () => {
+    expect(1 + 1).toBe(2);
+  });
+
+  it('should handle async operations', async () => {
+    const result = await Promise.resolve('test');
+    expect(result).toBe('test');
+  });
+});

package/templates/api/jest.config.js

@@ -0,0 +1,23 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src', '<rootDir>/__tests__'],
+  testMatch: [
+    '**/__tests__/**/*.{ts,tsx,js}',
+    '**/*.{test,spec}.{ts,tsx,js}'
+  ],
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest',
+  },
+  collectCoverageFrom: [
+    'src/**/*.{ts,tsx}',
+    '!src/**/*.d.ts',
+    '!src/**/index.ts',
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov'],
+  testTimeout: 10000,
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json'],
+  setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
+};

package/templates/api/jest.setup.js

@@ -0,0 +1,9 @@
+// Global test setup for API tests
+// This file runs before all tests
+
+// Mock environment variables for testing
+process.env.NODE_ENV = 'test';
+process.env.DATABASE_URL = 'file:./test.db';
+
+// Increase timeout for async operations
+jest.setTimeout(10000);

package/templates/api/package.json

@@ -15,6 +15,9 @@
     "build": "tsc",
     "dev": "tsx watch src/server.ts",
     "start": "node dist/server.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
     "db:generate": "prisma generate",
     "db:push": "prisma db push",
     "db:studio": "prisma studio",
@@ -35,11 +38,14 @@
   "devDependencies": {
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
+    "@types/jest": "^29.5.12",
     "@types/node": "^20.10.4",
     "@typescript-eslint/eslint-plugin": "^6.13.1",
     "@typescript-eslint/parser": "^6.13.1",
     "eslint": "^8.54.0",
+    "jest": "^29.7.0",
     "prisma": "^5.7.1",
+    "ts-jest": "^29.1.2",
     "tsx": "^4.6.2",
     "typescript": "^5.3.3"
   },

package/templates/native/__tests__/App.test.tsx

@@ -0,0 +1,156 @@
+/**
+ * @format
+ */
+
+import React from 'react';
+import ReactTestRenderer from 'react-test-renderer';
+import App from '../App';
+
+// Mock the NavigatorProvider to avoid complex navigation setup
+jest.mock('@idealyst/navigation', () => ({
+  NavigatorProvider: ({ children }: { children?: React.ReactNode }) => (
+    React.createElement('View', { testID: 'navigator-provider' }, children || 'Navigator Content')
+  ),
+}));
+
+jest.mock('@idealyst/navigation/examples', () => ({
+  ExampleStackRouter: {},
+}));
+
+describe('App Component', () => {
+  it('renders correctly', async () => {
+    let component: ReactTestRenderer.ReactTestRenderer;
+    
+    await ReactTestRenderer.act(() => {
+      component = ReactTestRenderer.create(<App />);
+    });
+    
+    expect(component!).toBeDefined();
+    expect(component!.toJSON()).toMatchSnapshot();
+  });
+
+  it('renders without crashing', () => {
+    const tree = ReactTestRenderer.create(<App />);
+    expect(tree).toBeDefined();
+    expect(tree.root).toBeDefined();
+  });
+
+  it('contains NavigatorProvider', () => {
+    const tree = ReactTestRenderer.create(<App />);
+    const navigatorProvider = tree.root.findByProps({ testID: 'navigator-provider' });
+    expect(navigatorProvider).toBeDefined();
+  });
+
+  it('has proper SafeAreaView structure', () => {
+    const tree = ReactTestRenderer.create(<App />);
+    const safeAreaView = tree.root.findByType('SafeAreaView');
+    expect(safeAreaView).toBeDefined();
+    expect(safeAreaView.props.style).toEqual({ flex: 1 });
+  });
+});
+
+describe('Sample Component Tests', () => {
+  // Example of testing a simple functional component
+  const SimpleButton = ({ title, onPress, disabled = false }: {
+    title: string;
+    onPress: () => void;
+    disabled?: boolean;
+  }) => {
+    return React.createElement(
+      'TouchableOpacity',
+      {
+        testID: 'simple-button',
+        onPress: disabled ? undefined : onPress,
+        style: { opacity: disabled ? 0.5 : 1 }
+      },
+      React.createElement('Text', null, title)
+    );
+  };
+
+  it('renders button with correct title', () => {
+    const mockPress = jest.fn();
+    const tree = ReactTestRenderer.create(
+      <SimpleButton title="Test Button" onPress={mockPress} />
+    );
+    
+    const textElement = tree.root.findByType('Text');
+    expect(textElement.children).toEqual(['Test Button']);
+  });
+
+  it('handles press events', () => {
+    const mockPress = jest.fn();
+    const tree = ReactTestRenderer.create(
+      <SimpleButton title="Test Button" onPress={mockPress} />
+    );
+    
+    const button = tree.root.findByProps({ testID: 'simple-button' });
+    ReactTestRenderer.act(() => {
+      button.props.onPress();
+    });
+    
+    expect(mockPress).toHaveBeenCalledTimes(1);
+  });
+
+  it('disables button when disabled prop is true', () => {
+    const mockPress = jest.fn();
+    const tree = ReactTestRenderer.create(
+      <SimpleButton title="Disabled Button" onPress={mockPress} disabled={true} />
+    );
+    
+    const button = tree.root.findByProps({ testID: 'simple-button' });
+    expect(button.props.onPress).toBeUndefined();
+    expect(button.props.style.opacity).toBe(0.5);
+  });
+
+  it('handles component state changes', () => {
+    const StatefulComponent = () => {
+      const [count, setCount] = React.useState(0);
+      
+      return React.createElement(
+        'View',
+        { testID: 'stateful-component' },
+        React.createElement('Text', { testID: 'count' }, count.toString()),
+        React.createElement(
+          'TouchableOpacity',
+          {
+            testID: 'increment-button',
+            onPress: () => setCount(c => c + 1)
+          },
+          React.createElement('Text', null, 'Increment')
+        )
+      );
+    };
+
+    const tree = ReactTestRenderer.create(<StatefulComponent />);
+    
+    // Check initial state
+    const countText = tree.root.findByProps({ testID: 'count' });
+    expect(countText.children).toEqual(['0']);
+    
+    // Simulate button press
+    const incrementButton = tree.root.findByProps({ testID: 'increment-button' });
+    ReactTestRenderer.act(() => {
+      incrementButton.props.onPress();
+    });
+    
+    // Check updated state
+    expect(countText.children).toEqual(['1']);
+  });
+});
+
+describe('Sample Native Tests', () => {
+  it('should pass a basic test', () => {
+    expect(1 + 1).toBe(2);
+  });
+
+  it('should handle string operations', () => {
+    const greeting = 'Hello World';
+    expect(greeting).toContain('World');
+  });
+
+  it('should work with arrays', () => {
+    const items = [1, 2, 3];
+    expect(items).toHaveLength(3);
+    expect(items).toContain(2);
+  });
+});