@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/database/seeding.md

@@ -1,246 +0,0 @@
-# Database Seeding Patterns
-
-Patterns for seeding database with test data.
-
-## Basic Seed Script
-
-```typescript
-// prisma/seed.ts
-import { prisma } from '../src/lib/db'
-import { hash } from 'bcryptjs'
-
-async function main() {
-  console.log('Seeding database...')
-
-  // Create admin user
-  const adminPassword = await hash('admin123', 12)
-  const admin = await prisma.user.upsert({
-    where: { email: 'admin@example.com' },
-    update: {},
-    create: {
-      email: 'admin@example.com',
-      name: 'Admin User',
-      password: adminPassword,
-      role: 'ADMIN',
-      emailVerified: new Date()
-    }
-  })
-
-  console.log('Created admin:', admin.email)
-
-  // Create categories
-  const categories = await Promise.all(
-    ['Technology', 'Design', 'Business'].map(name =>
-      prisma.category.upsert({
-        where: { slug: name.toLowerCase() },
-        update: {},
-        create: { name, slug: name.toLowerCase() }
-      })
-    )
-  )
-
-  console.log('Created categories:', categories.length)
-
-  // Create sample posts
-  for (let i = 0; i < 10; i++) {
-    await prisma.post.create({
-      data: {
-        title: `Sample Post ${i + 1}`,
-        slug: `sample-post-${i + 1}`,
-        content: `This is the content for post ${i + 1}`,
-        published: true,
-        authorId: admin.id,
-        categoryId: categories[i % categories.length].id
-      }
-    })
-  }
-
-  console.log('Created 10 sample posts')
-}
-
-main()
-  .catch(console.error)
-  .finally(() => prisma.$disconnect())
-```
-
-## Faker-Based Seeding
-
-```typescript
-// prisma/seed.ts
-import { prisma } from '../src/lib/db'
-import { faker } from '@faker-js/faker'
-import { hash } from 'bcryptjs'
-
-async function main() {
-  // Clear existing data
-  await prisma.post.deleteMany()
-  await prisma.user.deleteMany()
-
-  // Create users
-  const password = await hash('password123', 12)
-
-  const users = await Promise.all(
-    Array.from({ length: 20 }).map(() =>
-      prisma.user.create({
-        data: {
-          email: faker.internet.email(),
-          name: faker.person.fullName(),
-          password,
-          image: faker.image.avatar(),
-          emailVerified: faker.datatype.boolean() ? faker.date.past() : null
-        }
-      })
-    )
-  )
-
-  // Create posts
-  const posts = await Promise.all(
-    Array.from({ length: 50 }).map(() =>
-      prisma.post.create({
-        data: {
-          title: faker.lorem.sentence(),
-          slug: faker.helpers.slugify(faker.lorem.words(3)),
-          content: faker.lorem.paragraphs(5),
-          excerpt: faker.lorem.paragraph(),
-          published: faker.datatype.boolean(),
-          authorId: faker.helpers.arrayElement(users).id,
-          createdAt: faker.date.past(),
-          updatedAt: faker.date.recent()
-        }
-      })
-    )
-  )
-
-  // Create comments
-  await Promise.all(
-    posts.flatMap(post =>
-      Array.from({ length: faker.number.int({ min: 0, max: 10 }) }).map(() =>
-        prisma.comment.create({
-          data: {
-            content: faker.lorem.sentences(),
-            postId: post.id,
-            userId: faker.helpers.arrayElement(users).id,
-            createdAt: faker.date.recent()
-          }
-        })
-      )
-    )
-  )
-
-  console.log('Database seeded!')
-}
-
-main()
-  .catch(console.error)
-  .finally(() => prisma.$disconnect())
-```
-
-## Environment-Specific Seeds
-
-```typescript
-// prisma/seed.ts
-import { prisma } from '../src/lib/db'
-
-const ENV = process.env.SEED_ENV || 'development'
-
-async function seedDevelopment() {
-  // Create test users and data
-  await createTestUsers()
-  await createSampleContent()
-}
-
-async function seedProduction() {
-  // Only create essential data
-  await createAdminUser()
-  await createDefaultCategories()
-  await createSystemSettings()
-}
-
-async function seedStaging() {
-  // Production-like but with some test data
-  await seedProduction()
-  await createDemoAccounts()
-}
-
-async function main() {
-  console.log(`Seeding for environment: ${ENV}`)
-
-  switch (ENV) {
-    case 'production':
-      await seedProduction()
-      break
-    case 'staging':
-      await seedStaging()
-      break
-    default:
-      await seedDevelopment()
-  }
-}
-
-main()
-  .catch(console.error)
-  .finally(() => prisma.$disconnect())
-```
-
-## Seed with Relations
-
-```typescript
-// prisma/seed.ts
-async function seedWithRelations() {
-  // Create team with members
-  const team = await prisma.team.create({
-    data: {
-      name: 'Development Team',
-      members: {
-        create: [
-          { role: 'OWNER', user: { create: { email: 'owner@example.com', name: 'Owner' } } },
-          { role: 'ADMIN', user: { create: { email: 'admin@example.com', name: 'Admin' } } },
-          { role: 'MEMBER', user: { create: { email: 'member@example.com', name: 'Member' } } }
-        ]
-      },
-      projects: {
-        create: [
-          {
-            name: 'Project Alpha',
-            tasks: {
-              create: [
-                { title: 'Task 1', status: 'TODO' },
-                { title: 'Task 2', status: 'IN_PROGRESS' },
-                { title: 'Task 3', status: 'DONE' }
-              ]
-            }
-          }
-        ]
-      }
-    },
-    include: {
-      members: { include: { user: true } },
-      projects: { include: { tasks: true } }
-    }
-  })
-
-  console.log('Created team with members and projects:', team.name)
-}
-```
-
-## Package.json Scripts
-
-```json
-{
-  "prisma": {
-    "seed": "ts-node --compiler-options {\"module\":\"CommonJS\"} prisma/seed.ts"
-  },
-  "scripts": {
-    "db:seed": "prisma db seed",
-    "db:seed:prod": "SEED_ENV=production prisma db seed",
-    "db:reset": "prisma migrate reset"
-  }
-}
-```
-
-## When to Use
-
-- Development setup
-- Testing data
-- Demo environments
-- Initial deployment

package/skills/patterns/database/soft-delete.md

@@ -1,153 +0,0 @@
-# Soft Delete Patterns
-
-Patterns for implementing soft delete with Prisma.
-
-## Schema Setup
-
-```prisma
-// schema.prisma
-model Document {
-  id        String    @id @default(cuid())
-  title     String
-  content   String?
-  deletedAt DateTime? // Soft delete marker
-  createdAt DateTime  @default(now())
-  updatedAt DateTime  @updatedAt
-
-  @@index([deletedAt])
-}
-```
-
-## Prisma Client Extension
-
-```typescript
-// lib/db.ts
-import { PrismaClient } from '@prisma/client'
-
-const prisma = new PrismaClient().$extends({
-  query: {
-    document: {
-      async findMany({ args, query }) {
-        args.where = { ...args.where, deletedAt: null }
-        return query(args)
-      },
-      async findFirst({ args, query }) {
-        args.where = { ...args.where, deletedAt: null }
-        return query(args)
-      },
-      async findUnique({ args, query }) {
-        // findUnique doesn't support compound where, use findFirst
-        return query(args)
-      },
-      async delete({ args }) {
-        return prisma.document.update({
-          where: args.where,
-          data: { deletedAt: new Date() }
-        })
-      },
-      async deleteMany({ args }) {
-        return prisma.document.updateMany({
-          where: args.where,
-          data: { deletedAt: new Date() }
-        })
-      }
-    }
-  }
-})
-
-export { prisma }
-```
-
-## Manual Soft Delete
-
-```typescript
-// lib/documents.ts
-import { prisma } from '@/lib/db'
-
-export async function softDelete(id: string) {
-  return prisma.document.update({
-    where: { id },
-    data: { deletedAt: new Date() }
-  })
-}
-
-export async function restore(id: string) {
-  return prisma.document.update({
-    where: { id },
-    data: { deletedAt: null }
-  })
-}
-
-export async function hardDelete(id: string) {
-  return prisma.document.delete({
-    where: { id }
-  })
-}
-```
-
-## Query Helpers
-
-```typescript
-// lib/documents.ts
-// Only active (non-deleted)
-export async function findActive() {
-  return prisma.document.findMany({
-    where: { deletedAt: null }
-  })
-}
-
-// Only deleted
-export async function findDeleted() {
-  return prisma.document.findMany({
-    where: { deletedAt: { not: null } }
-  })
-}
-
-// Include deleted (for admin)
-export async function findAll() {
-  return prisma.document.findMany()
-}
-
-// With deleted flag
-export async function findWithDeletedFlag(id: string) {
-  const doc = await prisma.document.findUnique({
-    where: { id }
-  })
-
-  return doc ? { ...doc, isDeleted: !!doc.deletedAt } : null
-}
-```
-
-## Cascade Soft Delete
-
-```typescript
-// lib/documents.ts
-export async function softDeleteWithRelations(userId: string) {
-  const now = new Date()
-
-  return prisma.$transaction([
-    // Soft delete user
-    prisma.user.update({
-      where: { id: userId },
-      data: { deletedAt: now }
-    }),
-    // Soft delete user's posts
-    prisma.post.updateMany({
-      where: { authorId: userId },
-      data: { deletedAt: now }
-    }),
-    // Soft delete user's comments
-    prisma.comment.updateMany({
-      where: { authorId: userId },
-      data: { deletedAt: now }
-    })
-  ])
-}
-```
-
-## When to Use
-
-- User data retention requirements
-- Audit trail needs
-- Undo/restore functionality
-- Legal compliance

package/skills/patterns/database/transactions.md

@@ -1,162 +0,0 @@
-# Database Transaction Patterns
-
-Patterns for handling database transactions with Prisma.
-
-## Basic Transaction
-
-```typescript
-// lib/db.ts
-import { prisma } from '@/lib/db'
-
-export async function transferCredits(
-  fromUserId: string,
-  toUserId: string,
-  amount: number
-) {
-  return prisma.$transaction(async (tx) => {
-    // Deduct from sender
-    const sender = await tx.user.update({
-      where: { id: fromUserId },
-      data: { credits: { decrement: amount } }
-    })
-
-    if (sender.credits < 0) {
-      throw new Error('Insufficient credits')
-    }
-
-    // Add to recipient
-    await tx.user.update({
-      where: { id: toUserId },
-      data: { credits: { increment: amount } }
-    })
-
-    // Record transaction
-    return tx.transaction.create({
-      data: {
-        fromUserId,
-        toUserId,
-        amount,
-        type: 'TRANSFER'
-      }
-    })
-  })
-}
-```
-
-## Sequential Operations
-
-```typescript
-// lib/db.ts
-export async function createOrder(
-  userId: string,
-  items: { productId: string; quantity: number }[]
-) {
-  return prisma.$transaction(async (tx) => {
-    // 1. Check inventory
-    for (const item of items) {
-      const product = await tx.product.findUnique({
-        where: { id: item.productId }
-      })
-
-      if (!product || product.stock < item.quantity) {
-        throw new Error(`Insufficient stock for ${item.productId}`)
-      }
-    }
-
-    // 2. Create order
-    const order = await tx.order.create({
-      data: {
-        userId,
-        status: 'PENDING',
-        items: {
-          create: items.map((item) => ({
-            productId: item.productId,
-            quantity: item.quantity
-          }))
-        }
-      }
-    })
-
-    // 3. Decrement inventory
-    for (const item of items) {
-      await tx.product.update({
-        where: { id: item.productId },
-        data: { stock: { decrement: item.quantity } }
-      })
-    }
-
-    return order
-  })
-}
-```
-
-## Transaction Options
-
-```typescript
-// lib/db.ts
-export async function riskyOperation() {
-  return prisma.$transaction(
-    async (tx) => {
-      // Long-running operation
-      await tx.heavyComputation.create({ ... })
-    },
-    {
-      maxWait: 5000, // Wait up to 5s for transaction slot
-      timeout: 10000, // Allow up to 10s for transaction
-      isolationLevel: 'Serializable' // Strictest isolation
-    }
-  )
-}
-```
-
-## Batch Operations
-
-```typescript
-// lib/db.ts
-export async function batchUpdate(updates: { id: string; data: any }[]) {
-  // Use $transaction for batching multiple operations
-  return prisma.$transaction(
-    updates.map((update) =>
-      prisma.item.update({
-        where: { id: update.id },
-        data: update.data
-      })
-    )
-  )
-}
-```
-
-## Optimistic Locking
-
-```typescript
-// lib/db.ts
-export async function updateWithVersion(
-  id: string,
-  expectedVersion: number,
-  data: any
-) {
-  const result = await prisma.document.updateMany({
-    where: {
-      id,
-      version: expectedVersion
-    },
-    data: {
-      ...data,
-      version: { increment: 1 }
-    }
-  })
-
-  if (result.count === 0) {
-    throw new Error('Concurrent modification detected')
-  }
-
-  return prisma.document.findUnique({ where: { id } })
-}
-```
-
-## When to Use
-
-- Money/credit transfers
-- Order processing
-- Inventory management
-- Multi-table updates