@idealyst/cli 1.0.27 → 1.0.29

package/dist/index.js

@@ -52,7 +52,10 @@ async function copyTemplate(templatePath, destPath, data) {
         await fs.copy(templatePath, destPath, {
             filter: (src) => {
                 const relativePath = path.relative(templatePath, src);
-                return !relativePath.includes('node_modules') && !relativePath.includes('.git');
+                // Skip App-with-trpc.tsx as it's only copied when tRPC is enabled
+                return !relativePath.includes('node_modules') &&
+                    !relativePath.includes('.git') &&
+                    !relativePath.endsWith('App-with-trpc.tsx');
             }
         });
         // Process template files
@@ -134,10 +137,15 @@ function runCommand(command, args, options) {
         });
     });
 }
-function getTemplateData(projectName, description, appName) {
+function getTemplateData(projectName, description, appName, workspaceScope) {
+    let packageName = createPackageName(projectName);
+    // If we have a workspace scope, prefix the package name with it
+    if (workspaceScope) {
+        packageName = `@${workspaceScope}/${packageName}`;
+    }
     return {
         projectName,
-        packageName: createPackageName(projectName),
+        packageName,
         version: '1.0.0',
         description: description || `A new Idealyst project: ${projectName}`,
         appName
@@ -159,6 +167,22 @@ async function isWorkspaceRoot(directory) {
     }
     return false;
 }
+/**
+ * Gets the workspace name from the workspace root's package.json
+ */
+async function getWorkspaceName(directory) {
+    const packageJsonPath = path.join(directory, 'package.json');
+    if (await fs.pathExists(packageJsonPath)) {
+        try {
+            const packageJson = await fs.readJSON(packageJsonPath);
+            return packageJson.name || null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    return null;
+}
 /**
  * Resolves the correct project path for individual projects (native, web, shared).
  * Individual projects can ONLY be created within an existing workspace.
@@ -172,12 +196,15 @@ async function resolveProjectPath(projectName, directory) {
             `Please first create a workspace with: idealyst init my-workspace\n` +
             `Then navigate to the workspace directory and create your project.`);
     }
+    // Get the workspace name to use as scope
+    const workspaceScope = await getWorkspaceName(directory);
     // Create project in workspace's packages/ folder
     const packagesDir = path.join(directory, 'packages');
     await fs.ensureDir(packagesDir);
     return {
         projectPath: path.join(packagesDir, projectName),
-        workspacePath: `packages/${projectName}`
+        workspacePath: `packages/${projectName}`,
+        workspaceScope
     };
 }
 async function initializeReactNativeProject(projectName, directory, displayName, skipInstall) {
@@ -219,9 +246,11 @@ async function overlayIdealystFiles(templatePath, projectPath, data) {
             filter: (src) => {
                 const relativePath = path.relative(templatePath, src);
                 // Skip package.json as we'll merge it separately
+                // Skip App-with-trpc.tsx as it's only copied when tRPC is enabled
                 return !relativePath.includes('node_modules') &&
                     !relativePath.includes('.git') &&
-                    !relativePath.endsWith('package.json');
+                    !relativePath.endsWith('package.json') &&
+                    !relativePath.endsWith('App-with-trpc.tsx');
             }
         });
         // Process template files
@@ -444,6 +473,7 @@ var utils = /*#__PURE__*/Object.freeze({
   copyTrpcFiles: copyTrpcFiles,
   createPackageName: createPackageName,
   getTemplateData: getTemplateData,
+  getWorkspaceName: getWorkspaceName,
   initializeReactNativeProject: initializeReactNativeProject,
   installDependencies: installDependencies,
   isWorkspaceRoot: isWorkspaceRoot,
@@ -472,9 +502,9 @@ async function generateNativeProject(options) {
     const displayName = appName || name.split('-').map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' ');
     console.log(chalk.blue(`📱 Creating React Native project: ${name}`));
     console.log(chalk.gray(`   App display name: ${displayName}`));
-    const { projectPath, workspacePath } = await resolveProjectPath(name, directory);
+    const { projectPath, workspacePath, workspaceScope } = await resolveProjectPath(name, directory);
     const templatePath = path.join(__dirname$4, '..', 'templates', 'native');
-    const templateData = getTemplateData(name, `React Native app built with Idealyst Framework`, displayName);
+    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)
         await updateWorkspacePackageJson(workspacePath, directory);
@@ -530,9 +560,9 @@ async function generateWebProject(options) {
         throw new Error(`Invalid project name: ${name}`);
     }
     console.log(chalk.blue(`🌐 Creating React Web project: ${name}`));
-    const { projectPath, workspacePath } = await resolveProjectPath(name, directory);
+    const { projectPath, workspacePath, workspaceScope } = await resolveProjectPath(name, directory);
     const templatePath = path.join(__dirname$3, '..', 'templates', 'web');
-    const templateData = getTemplateData(name, `React web app built with Idealyst Framework`);
+    const templateData = getTemplateData(name, `React web app built with Idealyst Framework`, undefined, workspaceScope || undefined);
     await copyTemplate(templatePath, projectPath, templateData);
     // Handle tRPC setup
     if (withTrpc) {
@@ -569,9 +599,9 @@ async function generateSharedLibrary(options) {
         throw new Error(`Invalid project name: ${name}`);
     }
     console.log(chalk.blue(`📦 Creating shared library: ${name}`));
-    const { projectPath, workspacePath } = await resolveProjectPath(name, directory);
+    const { projectPath, workspacePath, workspaceScope } = await resolveProjectPath(name, directory);
     const templatePath = path.join(__dirname$2, '..', 'templates', 'shared');
-    const templateData = getTemplateData(name, `Shared library built with Idealyst Framework`);
+    const templateData = getTemplateData(name, `Shared library built with Idealyst Framework`, undefined, workspaceScope || undefined);
     await copyTemplate(templatePath, projectPath, templateData);
     await installDependencies(projectPath, skipInstall);
     await updateWorkspacePackageJson(workspacePath, directory);
@@ -614,9 +644,9 @@ async function generateApiProject(options) {
         throw new Error(`Invalid project name: ${name}`);
     }
     console.log(chalk.blue(`🚀 Creating API project: ${name}`));
-    const { projectPath, workspacePath } = await resolveProjectPath(name, directory);
+    const { projectPath, workspacePath, workspaceScope } = await resolveProjectPath(name, directory);
     const templatePath = path.join(__dirname, '..', 'templates', 'api');
-    const templateData = getTemplateData(name, `Clean API server template with tRPC, Prisma, and Zod`);
+    const templateData = getTemplateData(name, `Clean API server template with tRPC, Prisma, and Zod`, undefined, workspaceScope || undefined);
     await copyTemplate(templatePath, projectPath, templateData);
     await installDependencies(projectPath, skipInstall);
     await updateWorkspacePackageJson(workspacePath, directory);

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

@@ -9,11 +9,15 @@ export declare function installDependencies(projectPath: string, skipInstall?: b
 export declare function runCommand(command: string, args: string[], options: {
     cwd: string;
 }): Promise<void>;
-export declare function getTemplateData(projectName: string, description?: string, appName?: string): TemplateData;
+export declare function getTemplateData(projectName: string, description?: string, appName?: string, workspaceScope?: string): TemplateData;
 /**
  * Detects if we're in a workspace root directory
  */
 export declare function isWorkspaceRoot(directory: string): Promise<boolean>;
+/**
+ * Gets the workspace name from the workspace root's package.json
+ */
+export declare function getWorkspaceName(directory: string): Promise<string | null>;
 /**
  * Resolves the correct project path for individual projects (native, web, shared).
  * Individual projects can ONLY be created within an existing workspace.
@@ -22,6 +26,7 @@ export declare function isWorkspaceRoot(directory: string): Promise<boolean>;
 export declare function resolveProjectPath(projectName: string, directory: string): Promise<{
     projectPath: string;
     workspacePath: string;
+    workspaceScope: string | null;
 }>;
 export declare function initializeReactNativeProject(projectName: string, directory: string, displayName?: string, skipInstall?: boolean): Promise<void>;
 export declare function overlayIdealystFiles(templatePath: string, projectPath: string, data: TemplateData): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idealyst/cli",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "description": "CLI tool for generating Idealyst Framework projects",
   "type": "module",
   "main": "dist/index.js",

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

@@ -4,10 +4,20 @@
   "description": "{{description}}",
   "type": "module",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
   "scripts": {
     "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",
@@ -28,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);
+  });
+});