@idealyst/cli 1.0.90 → 1.0.92

package/template/docker-compose.prod.yml

@@ -0,0 +1,146 @@
+version: '3.8'
+
+# Production overrides for docker-compose.yml
+# Usage: docker-compose -f docker-compose.yml -f docker-compose.prod.yml up
+
+services:
+  postgres:
+    environment:
+      POSTGRES_DB: ${POSTGRES_DB}
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+    volumes:
+      - postgres_prod_data:/var/lib/postgresql/data
+    deploy:
+      resources:
+        limits:
+          memory: 1G
+          cpus: '0.5'
+        reservations:
+          memory: 512M
+          cpus: '0.25'
+
+  redis:
+    volumes:
+      - redis_prod_data:/data
+    deploy:
+      resources:
+        limits:
+          memory: 256M
+          cpus: '0.25'
+        reservations:
+          memory: 128M
+          cpus: '0.1'
+
+  api:
+    environment:
+      NODE_ENV: production
+      LOG_LEVEL: info
+      RATE_LIMIT_WINDOW_MS: 900000
+      RATE_LIMIT_MAX_REQUESTS: 100
+    deploy:
+      replicas: 2
+      resources:
+        limits:
+          memory: 512M
+          cpus: '0.5'
+        reservations:
+          memory: 256M
+          cpus: '0.25'
+      restart_policy:
+        condition: on-failure
+        delay: 5s
+        max_attempts: 3
+        window: 120s
+
+  web:
+    deploy:
+      replicas: 2
+      resources:
+        limits:
+          memory: 128M
+          cpus: '0.25'
+        reservations:
+          memory: 64M
+          cpus: '0.1'
+      restart_policy:
+        condition: on-failure
+        delay: 5s
+        max_attempts: 3
+        window: 120s
+
+  # Load balancer for production
+  nginx:
+    image: nginx:alpine
+    container_name: ${PROJECT_NAME:-idealyst}-nginx
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./docker/nginx/prod.conf:/etc/nginx/nginx.conf:ro
+      - ./docker/nginx/ssl:/etc/nginx/ssl:ro
+      - ./logs/nginx:/var/log/nginx
+    depends_on:
+      - api
+      - web
+    restart: unless-stopped
+    deploy:
+      resources:
+        limits:
+          memory: 128M
+          cpus: '0.25'
+        reservations:
+          memory: 64M
+          cpus: '0.1'
+    networks:
+      - idealyst-network
+
+  # Monitoring with Prometheus (optional)
+  prometheus:
+    image: prom/prometheus:latest
+    container_name: ${PROJECT_NAME:-idealyst}-prometheus
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./docker/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
+      - prometheus_data:/prometheus
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--web.console.libraries=/etc/prometheus/console_libraries'
+      - '--web.console.templates=/etc/prometheus/consoles'
+      - '--storage.tsdb.retention.time=200h'
+      - '--web.enable-lifecycle'
+    restart: unless-stopped
+    networks:
+      - idealyst-network
+    profiles:
+      - monitoring
+
+  # Log aggregation with Grafana (optional)
+  grafana:
+    image: grafana/grafana:latest
+    container_name: ${PROJECT_NAME:-idealyst}-grafana
+    ports:
+      - "3002:3000"
+    volumes:
+      - grafana_data:/var/lib/grafana
+      - ./docker/grafana/provisioning:/etc/grafana/provisioning
+    environment:
+      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_PASSWORD:-admin}
+      GF_USERS_ALLOW_SIGN_UP: false
+    restart: unless-stopped
+    networks:
+      - idealyst-network
+    profiles:
+      - monitoring
+
+volumes:
+  postgres_prod_data:
+  redis_prod_data:
+  prometheus_data:
+  grafana_data:
+
+networks:
+  idealyst-network:
+    driver: bridge

package/template/docker-compose.yml

@@ -0,0 +1,143 @@
+version: '3.8'
+
+services:
+  # PostgreSQL Database
+  postgres:
+    image: postgres:15-alpine
+    container_name: ${PROJECT_NAME:-idealyst}-postgres
+    environment:
+      POSTGRES_DB: ${POSTGRES_DB:-idealyst_db}
+      POSTGRES_USER: ${POSTGRES_USER:-postgres}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
+    ports:
+      - "${POSTGRES_PORT:-5432}:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+      - ./docker/postgres/init.sql:/docker-entrypoint-initdb.d/init.sql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-postgres}"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+    networks:
+      - idealyst-network
+
+  # Redis Cache
+  redis:
+    image: redis:7-alpine
+    container_name: ${PROJECT_NAME:-idealyst}-redis
+    ports:
+      - "${REDIS_PORT:-6379}:6379"
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+    networks:
+      - idealyst-network
+
+  # API Service
+  api:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: api-runner
+    container_name: ${PROJECT_NAME:-idealyst}-api
+    environment:
+      NODE_ENV: ${NODE_ENV:-production}
+      PORT: 3000
+      DATABASE_URL: postgresql://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD:-postgres}@postgres:5432/${POSTGRES_DB:-idealyst_db}
+      REDIS_URL: redis://redis:6379
+    ports:
+      - "${API_PORT:-3000}:3000"
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    volumes:
+      - ./uploads:/app/uploads
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+    networks:
+      - idealyst-network
+
+  # Web Application
+  web:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: web-runner
+    container_name: ${PROJECT_NAME:-idealyst}-web
+    ports:
+      - "${WEB_PORT:-80}:80"
+    depends_on:
+      - api
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+    networks:
+      - idealyst-network
+
+  # Development Service (for local development)
+  dev:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: dev
+    container_name: ${PROJECT_NAME:-idealyst}-dev
+    environment:
+      NODE_ENV: development
+    ports:
+      - "3000:3000"   # API dev server
+      - "5173:5173"   # Vite dev server
+      - "8080:8080"   # Additional dev server
+      - "19006:19006" # Expo dev tools
+    volumes:
+      - .:/app
+      - /app/node_modules
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    networks:
+      - idealyst-network
+    tty: true
+    stdin_open: true
+
+  # Test Runner
+  test:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: test-runner
+    container_name: ${PROJECT_NAME:-idealyst}-test
+    environment:
+      NODE_ENV: test
+      CI: true
+    volumes:
+      - .:/app
+      - /app/node_modules
+    networks:
+      - idealyst-network
+    profiles:
+      - testing
+
+volumes:
+  postgres_data:
+  redis_data:
+
+networks:
+  idealyst-network:
+    driver: bridge

package/template/jest.config.js

@@ -0,0 +1,20 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  projects: [
+    '<rootDir>/packages/*/jest.config.js',
+  ],
+  collectCoverage: true,
+  collectCoverageFrom: [
+    'packages/*/src/**/*.{ts,tsx}',
+    '!packages/*/src/**/*.d.ts',
+    '!packages/*/src/**/index.ts',
+  ],
+  coverageDirectory: '<rootDir>/coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  testTimeout: 30000,
+  // Ignore template files in node_modules
+  testPathIgnorePatterns: [
+    '/node_modules/',
+    '/templates/',
+  ],
+};

package/template/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "{{packageName}}",
+  "version": "{{version}}",
+  "description": "{{description}}",
+  "private": true,
+  "workspaces": [
+    "packages/*"
+  ],
+  "packageManager": "yarn@4.1.0",
+  "scripts": {
+    "dev": "concurrently \"yarn api:dev\" \"yarn web:dev\" \"yarn mobile:start\"",
+    "build": "yarn build:packages && yarn api:build && yarn web:build",
+    "build:packages": "yarn workspace @{{workspaceScope}}/database build && yarn workspace @{{workspaceScope}}/shared build",
+    "api:dev": "yarn workspace @{{workspaceScope}}/api dev",
+    "api:build": "yarn workspace @{{workspaceScope}}/api build",
+    "web:dev": "yarn workspace @{{workspaceScope}}/web dev",
+    "web:build": "yarn workspace @{{workspaceScope}}/web build",
+    "mobile:start": "yarn workspace @{{workspaceScope}}/mobile start",
+    "mobile:android": "yarn workspace @{{workspaceScope}}/mobile android",
+    "mobile:ios": "yarn workspace @{{workspaceScope}}/mobile ios",
+    "db:generate": "yarn workspace @{{workspaceScope}}/database db:generate",
+    "db:push": "yarn workspace @{{workspaceScope}}/database db:push",
+    "db:migrate": "yarn workspace @{{workspaceScope}}/database db:migrate",
+    "db:studio": "yarn workspace @{{workspaceScope}}/database db:studio",
+    "test": "yarn workspaces foreach --include '@/*' run test",
+    "test:watch": "yarn workspaces foreach --include '@/*' run test:watch",
+    "test:coverage": "yarn workspaces foreach --include '@/*' run test:coverage",
+    "test:ci": "yarn workspaces foreach --include '@/*' --parallel run test --passWithNoTests",
+    "type-check": "yarn workspaces run type-check"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.0",
+    "@babel/preset-env": "^7.28.0",
+    "@babel/preset-react": "^7.27.1",
+    "@babel/preset-typescript": "^7.27.1",
+    "@idealyst/mcp-server": "^{{idealystVersion}}",
+    "@mobilenext/mobile-mcp": "^0.0.34",
+    "@playwright/mcp": "^0.0.45",
+    "@types/jest": "^29.5.12",
+    "concurrently": "^8.2.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.0.0"
+  }
+} 

package/template/packages/api/.env.example

@@ -0,0 +1,6 @@
+# Server Configuration
+PORT=3000
+NODE_ENV=development
+
+# Add your environment variables here
+# Example: API keys, external service URLs, etc.

package/template/packages/api/README.md

@@ -0,0 +1,274 @@
+# {{projectName}} API
+
+{{description}}
+
+A simplified tRPC API with automatic CRUD generation for Prisma models.
+
+This API project is built with:
+- **tRPC** - End-to-end```typescript
+import { z } from 'zod';
+import { router, publicProcedure } from '../trpc.js';
+import { createCrudRouter } from '../lib/crud.js';
+import { prisma } from '../lib/database.js';
+
+const baseCrudRouter = createCrudRouter('user', createUserSchema);
+
+export const userRouter = router({
+  ...baseCrudRouter,
+  
+  // Add custom procedures
+  getByEmail: publicProcedure
+    .input(z.object({ email: z.string().email() }))
+    .query(async ({ input }) => {
+      return await prisma.user.findUnique({
+        where: { email: input.email }
+      });
+    }),
+});
+```Zod** - TypeScript-first schema validation
+- **Express.js** - Web framework for Node.js
+- **TypeScript** - Type-safe JavaScript
+- **Prisma** - Next-generation ORM for database access
+
+## Quick Start
+
+1. **Setup environment variables:**
+   ```bash
+   cp .env.example .env
+   ```
+
+2. **Install dependencies:**
+   ```bash
+   yarn install
+   ```
+
+3. **Setup database:**
+   ```bash
+   # Generate Prisma client
+   yarn prisma:generate
+   
+   # Run migrations
+   yarn prisma:migrate
+   
+   # Seed database with sample data
+   yarn prisma:seed
+   ```
+
+4. **Start development server:**
+   ```bash
+   yarn dev
+   ```
+
+The API will be available at `http://localhost:3000`
+
+## Creating CRUD APIs
+
+This template provides a simple way to create type-safe APIs with automatic CRUD operations for your Prisma models.
+
+### 1. Define Your Prisma Model
+
+Add models to `packages/database/schema.prisma`:
+
+```prisma
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
+
+### 2. Create a Router
+
+Create `src/routers/user.ts`:
+
+```typescript
+import { z } from 'zod';
+import { createCrudRouter } from '../lib/crud.js';
+
+const createUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1),
+});
+
+const updateUserSchema = z.object({
+  email: z.string().email().optional(),
+  name: z.string().min(1).optional(),
+});
+
+export const userRouter = createCrudRouter(
+  'user',
+  createUserSchema,
+  updateUserSchema
+);
+```
+
+### 3. Add to Main Router
+
+Update `src/router/index.ts`:
+
+```typescript
+import { userRouter } from '../routers/user.js';
+
+export const appRouter = router({
+  // ... existing routes
+  users: userRouter,
+});
+```
+
+### 4. Use in Frontend
+
+```typescript
+// Get all users
+const { data: users } = trpc.users.getAll.useQuery();
+
+// Create user
+const createUser = trpc.users.create.useMutation();
+await createUser.mutateAsync({ 
+  email: 'user@example.com', 
+  name: 'John Doe' 
+});
+
+// Update user
+const updateUser = trpc.users.update.useMutation();
+await updateUser.mutateAsync({ 
+  id: 'user-id', 
+  data: { name: 'Jane Doe' } 
+});
+
+// Delete user
+const deleteUser = trpc.users.delete.useMutation();
+await deleteUser.mutateAsync({ id: 'user-id' });
+```
+
+## Generated CRUD Operations
+
+Each `createCrudRouter` call generates:
+
+- `getAll({ skip?, take?, orderBy? })` - List with pagination
+- `getById({ id })` - Get single record
+- `create(data)` - Create new record
+- `update({ id, data })` - Update existing record  
+- `delete({ id })` - Delete record
+- `count({ where? })` - Count records
+
+## Available Scripts
+
+- `yarn dev` - Start development server with hot reload
+- `yarn build` - Build production bundle
+- `yarn start` - Start production server
+- `yarn test` - Run tests
+- `yarn lint` - Lint code
+- `yarn type-check` - Check TypeScript types
+
+## Project Structure
+
+```
+src/
+├── router/
+│   └── index.ts          # Main router definition
+├── routers/
+│   ├── test.ts          # Example CRUD router for Test model
+│   └── user.example.ts  # Example CRUD router for User model
+├── lib/
+│   ├── crud.ts          # CRUD router generator
+│   └── database.ts      # Database connection
+├── context.ts           # tRPC context
+├── trpc.ts             # tRPC setup
+└── server.ts           # Express server setup
+```
+
+## Advanced Usage
+
+### Custom Procedures
+
+Extend generated routers with custom procedures:
+
+```typescript
+import { router, publicProcedure } from '../trpc.js';
+import { createCrudRouter } from '../lib/crud.js';
+
+const baseCrudRouter = createCrudRouter('user', createUserSchema);
+
+export const userRouter = router({
+  ...baseCrudRouter,
+  
+  // Add custom procedures
+  getByEmail: publicProcedure
+    .input(z.object({ email: z.string().email() }))
+    .query(async ({ input }) => {
+      return await db.user.findUnique({
+        where: { email: input.email }
+      });
+    }),
+});
+```
+
+### Authentication
+
+For protected routes, you can add authentication middleware to the tRPC setup or create protected procedures:
+
+```typescript
+import { protectedProcedure } from '../trpc.js';
+
+// Use protectedProcedure instead of publicProcedure in your CRUD router
+```
+
+## Development
+
+1. **Add New Model**: 
+   - Add to Prisma schema
+   - Run `yarn db:migrate`
+   - Create router with `createCrudRouter`
+   - Add to main router
+
+2. **Test API**: 
+   - Start development: `yarn dev`
+   - API available at `http://localhost:3000/trpc`
+
+3. **Type Safety**: 
+   - All operations are fully type-safe
+   - Frontend gets autocomplete and validation
+   - Schemas ensure data integrity
+
+This simplified approach removes controller complexity while maintaining full type safety and providing powerful CRUD operations for all your Prisma models.
+
+## Environment Variables
+
+Create a `.env` file with:
+
+```env
+# Database
+DATABASE_URL="file:./dev.db"
+
+# API
+PORT=3000
+NODE_ENV=development
+
+# Add your environment variables here
+```
+
+## Testing
+
+The project includes Jest for testing:
+
+```typescript
+import { createContext } from '../src/context.js';
+import { appRouter } from '../src/router/index.js';
+
+describe('API Tests', () => {
+  test('should get test records', async () => {
+    const ctx = createContext({} as any);
+    const caller = appRouter.createCaller(ctx);
+    
+    const tests = await caller.test.getAll({});
+    expect(tests).toBeDefined();
+  });
+});
+```
+
+Run tests with:
+```bash
+yarn test
+```

package/template/packages/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/template/packages/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/template/packages/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);