@idealyst/cli 1.0.45 → 1.0.48

package/dist/templates/shared/src/utils/index.ts

@@ -1,278 +0,0 @@
-// Date and time utilities
-export const formatDate = (date: Date | string): string => {
-  const d = typeof date === 'string' ? new Date(date) : date;
-  return d.toLocaleDateString('en-US', {
-    year: 'numeric',
-    month: 'long',
-    day: 'numeric'
-  });
-};
-
-export const formatDateTime = (date: Date | string): string => {
-  const d = typeof date === 'string' ? new Date(date) : date;
-  return d.toLocaleString('en-US', {
-    year: 'numeric',
-    month: 'short',
-    day: 'numeric',
-    hour: '2-digit',
-    minute: '2-digit'
-  });
-};
-
-export const formatRelativeTime = (date: Date | string): string => {
-  const d = typeof date === 'string' ? new Date(date) : date;
-  const now = new Date();
-  const diffInSeconds = Math.floor((now.getTime() - d.getTime()) / 1000);
-  
-  if (diffInSeconds < 60) return 'just now';
-  if (diffInSeconds < 3600) return `${Math.floor(diffInSeconds / 60)} minutes ago`;
-  if (diffInSeconds < 86400) return `${Math.floor(diffInSeconds / 3600)} hours ago`;
-  if (diffInSeconds < 2592000) return `${Math.floor(diffInSeconds / 86400)} days ago`;
-  return formatDate(d);
-};
-
-// String utilities
-export const truncateText = (text: string, maxLength: number): string => {
-  if (text.length <= maxLength) return text;
-  return text.substring(0, maxLength).trim() + '...';
-};
-
-export const capitalizeFirst = (text: string): string => {
-  if (!text) return text;
-  return text.charAt(0).toUpperCase() + text.slice(1);
-};
-
-export const slugify = (text: string): string => {
-  return text
-    .toLowerCase()
-    .replace(/[^\w\s-]/g, '') // Remove special chars
-    .replace(/[\s_-]+/g, '-') // Replace spaces and underscores with hyphens
-    .replace(/^-+|-+$/g, ''); // Remove leading/trailing hyphens
-};
-
-// Array utilities
-export const paginate = <T>(array: T[], page: number, pageSize: number) => {
-  const startIndex = (page - 1) * pageSize;
-  const endIndex = startIndex + pageSize;
-  
-  return {
-    items: array.slice(startIndex, endIndex),
-    total: array.length,
-    page,
-    pageSize,
-    hasMore: endIndex < array.length,
-    totalPages: Math.ceil(array.length / pageSize)
-  };
-};
-
-export const sortBy = <T>(array: T[], key: keyof T, order: 'asc' | 'desc' = 'asc'): T[] => {
-  return [...array].sort((a, b) => {
-    const aVal = a[key];
-    const bVal = b[key];
-    
-    if (aVal < bVal) return order === 'asc' ? -1 : 1;
-    if (aVal > bVal) return order === 'asc' ? 1 : -1;
-    return 0;
-  });
-};
-
-// Object utilities
-export const pick = <T extends object, K extends keyof T>(
-  obj: T,
-  keys: K[]
-): Pick<T, K> => {
-  const result = {} as Pick<T, K>;
-  keys.forEach(key => {
-    if (key in obj) {
-      result[key] = obj[key];
-    }
-  });
-  return result;
-};
-
-export const omit = <T extends object, K extends keyof T>(
-  obj: T,
-  keys: K[]
-): Omit<T, K> => {
-  const result = { ...obj };
-  keys.forEach(key => {
-    delete result[key];
-  });
-  return result as Omit<T, K>;
-};
-
-// Validation utilities
-export const isValidEmail = (email: string): boolean => {
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailRegex.test(email);
-};
-
-export const isValidUrl = (url: string): boolean => {
-  try {
-    new URL(url);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-// Local storage utilities (with fallbacks for environments without localStorage)
-export const storage = {
-  get: (key: string): string | null => {
-    try {
-      if (typeof localStorage !== 'undefined') {
-        return localStorage.getItem(key);
-      }
-    } catch (error) {
-      console.warn('localStorage not available:', error);
-    }
-    return null;
-  },
-  
-  set: (key: string, value: string): void => {
-    try {
-      if (typeof localStorage !== 'undefined') {
-        localStorage.setItem(key, value);
-      }
-    } catch (error) {
-      console.warn('localStorage not available:', error);
-    }
-  },
-  
-  remove: (key: string): void => {
-    try {
-      if (typeof localStorage !== 'undefined') {
-        localStorage.removeItem(key);
-      }
-    } catch (error) {
-      console.warn('localStorage not available:', error);
-    }
-  },
-  
-  getObject: <T>(key: string): T | null => {
-    const value = storage.get(key);
-    if (value) {
-      try {
-        return JSON.parse(value);
-      } catch (error) {
-        console.warn('Failed to parse stored object:', error);
-      }
-    }
-    return null;
-  },
-  
-  setObject: <T>(key: string, value: T): void => {
-    try {
-      storage.set(key, JSON.stringify(value));
-    } catch (error) {
-      console.warn('Failed to stringify object for storage:', error);
-    }
-  }
-};
-
-// Debounce utility for search and input handling
-export const debounce = <T extends (...args: any[]) => any>(
-  func: T,
-  delay: number
-): ((...args: Parameters<T>) => void) => {
-  let timeoutId: NodeJS.Timeout;
-  
-  return (...args: Parameters<T>) => {
-    clearTimeout(timeoutId);
-    timeoutId = setTimeout(() => func(...args), delay);
-  };
-};
-
-// Theme utilities
-export const getSystemTheme = (): 'light' | 'dark' => {
-  if (typeof window !== 'undefined' && window.matchMedia) {
-    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
-  }
-  return 'light';
-};
-
-// Error handling utilities
-export const getErrorMessage = (error: unknown): string => {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === 'string') {
-    return error;
-  }
-  return 'An unexpected error occurred';
-};
-
-// Platform detection utilities
-export const isWeb = (): boolean => {
-  return typeof window !== 'undefined';
-};
-
-export const isMobile = (): boolean => {
-  return typeof navigator !== 'undefined' && /Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
-};
-
-// Constants for demo data
-export const DEMO_USERS = [
-  {
-    id: '1',
-    name: 'Alice Johnson',
-    email: 'alice@example.com',
-    avatar: 'https://via.placeholder.com/150/4CAF50/white?text=AJ',
-    bio: 'Full-stack developer passionate about React and TypeScript',
-    location: 'San Francisco, CA',
-    website: 'https://alice-dev.com'
-  },
-  {
-    id: '2', 
-    name: 'Bob Smith',
-    email: 'bob@example.com',
-    avatar: 'https://via.placeholder.com/150/2196F3/white?text=BS',
-    bio: 'UI/UX designer and frontend enthusiast',
-    location: 'New York, NY',
-    website: 'https://bobdesigns.co'
-  },
-  {
-    id: '3',
-    name: 'Carol Williams', 
-    email: 'carol@example.com',
-    avatar: 'https://via.placeholder.com/150/FF9800/white?text=CW',
-    bio: 'Product manager with a love for user research',
-    location: 'Austin, TX'
-  }
-];
-
-export const DEMO_POSTS = [
-  {
-    id: '1',
-    title: 'Getting Started with React Native',
-    content: 'React Native is a powerful framework for building cross-platform mobile applications...',
-    excerpt: 'Learn the basics of React Native development',
-    authorId: '1',
-    tags: ['react-native', 'mobile', 'javascript'],
-    published: true,
-    views: 234,
-    likes: 15
-  },
-  {
-    id: '2',
-    title: 'Design Systems in Modern Web Development',
-    content: 'A design system is a complete set of standards intended to manage design at scale...',
-    excerpt: 'Building consistent user interfaces across applications',
-    authorId: '2', 
-    tags: ['design-systems', 'ui-ux', 'frontend'],
-    published: true,
-    views: 189,
-    likes: 23
-  },
-  {
-    id: '3',
-    title: 'User Research Best Practices',
-    content: 'Understanding your users is crucial for building successful products...',
-    excerpt: 'How to conduct effective user research',
-    authorId: '3',
-    tags: ['user-research', 'product-management', 'ux'],
-    published: true,
-    views: 156,
-    likes: 31
-  }
-];

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,
-}); 

package/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/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/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');