@idealyst/cli 1.0.28 → 1.0.30

package/templates/workspace/docker-compose.yml

@@ -0,0 +1,144 @@
+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: 3001
+      DATABASE_URL: postgresql://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD:-postgres}@postgres:5432/${POSTGRES_DB:-idealyst_db}
+      REDIS_URL: redis://redis:6379
+    ports:
+      - "${API_PORT:-3001}:3001"
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    volumes:
+      - ./uploads:/app/uploads
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3001/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"   # Web dev server
+      - "3001:3001"   # 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/templates/workspace/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/templates/workspace/package.json

@@ -8,18 +8,28 @@
   ],
   "packageManager": "yarn@4.1.0",
   "scripts": {
+    "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",
+    "test:runner": "node scripts/test-runner.js",
+    "test:help": "node scripts/test-runner.js help",
     "publish:all": "yarn workspaces foreach --include '@/*' npm publish",
     "version:patch": "yarn workspaces foreach --include '@/*' version patch",
     "version:minor": "yarn workspaces foreach --include '@/*' version minor",
     "version:major": "yarn workspaces foreach --include '@/*' version major",
     "build:all": "yarn workspaces foreach --include '@/*' run build",
-    "test:all": "yarn workspaces foreach --include '@/*' run test"
+    "lint:all": "yarn workspaces foreach --include '@/*' run lint",
+    "type-check:all": "yarn workspaces foreach --include '@/*' 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",
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
     "typescript": "^5.0.0"
   }
 } 

package/templates/workspace/scripts/docker/db-backup.sh

@@ -0,0 +1,230 @@
+#!/bin/bash
+
+# Database backup and restore script for Idealyst workspace
+# Usage: ./scripts/docker/db-backup.sh [backup|restore] [filename]
+
+set -e
+
+COMMAND=${1:-backup}
+FILENAME=${2:-"backup-$(date +%Y%m%d-%H%M%S).sql"}
+PROJECT_NAME=${PROJECT_NAME:-idealyst}
+
+# Source environment variables
+if [ -f ".env" ]; then
+    source .env
+fi
+
+POSTGRES_CONTAINER="${PROJECT_NAME}-postgres"
+DATABASE=${POSTGRES_DB:-idealyst_db}
+USERNAME=${POSTGRES_USER:-postgres}
+
+echo "🗄️ Database Operations for Idealyst"
+echo "===================================="
+
+# Function to check if database container is running
+check_database() {
+    if ! docker ps | grep -q "$POSTGRES_CONTAINER"; then
+        echo "❌ Database container '$POSTGRES_CONTAINER' is not running"
+        echo "💡 Start it with: docker-compose up -d postgres"
+        exit 1
+    fi
+}
+
+# Function to create backup
+create_backup() {
+    local backup_file=$1
+    
+    echo "📦 Creating backup of database '$DATABASE'..."
+    echo "📁 Backup file: $backup_file"
+    
+    # Create backups directory if it doesn't exist
+    mkdir -p backups
+    
+    # Create the backup
+    docker exec "$POSTGRES_CONTAINER" pg_dump \
+        -U "$USERNAME" \
+        -d "$DATABASE" \
+        --clean \
+        --if-exists \
+        --create \
+        --verbose > "backups/$backup_file"
+    
+    if [ $? -eq 0 ]; then
+        echo "✅ Backup created successfully: backups/$backup_file"
+        
+        # Show backup info
+        local size=$(du -h "backups/$backup_file" | cut -f1)
+        echo "📊 Backup size: $size"
+        
+        # Compress the backup
+        gzip "backups/$backup_file"
+        echo "🗜️ Backup compressed: backups/$backup_file.gz"
+        
+    else
+        echo "❌ Backup failed"
+        exit 1
+    fi
+}
+
+# Function to restore backup
+restore_backup() {
+    local backup_file=$1
+    
+    # Check if backup file exists
+    if [ ! -f "$backup_file" ]; then
+        # Try with .gz extension
+        if [ -f "$backup_file.gz" ]; then
+            echo "📦 Found compressed backup, extracting..."
+            gunzip "$backup_file.gz"
+        else
+            echo "❌ Backup file not found: $backup_file"
+            echo "📁 Available backups:"
+            ls -la backups/ 2>/dev/null || echo "No backups directory found"
+            exit 1
+        fi
+    fi
+    
+    echo "⚠️  WARNING: This will replace the current database '$DATABASE'"
+    echo "📁 Restoring from: $backup_file"
+    
+    read -p "Are you sure you want to continue? (y/N): " -n 1 -r
+    echo
+    
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        echo "❌ Restore cancelled"
+        exit 1
+    fi
+    
+    echo "🔄 Restoring database..."
+    
+    # Stop API container to prevent connections
+    echo "🛑 Stopping API container..."
+    docker-compose stop api 2>/dev/null || true
+    
+    # Wait a moment for connections to close
+    sleep 2
+    
+    # Restore the backup
+    docker exec -i "$POSTGRES_CONTAINER" psql \
+        -U "$USERNAME" \
+        -d postgres < "$backup_file"
+    
+    if [ $? -eq 0 ]; then
+        echo "✅ Database restored successfully"
+        
+        # Restart API container
+        echo "🚀 Restarting API container..."
+        docker-compose start api
+        
+    else
+        echo "❌ Restore failed"
+        echo "🚀 Restarting API container..."
+        docker-compose start api
+        exit 1
+    fi
+}
+
+# Function to list backups
+list_backups() {
+    echo "📁 Available backups:"
+    echo "===================="
+    
+    if [ -d "backups" ]; then
+        ls -lah backups/ | grep -E '\.(sql|gz)$' || echo "No backup files found"
+    else
+        echo "No backups directory found"
+    fi
+}
+
+# Function to clean old backups
+clean_backups() {
+    local days=${1:-7}
+    
+    echo "🧹 Cleaning backups older than $days days..."
+    
+    if [ -d "backups" ]; then
+        find backups/ -name "*.sql.gz" -mtime +$days -delete
+        find backups/ -name "*.sql" -mtime +$days -delete
+        echo "✅ Old backups cleaned"
+    else
+        echo "No backups directory found"
+    fi
+}
+
+# Function to show database info
+show_db_info() {
+    echo "📊 Database Information:"
+    echo "======================="
+    echo "Container: $POSTGRES_CONTAINER"
+    echo "Database: $DATABASE"
+    echo "Username: $USERNAME"
+    echo ""
+    
+    # Show database size
+    echo "🗄️ Database size:"
+    docker exec "$POSTGRES_CONTAINER" psql \
+        -U "$USERNAME" \
+        -d "$DATABASE" \
+        -c "SELECT pg_size_pretty(pg_database_size('$DATABASE')) as database_size;"
+    
+    echo ""
+    echo "📋 Tables:"
+    docker exec "$POSTGRES_CONTAINER" psql \
+        -U "$USERNAME" \
+        -d "$DATABASE" \
+        -c "\dt"
+}
+
+# Main script logic
+main() {
+    case $COMMAND in
+        "backup")
+            check_database
+            create_backup "$FILENAME"
+            ;;
+            
+        "restore")
+            check_database
+            if [ -z "$FILENAME" ]; then
+                echo "❌ Please specify a backup file to restore"
+                echo "Usage: $0 restore <backup-file>"
+                exit 1
+            fi
+            restore_backup "$FILENAME"
+            ;;
+            
+        "list")
+            list_backups
+            ;;
+            
+        "clean")
+            local days=${FILENAME:-7}
+            clean_backups "$days"
+            ;;
+            
+        "info")
+            check_database
+            show_db_info
+            ;;
+            
+        *)
+            echo "Usage: $0 [backup|restore|list|clean|info] [filename|days]"
+            echo ""
+            echo "Commands:"
+            echo "  backup [filename]    - Create a database backup"
+            echo "  restore <filename>   - Restore from a backup file"
+            echo "  list                 - List available backups"
+            echo "  clean [days]         - Clean backups older than N days (default: 7)"
+            echo "  info                 - Show database information"
+            echo ""
+            echo "Examples:"
+            echo "  $0 backup"
+            echo "  $0 backup my-backup.sql"
+            echo "  $0 restore backups/backup-20240101-120000.sql"
+            echo "  $0 clean 30"
+            exit 1
+            ;;
+    esac
+}
+
+main

package/templates/workspace/scripts/docker/deploy.sh

@@ -0,0 +1,212 @@
+#!/bin/bash
+
+# Docker deployment script for Idealyst workspace
+# Usage: ./scripts/docker/deploy.sh [environment]
+
+set -e
+
+ENVIRONMENT=${1:-production}
+PROJECT_NAME=${PROJECT_NAME:-idealyst}
+
+echo "🚀 Deploying Idealyst to $ENVIRONMENT environment..."
+
+# Validate environment
+if [[ ! "$ENVIRONMENT" =~ ^(development|staging|production)$ ]]; then
+    echo "❌ Invalid environment. Use: development, staging, or production"
+    exit 1
+fi
+
+# Check if required files exist
+if [ ! -f "docker-compose.yml" ]; then
+    echo "❌ docker-compose.yml not found. Run this script from the project root."
+    exit 1
+fi
+
+if [ ! -f ".env" ]; then
+    echo "⚠️  .env file not found. Creating from .env.example..."
+    cp .env.example .env
+    echo "📝 Please edit .env with your configuration before proceeding."
+    exit 1
+fi
+
+# Source environment variables
+source .env
+
+# Function to wait for service health
+wait_for_service() {
+    local service=$1
+    local max_attempts=30
+    local attempt=1
+    
+    echo "⏳ Waiting for $service to be healthy..."
+    
+    while [ $attempt -le $max_attempts ]; do
+        if docker-compose ps $service | grep -q "healthy\|Up"; then
+            echo "✅ $service is ready"
+            return 0
+        fi
+        
+        echo "🔄 Attempt $attempt/$max_attempts - waiting for $service..."
+        sleep 10
+        attempt=$((attempt + 1))
+    done
+    
+    echo "❌ $service failed to become healthy"
+    return 1
+}
+
+# Function to run database migrations
+run_migrations() {
+    echo "🗄️ Running database migrations..."
+    
+    # Check if any package has Prisma schema
+    for package_dir in packages/*/; do
+        if [ -f "${package_dir}prisma/schema.prisma" ]; then
+            echo "📦 Running migrations for $(basename "$package_dir")..."
+            docker-compose exec api yarn workspace $(basename "$package_dir") prisma migrate deploy
+        fi
+    done
+}
+
+# Function to build and deploy
+deploy() {
+    case $ENVIRONMENT in
+        "development")
+            echo "🔧 Starting development environment..."
+            docker-compose up --build -d postgres redis
+            wait_for_service postgres
+            wait_for_service redis
+            docker-compose up --build -d dev
+            ;;
+            
+        "staging"|"production")
+            echo "🏗️ Building application..."
+            docker-compose build --no-cache
+            
+            if [ "$ENVIRONMENT" = "production" ]; then
+                echo "🚀 Deploying to production..."
+                docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d postgres redis
+            else
+                echo "🧪 Deploying to staging..."
+                docker-compose up -d postgres redis
+            fi
+            
+            wait_for_service postgres
+            wait_for_service redis
+            
+            # Run migrations
+            run_migrations
+            
+            if [ "$ENVIRONMENT" = "production" ]; then
+                docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d api web nginx
+            else
+                docker-compose up -d api web
+            fi
+            
+            wait_for_service api
+            wait_for_service web
+            ;;
+    esac
+}
+
+# Function to show deployment status
+show_status() {
+    echo ""
+    echo "📊 Deployment Status:"
+    echo "===================="
+    docker-compose ps
+    
+    echo ""
+    echo "🌐 Service URLs:"
+    echo "==============="
+    
+    if [ "$ENVIRONMENT" = "development" ]; then
+        echo "Web App (Dev): http://localhost:3000"
+        echo "API (Dev): http://localhost:3001"
+        echo "Database: postgresql://postgres:postgres@localhost:5432/${POSTGRES_DB}"
+        echo "Redis: redis://localhost:6379"
+    else
+        echo "Web App: http://localhost:${WEB_PORT:-80}"
+        echo "API: http://localhost:${API_PORT:-3001}"
+        
+        if [ "$ENVIRONMENT" = "production" ]; then
+            echo "Nginx: http://localhost"
+            echo "Monitoring: http://localhost:3002 (Grafana)"
+            echo "Metrics: http://localhost:9090 (Prometheus)"
+        fi
+    fi
+    
+    echo ""
+    echo "📝 Logs:"
+    echo "========"
+    echo "View logs: docker-compose logs -f [service]"
+    echo "Available services: $(docker-compose config --services | tr '\n' ' ')"
+}
+
+# Function to run tests
+run_tests() {
+    echo "🧪 Running tests..."
+    docker-compose --profile testing run --rm test
+}
+
+# Main deployment process
+main() {
+    echo "🏗️ Environment: $ENVIRONMENT"
+    echo "📦 Project: $PROJECT_NAME"
+    echo ""
+    
+    # Stop existing containers
+    echo "🛑 Stopping existing containers..."
+    docker-compose down
+    
+    # Clean up orphaned containers
+    docker-compose down --remove-orphans
+    
+    # Deploy
+    deploy
+    
+    # Show status
+    show_status
+    
+    echo ""
+    echo "✅ Deployment complete!"
+    echo ""
+    echo "💡 Useful commands:"
+    echo "  View logs: docker-compose logs -f"
+    echo "  Stop services: docker-compose down"
+    echo "  Restart service: docker-compose restart [service]"
+    echo "  Run tests: ./scripts/docker/deploy.sh test"
+    echo ""
+}
+
+# Handle special commands
+case $ENVIRONMENT in
+    "test")
+        run_tests
+        exit 0
+        ;;
+    "status")
+        show_status
+        exit 0
+        ;;
+    "logs")
+        docker-compose logs -f
+        exit 0
+        ;;
+    "stop")
+        echo "🛑 Stopping all services..."
+        docker-compose down
+        echo "✅ All services stopped"
+        exit 0
+        ;;
+    "clean")
+        echo "🧹 Cleaning up Docker resources..."
+        docker-compose down -v --remove-orphans
+        docker system prune -f
+        echo "✅ Cleanup complete"
+        exit 0
+        ;;
+esac
+
+# Run main deployment
+main