create-blitzpack 0.1.0

package/template/apps/web/src/config/landing-data.ts

@@ -0,0 +1,152 @@
+export const features = [
+  {
+    iconName: 'Rocket' as const,
+    title: 'Production Ready',
+    description:
+      'Helmet security, rate limiting, CORS, validated environment configs, and GitHub Actions CI/CD',
+  },
+  {
+    iconName: 'Zap' as const,
+    title: 'Fast Development',
+    description:
+      'Turborepo for optimized builds and pnpm for efficient package management',
+  },
+  {
+    iconName: 'Shield' as const,
+    title: 'Type Safe',
+    description:
+      'Zod schemas with TypeScript everywhere for runtime and compile-time safety',
+  },
+  {
+    iconName: 'Code2' as const,
+    title: 'Modern UI Components',
+    description:
+      'shadcn/ui with Radix primitives, Tailwind v4, dark mode, and Framer Motion',
+  },
+  {
+    iconName: 'Workflow' as const,
+    title: 'Database Ready',
+    description:
+      'Prisma ORM with PostgreSQL, migrations, better-auth and Docker setup',
+  },
+  {
+    iconName: 'Lock' as const,
+    title: 'Authentication',
+    description:
+      'Better-auth with email/password, session management and OAuth support',
+  },
+  {
+    iconName: 'TestTube' as const,
+    title: 'Comprehensive Testing',
+    description:
+      'Vitest for unit and integration tests with coverage reports across all packages',
+  },
+  {
+    iconName: 'PackageOpen' as const,
+    title: 'Shared Packages',
+    description: 'Types and utilities shared across web and backend',
+  },
+  {
+    iconName: 'Bot' as const,
+    title: 'AI-Assisted Development',
+    description:
+      'Comprehensive CLAUDE.md enables instant onboarding for AI coding assistants',
+  },
+] as const;
+
+export const techStack = {
+  web: {
+    title: 'Web',
+    items: [
+      'Next.js 16',
+      'React 19',
+      'TypeScript',
+      'Tailwind CSS v4',
+      'shadcn/ui',
+      'TanStack Query',
+      'Zod',
+      'Jotai',
+      'React Hook Form',
+      'Framer Motion',
+      'Sonner',
+      'next-themes',
+    ],
+  },
+  api: {
+    title: 'API',
+    items: [
+      'Fastify 5',
+      'TypeScript',
+      'Prisma 7',
+      'PostgreSQL',
+      'Better-auth',
+      'Zod',
+      'Scalar Docs',
+      'Helmet',
+      'Rate Limiting',
+      'CORS',
+    ],
+  },
+  sharedPackages: {
+    title: 'Shared Packages',
+    items: ['Zod Schemas', 'Utility Functions', 'Type Definitions'],
+  },
+  devOps: {
+    title: 'DevOps',
+    items: [
+      'Turborepo',
+      'pnpm Workspaces',
+      'Vitest',
+      'GitHub Actions CI',
+      'ESLint',
+      'Prettier',
+      'Husky + lint-staged',
+    ],
+  },
+} as const;
+
+export const quickStartCommands: Array<{
+  command: string;
+  tooltip?: string;
+}> = [
+  {
+    command: 'pnpm install',
+  },
+  {
+    command: 'pnpm init:project',
+    tooltip:
+      'Automated setup: checks prerequisites, creates environment files, starts Docker containers, runs database migrations, and optionally seeds data',
+  },
+  {
+    command: 'pnpm dev',
+  },
+];
+
+export const includedFeatures = [
+  {
+    iconName: 'Lock' as const,
+    title: 'Authentication System',
+    pages: [
+      { name: 'Sign in', href: '/login' },
+      { name: 'Sign up', href: '/signup' },
+      { name: 'Forgot password', href: '/forgot-password' },
+    ],
+  },
+  {
+    iconName: 'LayoutDashboard' as const,
+    title: 'User Dashboard',
+    pages: [
+      { name: 'Dashboard', href: '/dashboard' },
+      { name: 'Change password', href: '/dashboard/change-password' },
+    ],
+  },
+  {
+    iconName: 'ShieldCheck' as const,
+    title: 'Admin Dashboard',
+    pages: [
+      { name: 'System monitoring', href: '/admin' },
+      { name: 'User management', href: '/admin/users' },
+      { name: 'Sessions management', href: '/admin/sessions' },
+    ],
+  },
+] as const;

package/template/apps/web/src/config/site.ts

@@ -0,0 +1,5 @@
+export const siteConfig = {
+  name: 'Blitzpack',
+  description: 'Production-ready TypeScript monorepo template',
+  github: 'https://github.com/CarboxyDev/blitzpack',
+} as const;

package/template/apps/web/src/hooks/api/__tests__/use-users.test.tsx

@@ -0,0 +1,181 @@
+import type { PaginatedResponse } from '@repo/packages-types/pagination';
+import type { CreateUser, User } from '@repo/packages-types/user';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  useCreateUser,
+  useFetchUser,
+  useFetchUsers,
+  userKeys,
+} from '@/hooks/api/use-users';
+import * as apiModule from '@/lib/api';
+
+vi.mock('@/lib/api', () => ({
+  api: {
+    get: vi.fn(),
+    post: vi.fn(),
+  },
+  isApiError: vi.fn(),
+  getErrorMessage: vi.fn(),
+  ApiError: class ApiError extends Error {
+    constructor(
+      message: string,
+      public status: number,
+      public data?: unknown
+    ) {
+      super(message);
+      this.name = 'ApiError';
+    }
+  },
+}));
+
+const createWrapper = () => {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: { retry: false },
+      mutations: { retry: false },
+    },
+  });
+
+  const Wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+  Wrapper.displayName = 'TestWrapper';
+  return Wrapper;
+};
+
+describe('useUsers API Hooks', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('useFetchUsers', () => {
+    it('should fetch paginated users successfully', async () => {
+      const mockResponse: PaginatedResponse<User> = {
+        data: [
+          {
+            id: '123',
+            email: 'test@example.com',
+            name: 'Test User',
+            createdAt: '2024-01-01T00:00:00Z',
+            updatedAt: '2024-01-01T00:00:00Z',
+            role: 'user',
+          },
+        ],
+        pagination: {
+          page: 1,
+          limit: 10,
+          total: 1,
+          totalPages: 1,
+        },
+      };
+
+      vi.spyOn(apiModule.api, 'get').mockResolvedValue(mockResponse);
+
+      const { result } = renderHook(
+        () =>
+          useFetchUsers({
+            page: 1,
+            limit: 10,
+            sortBy: 'createdAt',
+            sortOrder: 'desc',
+          }),
+        { wrapper: createWrapper() }
+      );
+
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+      expect(result.current.data).toEqual(mockResponse);
+      expect(apiModule.api.get).toHaveBeenCalledWith('/users', {
+        params: { page: 1, limit: 10, sortBy: 'createdAt', sortOrder: 'desc' },
+      });
+    });
+
+    it('should use correct query key for caching', () => {
+      const params = {
+        page: 1,
+        limit: 10,
+        sortBy: 'createdAt' as const,
+        sortOrder: 'desc' as const,
+      };
+      const key = userKeys.list(params);
+
+      expect(key).toEqual(['users', 'list', params]);
+    });
+  });
+
+  describe('useFetchUser', () => {
+    it('should fetch a single user by ID', async () => {
+      const mockUser: User = {
+        id: '123',
+        email: 'test@example.com',
+        name: 'Test User',
+        createdAt: '2024-01-01T00:00:00Z',
+        updatedAt: '2024-01-01T00:00:00Z',
+        role: 'user',
+      };
+
+      vi.spyOn(apiModule.api, 'get').mockResolvedValue(mockUser);
+
+      const { result } = renderHook(() => useFetchUser('123'), {
+        wrapper: createWrapper(),
+      });
+
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+      expect(result.current.data).toEqual(mockUser);
+      expect(apiModule.api.get).toHaveBeenCalledWith('/users/123');
+    });
+
+    it('should not fetch if ID is empty', () => {
+      const { result } = renderHook(() => useFetchUser(''), {
+        wrapper: createWrapper(),
+      });
+
+      expect(result.current.fetchStatus).toBe('idle');
+      expect(apiModule.api.get).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('useCreateUser', () => {
+    it('should create a new user', async () => {
+      const newUser: CreateUser = {
+        name: 'New User',
+        email: 'new@example.com',
+        role: 'user',
+      };
+
+      const mockResponse: User = {
+        id: '456',
+        ...newUser,
+        createdAt: '2024-01-01T00:00:00Z',
+        updatedAt: '2024-01-01T00:00:00Z',
+      };
+
+      vi.spyOn(apiModule.api, 'post').mockResolvedValue(mockResponse);
+
+      const { result } = renderHook(() => useCreateUser(), {
+        wrapper: createWrapper(),
+      });
+
+      result.current.mutate(newUser);
+
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+      expect(result.current.data).toEqual(mockResponse);
+      expect(apiModule.api.post).toHaveBeenCalledWith('/users', newUser);
+    });
+  });
+
+  describe('userKeys', () => {
+    it('should generate correct query keys', () => {
+      expect(userKeys.all).toEqual(['users']);
+      expect(userKeys.lists()).toEqual(['users', 'list']);
+      expect(userKeys.details()).toEqual(['users', 'detail']);
+      expect(userKeys.detail('123')).toEqual(['users', 'detail', '123']);
+    });
+  });
+});

package/template/apps/web/src/hooks/api/use-admin-sessions.ts

@@ -0,0 +1,75 @@
+import type { PaginatedResponse } from '@repo/packages-types/pagination';
+import type {
+  AdminSession,
+  QuerySessions,
+  SessionStats,
+} from '@repo/packages-types/session';
+import {
+  useMutation,
+  useQuery,
+  useQueryClient,
+  type UseQueryOptions,
+} from '@tanstack/react-query';
+
+import { api } from '@/lib/api';
+
+export const adminSessionKeys = {
+  all: ['adminSessions'] as const,
+  lists: () => [...adminSessionKeys.all, 'list'] as const,
+  list: (params: QuerySessions) =>
+    [...adminSessionKeys.lists(), params] as const,
+  stats: () => [...adminSessionKeys.all, 'stats'] as const,
+};
+
+export function useFetchAdminSessions(
+  params: QuerySessions,
+  options?: Omit<
+    UseQueryOptions<PaginatedResponse<AdminSession>>,
+    'queryKey' | 'queryFn'
+  >
+) {
+  return useQuery({
+    queryKey: adminSessionKeys.list(params),
+    queryFn: () =>
+      api.get<PaginatedResponse<AdminSession>>('/admin/sessions', {
+        params: params as Record<string, string | number | boolean>,
+      }),
+    ...options,
+  });
+}
+
+export function useFetchSessionStats(
+  options?: Omit<UseQueryOptions<SessionStats>, 'queryKey' | 'queryFn'>
+) {
+  return useQuery({
+    queryKey: adminSessionKeys.stats(),
+    queryFn: () => api.get<SessionStats>('/admin/sessions/stats'),
+    ...options,
+  });
+}
+
+export function useRevokeSession() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (sessionId: string) =>
+      api.delete(`/admin/sessions/${sessionId}`),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: adminSessionKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: adminSessionKeys.stats() });
+    },
+  });
+}
+
+export function useRevokeUserSessions() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (userId: string) =>
+      api.delete(`/admin/sessions/user/${userId}`),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: adminSessionKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: adminSessionKeys.stats() });
+    },
+  });
+}

package/template/apps/web/src/hooks/api/use-admin-stats.ts

@@ -0,0 +1,33 @@
+import type {
+  HealthCheckResponse,
+  SystemStats,
+} from '@repo/packages-types/stats';
+import { useQuery, type UseQueryOptions } from '@tanstack/react-query';
+
+import { api } from '@/lib/api';
+
+export const adminStatsKeys = {
+  all: ['adminStats'] as const,
+  stats: () => [...adminStatsKeys.all, 'stats'] as const,
+  health: () => [...adminStatsKeys.all, 'health'] as const,
+};
+
+export function useFetchSystemStats(
+  options?: Omit<UseQueryOptions<SystemStats>, 'queryKey' | 'queryFn'>
+) {
+  return useQuery({
+    queryKey: adminStatsKeys.stats(),
+    queryFn: () => api.get<SystemStats>('/admin/stats'),
+    ...options,
+  });
+}
+
+export function useFetchHealthCheck(
+  options?: Omit<UseQueryOptions<HealthCheckResponse>, 'queryKey' | 'queryFn'>
+) {
+  return useQuery({
+    queryKey: adminStatsKeys.health(),
+    queryFn: () => api.get<HealthCheckResponse>('/admin/stats/health'),
+    ...options,
+  });
+}

package/template/apps/web/src/hooks/api/use-sessions.ts

@@ -0,0 +1,52 @@
+import type {
+  ListResponse,
+  MessageResponse,
+} from '@repo/packages-types/api-response';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+
+import { fetcher } from '@/lib/api';
+
+export interface SessionInfo {
+  id: string;
+  ipAddress: string | null;
+  userAgent: string | null;
+  createdAt: string;
+  updatedAt: string;
+  expiresAt: string;
+  isCurrent?: boolean;
+}
+
+export function useGetSessions() {
+  return useQuery<ListResponse<SessionInfo>>({
+    queryKey: ['sessions'],
+    queryFn: () => fetcher<ListResponse<SessionInfo>>('/sessions'),
+  });
+}
+
+export function useDeleteSession() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (sessionId: string) =>
+      fetcher<MessageResponse>(`/sessions/${sessionId}`, {
+        method: 'DELETE',
+      }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['sessions'] });
+    },
+  });
+}
+
+export function useRevokeAllSessions() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: () =>
+      fetcher<MessageResponse>('/sessions', {
+        method: 'DELETE',
+      }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['sessions'] });
+    },
+  });
+}

package/template/apps/web/src/hooks/api/use-uploads.ts

@@ -0,0 +1,156 @@
+import type {
+  DeleteUploadParams,
+  GetUploadsQuery,
+  Upload,
+  UploadResponse,
+  UploadStats,
+} from '@repo/packages-types/upload';
+import {
+  useMutation,
+  type UseMutationOptions,
+  useQuery,
+  useQueryClient,
+  type UseQueryOptions,
+} from '@tanstack/react-query';
+
+import { api } from '@/lib/api';
+
+/**
+ * Query Keys
+ * Centralized query keys for cache management and invalidation
+ */
+export const uploadKeys = {
+  all: ['uploads'] as const,
+  lists: () => [...uploadKeys.all, 'list'] as const,
+  list: (params: GetUploadsQuery) => [...uploadKeys.lists(), params] as const,
+  stats: () => [...uploadKeys.all, 'stats'] as const,
+};
+
+/**
+ * Fetch user's uploads
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useFetchUploads({ limit: 50, offset: 0 });
+ * ```
+ */
+export function useFetchUploads(
+  params: GetUploadsQuery = { limit: 50, offset: 0 },
+  options?: Omit<UseQueryOptions<Upload[]>, 'queryKey' | 'queryFn'>
+) {
+  return useQuery({
+    queryKey: uploadKeys.list(params),
+    queryFn: async () => {
+      const searchParams = new globalThis.URLSearchParams({
+        limit: String(params.limit),
+        offset: String(params.offset),
+      });
+
+      return api.get<Upload[]>(`/uploads?${searchParams.toString()}`);
+    },
+    ...options,
+  });
+}
+
+/**
+ * Fetch upload statistics
+ *
+ * @example
+ * ```tsx
+ * const { data: stats } = useFetchUploadStats();
+ * // stats: { totalFiles: 10, totalSize: 5242880 }
+ * ```
+ */
+export function useFetchUploadStats(
+  options?: Omit<UseQueryOptions<UploadStats>, 'queryKey' | 'queryFn'>
+) {
+  return useQuery({
+    queryKey: uploadKeys.stats(),
+    queryFn: () => api.get<UploadStats>('/uploads/stats'),
+    ...options,
+  });
+}
+
+/**
+ * Upload a file
+ *
+ * @example
+ * ```tsx
+ * const uploadMutation = useUploadFile();
+ *
+ * const handleUpload = (file: File) => {
+ *   uploadMutation.mutate(file, {
+ *     onSuccess: (data) => console.log('Uploaded:', data.url),
+ *     onError: (error) => console.error('Upload failed:', error)
+ *   });
+ * };
+ * ```
+ */
+export function useUploadFile(
+  options?: Omit<
+    UseMutationOptions<UploadResponse, Error, globalThis.File>,
+    'mutationFn'
+  >
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (file: globalThis.File) => {
+      const formData = new globalThis.FormData();
+      formData.append('file', file);
+
+      const response = await fetch(
+        `${process.env.NEXT_PUBLIC_API_URL}/uploads`,
+        {
+          method: 'POST',
+          body: formData,
+          credentials: 'include',
+        }
+      );
+
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error?.message || 'Upload failed');
+      }
+
+      return response.json();
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: uploadKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: uploadKeys.stats() });
+    },
+    ...options,
+  });
+}
+
+/**
+ * Delete an upload
+ *
+ * @example
+ * ```tsx
+ * const deleteMutation = useDeleteUpload();
+ *
+ * const handleDelete = (uploadId: string) => {
+ *   deleteMutation.mutate({ id: uploadId });
+ * };
+ * ```
+ */
+export function useDeleteUpload(
+  options?: Omit<
+    UseMutationOptions<void, Error, DeleteUploadParams>,
+    'mutationFn'
+  >
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({ id }: DeleteUploadParams) => {
+      await api.delete(`/uploads/${id}`);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: uploadKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: uploadKeys.stats() });
+    },
+    ...options,
+  });
+}