@idealyst/cli 1.0.24 → 1.0.26

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

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

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

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

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

@@ -1,7 +1,7 @@
 import { TemplateData } from '../types';
 export declare function validateProjectName(name: string): boolean;
 export declare function createPackageName(name: string): string;
-export declare function updateWorkspacePackageJson(projectName: string, directory: string): Promise<void>;
+export declare function updateWorkspacePackageJson(workspacePath: string, directory: string): Promise<void>;
 export declare function copyTemplate(templatePath: string, destPath: string, data: TemplateData): Promise<void>;
 export declare function processTemplateFiles(dir: string, data: TemplateData): Promise<void>;
 export declare function processTemplateFile(filePath: string, data: TemplateData): Promise<void>;
@@ -10,10 +10,27 @@ export declare function runCommand(command: string, args: string[], options: {
     cwd: string;
 }): Promise<void>;
 export declare function getTemplateData(projectName: string, description?: string, appName?: string): TemplateData;
+/**
+ * Detects if we're in a workspace root directory
+ */
+export declare function isWorkspaceRoot(directory: string): Promise<boolean>;
+/**
+ * Resolves the correct project path for individual projects (native, web, shared).
+ * Individual projects can ONLY be created within an existing workspace.
+ * This enforces proper monorepo structure and prevents scattered individual projects.
+ */
+export declare function resolveProjectPath(projectName: string, directory: string): Promise<{
+    projectPath: string;
+    workspacePath: string;
+}>;
 export declare function initializeReactNativeProject(projectName: string, directory: string, displayName?: string, skipInstall?: boolean): Promise<void>;
 export declare function overlayIdealystFiles(templatePath: string, projectPath: string, data: TemplateData): Promise<void>;
 export declare function mergePackageJsonDependencies(templatePath: string, projectPath: string): Promise<void>;
 export declare function promptForProjectName(): Promise<string>;
 export declare function promptForProjectType(): Promise<string>;
 export declare function promptForAppName(projectName: string): Promise<string>;
+export declare function promptForTrpcIntegration(): Promise<boolean>;
+export declare function copyTrpcFiles(templatePath: string, projectPath: string, data: TemplateData): Promise<void>;
+export declare function copyTrpcAppComponent(templatePath: string, projectPath: string, data: TemplateData): Promise<void>;
+export declare function removeTrpcDependencies(projectPath: string): Promise<void>;
 export declare function configureAndroidVectorIcons(projectPath: string): Promise<void>;

package/dist/types/types.d.ts

@@ -1,10 +1,11 @@
-export type ProjectType = 'native' | 'web' | 'shared' | 'workspace';
+export type ProjectType = 'native' | 'web' | 'shared' | 'workspace' | 'api';
 export interface GenerateProjectOptions {
     name: string;
     type: ProjectType;
     directory: string;
     skipInstall: boolean;
     appName?: string;
+    withTrpc?: boolean;
 }
 export interface TemplateData {
     projectName: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idealyst/cli",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "CLI tool for generating Idealyst Framework projects",
   "type": "module",
   "main": "dist/index.js",

package/templates/api/README.md

@@ -0,0 +1,207 @@
+# {{projectName}}
+
+{{description}}
+
+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
+
+## 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 db:generate
+   
+   # Push schema to database (for development)
+   yarn db:push
+   
+   # Or run migrations (for production)
+   yarn db:migrate
+   ```
+
+4. **Start development server:**
+   ```bash
+   yarn dev
+   ```
+
+The API will be available at `http://localhost:3000`
+
+## Available Scripts
+
+- `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
+
+## API Endpoints
+
+### tRPC Routes
+
+All tRPC routes are available at `/trpc/[procedure]`
+
+#### Example Routes
+- `hello` - Simple greeting endpoint (accepts optional name parameter)
+- `health` - API health check with timestamp
+
+### REST Endpoints
+- `GET /` - API information
+- `GET /health` - Health check
+
+## 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`.
+
+### Database Schema
+
+The schema starts empty - you can add your own models in `prisma/schema.prisma`. Example model structure is provided in comments.
+
+## Development
+
+### Adding New Routes
+
+You can add routes in two ways:
+
+#### 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`
+
+#### 2. Controller & Middleware System (Recommended)
+This template includes a powerful controller and middleware system:
+
+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(),
+});
+
+export class PostController extends BaseController {
+  // Public endpoint
+  getAll = this.createQuery(
+    z.object({ published: z.boolean().optional() }),
+    async (input, ctx) => {
+      return ctx.prisma.post.findMany({
+        where: { published: input.published }
+      });
+    }
+  );
+
+  // Protected endpoint with middleware
+  create = this.createMutationWithMiddleware(
+    createPostSchema,
+    [logger, rateLimit(5, 60000), requireAuth],
+    async (input, ctx) => {
+      return ctx.prisma.post.create({ data: input });
+    }
+  );
+
+  // Admin-only endpoint
+  delete = this.createMutationWithMiddleware(
+    z.object({ id: z.string() }),
+    [requireAuth, requireAdmin],
+    async (input, ctx) => {
+      return ctx.prisma.post.delete({ where: { id: input.id } });
+    }
+  );
+}
+
+export const postRouter = controllerToRouter({
+  getAll: new PostController({} as any).getAll,
+  create: new PostController({} as any).create,
+  delete: new PostController({} as any).delete,
+});
+```
+
+2. **Add to Main Router:**
+```typescript
+// src/router/index.ts
+import { postRouter } from '../controllers/PostController.js';
+
+export const appRouter = router({
+  posts: postRouter,
+  // ... other routes
+});
+```
+
+### Available Middleware
+
+#### Authentication
+- `requireAuth` - Requires Bearer token authentication
+- `requireRole(role)` - Requires specific user role
+- `requireAdmin` - Requires admin role
+
+#### 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
+
+### Example tRPC Client Usage
+
+```typescript
+import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';
+import type { AppRouter } from './path/to/your/api';
+
+const client = createTRPCProxyClient<AppRouter>({
+  links: [
+    httpBatchLink({
+      url: 'http://localhost:3000/trpc',
+    }),
+  ],
+});
+
+// Use the client
+const greeting = await client.hello.query({ name: 'John' });
+const healthStatus = await client.health.query();
+```
+
+## Environment Variables
+
+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
+
+## 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`
+
+## 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/templates/api/env.example

@@ -0,0 +1,12 @@
+# Database
+DATABASE_URL="file:./dev.db"
+
+# Server
+PORT=3000
+NODE_ENV=development
+
+# CORS
+CORS_ORIGIN="http://localhost:3000"
+
+# Optional: Database for production (uncomment and configure as needed)
+# DATABASE_URL="postgresql://username:password@localhost:5432/{{projectName}}" 

package/templates/api/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "{{packageName}}",
+  "version": "{{version}}",
+  "description": "{{description}}",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/server.ts",
+    "start": "node dist/server.js",
+    "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",
+    "express": "^4.18.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.10.4",
+    "@typescript-eslint/eslint-plugin": "^6.13.1",
+    "@typescript-eslint/parser": "^6.13.1",
+    "eslint": "^8.54.0",
+    "prisma": "^5.7.1",
+    "tsx": "^4.6.2",
+    "typescript": "^5.3.3"
+  },
+  "keywords": [
+    "api",
+    "trpc",
+    "prisma",
+    "zod",
+    "typescript",
+    "express"
+  ],
+  "author": "",
+  "license": "MIT"
+} 

package/templates/api/prisma/schema.prisma

@@ -0,0 +1,21 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "sqlite"
+  url      = env("DATABASE_URL")
+}
+
+// Add your models here
+// Example:
+// model User {
+//   id        String   @id @default(cuid())
+//   email     String   @unique
+//   name      String?
+//   createdAt DateTime @default(now())
+//   updatedAt DateTime @updatedAt
+// } 

package/templates/api/src/context.ts

@@ -0,0 +1,23 @@
+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'];
+}
+
+export const createContext = ({ req, res }: CreateExpressContextOptions): Context => {
+  return {
+    prisma,
+    req,
+    res,
+  };
+};
+
+export type { CreateExpressContextOptions }; 

package/templates/api/src/controllers/UserController.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import { BaseController, controllerToRouter } from '../lib/controller.js';
+import { requireAuth, requireAdmin } from '../middleware/auth.js';
+
+// Input schemas
+const createUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().optional(),
+});
+
+const getUserSchema = z.object({
+  id: z.string(),
+});
+
+const updateUserSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+});
+
+// User controller class
+export class UserController extends BaseController {
+  // Get all users (admin only)
+  getAll = this.createQueryWithMiddleware(
+    z.object({}),
+    [requireAuth, requireAdmin],
+    async (input, ctx) => {
+      // Simulate database query
+      return [
+        { id: '1', email: 'user1@example.com', name: 'User 1' },
+        { id: '2', email: 'user2@example.com', name: 'User 2' },
+      ];
+    }
+  );
+
+  // Get user by ID (authenticated users)
+  getById = this.createQueryWithMiddleware(
+    getUserSchema,
+    [requireAuth],
+    async (input, ctx) => {
+      // In a real app, you'd query your database
+      const user = { id: input.id, email: 'user@example.com', name: 'John Doe' };
+      
+      if (!user) {
+        throw new Error('User not found');
+      }
+      
+      return user;
+    }
+  );
+
+  // Create user (public endpoint)
+  create = this.createMutation(
+    createUserSchema,
+    async (input, ctx) => {
+      // In a real app, you'd save to database
+      const newUser = {
+        id: Math.random().toString(36),
+        email: input.email,
+        name: input.name || null,
+        createdAt: new Date(),
+      };
+      
+      return newUser;
+    }
+  );
+
+  // Update user (authenticated users)
+  update = this.createMutationWithMiddleware(
+    updateUserSchema,
+    [requireAuth],
+    async (input, ctx) => {
+      // In a real app, you'd update the database
+      const updatedUser = {
+        id: input.id,
+        email: 'user@example.com', // Would come from database
+        name: input.name || 'Updated Name',
+        updatedAt: new Date(),
+      };
+      
+      return updatedUser;
+    }
+  );
+
+  // Delete user (admin only)
+  delete = this.createMutationWithMiddleware(
+    z.object({ id: z.string() }),
+    [requireAuth, requireAdmin],
+    async (input, ctx) => {
+      // In a real app, you'd delete from database
+      return { success: true, deletedId: input.id };
+    }
+  );
+}
+
+// Export router - this would be used in your main router
+export const userRouter = controllerToRouter({
+  getAll: new UserController({} as any).getAll,
+  getById: new UserController({} as any).getById,
+  create: new UserController({} as any).create,
+  update: new UserController({} as any).update,
+  delete: new UserController({} as any).delete,
+}); 

package/templates/api/src/index.ts

@@ -0,0 +1,14 @@
+// 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 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'; 

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

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import type { Context } from '../context.js';
+import { publicProcedure } from '../trpc.js';
+
+// Base controller class
+export abstract class BaseController {
+  protected ctx: Context;
+
+  constructor(ctx: Context) {
+    this.ctx = ctx;
+  }
+
+  // Helper method to create a query procedure
+  protected createQuery<TInput, TOutput>(
+    inputSchema: z.ZodSchema<TInput>,
+    handler: (input: TInput, ctx: Context) => Promise<TOutput> | TOutput
+  ) {
+    return publicProcedure
+      .input(inputSchema)
+      .query(async ({ input, ctx }) => {
+        return handler(input, ctx);
+      });
+  }
+
+  // Helper method to create a mutation procedure
+  protected createMutation<TInput, TOutput>(
+    inputSchema: z.ZodSchema<TInput>,
+    handler: (input: TInput, ctx: Context) => Promise<TOutput> | TOutput
+  ) {
+    return publicProcedure
+      .input(inputSchema)
+      .mutation(async ({ input, ctx }) => {
+        return handler(input, ctx);
+      });
+  }
+
+  // Helper method to create a query with middleware
+  protected createQueryWithMiddleware<TInput, TOutput>(
+    inputSchema: z.ZodSchema<TInput>,
+    middleware: MiddlewareFn[],
+    handler: (input: TInput, ctx: Context) => Promise<TOutput> | TOutput
+  ) {
+    let procedure = publicProcedure.input(inputSchema);
+    
+    // Apply middleware
+    for (const mw of middleware) {
+      procedure = procedure.use(mw);
+    }
+    
+    return procedure.query(async ({ input, ctx }) => {
+      return handler(input, ctx);
+    });
+  }
+
+  // Helper method to create a mutation with middleware
+  protected createMutationWithMiddleware<TInput, TOutput>(
+    inputSchema: z.ZodSchema<TInput>,
+    middleware: MiddlewareFn[],
+    handler: (input: TInput, ctx: Context) => Promise<TOutput> | TOutput
+  ) {
+    let procedure = publicProcedure.input(inputSchema);
+    
+    // Apply middleware
+    for (const mw of middleware) {
+      procedure = procedure.use(mw);
+    }
+    
+    return procedure.mutation(async ({ input, ctx }) => {
+      return handler(input, ctx);
+    });
+  }
+}
+
+// Middleware function type compatible with tRPC
+export type MiddlewareFn = (opts: {
+  ctx: Context;
+  next: () => Promise<{ ctx: Context }>;
+}) => Promise<{ ctx: Context }>;
+
+// Controller method decorator type
+export interface ControllerMethod {
+  [key: string]: ReturnType<typeof publicProcedure.query> | ReturnType<typeof publicProcedure.mutation>;
+}
+
+// Helper function to convert controller to tRPC router object
+export function controllerToRouter<T extends Record<string, any>>(
+  controllerMethods: T
+): T {
+  return controllerMethods;
+}