create-blitzpack 0.1.0 → 0.1.2

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,21 +0,0 @@
-{
-  "$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"
-  }
-}