@idealyst/cli 1.0.46 → 1.0.48

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

@@ -1,102 +0,0 @@
-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/dist/templates/api/src/lib/controller.ts

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

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

@@ -1,170 +0,0 @@
-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/dist/templates/api/src/middleware/auth.ts

@@ -1,75 +0,0 @@
-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/dist/templates/api/src/middleware/common.ts

@@ -1,103 +0,0 @@
-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/dist/templates/database/.env.example

@@ -1 +0,0 @@
-DATABASE_URL="sqlite:./dev.db"

package/dist/templates/native/App.tsx

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

package/dist/templates/native/src/App-with-trpc-and-shared.tsx

@@ -1,12 +0,0 @@
-import React from 'react';
-
-// Import shared components
-import { HelloWorld } from '@{{workspaceScope}}/shared';
-
-function App() {
-  return (
-    <HelloWorld name="{{projectName}} Mobile User" platform="mobile" projectName="{{projectName}}" />
-  );
-}
-
-export default App;

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

@@ -1,102 +0,0 @@
-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,
-});