@idealyst/cli 1.0.37 → 1.0.39

package/dist/templates/api/README.md

@@ -4,7 +4,6 @@
 
 This API project is built with:
 - **tRPC** - End-to-end typesafe APIs
-- **Prisma** - Modern database toolkit
 - **Zod** - TypeScript-first schema validation
 - **Express.js** - Web framework for Node.js
 - **TypeScript** - Type-safe JavaScript
@@ -13,7 +12,7 @@ This API project is built with:
 
 1. **Setup environment variables:**
    ```bash
-   cp env.example .env
+   cp .env.example .env
    ```
 
 2. **Install dependencies:**
@@ -21,19 +20,7 @@ This API project is built with:
    yarn install
    ```
 
-3. **Setup database:**
-   ```bash
-   # Generate Prisma client
-   yarn db:generate
-   
-   # Push schema to database (for development)
-   yarn db:push
-   
-   # Or run migrations (for production)
-   yarn db:migrate
-   ```
-
-4. **Start development server:**
+3. **Start development server:**
    ```bash
    yarn dev
    ```
@@ -45,11 +32,6 @@ The API will be available at `http://localhost:3000`
 - `yarn dev` - Start development server with hot reload
 - `yarn build` - Build for production
 - `yarn start` - Start production server
-- `yarn db:generate` - Generate Prisma client
-- `yarn db:push` - Push schema changes to database
-- `yarn db:studio` - Open Prisma Studio (database GUI)
-- `yarn db:migrate` - Run database migrations
-- `yarn db:reset` - Reset database and run all migrations
 - `yarn lint` - Run ESLint
 - `yarn type-check` - Run TypeScript type checking
 
@@ -67,13 +49,21 @@ All tRPC routes are available at `/trpc/[procedure]`
 - `GET /` - API information
 - `GET /health` - Health check
 
-## Database
+## Connecting to a Database
 
-This project uses SQLite by default for development. You can switch to PostgreSQL or MySQL by updating the `DATABASE_URL` in your `.env` file and the `provider` in `prisma/schema.prisma`.
+For database functionality, create a separate database package using:
+```bash
+idealyst create my-database --type database
+```
 
-### Database Schema
+Then import and use it in your API:
+```typescript
+// In your API context or controllers
+import { db } from '@your-org/my-database';
 
-The schema starts empty - you can add your own models in `prisma/schema.prisma`. Example model structure is provided in comments.
+// Use the database client
+const users = await db.user.findMany();
+```
 
 ## Development
 
@@ -107,9 +97,11 @@ export class PostController extends BaseController {
   getAll = this.createQuery(
     z.object({ published: z.boolean().optional() }),
     async (input, ctx) => {
-      return ctx.prisma.post.findMany({
-        where: { published: input.published }
-      });
+      // Mock data - replace with your database calls
+      return [
+        { id: '1', title: 'Post 1', content: 'Content 1', published: true },
+        { id: '2', title: 'Post 2', content: 'Content 2', published: false },
+      ];
     }
   );
 
@@ -118,7 +110,8 @@ export class PostController extends BaseController {
     createPostSchema,
     [logger, rateLimit(5, 60000), requireAuth],
     async (input, ctx) => {
-      return ctx.prisma.post.create({ data: input });
+      // Mock creation - replace with your database calls
+      return { id: '3', ...input, published: false };
     }
   );
 
@@ -127,7 +120,8 @@ export class PostController extends BaseController {
     z.object({ id: z.string() }),
     [requireAuth, requireAdmin],
     async (input, ctx) => {
-      return ctx.prisma.post.delete({ where: { id: input.id } });
+      // Mock deletion - replace with your database calls
+      return { success: true, deletedId: input.id };
     }
   );
 }
@@ -185,9 +179,8 @@ const healthStatus = await client.health.query();
 
 ## Environment Variables
 
-Copy `env.example` to `.env` and configure:
+Copy `.env.example` to `.env` and configure:
 
-- `DATABASE_URL` - Database connection string
 - `PORT` - Server port (default: 3000)
 - `NODE_ENV` - Environment (development/production)
 - `CORS_ORIGIN` - CORS origin for client requests
@@ -195,13 +188,10 @@ Copy `env.example` to `.env` and configure:
 ## Deployment
 
 1. Build the project: `yarn build`
-2. Set up your production database
-3. Run migrations: `yarn db:migrate`
-4. Start the server: `yarn start`
+2. Start the server: `yarn start`
 
 ## Learn More
 
 - [tRPC Documentation](https://trpc.io/)
-- [Prisma Documentation](https://www.prisma.io/docs/)
 - [Zod Documentation](https://zod.dev/)
 - [Express.js Documentation](https://expressjs.com/) 

package/dist/templates/api/package.json

@@ -18,17 +18,11 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
-    "db:generate": "prisma generate",
-    "db:push": "prisma db push",
-    "db:studio": "prisma studio",
-    "db:migrate": "prisma migrate dev",
-    "db:reset": "prisma migrate reset",
     "lint": "eslint src --ext .ts,.tsx",
     "lint:fix": "eslint src --ext .ts,.tsx --fix",
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@prisma/client": "^5.7.1",
     "@trpc/server": "^10.44.1",
     "cors": "^2.8.5",
     "dotenv": "^16.3.1",
@@ -44,7 +38,6 @@
     "@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"
@@ -52,7 +45,6 @@
   "keywords": [
     "api",
     "trpc",
-    "prisma",
     "zod",
     "typescript",
     "express"

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

@@ -1,22 +1,18 @@
-import { PrismaClient } from '@prisma/client';
 import type { CreateExpressContextOptions } from '@trpc/server/adapters/express';
 
-// Create Prisma client
-const prisma = new PrismaClient({
-  log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
-});
-
 export interface Context {
-  prisma: PrismaClient;
   req: CreateExpressContextOptions['req'];
   res: CreateExpressContextOptions['res'];
+  // Add your dependencies here (e.g., database client, external services)
+  // Example: db: PrismaClient;
 }
 
 export const createContext = ({ req, res }: CreateExpressContextOptions): Context => {
   return {
-    prisma,
     req,
     res,
+    // Initialize your dependencies here
+    // Example: db: prisma,
   };
 };
 

package/dist/templates/database/.env.example

@@ -0,0 +1,8 @@
+# Database
+DATABASE_URL="file:./dev.db"
+
+# Optional: PostgreSQL example
+# DATABASE_URL="postgresql://username:password@localhost:5432/mydb?schema=public"
+
+# Optional: MySQL example  
+# DATABASE_URL="mysql://username:password@localhost:3306/mydb"

package/dist/templates/database/README.md

@@ -0,0 +1,93 @@
+# {{projectName}}
+
+{{description}}
+
+A database layer built with Prisma and TypeScript, designed to be shared across multiple applications in your monorepo.
+
+## Features
+
+- 🗄️ **Prisma ORM** - Type-safe database access
+- 📝 **Zod Schemas** - Runtime validation matching your database models
+- 📦 **Exportable Client** - Share database access across packages
+- 🔒 **TypeScript** - Full type safety
+- 🧪 **Testing Setup** - Jest configuration for database testing
+- 🔄 **Migration Scripts** - Database versioning and seeding
+
+## Getting Started
+
+1. **Environment Setup**
+   ```bash
+   cp .env.example .env
+   # Edit .env with your database URL
+   ```
+
+2. **Generate Prisma Client**
+   ```bash
+   yarn db:generate
+   ```
+
+3. **Push Schema to Database**
+   ```bash
+   yarn db:push
+   ```
+
+4. **Open Prisma Studio** (Optional)
+   ```bash
+   yarn db:studio
+   ```
+
+## Usage
+
+### In Other Packages
+
+```typescript
+import { db, schemas } from '@your-org/{{projectName}}';
+
+// Use the database client
+const users = await db.user.findMany();
+
+// Use Zod schemas for validation
+const userData = schemas.createUser.parse(input);
+```
+
+### Adding Models
+
+1. Update `prisma/schema.prisma` with your models
+2. Update `src/schemas.ts` with corresponding Zod schemas
+3. Run `yarn db:generate` to update the client
+4. Run `yarn db:push` to update the database
+
+## Scripts
+
+- `yarn build` - Build the package for distribution
+- `yarn dev` - Run in development mode with file watching
+- `yarn test` - Run tests
+- `yarn test:watch` - Run tests in watch mode
+- `yarn db:generate` - Generate Prisma client
+- `yarn db:push` - Push schema changes to database
+- `yarn db:studio` - Open Prisma Studio
+- `yarn db:migrate` - Create and apply migrations
+- `yarn db:reset` - Reset database and apply migrations
+- `yarn db:seed` - Seed the database
+
+## Project Structure
+
+```
+src/
+├── index.ts          # Main exports
+├── client.ts         # Prisma client setup
+└── schemas.ts        # Zod validation schemas
+prisma/
+├── schema.prisma     # Database schema
+└── migrations/       # Database migrations
+__tests__/
+└── database.test.ts  # Database tests
+```
+
+## Best Practices
+
+- Always update Zod schemas when changing Prisma models
+- Use meaningful migration names
+- Test database operations
+- Export only what's needed from the main index
+- Keep the client singleton pattern for performance

package/dist/templates/database/__tests__/database.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from '@jest/globals';
+import { db } from '../src';
+
+describe('Database', () => {
+  it('should export database client', () => {
+    expect(db).toBeDefined();
+  });
+
+  it('should connect to database', async () => {
+    // This is a basic connection test
+    // Add your own model-specific tests here
+    expect(db.$connect).toBeDefined();
+  });
+});

package/dist/templates/database/jest.config.js

@@ -0,0 +1,19 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  collectCoverageFrom: [
+    'src/**/*.{ts,tsx}',
+    '!src/**/*.d.ts',
+  ],
+  testMatch: [
+    '**/__tests__/**/*.test.{ts,tsx}',
+  ],
+  setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json'],
+  transform: {
+    '^.+\\.(ts|tsx)$': 'ts-jest',
+  },
+  moduleNameMapping: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+  },
+};

package/dist/templates/database/jest.setup.js

@@ -0,0 +1,11 @@
+// Global test setup
+import { beforeEach, afterEach } from '@jest/globals';
+
+// Mock environment variables for testing
+process.env.NODE_ENV = 'test';
+process.env.DATABASE_URL = 'file:./test.db';
+
+// Clean up after each test
+afterEach(async () => {
+  // Add any cleanup logic here
+});

package/dist/templates/database/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "{{packageName}}",
+  "version": "{{version}}",
+  "description": "{{description}}",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas.d.ts",
+      "import": "./dist/schemas.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "db:generate": "prisma generate",
+    "db:push": "prisma db push",
+    "db:studio": "prisma studio",
+    "db:migrate": "prisma migrate dev",
+    "db:reset": "prisma migrate reset",
+    "db:seed": "tsx prisma/seed.ts",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "type-check": "tsc --noEmit",
+    "dev": "tsx watch src/index.ts"
+  },
+  "dependencies": {
+    "@prisma/client": "^5.7.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.10.4",
+    "@typescript-eslint/eslint-plugin": "^6.13.1",
+    "@typescript-eslint/parser": "^6.13.1",
+    "dotenv": "^16.3.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"
+  },
+  "keywords": [
+    "database",
+    "prisma",
+    "typescript",
+    "orm"
+  ]
+}

package/dist/templates/{api → database}/prisma/schema.prisma

@@ -18,4 +18,4 @@ datasource db {
 //   name      String?
 //   createdAt DateTime @default(now())
 //   updatedAt DateTime @updatedAt
-// } 
+// }

package/dist/templates/database/prisma/seed.ts

@@ -0,0 +1,28 @@
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+async function main() {
+  console.log('🌱 Seeding database...');
+
+  // Add your seed data here
+  // Example:
+  // const user = await prisma.user.create({
+  //   data: {
+  //     email: 'admin@example.com',
+  //     name: 'Admin User',
+  //   },
+  // });
+  // console.log('Created user:', user);
+
+  console.log('✅ Database seeded successfully!');
+}
+
+main()
+  .catch((e) => {
+    console.error('❌ Error seeding database:', e);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await prisma.$disconnect();
+  });

package/dist/templates/database/src/client.ts

@@ -0,0 +1,18 @@
+import { PrismaClient } from '@prisma/client';
+
+declare global {
+  // Prevent multiple instances of Prisma Client in development
+  var __globalPrisma: PrismaClient | undefined;
+}
+
+const prisma =
+  globalThis.__globalPrisma ??
+  new PrismaClient({
+    log: ['query', 'error', 'warn'],
+  });
+
+if (process.env.NODE_ENV !== 'production') {
+  globalThis.__globalPrisma = prisma;
+}
+
+export default prisma;

package/dist/templates/database/src/index.ts

@@ -0,0 +1,11 @@
+// Export Prisma client
+export { PrismaClient } from '@prisma/client';
+
+// Export database client instance
+export { default as db } from './client';
+
+// Export Zod schemas
+export * from './schemas';
+
+// Export types from Prisma
+export type * from '@prisma/client';

package/dist/templates/database/src/schemas.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+// Add your Zod schemas here to match your Prisma models
+// Example:
+// export const UserSchema = z.object({
+//   id: z.string().cuid(),
+//   email: z.string().email(),
+//   name: z.string().optional(),
+//   createdAt: z.date(),
+//   updatedAt: z.date(),
+// });
+
+// export const CreateUserSchema = UserSchema.omit({
+//   id: true,
+//   createdAt: true,
+//   updatedAt: true,
+// });
+
+// export const UpdateUserSchema = CreateUserSchema.partial();
+
+// Export all your schemas
+export const schemas = {
+  // user: UserSchema,
+  // createUser: CreateUserSchema,
+  // updateUser: UpdateUserSchema,
+} as const;

package/dist/templates/database/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "resolveJsonModule": true,
+    "allowJs": false,
+    "noUncheckedIndexedAccess": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  },
+  "include": [
+    "src/**/*",
+    "prisma/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "__tests__"
+  ]
+}

package/dist/templates/workspace/.devcontainer/post-create.sh

@@ -1,89 +0,0 @@
-#!/bin/bash
-
-# Post-create script for Idealyst dev container
-echo "🚀 Setting up Idealyst development environment..."
-
-# Set proper permissions
-sudo chown -R devuser:devuser /app
-
-# Make scripts executable
-chmod +x /app/scripts/*.sh
-
-# Install dependencies if not already installed
-if [ ! -d "/app/node_modules" ]; then
-    echo "📦 Installing dependencies..."
-    yarn install
-fi
-
-# Set up git configuration (if not already set)
-if [ -z "$(git config --global user.name)" ]; then
-    echo "⚙️ Please configure git:"
-    echo "  git config --global user.name \"Your Name\""
-    echo "  git config --global user.email \"your.email@example.com\""
-fi
-
-# Create environment file if it doesn't exist
-if [ ! -f "/app/.env" ]; then
-    echo "📝 Creating .env file..."
-    cat > /app/.env << EOF
-# Database Configuration
-DATABASE_URL=postgresql://postgres:postgres@postgres:5432/idealyst_db
-POSTGRES_DB=idealyst_db
-POSTGRES_USER=postgres
-POSTGRES_PASSWORD=postgres
-
-# Redis Configuration
-REDIS_URL=redis://redis:6379
-
-# API Configuration
-API_PORT=3001
-JWT_SECRET=your-jwt-secret-here
-
-# Web Configuration
-WEB_PORT=3000
-
-# Development Configuration
-NODE_ENV=development
-LOG_LEVEL=debug
-
-# Project Configuration
-PROJECT_NAME={{packageName}}
-EOF
-fi
-
-# Wait for database to be ready
-echo "⏳ Waiting for database to be ready..."
-until pg_isready -h postgres -p 5432 -U postgres; do
-    echo "Database is unavailable - sleeping"
-    sleep 1
-done
-
-echo "✅ Database is ready!"
-
-# Run database migrations if they exist
-if [ -d "/app/packages" ]; then
-    echo "🗄️ Setting up database..."
-    
-    # Check if any package has prisma
-    for package_dir in /app/packages/*/; do
-        if [ -f "${package_dir}prisma/schema.prisma" ]; then
-            echo "Running Prisma setup for $(basename "$package_dir")..."
-            cd "$package_dir"
-            npx prisma generate
-            npx prisma db push
-            cd /app
-        fi
-    done
-fi
-
-# Set up git hooks if husky is present
-if [ -f "/app/package.json" ] && grep -q "husky" /app/package.json; then
-    echo "🐕 Setting up git hooks..."
-    yarn husky install
-fi
-
-# Create helpful aliases
-echo "⚡ Setting up helpful aliases..."
-cat >> ~/.bashrc << EOF
-
-source ~/.bashrc

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

@@ -0,0 +1,2 @@
+import { GenerateProjectOptions } from '../types';
+export declare function generateDatabaseProject(options: GenerateProjectOptions): Promise<void>;

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

@@ -5,3 +5,4 @@ export * from './web';
 export * from './shared';
 export * from './workspace';
 export * from './api';
+export * from './database';

package/dist/types/types.d.ts

@@ -1,4 +1,4 @@
-export type ProjectType = 'native' | 'web' | 'shared' | 'workspace' | 'api';
+export type ProjectType = 'native' | 'web' | 'shared' | 'workspace' | 'api' | 'database';
 export interface GenerateProjectOptions {
     name: string;
     type: ProjectType;