@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/utils/validation.md

@@ -1,434 +0,0 @@
-# Validation Patterns
-
-Patterns for input validation with Zod.
-
-## Basic Schemas
-
-```typescript
-// lib/validations/common.ts
-import { z } from 'zod'
-
-// Email validation
-export const emailSchema = z
-  .string()
-  .email('Invalid email address')
-  .toLowerCase()
-  .trim()
-
-// Password validation
-export const passwordSchema = z
-  .string()
-  .min(8, 'Password must be at least 8 characters')
-  .regex(/[A-Z]/, 'Password must contain an uppercase letter')
-  .regex(/[a-z]/, 'Password must contain a lowercase letter')
-  .regex(/[0-9]/, 'Password must contain a number')
-
-// Username validation
-export const usernameSchema = z
-  .string()
-  .min(3, 'Username must be at least 3 characters')
-  .max(20, 'Username must be at most 20 characters')
-  .regex(/^[a-zA-Z0-9_]+$/, 'Username can only contain letters, numbers, and underscores')
-
-// URL validation
-export const urlSchema = z
-  .string()
-  .url('Invalid URL')
-  .or(z.literal(''))
-
-// Phone number
-export const phoneSchema = z
-  .string()
-  .regex(/^\+?[1-9]\d{1,14}$/, 'Invalid phone number')
-
-// Slug validation
-export const slugSchema = z
-  .string()
-  .min(1)
-  .max(100)
-  .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'Invalid slug format')
-
-// UUID validation
-export const uuidSchema = z.string().uuid('Invalid ID format')
-
-// Date string (ISO format)
-export const dateStringSchema = z
-  .string()
-  .datetime({ message: 'Invalid date format' })
-
-// Positive number
-export const positiveNumberSchema = z
-  .number()
-  .positive('Must be a positive number')
-
-// Non-empty string
-export const nonEmptyStringSchema = z
-  .string()
-  .min(1, 'This field is required')
-  .trim()
-```
-
-## Form Schemas
-
-```typescript
-// lib/validations/auth.ts
-import { z } from 'zod'
-import { emailSchema, passwordSchema } from './common'
-
-export const loginSchema = z.object({
-  email: emailSchema,
-  password: z.string().min(1, 'Password is required'),
-  rememberMe: z.boolean().optional()
-})
-
-export const registerSchema = z
-  .object({
-    name: z.string().min(2, 'Name must be at least 2 characters'),
-    email: emailSchema,
-    password: passwordSchema,
-    confirmPassword: z.string()
-  })
-  .refine(data => data.password === data.confirmPassword, {
-    message: 'Passwords do not match',
-    path: ['confirmPassword']
-  })
-
-export const forgotPasswordSchema = z.object({
-  email: emailSchema
-})
-
-export const resetPasswordSchema = z
-  .object({
-    token: z.string().min(1),
-    password: passwordSchema,
-    confirmPassword: z.string()
-  })
-  .refine(data => data.password === data.confirmPassword, {
-    message: 'Passwords do not match',
-    path: ['confirmPassword']
-  })
-
-export type LoginInput = z.infer<typeof loginSchema>
-export type RegisterInput = z.infer<typeof registerSchema>
-```
-
-## API Input Validation
-
-```typescript
-// lib/validations/api.ts
-import { z } from 'zod'
-
-// Pagination params
-export const paginationSchema = z.object({
-  page: z.coerce.number().int().positive().default(1),
-  limit: z.coerce.number().int().min(1).max(100).default(20),
-  sort: z.string().optional(),
-  order: z.enum(['asc', 'desc']).default('desc')
-})
-
-// Search params
-export const searchSchema = z.object({
-  q: z.string().min(1).max(100).optional(),
-  filters: z.record(z.string()).optional()
-})
-
-// ID param
-export const idParamSchema = z.object({
-  id: z.string().cuid()
-})
-
-// Create post
-export const createPostSchema = z.object({
-  title: z.string().min(1).max(200),
-  content: z.string().min(1),
-  excerpt: z.string().max(500).optional(),
-  slug: z.string().regex(/^[a-z0-9-]+$/).optional(),
-  published: z.boolean().default(false),
-  categoryId: z.string().cuid().optional(),
-  tags: z.array(z.string()).max(10).optional()
-})
-
-// Update post (partial)
-export const updatePostSchema = createPostSchema.partial()
-
-// Validate in API route
-import { NextRequest, NextResponse } from 'next/server'
-
-export async function POST(request: NextRequest) {
-  const body = await request.json()
-
-  const result = createPostSchema.safeParse(body)
-
-  if (!result.success) {
-    return NextResponse.json(
-      {
-        error: 'Validation failed',
-        details: result.error.flatten().fieldErrors
-      },
-      { status: 400 }
-    )
-  }
-
-  // result.data is typed and validated
-  const post = await prisma.post.create({ data: result.data })
-
-  return NextResponse.json(post, { status: 201 })
-}
-```
-
-## Validation Helper
-
-```typescript
-// lib/validations/validate.ts
-import { z } from 'zod'
-import { NextRequest, NextResponse } from 'next/server'
-
-export class ValidationError extends Error {
-  constructor(
-    public errors: z.ZodError,
-    message = 'Validation failed'
-  ) {
-    super(message)
-    this.name = 'ValidationError'
-  }
-}
-
-export function validate<T extends z.ZodSchema>(
-  schema: T,
-  data: unknown
-): z.infer<T> {
-  const result = schema.safeParse(data)
-
-  if (!result.success) {
-    throw new ValidationError(result.error)
-  }
-
-  return result.data
-}
-
-// Middleware wrapper
-type Handler<T> = (
-  req: NextRequest,
-  validated: T,
-  context?: any
-) => Promise<NextResponse>
-
-export function withValidation<T extends z.ZodSchema>(
-  schema: T,
-  handler: Handler<z.infer<T>>
-) {
-  return async (req: NextRequest, context?: any) => {
-    try {
-      const body = await req.json()
-      const validated = validate(schema, body)
-      return handler(req, validated, context)
-    } catch (error) {
-      if (error instanceof ValidationError) {
-        return NextResponse.json(
-          {
-            error: 'Validation failed',
-            details: error.errors.flatten().fieldErrors
-          },
-          { status: 400 }
-        )
-      }
-      throw error
-    }
-  }
-}
-
-// Usage
-export const POST = withValidation(createPostSchema, async (req, data) => {
-  const post = await prisma.post.create({ data })
-  return NextResponse.json(post, { status: 201 })
-})
-```
-
-## Custom Validators
-
-```typescript
-// lib/validations/custom.ts
-import { z } from 'zod'
-import { prisma } from '@/lib/db'
-
-// Unique email check
-export const uniqueEmailSchema = z
-  .string()
-  .email()
-  .refine(
-    async email => {
-      const existing = await prisma.user.findUnique({
-        where: { email },
-        select: { id: true }
-      })
-      return !existing
-    },
-    { message: 'Email already in use' }
-  )
-
-// Existing resource check
-export function existsInDatabase(
-  table: 'user' | 'post' | 'team',
-  field: 'id' | 'slug' = 'id'
-) {
-  return z.string().refine(
-    async value => {
-      const record = await (prisma as any)[table].findUnique({
-        where: { [field]: value },
-        select: { id: true }
-      })
-      return !!record
-    },
-    { message: `${table} not found` }
-  )
-}
-
-// File validation
-export const fileSchema = z.object({
-  name: z.string(),
-  size: z.number().max(5 * 1024 * 1024, 'File must be less than 5MB'),
-  type: z.string().refine(
-    type => ['image/jpeg', 'image/png', 'image/webp'].includes(type),
-    'Invalid file type'
-  )
-})
-
-// Credit card (basic format)
-export const creditCardSchema = z
-  .string()
-  .regex(/^\d{13,19}$/, 'Invalid card number')
-  .refine(luhnCheck, 'Invalid card number')
-
-function luhnCheck(cardNumber: string): boolean {
-  let sum = 0
-  let isEven = false
-
-  for (let i = cardNumber.length - 1; i >= 0; i--) {
-    let digit = parseInt(cardNumber[i], 10)
-
-    if (isEven) {
-      digit *= 2
-      if (digit > 9) digit -= 9
-    }
-
-    sum += digit
-    isEven = !isEven
-  }
-
-  return sum % 10 === 0
-}
-```
-
-## Form Validation Hook
-
-```tsx
-// hooks/useFormValidation.ts
-'use client'
-
-import { useState, useCallback } from 'react'
-import { z } from 'zod'
-
-interface UseFormValidationOptions<T extends z.ZodSchema> {
-  schema: T
-  onSubmit: (data: z.infer<T>) => Promise<void>
-}
-
-export function useFormValidation<T extends z.ZodSchema>({
-  schema,
-  onSubmit
-}: UseFormValidationOptions<T>) {
-  const [errors, setErrors] = useState<Record<string, string>>({})
-  const [isSubmitting, setIsSubmitting] = useState(false)
-
-  const validate = useCallback(
-    (data: unknown): z.infer<T> | null => {
-      const result = schema.safeParse(data)
-
-      if (!result.success) {
-        const fieldErrors: Record<string, string> = {}
-        result.error.errors.forEach(err => {
-          const path = err.path.join('.')
-          if (!fieldErrors[path]) {
-            fieldErrors[path] = err.message
-          }
-        })
-        setErrors(fieldErrors)
-        return null
-      }
-
-      setErrors({})
-      return result.data
-    },
-    [schema]
-  )
-
-  const handleSubmit = useCallback(
-    async (data: unknown) => {
-      const validated = validate(data)
-      if (!validated) return
-
-      setIsSubmitting(true)
-      try {
-        await onSubmit(validated)
-      } finally {
-        setIsSubmitting(false)
-      }
-    },
-    [validate, onSubmit]
-  )
-
-  const getFieldError = useCallback(
-    (field: string) => errors[field],
-    [errors]
-  )
-
-  const clearErrors = useCallback(() => setErrors({}), [])
-
-  return {
-    errors,
-    isSubmitting,
-    validate,
-    handleSubmit,
-    getFieldError,
-    clearErrors
-  }
-}
-```
-
-## Error Display Component
-
-```tsx
-// components/FormError.tsx
-interface FormErrorProps {
-  error?: string
-}
-
-export function FormError({ error }: FormErrorProps) {
-  if (!error) return null
-
-  return (
-    <p className="mt-1 text-sm text-red-600" role="alert">
-      {error}
-    </p>
-  )
-}
-
-// Usage
-<div>
-  <label htmlFor="email">Email</label>
-  <input
-    id="email"
-    type="email"
-    aria-invalid={!!errors.email}
-    aria-describedby={errors.email ? 'email-error' : undefined}
-  />
-  <FormError error={errors.email} />
-</div>
-```
-
-## When to Use
-
-- Form validation
-- API input validation
-- Data sanitization
-- Type safety

package/templates/bootspring.config.js

@@ -1,83 +0,0 @@
-/**
- * Bootspring Configuration
- * Copy this file to your project root and customize
- */
-module.exports = {
-  // Project information
-  project: {
-    name: 'My Project',
-    description: 'A modern web application',
-    version: '0.1.0'
-  },
-
-  // Technology stack
-  stack: {
-    framework: 'nextjs',      // nextjs, remix, astro
-    language: 'typescript',   // typescript, javascript
-    database: 'postgresql',   // postgresql, mysql, mongodb
-    hosting: 'vercel'         // vercel, aws, railway
-  },
-
-  // Enabled plugins
-  plugins: {
-    auth: {
-      enabled: true,
-      provider: 'clerk',      // clerk, nextauth, auth0, supabase
-      features: ['social_login', 'email_password']
-    },
-    payments: {
-      enabled: false,
-      provider: 'stripe',     // stripe, paddle, lemonsqueezy
-      features: ['checkout', 'subscriptions']
-    },
-    database: {
-      enabled: true,
-      provider: 'prisma',     // prisma, drizzle, typeorm
-      features: ['migrations', 'transactions']
-    },
-    testing: {
-      enabled: true,
-      provider: 'vitest',     // vitest, jest, playwright
-      features: ['unit', 'integration']
-    },
-    security: {
-      enabled: true,
-      features: ['input_validation', 'rate_limiting']
-    },
-    ai: {
-      enabled: false,
-      provider: 'anthropic',  // anthropic, openai, google
-      features: ['streaming', 'tool_use']
-    }
-  },
-
-  // Dashboard settings
-  dashboard: {
-    port: 3456,
-    autoOpen: false
-  },
-
-  // Context generation options
-  context: {
-    includeEnvVars: true,
-    includeTechStack: true,
-    includePlugins: true,
-    customSections: []
-  },
-
-  // Quality gate settings
-  quality: {
-    preCommit: {
-      enabled: true,
-      checks: ['lint', 'typecheck']
-    },
-    prePush: {
-      enabled: true,
-      checks: ['test', 'build']
-    },
-    preDeploy: {
-      enabled: true,
-      checks: ['security', 'coverage']
-    }
-  }
-};