create-blitzpack 0.1.0

package/template/packages/types/src/__tests__/schemas.test.ts

@@ -0,0 +1,255 @@
+import {
+  ListResponseSchema,
+  MessageResponseSchema,
+} from '@repo/packages-types/api-response';
+import { HealthCheckSchema } from '@repo/packages-types/health-check';
+import { CreateUserSchema, UserSchema } from '@repo/packages-types/user';
+import { describe, expect, it } from 'vitest';
+
+describe('HealthCheckSchema', () => {
+  it('should validate a valid health check object', () => {
+    const validHealthCheck = {
+      status: 'ok' as const,
+      timestamp: new Date().toISOString(),
+      version: '1.0.0',
+      uptime: 12345,
+      environment: 'development' as const,
+    };
+
+    const result = HealthCheckSchema.safeParse(validHealthCheck);
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject invalid status', () => {
+    const invalidHealthCheck = {
+      status: 'invalid',
+      timestamp: new Date().toISOString(),
+      version: '1.0.0',
+      uptime: 12345,
+      environment: 'development',
+    };
+
+    const result = HealthCheckSchema.safeParse(invalidHealthCheck);
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject negative uptime', () => {
+    const invalidHealthCheck = {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      version: '1.0.0',
+      uptime: -100,
+      environment: 'development',
+    };
+
+    const result = HealthCheckSchema.safeParse(invalidHealthCheck);
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject invalid environment', () => {
+    const invalidHealthCheck = {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      version: '1.0.0',
+      uptime: 12345,
+      environment: 'invalid',
+    };
+
+    const result = HealthCheckSchema.safeParse(invalidHealthCheck);
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('UserSchema', () => {
+  it('should validate a valid user object with Date', () => {
+    const validUser = {
+      id: 'cm1abc2def3ghi4jkl',
+      email: 'test@example.com',
+      name: 'John Doe',
+      role: 'user' as const,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    const result = UserSchema.safeParse(validUser);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate a valid user object with ISO string dates', () => {
+    const validUser = {
+      id: 'cm1abc2def3ghi4jkl',
+      email: 'test@example.com',
+      name: 'John Doe',
+      role: 'user' as const,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    const result = UserSchema.safeParse(validUser);
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept Better Auth ID format', () => {
+    const validUser = {
+      id: 'auth-1763496954387-0tr9175',
+      email: 'test@example.com',
+      name: 'John Doe',
+      role: 'user' as const,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    const result = UserSchema.safeParse(validUser);
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject empty id', () => {
+    const invalidUser = {
+      id: '',
+      email: 'test@example.com',
+      name: 'John Doe',
+      role: 'user' as const,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    const result = UserSchema.safeParse(invalidUser);
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject invalid email', () => {
+    const invalidUser = {
+      id: 'cm1abc2def3ghi4jkl',
+      email: 'not-an-email',
+      name: 'John Doe',
+      role: 'user' as const,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    const result = UserSchema.safeParse(invalidUser);
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject empty name', () => {
+    const invalidUser = {
+      id: 'cm1abc2def3ghi4jkl',
+      email: 'test@example.com',
+      name: '',
+      role: 'user' as const,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    const result = UserSchema.safeParse(invalidUser);
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('CreateUserSchema', () => {
+  it('should validate user creation without id and timestamps', () => {
+    const validCreateUser = {
+      email: 'new@example.com',
+      name: 'Jane Doe',
+    };
+
+    const result = CreateUserSchema.safeParse(validCreateUser);
+    expect(result.success).toBe(true);
+  });
+
+  it('should omit id, createdAt, and updatedAt fields', () => {
+    const createUserWithExtra = {
+      id: '123e4567-e89b-12d3-a456-426614174000',
+      email: 'new@example.com',
+      name: 'Jane Doe',
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    const result = CreateUserSchema.safeParse(createUserWithExtra);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data).toEqual({
+        email: 'new@example.com',
+        name: 'Jane Doe',
+        role: 'user',
+      });
+    }
+  });
+
+  it('should reject invalid email in create', () => {
+    const invalidCreateUser = {
+      email: 'invalid-email',
+      name: 'Jane Doe',
+    };
+
+    const result = CreateUserSchema.safeParse(invalidCreateUser);
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('MessageResponseSchema', () => {
+  it('should validate message response', () => {
+    const validResponse = {
+      message: 'Operation successful',
+    };
+
+    const result = MessageResponseSchema.safeParse(validResponse);
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject response without message field', () => {
+    const invalidResponse = {
+      data: 'something',
+    };
+
+    const result = MessageResponseSchema.safeParse(invalidResponse);
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('ListResponseSchema', () => {
+  it('should validate list response with data array', () => {
+    const validResponse = {
+      data: [
+        {
+          id: 'cm1abc2def3ghi4jkl',
+          email: 'user1@example.com',
+          name: 'User One',
+          role: 'user' as const,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        {
+          id: 'cm2xyz3abc4def5ghi',
+          email: 'user2@example.com',
+          name: 'User Two',
+          role: 'admin' as const,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ],
+    };
+
+    const result = ListResponseSchema(UserSchema).safeParse(validResponse);
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject response without data field', () => {
+    const invalidResponse = {
+      items: [
+        {
+          id: 'cm1abc2def3ghi4jkl',
+          email: 'user1@example.com',
+          name: 'User One',
+          role: 'user' as const,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ],
+    };
+
+    const result = ListResponseSchema(UserSchema).safeParse(invalidResponse);
+    expect(result.success).toBe(false);
+  });
+});

package/template/packages/types/src/api-response.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+
+/**
+ * Standard error response returned by all API endpoints
+ * Used by global error handler for consistent error formatting
+ */
+export const ErrorResponseSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    code: z.string(),
+    details: z.record(z.string(), z.unknown()).optional(),
+  }),
+});
+
+export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+
+/**
+ * Standard success response wrapper for single items
+ * Used for: GET /users/:id, POST /users, etc.
+ */
+export const SuccessResponseSchema = <T extends z.ZodTypeAny>(dataSchema: T) =>
+  z.object({
+    data: dataSchema,
+  });
+
+export type SuccessResponse<T> = {
+  data: T;
+};
+
+/**
+ * Simple message response for action/command operations
+ * Used for: password changes, session revocations, deletions with confirmation
+ */
+export const MessageResponseSchema = z.object({
+  message: z.string(),
+});
+
+export type MessageResponse = {
+  message: string;
+};
+
+/**
+ * List response for collections without pagination
+ * Used for: sessions list, etc.
+ */
+export const ListResponseSchema = <T extends z.ZodTypeAny>(dataSchema: T) =>
+  z.object({
+    data: z.array(dataSchema),
+  });
+
+export type ListResponse<T> = {
+  data: T[];
+};

package/template/packages/types/src/health-check.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const HealthCheckSchema = z.object({
+  status: z.enum(['ok', 'error']),
+  timestamp: z.string().datetime(),
+  version: z.string(),
+  uptime: z.number().nonnegative(),
+  environment: z.enum(['development', 'staging', 'production']),
+});
+
+export type HealthCheck = z.infer<typeof HealthCheckSchema>;

package/template/packages/types/src/pagination.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+
+export const PaginationSchema = z.object({
+  page: z.coerce.number().int().positive().default(1),
+  limit: z.coerce.number().int().positive().max(100).default(10),
+});
+
+export type Pagination = z.infer<typeof PaginationSchema>;
+
+export const QueryUsersSchema = PaginationSchema.extend({
+  search: z.string().optional(),
+  sortBy: z.enum(['name', 'email', 'createdAt']).default('createdAt'),
+  sortOrder: z.enum(['asc', 'desc']).default('desc'),
+});
+
+export type QueryUsers = z.infer<typeof QueryUsersSchema>;
+
+export const PaginatedResponseSchema = <T extends z.ZodTypeAny>(
+  dataSchema: T
+) =>
+  z.object({
+    data: z.array(dataSchema),
+    pagination: z.object({
+      page: z.number().int().positive(),
+      limit: z.number().int().positive(),
+      total: z.number().int().nonnegative(),
+      totalPages: z.number().int().nonnegative(),
+    }),
+  });
+
+export type PaginationMeta = {
+  page: number;
+  limit: number;
+  total: number;
+  totalPages: number;
+};
+
+export type PaginatedResponse<T> = {
+  data: T[];
+  pagination: PaginationMeta;
+};

package/template/packages/types/src/role.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const RoleSchema = z.enum(['user', 'admin', 'super_admin']);
+
+export type Role = z.infer<typeof RoleSchema>;

package/template/packages/types/src/session.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+
+import { PaginationSchema } from './pagination';
+
+export const AdminSessionSchema = z.object({
+  id: z.string(),
+  userId: z.string(),
+  ipAddress: z.string().nullable(),
+  userAgent: z.string().nullable(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+  expiresAt: z.coerce.date(),
+  user: z.object({
+    id: z.string(),
+    name: z.string().nullable(),
+    email: z.string(),
+    image: z.string().nullable(),
+  }),
+});
+
+export type AdminSession = z.infer<typeof AdminSessionSchema>;
+
+export const QuerySessionsSchema = PaginationSchema.extend({
+  search: z.string().optional(),
+  status: z.enum(['active', 'expired', 'all']).default('active'),
+  userId: z.string().optional(),
+  sortBy: z.enum(['createdAt', 'expiresAt']).default('createdAt'),
+  sortOrder: z.enum(['asc', 'desc']).default('desc'),
+});
+
+export type QuerySessions = z.infer<typeof QuerySessionsSchema>;
+
+export const SessionStatsSchema = z.object({
+  activeSessions: z.number(),
+  uniqueUsers: z.number(),
+  sessionsToday: z.number(),
+  expiringSoon: z.number(),
+});
+
+export type SessionStats = z.infer<typeof SessionStatsSchema>;
+
+export const RevokeSessionParamsSchema = z.object({
+  sessionId: z.string(),
+});
+
+export const RevokeUserSessionsParamsSchema = z.object({
+  userId: z.string(),
+});

package/template/packages/types/src/stats.ts

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+
+export const StatsOverviewSchema = z.object({
+  totalUsers: z.number(),
+  activeSessionsLast24h: z.number(),
+  totalUploads: z.number(),
+  storageUsedBytes: z.number(),
+  newUsersToday: z.number(),
+  newUsersThisWeek: z.number(),
+});
+
+export type StatsOverview = z.infer<typeof StatsOverviewSchema>;
+
+export const UserGrowthPointSchema = z.object({
+  date: z.string(),
+  count: z.number(),
+  cumulative: z.number(),
+});
+
+export type UserGrowthPoint = z.infer<typeof UserGrowthPointSchema>;
+
+export const SessionActivityPointSchema = z.object({
+  date: z.string(),
+  count: z.number(),
+});
+
+export type SessionActivityPoint = z.infer<typeof SessionActivityPointSchema>;
+
+export const AuthBreakdownSchema = z.object({
+  verified: z.number(),
+  unverified: z.number(),
+  banned: z.number(),
+});
+
+export type AuthBreakdown = z.infer<typeof AuthBreakdownSchema>;
+
+export const RoleDistributionItemSchema = z.object({
+  role: z.string(),
+  count: z.number(),
+});
+
+export type RoleDistributionItem = z.infer<typeof RoleDistributionItemSchema>;
+
+export const RecentSignupSchema = z.object({
+  id: z.string(),
+  email: z.string(),
+  name: z.string().nullable(),
+  image: z.string().nullable(),
+  createdAt: z.string(),
+});
+
+export type RecentSignup = z.infer<typeof RecentSignupSchema>;
+
+export const DatabaseHealthSchema = z.enum([
+  'connected',
+  'degraded',
+  'disconnected',
+]);
+
+export type DatabaseHealth = z.infer<typeof DatabaseHealthSchema>;
+
+export const SystemHealthSchema = z.object({
+  database: DatabaseHealthSchema,
+  uptime: z.number(),
+  lastChecked: z.string(),
+  dbLatencyMs: z.number().optional(),
+});
+
+export type SystemHealth = z.infer<typeof SystemHealthSchema>;
+
+export const SystemStatsSchema = z.object({
+  overview: StatsOverviewSchema,
+  userGrowth: z.array(UserGrowthPointSchema),
+  sessionActivity: z.array(SessionActivityPointSchema),
+  authBreakdown: AuthBreakdownSchema,
+  roleDistribution: z.array(RoleDistributionItemSchema),
+  recentSignups: z.array(RecentSignupSchema),
+  systemHealth: SystemHealthSchema,
+});
+
+export type SystemStats = z.infer<typeof SystemStatsSchema>;
+
+export const HealthCheckResponseSchema = z.object({
+  status: z.enum(['ok', 'degraded', 'error']),
+  database: DatabaseHealthSchema,
+  dbLatencyMs: z.number(),
+  uptime: z.number(),
+  timestamp: z.string(),
+});
+
+export type HealthCheckResponse = z.infer<typeof HealthCheckResponseSchema>;
+
+export const RealtimeMetricsPointSchema = z.object({
+  timestamp: z.number(),
+  memory: z.object({
+    heapUsedMB: z.number(),
+    heapTotalMB: z.number(),
+    rssMB: z.number(),
+    usedPercent: z.number(),
+  }),
+  cpu: z.object({
+    percentage: z.number(),
+  }),
+  errors: z.object({
+    rate: z.number(),
+  }),
+  requests: z.object({
+    perSecond: z.number(),
+    avgResponseTimeMs: z.number(),
+  }),
+});
+
+export type RealtimeMetricsPoint = z.infer<typeof RealtimeMetricsPointSchema>;

package/template/packages/types/src/upload.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+export const UploadSchema = z.object({
+  id: z.string(),
+  filename: z.string(),
+  originalName: z.string(),
+  mimeType: z.string(),
+  size: z.number().int().positive(),
+  url: z.string().url(),
+  userId: z.string(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export type Upload = z.infer<typeof UploadSchema>;
+
+export const UploadResponseSchema = z.object({
+  id: z.string(),
+  filename: z.string(),
+  originalName: z.string(),
+  mimeType: z.string(),
+  size: z.number().int().positive(),
+  url: z.string().url(),
+  createdAt: z.coerce.date(),
+  user: z.object({
+    id: z.string(),
+    name: z.string().nullable(),
+  }),
+});
+
+export type UploadResponse = z.infer<typeof UploadResponseSchema>;
+
+export const GetUploadsQuerySchema = z.object({
+  limit: z.coerce.number().int().positive().max(100).default(50),
+  offset: z.coerce.number().int().nonnegative().default(0),
+});
+
+export type GetUploadsQuery = z.infer<typeof GetUploadsQuerySchema>;
+
+export const DeleteUploadParamsSchema = z.object({
+  id: z.string().min(1),
+});
+
+export type DeleteUploadParams = z.infer<typeof DeleteUploadParamsSchema>;
+
+export const UploadStatsSchema = z.object({
+  totalFiles: z.number().int().nonnegative(),
+  totalSize: z.number().int().nonnegative(),
+});
+
+export type UploadStats = z.infer<typeof UploadStatsSchema>;

package/template/packages/types/src/user.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+
+import { RoleSchema } from './role';
+
+export const UserSchema = z.object({
+  id: z.string().min(1),
+  email: z.string().email(),
+  name: z.string().min(1),
+  role: RoleSchema.default('user'),
+  createdAt: z.date().or(z.string().datetime()),
+  updatedAt: z.date().or(z.string().datetime()),
+});
+
+export type User = z.infer<typeof UserSchema>;
+
+export const CreateUserSchema = UserSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export type CreateUser = z.infer<typeof CreateUserSchema>;
+
+export const UpdateUserSchema = UserSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+}).partial();
+
+export type UpdateUser = z.infer<typeof UpdateUserSchema>;
+
+export const GetUserByIdSchema = z.object({
+  id: z.string().min(1),
+});
+
+export type GetUserById = z.infer<typeof GetUserByIdSchema>;

package/template/packages/types/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}

package/template/packages/types/vitest.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig, mergeConfig } from 'vitest/config';
+
+import { sharedConfig } from '../../vitest.shared';
+
+export default mergeConfig(
+  sharedConfig,
+  defineConfig({
+    test: {
+      name: '@repo/packages-types',
+      include: ['src/**/*.{test,spec}.{ts,tsx}'],
+      coverage: {
+        thresholds: {
+          lines: 70,
+          functions: 70,
+          branches: 60,
+          statements: 70,
+        },
+      },
+    },
+  })
+);

package/template/packages/ui/components.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": ".",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  }
+}