@idealyst/cli 1.0.24 → 1.0.26

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

@@ -0,0 +1,170 @@
+import { TRPCError } from '@trpc/server';
+import type { Context } from '../context.js';
+
+// Middleware function type that works with tRPC
+export type MiddlewareFunction = (opts: {
+  ctx: Context;
+  next: () => Promise<{ ctx: Context }>;
+}) => Promise<{ ctx: Context }>;
+
+// Authentication middleware
+export const requireAuth: MiddlewareFunction = async ({ ctx, next }) => {
+  // Example: Check for authorization header
+  const authHeader = ctx.req.headers.authorization;
+  
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    throw new TRPCError({
+      code: 'UNAUTHORIZED',
+      message: 'Missing or invalid authorization header',
+    });
+  }
+
+  const token = authHeader.substring(7);
+  
+  // Here you would validate the token (JWT, session, etc.)
+  // For this example, we'll just check if it's not empty
+  if (!token) {
+    throw new TRPCError({
+      code: 'UNAUTHORIZED',
+      message: 'Invalid token',
+    });
+  }
+
+  // Add user info to context (replace with your actual user lookup)
+  const user = {
+    id: 'user-id-from-token',
+    email: 'user@example.com',
+    // ... other user properties
+  };
+
+  return next({
+    ctx: {
+      ...ctx,
+      user, // Add user to context
+    },
+  });
+};
+
+// Role-based authorization middleware
+export const requireRole = (role: string): MiddlewareFunction => {
+  return async ({ ctx, next }) => {
+    const user = (ctx as any).user;
+    
+    if (!user) {
+      throw new TRPCError({
+        code: 'UNAUTHORIZED',
+        message: 'Authentication required',
+      });
+    }
+
+    // Check if user has required role
+    if (!user.roles?.includes(role)) {
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: `Role '${role}' required`,
+      });
+    }
+
+    return next();
+  };
+};
+
+// Logging middleware
+export const logger: MiddlewareFunction = async ({ ctx, next }) => {
+  const start = Date.now();
+  
+  console.log(`📝 ${ctx.req.method} ${ctx.req.url} - ${new Date().toISOString()}`);
+  
+  try {
+    const result = await next();
+    const duration = Date.now() - start;
+    console.log(`✅ Request completed in ${duration}ms`);
+    return result;
+  } catch (error) {
+    const duration = Date.now() - start;
+    console.log(`❌ Request failed in ${duration}ms:`, error);
+    throw error;
+  }
+};
+
+// Rate limiting middleware (simple in-memory implementation)
+const requestCounts = new Map<string, { count: number; resetTime: number }>();
+
+export const rateLimit = (maxRequests: number, windowMs: number): MiddlewareFunction => {
+  return async ({ ctx, next }) => {
+    const clientId = ctx.req.ip || 'unknown';
+    const now = Date.now();
+    
+    const clientData = requestCounts.get(clientId);
+    
+    if (!clientData || now > clientData.resetTime) {
+      // Reset or initialize
+      requestCounts.set(clientId, {
+        count: 1,
+        resetTime: now + windowMs,
+      });
+    } else {
+      clientData.count++;
+      
+      if (clientData.count > maxRequests) {
+        throw new TRPCError({
+          code: 'TOO_MANY_REQUESTS',
+          message: 'Rate limit exceeded',
+        });
+      }
+    }
+    
+    return next();
+  };
+};
+
+// Validation middleware factory
+export const validateInput = <T>(schema: import('zod').ZodSchema<T>) => {
+  const middleware: MiddlewareFunction = async ({ ctx, next }) => {
+    return next();
+  };
+  return middleware;
+};
+
+// Error handling middleware
+export const errorHandler: MiddlewareFunction = async ({ ctx, next }) => {
+  try {
+    return await next();
+  } catch (error) {
+    // Log the error
+    console.error('❌ API Error:', error);
+    
+    // Re-throw tRPC errors as-is
+    if (error instanceof TRPCError) {
+      throw error;
+    }
+    
+    // Convert unknown errors to internal server error
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'An unexpected error occurred',
+      cause: error,
+    });
+  }
+};
+
+// Middleware composer utility
+export const composeMiddleware = (...middlewares: MiddlewareFunction[]): MiddlewareFunction => {
+  return async ({ ctx, next }) => {
+    let index = 0;
+    
+    const runMiddleware = async (currentCtx: Context): Promise<{ ctx: Context }> => {
+      if (index >= middlewares.length) {
+        return next();
+      }
+      
+      const middleware = middlewares[index++];
+      return middleware({
+        ctx: currentCtx,
+        next: () => runMiddleware(currentCtx),
+      });
+    };
+    
+    return runMiddleware(ctx);
+  };
+}; 

package/templates/api/src/middleware/auth.ts

@@ -0,0 +1,75 @@
+import { TRPCError } from '@trpc/server';
+import type { Context } from '../context.js';
+import type { MiddlewareFn } from '../lib/controller.js';
+
+// Extended context with user
+export interface AuthContext extends Context {
+  user: {
+    id: string;
+    email: string;
+    roles?: string[];
+  };
+}
+
+// Authentication middleware
+export const requireAuth: MiddlewareFn = async ({ ctx, next }) => {
+  const authHeader = ctx.req.headers.authorization;
+  
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    throw new TRPCError({
+      code: 'UNAUTHORIZED',
+      message: 'Missing or invalid authorization header',
+    });
+  }
+
+  const token = authHeader.substring(7);
+  
+  // Here you would validate the token (JWT, session, etc.)
+  // For example purposes, we'll simulate token validation
+  if (!token || token === 'invalid') {
+    throw new TRPCError({
+      code: 'UNAUTHORIZED',
+      message: 'Invalid token',
+    });
+  }
+
+  // Mock user lookup - replace with your actual implementation
+  const user = {
+    id: 'user-123',
+    email: 'user@example.com',
+    roles: ['user'],
+  };
+
+  return next({
+    ctx: {
+      ...ctx,
+      user,
+    } as AuthContext,
+  });
+};
+
+// Role-based authorization middleware factory
+export const requireRole = (requiredRole: string): MiddlewareFn => {
+  return async ({ ctx, next }) => {
+    const authCtx = ctx as AuthContext;
+    
+    if (!authCtx.user) {
+      throw new TRPCError({
+        code: 'UNAUTHORIZED',
+        message: 'Authentication required',
+      });
+    }
+
+    if (!authCtx.user.roles?.includes(requiredRole)) {
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: `Role '${requiredRole}' required`,
+      });
+    }
+
+    return next();
+  };
+};
+
+// Admin role middleware
+export const requireAdmin = requireRole('admin'); 

package/templates/api/src/middleware/common.ts

@@ -0,0 +1,103 @@
+import type { Context } from '../context.js';
+import type { MiddlewareFn } from '../lib/controller.js';
+
+// Logging middleware
+export const logger: MiddlewareFn = async ({ ctx, next }) => {
+  const start = Date.now();
+  const { method, url } = ctx.req;
+  
+  console.log(`📝 ${method} ${url} - ${new Date().toISOString()}`);
+  
+  try {
+    const result = await next();
+    const duration = Date.now() - start;
+    console.log(`✅ Request completed in ${duration}ms`);
+    return result;
+  } catch (error) {
+    const duration = Date.now() - start;
+    console.log(`❌ Request failed in ${duration}ms:`, error);
+    throw error;
+  }
+};
+
+// Simple rate limiting middleware (in-memory)
+const requestCounts = new Map<string, { count: number; resetTime: number }>();
+
+export const rateLimit = (maxRequests: number = 100, windowMs: number = 15 * 60 * 1000): MiddlewareFn => {
+  return async ({ ctx, next }) => {
+    const clientId = ctx.req.ip || ctx.req.socket.remoteAddress || 'unknown';
+    const now = Date.now();
+    
+    const clientData = requestCounts.get(clientId);
+    
+    if (!clientData || now > clientData.resetTime) {
+      // Reset or initialize
+      requestCounts.set(clientId, {
+        count: 1,
+        resetTime: now + windowMs,
+      });
+    } else {
+      clientData.count++;
+      
+      if (clientData.count > maxRequests) {
+        throw new Error('Rate limit exceeded');
+      }
+    }
+    
+    return next();
+  };
+};
+
+// CORS middleware (though this should typically be handled at Express level)
+export const cors: MiddlewareFn = async ({ ctx, next }) => {
+  // Set CORS headers (note: this is just for demonstration)
+  // In practice, use the cors Express middleware
+  ctx.res.setHeader('Access-Control-Allow-Origin', '*');
+  ctx.res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+  ctx.res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+  
+  return next();
+};
+
+// Error handling middleware
+export const errorHandler: MiddlewareFn = async ({ ctx, next }) => {
+  try {
+    return await next();
+  } catch (error) {
+    // Log the error
+    console.error('❌ API Error:', error);
+    
+    // Re-throw the error (tRPC will handle it properly)
+    throw error;
+  }
+};
+
+// Response time header middleware
+export const responseTime: MiddlewareFn = async ({ ctx, next }) => {
+  const start = Date.now();
+  
+  const result = await next();
+  
+  const duration = Date.now() - start;
+  ctx.res.setHeader('X-Response-Time', `${duration}ms`);
+  
+  return result;
+};
+
+// Request ID middleware
+export const requestId: MiddlewareFn = async ({ ctx, next }) => {
+  const id = Math.random().toString(36).substring(2, 15);
+  
+  // Add request ID to context
+  const newCtx = {
+    ...ctx,
+    requestId: id,
+  };
+  
+  // Set response header
+  ctx.res.setHeader('X-Request-ID', id);
+  
+  return next({
+    ctx: newCtx,
+  });
+}; 

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

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+import { router, publicProcedure } from '../trpc.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',
+    };
+  }),
+
+  // Add your procedures here
+  // Example:
+  // users: userRouter,
+  // posts: postRouter,
+
+  // Example controller integration:
+  // Uncomment the lines below and create the corresponding controllers
+  
+  // 1. Import your controllers at the top:
+  // import { userRouter } from '../controllers/UserController.js';
+  
+  // 2. Add them to the router:
+  // users: userRouter,
+});
+
+// Export type definition of API
+export type AppRouter = typeof appRouter;
+
+/*
+CONTROLLER & MIDDLEWARE SYSTEM USAGE:
+
+This API template includes a controller and middleware system that works seamlessly with tRPC.
+
+## Quick Start with Controllers:
+
+1. Create a controller (see src/controllers/UserController.ts for example):
+
+```typescript
+import { z } from 'zod';
+import { BaseController, controllerToRouter } from '../lib/controller.js';
+import { requireAuth } from '../middleware/auth.js';
+
+export class UserController extends BaseController {
+  getAll = this.createQueryWithMiddleware(
+    z.object({}),
+    [requireAuth],
+    async (input, ctx) => {
+      return await ctx.prisma.user.findMany();
+    }
+  );
+}
+
+export const userRouter = controllerToRouter({
+  getAll: new UserController({} as any).getAll,
+});
+```
+
+2. Add to main router:
+
+```typescript
+import { userRouter } from '../controllers/UserController.js';
+
+export const appRouter = router({
+  users: userRouter,
+  // ... other routes
+});
+```
+
+## Available Middleware:
+
+### Authentication:
+- `requireAuth` - Requires Bearer token
+- `requireRole(role)` - Requires specific role
+- `requireAdmin` - Requires admin role
+
+### Utility:
+- `logger` - Request/response logging
+- `rateLimit(max, window)` - Rate limiting
+- `responseTime` - Adds response time header
+- `requestId` - Adds unique request ID
+- `errorHandler` - Centralized error handling
+
+## Usage Examples:
+
+```typescript
+// Public endpoint
+getPublicData = this.createQuery(schema, handler);
+
+// Protected endpoint
+getPrivateData = this.createQueryWithMiddleware(
+  schema,
+  [requireAuth],
+  handler
+);
+
+// Admin-only endpoint
+adminAction = this.createMutationWithMiddleware(
+  schema,
+  [requireAuth, requireAdmin],
+  handler
+);
+
+// Multiple middleware
+complexEndpoint = this.createQueryWithMiddleware(
+  schema,
+  [logger, rateLimit(10, 60000), requireAuth],
+  handler
+);
+```
+
+This system provides:
+✅ Type safety with tRPC
+✅ Reusable middleware
+✅ Clean controller organization
+✅ Easy testing
+✅ Consistent error handling
+*/ 

package/templates/api/src/server.ts

@@ -0,0 +1,50 @@
+import express from 'express';
+import cors from 'cors';
+import { createExpressMiddleware } from '@trpc/server/adapters/express';
+import { appRouter } from './router/index.js';
+import { createContext } from './context.js';
+import dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// CORS configuration
+app.use(cors({
+  origin: process.env.CORS_ORIGIN || 'http://localhost:3000',
+  credentials: true,
+}));
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({ status: 'OK', timestamp: new Date().toISOString() });
+});
+
+// tRPC middleware
+app.use(
+  '/trpc',
+  createExpressMiddleware({
+    router: appRouter,
+    createContext,
+  })
+);
+
+// Default route
+app.get('/', (req, res) => {
+  res.json({
+    message: 'Welcome to {{projectName}} API',
+    endpoints: {
+      health: '/health',
+      trpc: '/trpc',
+      playground: '/trpc-playground' // Available in development
+    }
+  });
+});
+
+app.listen(PORT, () => {
+  console.log(`🚀 Server running on http://localhost:${PORT}`);
+  console.log(`📡 tRPC API available at http://localhost:${PORT}/trpc`);
+  console.log(`🏥 Health check at http://localhost:${PORT}/health`);
+}); 

package/templates/api/src/trpc.ts

@@ -0,0 +1,28 @@
+import { initTRPC } from '@trpc/server';
+import { type Context } from './context.js';
+import { ZodError } from 'zod';
+
+const t = initTRPC.context<Context>().create({
+  errorFormatter({ shape, error }) {
+    return {
+      ...shape,
+      data: {
+        ...shape.data,
+        zodError:
+          error.cause instanceof ZodError ? error.cause.flatten() : null,
+      },
+    };
+  },
+});
+
+// Export reusable router and procedure helpers
+export const router = t.router;
+export const publicProcedure = t.procedure;
+
+// You can create additional procedures with middleware here
+// For example, a protected procedure that requires authentication:
+// export const protectedProcedure = t.procedure.use(async ({ ctx, next }) => {
+//   // Add your authentication logic here
+//   // Example: check for valid session/token
+//   return next({ ctx: { ...ctx, user: { id: 'user-id' } } });
+// }); 

package/templates/api/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "allowJs": true,
+    "checkJs": false,
+    "jsx": "preserve",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "removeComments": false,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    "useUnknownInCatchVariables": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ],
+  "ts-node": {
+    "esm": true
+  }
+} 

package/templates/native/.yarnrc.yml

@@ -1,19 +1,19 @@
-nodeLinker: "node-modules"
-
-# Enable network for package downloads
-enableNetwork: true
-
-# Timeout for HTTP requests (in milliseconds)
-httpTimeout: 60000
-
-# Number of retry attempts for HTTP requests
-httpRetry: 3
-
-# Registry configuration
-npmRegistryServer: "https://registry.yarnpkg.com"
-
-# Enable progress bars
-enableProgressBars: true
-
-# Enable colors in output
+nodeLinker: "node-modules"
+
+# Enable network for package downloads
+enableNetwork: true
+
+# Timeout for HTTP requests (in milliseconds)
+httpTimeout: 60000
+
+# Number of retry attempts for HTTP requests
+httpRetry: 3
+
+# Registry configuration
+npmRegistryServer: "https://registry.yarnpkg.com"
+
+# Enable progress bars
+enableProgressBars: true
+
+# Enable colors in output
 enableColors: true 

package/templates/native/App.tsx

@@ -1,23 +1,23 @@
-import React from 'react';
-import {
-  SafeAreaView,
-} from 'react-native';
-
-import { ExampleStackRouter } from '@idealyst/navigation/examples';
-import { NavigatorProvider } from '@idealyst/navigation';
-
-
-function App() {  
-
-  const backgroundStyle = {
-    flex: 1,
-  };
-
-  return (
-    <SafeAreaView style={backgroundStyle}>
-      <NavigatorProvider route={ExampleStackRouter} />
-    </SafeAreaView>
-  );
-}
-
-export default App;
+import React from 'react';
+import {
+  SafeAreaView,
+} from 'react-native';
+
+import { ExampleStackRouter } from '@idealyst/navigation/examples';
+import { NavigatorProvider } from '@idealyst/navigation';
+
+
+function App() {  
+
+  const backgroundStyle = {
+    flex: 1,
+  };
+
+  return (
+    <SafeAreaView style={backgroundStyle}>
+      <NavigatorProvider route={ExampleStackRouter} />
+    </SafeAreaView>
+  );
+}
+
+export default App;