@idealyst/cli 1.0.89 → 1.0.90

package/templates/api/README.md

@@ -1,274 +0,0 @@
-# {{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/templates/api/__tests__/api.test.ts

@@ -1,26 +0,0 @@
-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/templates/api/jest.config.js

@@ -1,23 +0,0 @@
-/** @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/templates/api/jest.setup.js

@@ -1,9 +0,0 @@
-// 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);

package/templates/api/src/context.ts

@@ -1,19 +0,0 @@
-import type { CreateExpressContextOptions } from '@trpc/server/adapters/express';
-
-export interface Context {
-  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 {
-    req,
-    res,
-    // Initialize your dependencies here
-    // Example: db: prisma,
-  };
-};
-
-export type { CreateExpressContextOptions }; 

package/templates/api/src/index.ts

@@ -1,9 +0,0 @@
-// Main exports for the API
-export { appRouter } from './router/index.js';
-export type { AppRouter } from './router/index.js';
-
-// Export context type for client usage
-export type { Context } from './context.js';
-
-// Export CRUD utilities for creating routers
-export { createCrudRouter } from './lib/crud.js'; 

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

@@ -1,150 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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;

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

@@ -1,163 +0,0 @@
-import { z } from 'zod';
-import { router, publicProcedure } from '../trpc.js';
-import { testRouter } from '../routers/test.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',
-    };
-  }),
-
-  // Test CRUD endpoints - generated automatically from Prisma model
-  test: testRouter,
-
-  // Add your model routers here
-  // Example:
-  // users: userRouter,
-  // posts: postRouter,
-});
-
-// Export type definition of API
-export type AppRouter = typeof appRouter;
-
-/*
-SIMPLIFIED CRUD API SYSTEM:
-
-This API template uses a simplified approach with automatic CRUD generation for Prisma models.
-
-## Quick Start:
-
-1. **Define your Prisma model** in packages/database/schema.prisma
-2. **Create Zod schemas** for validation
-3. **Generate CRUD router** using createCrudRouter()
-4. **Add to main router** 
-
-## Example - Adding a User model:
-
-### 1. Define Prisma model:
-```prisma
-model User {
-  id        String   @id @default(cuid())
-  email     String   @unique
-  name      String
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-}
-```
-
-### 2. Create router file (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:
-```typescript
-import { userRouter } from '../routers/user.js';
-
-export const appRouter = router({
-  // ... other 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' } 
-});
-```
-
-## Available CRUD Operations:
-
-Each generated router includes:
-- `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
-
-## Advanced Usage:
-
-### Custom procedures:
-You can extend generated routers with custom procedures:
-
-```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 }
-      });
-    }),
-});
-```
-
-### Authentication & Authorization:
-Use middleware for protected procedures:
-
-```typescript
-import { protectedProcedure } from '../trpc.js';
-
-// Replace publicProcedure with protectedProcedure in createCrudRouter
-// or create a custom version for authenticated routes
-```
-
-This simplified system removes the controller layer complexity while providing
-type-safe, validated CRUD operations for all your Prisma models.
-*/