@idealyst/cli 1.0.46 → 1.0.48

package/templates/api/README.md

@@ -1,12 +1,34 @@
-# {{projectName}}
+# {{projectName}} API
 
 {{description}}
 
+A simplified tRPC API with automatic CRUD generation for Prisma models.
+
 This API project is built with:
-- **tRPC** - End-to-end typesafe APIs
-- **Zod** - TypeScript-first schema validation
+- **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
 
@@ -20,178 +42,233 @@ This API project is built with:
    yarn install
    ```
 
-3. **Start development server:**
+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`
 
-## Available Scripts
+## Creating CRUD APIs
 
-- `yarn dev` - Start development server with hot reload
-- `yarn build` - Build for production
-- `yarn start` - Start production server
-- `yarn lint` - Run ESLint
-- `yarn type-check` - Run TypeScript type checking
+This template provides a simple way to create type-safe APIs with automatic CRUD operations for your Prisma models.
 
-## API Endpoints
+### 1. Define Your Prisma Model
 
-### tRPC Routes
+Add models to `packages/database/schema.prisma`:
 
-All tRPC routes are available at `/trpc/[procedure]`
+```prisma
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
 
-#### Example Routes
-- `hello` - Simple greeting endpoint (accepts optional name parameter)
-- `health` - API health check with timestamp
+### 2. Create a Router
 
-### REST Endpoints
-- `GET /` - API information
-- `GET /health` - Health check
+Create `src/routers/user.ts`:
 
-## Connecting to a Database
+```typescript
+import { z } from 'zod';
+import { createCrudRouter } from '../lib/crud.js';
 
-For database functionality, create a separate database package using:
-```bash
-idealyst create my-database --type database
-```
+const createUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1),
+});
 
-Then import and use it in your API:
-```typescript
-// In your API context or controllers
-import { db } from '@your-org/my-database';
+const updateUserSchema = z.object({
+  email: z.string().email().optional(),
+  name: z.string().min(1).optional(),
+});
 
-// Use the database client
-const users = await db.user.findMany();
+export const userRouter = createCrudRouter(
+  'user',
+  createUserSchema,
+  updateUserSchema
+);
 ```
 
-## Development
+### 3. Add to Main Router
 
-### Adding New Routes
+Update `src/router/index.ts`:
 
-You can add routes in two ways:
+```typescript
+import { userRouter } from '../routers/user.js';
 
-#### 1. Simple tRPC Procedures (Traditional)
-1. Create a new router file in `src/router/`
-2. Define your procedures with Zod schemas for validation
-3. Export the router and add it to `src/router/index.ts`
+export const appRouter = router({
+  // ... existing routes
+  users: userRouter,
+});
+```
 
-#### 2. Controller & Middleware System (Recommended)
-This template includes a powerful controller and middleware system:
+### 4. Use in Frontend
 
-1. **Create a Controller:**
 ```typescript
-// src/controllers/PostController.ts
-import { z } from 'zod';
-import { BaseController, controllerToRouter } from '../lib/controller.js';
-import { requireAuth, requireAdmin } from '../middleware/auth.js';
-import { logger, rateLimit } from '../middleware/common.js';
-
-const createPostSchema = z.object({
-  title: z.string().min(1),
-  content: z.string(),
+// 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' 
 });
 
-export class PostController extends BaseController {
-  // Public endpoint
-  getAll = this.createQuery(
-    z.object({ published: z.boolean().optional() }),
-    async (input, ctx) => {
-      // 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 },
-      ];
-    }
-  );
-
-  // Protected endpoint with middleware
-  create = this.createMutationWithMiddleware(
-    createPostSchema,
-    [logger, rateLimit(5, 60000), requireAuth],
-    async (input, ctx) => {
-      // Mock creation - replace with your database calls
-      return { id: '3', ...input, published: false };
-    }
-  );
-
-  // Admin-only endpoint
-  delete = this.createMutationWithMiddleware(
-    z.object({ id: z.string() }),
-    [requireAuth, requireAdmin],
-    async (input, ctx) => {
-      // Mock deletion - replace with your database calls
-      return { success: true, deletedId: input.id };
-    }
-  );
-}
-
-export const postRouter = controllerToRouter({
-  getAll: new PostController({} as any).getAll,
-  create: new PostController({} as any).create,
-  delete: new PostController({} as any).delete,
+// 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' });
 ```
 
-2. **Add to Main Router:**
-```typescript
-// src/router/index.ts
-import { postRouter } from '../controllers/PostController.js';
+## Generated CRUD Operations
 
-export const appRouter = router({
-  posts: postRouter,
-  // ... other routes
-});
-```
+Each `createCrudRouter` call generates:
 
-### Available Middleware
+- `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
 
-#### Authentication
-- `requireAuth` - Requires Bearer token authentication
-- `requireRole(role)` - Requires specific user role
-- `requireAdmin` - Requires admin role
+## Available Scripts
 
-#### Utility Middleware
-- `logger` - Request/response logging with timing
-- `rateLimit(maxRequests, windowMs)` - Rate limiting per IP
-- `responseTime` - Adds X-Response-Time header
-- `requestId` - Adds unique X-Request-ID header
-- `errorHandler` - Centralized error handling
+- `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
 
-### Example tRPC Client Usage
+## Project Structure
 
-```typescript
-import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';
-import type { AppRouter } from './path/to/your/api';
+```
+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
+```
 
-const client = createTRPCProxyClient<AppRouter>({
-  links: [
-    httpBatchLink({
-      url: 'http://localhost:3000/trpc',
+## 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:
 
-// Use the client
-const greeting = await client.hello.query({ name: 'John' });
-const healthStatus = await client.health.query();
+```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
 
-Copy `.env.example` to `.env` and configure:
+Create a `.env` file with:
 
-- `PORT` - Server port (default: 3000)
-- `NODE_ENV` - Environment (development/production)
-- `CORS_ORIGIN` - CORS origin for client requests
+```env
+# Database
+DATABASE_URL="file:./dev.db"
 
-## Deployment
+# API
+PORT=3000
+NODE_ENV=development
 
-1. Build the project: `yarn build`
-2. Start the server: `yarn start`
+# Add your environment variables here
+```
+
+## Testing
 
-## Learn More
+The project includes Jest for testing:
 
-- [tRPC Documentation](https://trpc.io/)
-- [Zod Documentation](https://zod.dev/)
-- [Express.js Documentation](https://expressjs.com/) 
+```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/templates/api/package.json

@@ -3,12 +3,12 @@
   "version": "{{version}}",
   "description": "{{description}}",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
     }
   },
   "scripts": {
@@ -23,7 +23,7 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@trpc/server": "^10.44.1",
+    "@trpc/server": "^11.5.1",
     "cors": "^2.8.5",
     "dotenv": "^16.3.1",
     "express": "^4.18.2",

package/templates/api/src/index.ts

@@ -5,10 +5,5 @@ export type { AppRouter } from './router/index.js';
 // Export context type for client usage
 export type { Context } from './context.js';
 
-// Export middleware for potential external usage
-export * from './middleware/auth.js';
-export * from './middleware/common.js';
-
-// Export controller base classes for extensions
-export { BaseController, controllerToRouter } from './lib/controller.js';
-export type { MiddlewareFn } from './lib/controller.js'; 
+// Export CRUD utilities for creating routers
+export { createCrudRouter } from './lib/crud.js'; 

package/templates/api/src/lib/crud.ts

@@ -0,0 +1,150 @@
+import type { Prisma } from '@{{workspaceScope}}/database/client';
+import { z } from 'zod';
+import { prisma } from '../lib/database.js';
+import { publicProcedure, router } from '../trpc.js';
+
+/**
+ * Creates a standard CRUD router for any Prisma model
+ * 
+ * @param modelName - The name of the Prisma model (e.g., 'user', 'post', 'test')
+ * @param createSchema - Zod schema for creating new records
+ * @param updateSchema - Zod schema for updating records (optional, defaults to createSchema.partial())
+ * @returns tRPC router with standard CRUD operations
+ */
+export function createCrudRouter<
+  TModelName extends Prisma.ModelName,
+  TCreateInput extends Record<string, any>,
+  TUpdateInput extends Record<string, any> = Partial<TCreateInput>
+>(
+  modelName: TModelName,
+  createSchema: z.ZodSchema<TCreateInput>,
+  updateSchema?: z.ZodSchema<TUpdateInput>
+) {
+  const model = (prisma as any)[modelName];
+  const updateSchemaToUse = updateSchema || createSchema.partial();
+
+  return router({
+    // Get all records
+    getAll: publicProcedure
+      .input(z.object({
+        skip: z.number().min(0).optional(),
+        take: z.number().min(1).max(100).optional(),
+        orderBy: z.record(z.enum(['asc', 'desc'])).optional(),
+      }))
+      .query(async ({ input }) => {
+        return await model.findMany({
+          skip: input.skip,
+          take: input.take || 10,
+          orderBy: input.orderBy,
+        });
+      }),
+
+    // Get record by ID
+    getById: publicProcedure
+      .input(z.object({ id: z.string() }))
+      .query(async ({ input }) => {
+        const record = await model.findUnique({
+          where: { id: input.id },
+        });
+        
+        if (!record) {
+          throw new Error(`${modelName} not found`);
+        }
+        
+        return record;
+      }),
+
+    // Create new record
+    create: publicProcedure
+      .input(createSchema)
+      .mutation(async ({ input }) => {
+        return await model.create({
+          data: input,
+        });
+      }),
+
+    // Update record
+    update: publicProcedure
+      .input(z.object({
+        id: z.string(),
+        data: updateSchemaToUse,
+      }))
+      .mutation(async ({ input }) => {
+        const existingRecord = await model.findUnique({
+          where: { id: input.id },
+        });
+
+        if (!existingRecord) {
+          throw new Error(`${modelName} not found`);
+        }
+
+        return await model.update({
+          where: { id: input.id },
+          data: input.data,
+        });
+      }),
+
+    // Delete record
+    delete: publicProcedure
+      .input(z.object({ id: z.string() }))
+      .mutation(async ({ input }) => {
+        const existingRecord = await model.findUnique({
+          where: { id: input.id },
+        });
+
+        if (!existingRecord) {
+          throw new Error(`${modelName} not found`);
+        }
+
+        return await model.delete({
+          where: { id: input.id },
+        });
+      }),
+
+    // Get count
+    count: publicProcedure
+      .input(z.object({
+        where: z.record(z.any()).optional(),
+      }))
+      .query(async ({ input }) => {
+        return await model.count({
+          where: input.where,
+        });
+      }),
+  });
+}
+
+/**
+ * Example usage:
+ * 
+ * ```typescript
+ * import { z } from 'zod';
+ * import { createCrudRouter } from '../lib/crud.js';
+ * 
+ * // Define schemas for your model
+ * const createUserSchema = z.object({
+ *   email: z.string().email(),
+ *   name: z.string(),
+ * });
+ * 
+ * const updateUserSchema = z.object({
+ *   email: z.string().email().optional(),
+ *   name: z.string().optional(),
+ * });
+ * 
+ * // Create the CRUD router
+ * export const userRouter = createCrudRouter(
+ *   'user',
+ *   createUserSchema,
+ *   updateUserSchema
+ * );
+ * ```
+ * 
+ * This will generate:
+ * - users.getAll() - Get all users with pagination
+ * - users.getById({ id }) - Get user by ID
+ * - users.create({ email, name }) - Create new user
+ * - users.update({ id, data: { email?, name? } }) - Update user
+ * - users.delete({ id }) - Delete user
+ * - users.count() - Get user count
+ */

package/templates/api/src/lib/database.ts

@@ -0,0 +1,23 @@
+import { PrismaClient } from '@{{workspaceScope}}/database/client';
+
+// Initialize Prisma Client
+declare global {
+  // eslint-disable-next-line no-var
+  var __prisma: PrismaClient | undefined;
+}
+
+// Prevent multiple instances of Prisma Client in development
+export const prisma = globalThis.__prisma || new PrismaClient({
+  log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  globalThis.__prisma = prisma;
+}
+
+// Graceful shutdown
+process.on('beforeExit', async () => {
+  await prisma.$disconnect();
+});
+
+export default prisma;