@idealyst/cli 1.0.32 → 1.0.34

package/dist/templates/api/src/router/index.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+import { router, publicProcedure } from '../trpc.js';
+
+export const appRouter = router({
+  // Simple hello world procedure
+  hello: publicProcedure
+    .input(z.object({ name: z.string().optional() }))
+    .query(({ input }) => {
+      return {
+        greeting: `Hello ${input.name || 'World'}!`,
+        timestamp: new Date().toISOString(),
+      };
+    }),
+
+  // Health check procedure
+  health: publicProcedure.query(() => {
+    return {
+      status: 'OK',
+      timestamp: new Date().toISOString(),
+      version: '1.0.0',
+    };
+  }),
+
+  // Add your procedures here
+  // Example:
+  // users: userRouter,
+  // posts: postRouter,
+
+  // Example controller integration:
+  // Uncomment the lines below and create the corresponding controllers
+  
+  // 1. Import your controllers at the top:
+  // import { userRouter } from '../controllers/UserController.js';
+  
+  // 2. Add them to the router:
+  // users: userRouter,
+});
+
+// Export type definition of API
+export type AppRouter = typeof appRouter;
+
+/*
+CONTROLLER & MIDDLEWARE SYSTEM USAGE:
+
+This API template includes a controller and middleware system that works seamlessly with tRPC.
+
+## Quick Start with Controllers:
+
+1. Create a controller (see src/controllers/UserController.ts for example):
+
+```typescript
+import { z } from 'zod';
+import { BaseController, controllerToRouter } from '../lib/controller.js';
+import { requireAuth } from '../middleware/auth.js';
+
+export class UserController extends BaseController {
+  getAll = this.createQueryWithMiddleware(
+    z.object({}),
+    [requireAuth],
+    async (input, ctx) => {
+      return await ctx.prisma.user.findMany();
+    }
+  );
+}
+
+export const userRouter = controllerToRouter({
+  getAll: new UserController({} as any).getAll,
+});
+```
+
+2. Add to main router:
+
+```typescript
+import { userRouter } from '../controllers/UserController.js';
+
+export const appRouter = router({
+  users: userRouter,
+  // ... other routes
+});
+```
+
+## Available Middleware:
+
+### Authentication:
+- `requireAuth` - Requires Bearer token
+- `requireRole(role)` - Requires specific role
+- `requireAdmin` - Requires admin role
+
+### Utility:
+- `logger` - Request/response logging
+- `rateLimit(max, window)` - Rate limiting
+- `responseTime` - Adds response time header
+- `requestId` - Adds unique request ID
+- `errorHandler` - Centralized error handling
+
+## Usage Examples:
+
+```typescript
+// Public endpoint
+getPublicData = this.createQuery(schema, handler);
+
+// Protected endpoint
+getPrivateData = this.createQueryWithMiddleware(
+  schema,
+  [requireAuth],
+  handler
+);
+
+// Admin-only endpoint
+adminAction = this.createMutationWithMiddleware(
+  schema,
+  [requireAuth, requireAdmin],
+  handler
+);
+
+// Multiple middleware
+complexEndpoint = this.createQueryWithMiddleware(
+  schema,
+  [logger, rateLimit(10, 60000), requireAuth],
+  handler
+);
+```
+
+This system provides:
+✅ Type safety with tRPC
+✅ Reusable middleware
+✅ Clean controller organization
+✅ Easy testing
+✅ Consistent error handling
+*/ 

package/dist/templates/api/src/server.ts

@@ -0,0 +1,50 @@
+import express from 'express';
+import cors from 'cors';
+import { createExpressMiddleware } from '@trpc/server/adapters/express';
+import { appRouter } from './router/index.js';
+import { createContext } from './context.js';
+import dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// CORS configuration
+app.use(cors({
+  origin: process.env.CORS_ORIGIN || 'http://localhost:3000',
+  credentials: true,
+}));
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({ status: 'OK', timestamp: new Date().toISOString() });
+});
+
+// tRPC middleware
+app.use(
+  '/trpc',
+  createExpressMiddleware({
+    router: appRouter,
+    createContext,
+  })
+);
+
+// Default route
+app.get('/', (req, res) => {
+  res.json({
+    message: 'Welcome to {{projectName}} API',
+    endpoints: {
+      health: '/health',
+      trpc: '/trpc',
+      playground: '/trpc-playground' // Available in development
+    }
+  });
+});
+
+app.listen(PORT, () => {
+  console.log(`🚀 Server running on http://localhost:${PORT}`);
+  console.log(`📡 tRPC API available at http://localhost:${PORT}/trpc`);
+  console.log(`🏥 Health check at http://localhost:${PORT}/health`);
+}); 

package/dist/templates/api/src/trpc.ts

@@ -0,0 +1,28 @@
+import { initTRPC } from '@trpc/server';
+import { type Context } from './context.js';
+import { ZodError } from 'zod';
+
+const t = initTRPC.context<Context>().create({
+  errorFormatter({ shape, error }) {
+    return {
+      ...shape,
+      data: {
+        ...shape.data,
+        zodError:
+          error.cause instanceof ZodError ? error.cause.flatten() : null,
+      },
+    };
+  },
+});
+
+// Export reusable router and procedure helpers
+export const router = t.router;
+export const publicProcedure = t.procedure;
+
+// You can create additional procedures with middleware here
+// For example, a protected procedure that requires authentication:
+// export const protectedProcedure = t.procedure.use(async ({ ctx, next }) => {
+//   // Add your authentication logic here
+//   // Example: check for valid session/token
+//   return next({ ctx: { ...ctx, user: { id: 'user-id' } } });
+// }); 

package/dist/templates/api/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "allowJs": true,
+    "checkJs": false,
+    "jsx": "preserve",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "removeComments": false,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    "useUnknownInCatchVariables": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ],
+  "ts-node": {
+    "esm": true
+  }
+} 

package/dist/templates/native/.yarnrc.yml

@@ -0,0 +1,19 @@
+nodeLinker: "node-modules"
+
+# Enable network for package downloads
+enableNetwork: true
+
+# Timeout for HTTP requests (in milliseconds)
+httpTimeout: 60000
+
+# Number of retry attempts for HTTP requests
+httpRetry: 3
+
+# Registry configuration
+npmRegistryServer: "https://registry.yarnpkg.com"
+
+# Enable progress bars
+enableProgressBars: true
+
+# Enable colors in output
+enableColors: true 

package/dist/templates/native/App.tsx

@@ -0,0 +1,23 @@
+import React from 'react';
+import {
+  SafeAreaView,
+} from 'react-native';
+
+import { ExampleStackRouter } from '@idealyst/navigation/examples';
+import { NavigatorProvider } from '@idealyst/navigation';
+
+
+function App() {  
+
+  const backgroundStyle = {
+    flex: 1,
+  };
+
+  return (
+    <SafeAreaView style={backgroundStyle}>
+      <NavigatorProvider route={ExampleStackRouter} />
+    </SafeAreaView>
+  );
+}
+
+export default App;

package/dist/templates/native/README.md

@@ -0,0 +1,86 @@
+# {{projectName}}
+
+{{description}}
+
+## Getting Started
+
+This is a React Native application built with the Idealyst Framework.
+
+### Prerequisites
+
+- Node.js 18+
+- Yarn
+- React Native development environment
+- Android Studio (for Android development)
+- Xcode (for iOS development)
+
+### Installation
+
+Install dependencies:
+```bash
+yarn install
+```
+
+### Running the App
+
+Start the Metro bundler:
+```bash
+yarn start
+```
+
+Run on Android:
+```bash
+yarn android
+```
+
+Run on iOS:
+```bash
+yarn ios
+```
+
+### Project Structure
+
+```
+{{projectName}}/
+├── src/
+│   └── App.tsx        # Main app component
+├── android/           # Android-specific code
+├── ios/               # iOS-specific code
+├── babel.config.js    # Babel configuration
+├── metro.config.js    # Metro configuration
+└── tsconfig.json      # TypeScript configuration
+```
+
+### Features
+
+- **Idealyst Components**: Pre-built UI components
+- **Idealyst Navigation**: Cross-platform navigation
+- **Idealyst Theme**: Consistent theming system
+- **TypeScript**: Full type safety
+- **React Native 0.80.1**: Latest stable version
+
+### Development
+
+The app uses the Idealyst Framework for consistent UI and navigation across platforms.
+
+Edit `src/App.tsx` to start building your application.
+
+### Building for Production
+
+Build Android APK:
+```bash
+yarn build:android
+```
+
+### Testing
+
+Run tests:
+```bash
+yarn test
+```
+
+### Learn More
+
+- [Idealyst Framework Documentation](https://github.com/your-username/idealyst-framework)
+- [React Native Documentation](https://reactnative.dev/)
+- [TypeScript Documentation](https://www.typescriptlang.org/) 

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