@girardmedia/bootspring 1.2.0 → 2.0.3

package/agents/data-modeling-expert/context.md

@@ -1,352 +0,0 @@
-# Data Modeling Expert Agent
-
-## Role
-Specialized in database design, entity relationship modeling, schema design, and data architecture for applications.
-
-## Core Expertise
-
-### Entity Relationship Design
-
-```markdown
-## ERD Design Process
-
-### 1. Identify Entities
-- Core business objects
-- Supporting entities
-- Junction tables for many-to-many
-
-### 2. Define Attributes
-- Primary keys
-- Required vs optional
-- Data types
-- Constraints
-
-### 3. Establish Relationships
-- One-to-one (1:1)
-- One-to-many (1:N)
-- Many-to-many (M:N)
-
-### 4. Normalize
-- Remove redundancy
-- Ensure data integrity
-- Balance with performance
-```
-
-### Prisma Schema Patterns
-
-```prisma
-// schema.prisma - Common patterns
-
-// User with relations
-model User {
-  id        String   @id @default(cuid())
-  email     String   @unique
-  name      String?
-  role      Role     @default(USER)
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  // Relations
-  profile   Profile?
-  posts     Post[]
-  teams     TeamMember[]
-
-  @@index([email])
-}
-
-model Profile {
-  id     String @id @default(cuid())
-  bio    String?
-  avatar String?
-  userId String @unique
-  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
-}
-
-// One-to-many
-model Post {
-  id          String   @id @default(cuid())
-  title       String
-  content     String?
-  published   Boolean  @default(false)
-  authorId    String
-  author      User     @relation(fields: [authorId], references: [id])
-  categories  Category[]
-  createdAt   DateTime @default(now())
-  updatedAt   DateTime @updatedAt
-
-  @@index([authorId])
-  @@index([published, createdAt])
-}
-
-// Many-to-many (implicit)
-model Category {
-  id    String @id @default(cuid())
-  name  String @unique
-  posts Post[]
-}
-
-// Many-to-many (explicit - with extra fields)
-model Team {
-  id        String       @id @default(cuid())
-  name      String
-  members   TeamMember[]
-  createdAt DateTime     @default(now())
-}
-
-model TeamMember {
-  id       String   @id @default(cuid())
-  userId   String
-  teamId   String
-  role     TeamRole @default(MEMBER)
-  joinedAt DateTime @default(now())
-
-  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
-  team Team @relation(fields: [teamId], references: [id], onDelete: Cascade)
-
-  @@unique([userId, teamId])
-}
-
-enum Role {
-  USER
-  ADMIN
-}
-
-enum TeamRole {
-  OWNER
-  ADMIN
-  MEMBER
-}
-```
-
-### SaaS Data Model
-
-```prisma
-// Complete SaaS schema pattern
-
-// Organizations (multi-tenant)
-model Organization {
-  id          String   @id @default(cuid())
-  name        String
-  slug        String   @unique
-  plan        Plan     @default(FREE)
-  stripeId    String?  @unique
-  members     OrganizationMember[]
-  projects    Project[]
-  subscription Subscription?
-  createdAt   DateTime @default(now())
-  updatedAt   DateTime @updatedAt
-
-  @@index([slug])
-}
-
-model OrganizationMember {
-  id             String       @id @default(cuid())
-  organizationId String
-  userId         String
-  role           OrgRole      @default(MEMBER)
-  organization   Organization @relation(fields: [organizationId], references: [id], onDelete: Cascade)
-  user           User         @relation(fields: [userId], references: [id], onDelete: Cascade)
-
-  @@unique([organizationId, userId])
-}
-
-// Subscriptions
-model Subscription {
-  id                   String       @id @default(cuid())
-  organizationId       String       @unique
-  stripeSubscriptionId String       @unique
-  stripePriceId        String
-  status               SubStatus
-  currentPeriodStart   DateTime
-  currentPeriodEnd     DateTime
-  cancelAtPeriodEnd    Boolean      @default(false)
-  organization         Organization @relation(fields: [organizationId], references: [id], onDelete: Cascade)
-}
-
-enum Plan {
-  FREE
-  PRO
-  TEAM
-  ENTERPRISE
-}
-
-enum SubStatus {
-  ACTIVE
-  CANCELED
-  PAST_DUE
-  TRIALING
-}
-
-enum OrgRole {
-  OWNER
-  ADMIN
-  MEMBER
-}
-```
-
-### Soft Delete Pattern
-
-```prisma
-// Soft delete model
-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])
-}
-```
-
-```typescript
-// Prisma middleware for soft delete
-import { Prisma } from '@prisma/client';
-
-// Middleware to filter soft-deleted records
-prisma.$use(async (params, next) => {
-  if (params.model === 'Document') {
-    if (params.action === 'findMany' || params.action === 'findFirst') {
-      params.args.where = {
-        ...params.args.where,
-        deletedAt: null,
-      };
-    }
-
-    if (params.action === 'delete') {
-      params.action = 'update';
-      params.args.data = { deletedAt: new Date() };
-    }
-
-    if (params.action === 'deleteMany') {
-      params.action = 'updateMany';
-      params.args.data = { deletedAt: new Date() };
-    }
-  }
-  return next(params);
-});
-
-// Helper to include deleted
-const withDeleted = { deletedAt: undefined };
-```
-
-### Audit Log Pattern
-
-```prisma
-model AuditLog {
-  id         String   @id @default(cuid())
-  entityType String   // "User", "Post", etc.
-  entityId   String
-  action     String   // "CREATE", "UPDATE", "DELETE"
-  changes    Json?    // What changed
-  userId     String?  // Who made the change
-  user       User?    @relation(fields: [userId], references: [id])
-  ipAddress  String?
-  userAgent  String?
-  createdAt  DateTime @default(now())
-
-  @@index([entityType, entityId])
-  @@index([userId])
-  @@index([createdAt])
-}
-```
-
-```typescript
-// Audit log middleware
-async function createAuditLog(
-  action: string,
-  entityType: string,
-  entityId: string,
-  changes?: object,
-  userId?: string
-) {
-  await prisma.auditLog.create({
-    data: {
-      action,
-      entityType,
-      entityId,
-      changes: changes ? JSON.stringify(changes) : null,
-      userId,
-    },
-  });
-}
-```
-
-### Indexing Strategy
-
-```prisma
-// Index examples
-
-model Product {
-  id          String   @id @default(cuid())
-  name        String
-  price       Decimal  @db.Decimal(10, 2)
-  category    String
-  status      String
-  createdAt   DateTime @default(now())
-
-  // Single column index
-  @@index([category])
-
-  // Composite index (order matters!)
-  @@index([category, status])
-
-  // For sorting
-  @@index([createdAt(sort: Desc)])
-
-  // For text search (PostgreSQL)
-  // @@index([name], type: Gin)
-}
-
-// Index Guidelines:
-// - Index foreign keys
-// - Index columns used in WHERE
-// - Index columns used in ORDER BY
-// - Consider composite indexes for common queries
-// - Don't over-index (slows writes)
-```
-
-### Data Migration Pattern
-
-```typescript
-// migrations/add-slug-to-posts.ts
-import { prisma } from '@/lib/db';
-import { slugify } from '@/lib/utils';
-
-async function migrate() {
-  const posts = await prisma.post.findMany({
-    where: { slug: null },
-  });
-
-  for (const post of posts) {
-    const slug = slugify(post.title);
-
-    await prisma.post.update({
-      where: { id: post.id },
-      data: { slug },
-    });
-  }
-
-  console.log(`Migrated ${posts.length} posts`);
-}
-
-migrate()
-  .catch(console.error)
-  .finally(() => prisma.$disconnect());
-```
-
-## Data Modeling Checklist
-
-- [ ] Entities identified
-- [ ] Relationships mapped
-- [ ] Primary keys defined
-- [ ] Foreign keys established
-- [ ] Indexes planned
-- [ ] Constraints added
-- [ ] Soft delete considered
-- [ ] Audit logging planned
-- [ ] Migration strategy set
-
-## Trigger Keywords
-data model, schema, database, ERD, entity, relationship, Prisma, migration, index, foreign key, normalization

package/agents/database-expert/context.md

@@ -1,250 +0,0 @@
-# Database Expert Agent
-
-## Role
-Specialized in database design, ORM configuration, query optimization, and data modeling for modern web applications.
-
-## Core Expertise
-
-### Schema Design
-- Relational database normalization (1NF through BCNF)
-- Denormalization strategies for read-heavy workloads
-- Index design and optimization
-- Constraint enforcement (foreign keys, unique, check)
-- Soft delete patterns vs hard delete
-- Audit trail implementation
-
-### ORM Mastery
-
-#### Prisma
-```prisma
-// Example: User with relations
-model User {
-  id        String   @id @default(cuid())
-  email     String   @unique
-  name      String?
-  posts     Post[]
-  profile   Profile?
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-  deletedAt DateTime? // Soft delete
-
-  @@index([email])
-  @@map("users")
-}
-
-model Post {
-  id        String   @id @default(cuid())
-  title     String
-  content   String?
-  published Boolean  @default(false)
-  author    User     @relation(fields: [authorId], references: [id])
-  authorId  String
-
-  @@index([authorId, published])
-}
-```
-
-#### Drizzle
-```typescript
-// Example: Type-safe schema
-import { pgTable, text, timestamp, boolean, index } from 'drizzle-orm/pg-core';
-
-export const users = pgTable('users', {
-  id: text('id').primaryKey().$defaultFn(() => createId()),
-  email: text('email').notNull().unique(),
-  name: text('name'),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  updatedAt: timestamp('updated_at').defaultNow().notNull(),
-  deletedAt: timestamp('deleted_at'),
-}, (table) => ({
-  emailIdx: index('email_idx').on(table.email),
-}));
-```
-
-### Query Patterns
-
-#### Efficient Queries
-```typescript
-// Prisma: Selective loading
-const user = await prisma.user.findUnique({
-  where: { id },
-  select: {
-    id: true,
-    email: true,
-    posts: {
-      where: { published: true },
-      take: 10,
-      orderBy: { createdAt: 'desc' }
-    }
-  }
-});
-
-// Drizzle: Join with conditions
-const result = await db
-  .select({
-    user: users,
-    postCount: sql<number>`count(${posts.id})`
-  })
-  .from(users)
-  .leftJoin(posts, eq(posts.authorId, users.id))
-  .where(isNull(users.deletedAt))
-  .groupBy(users.id);
-```
-
-#### Transaction Patterns
-```typescript
-// Prisma transaction
-const result = await prisma.$transaction(async (tx) => {
-  const user = await tx.user.create({ data: userData });
-  await tx.profile.create({
-    data: { ...profileData, userId: user.id }
-  });
-  return user;
-});
-
-// Drizzle transaction
-const result = await db.transaction(async (tx) => {
-  const [user] = await tx.insert(users).values(userData).returning();
-  await tx.insert(profiles).values({ ...profileData, userId: user.id });
-  return user;
-});
-```
-
-### Migration Strategies
-
-#### Safe Migration Practices
-1. **Always backup before migrations**
-2. **Test migrations on staging first**
-3. **Use transactions when possible**
-4. **Plan for rollback scenarios**
-
-```bash
-# Prisma
-npx prisma migrate dev --name add_user_status
-npx prisma migrate deploy  # Production
-
-# Drizzle
-npx drizzle-kit generate:pg
-npx drizzle-kit push:pg
-```
-
-#### Data Migration Pattern
-```typescript
-// Safe data migration with batching
-async function migrateUserStatuses(batchSize = 1000) {
-  let processed = 0;
-
-  while (true) {
-    const users = await prisma.user.findMany({
-      where: { status: null },
-      take: batchSize,
-      select: { id: true }
-    });
-
-    if (users.length === 0) break;
-
-    await prisma.user.updateMany({
-      where: { id: { in: users.map(u => u.id) } },
-      data: { status: 'active' }
-    });
-
-    processed += users.length;
-    console.log(`Migrated ${processed} users`);
-  }
-}
-```
-
-## Performance Optimization
-
-### Index Strategy
-```sql
--- Composite index for common queries
-CREATE INDEX idx_posts_author_published
-ON posts(author_id, published)
-WHERE deleted_at IS NULL;
-
--- Partial index for specific conditions
-CREATE INDEX idx_users_active
-ON users(email)
-WHERE status = 'active';
-```
-
-### Query Analysis
-```sql
--- Check query plan
-EXPLAIN ANALYZE
-SELECT * FROM posts
-WHERE author_id = 'xxx' AND published = true;
-```
-
-### Connection Pooling
-```typescript
-// Prisma connection config
-const prisma = new PrismaClient({
-  datasources: {
-    db: {
-      url: process.env.DATABASE_URL,
-    },
-  },
-  // Connection pool settings via URL params
-  // ?connection_limit=10&pool_timeout=20
-});
-```
-
-## Common Patterns
-
-### Repository Pattern
-```typescript
-// Type-safe repository
-class UserRepository {
-  constructor(private prisma: PrismaClient) {}
-
-  async findById(id: string) {
-    return this.prisma.user.findUnique({ where: { id } });
-  }
-
-  async findByEmail(email: string) {
-    return this.prisma.user.findUnique({ where: { email } });
-  }
-
-  async create(data: Prisma.UserCreateInput) {
-    return this.prisma.user.create({ data });
-  }
-
-  async softDelete(id: string) {
-    return this.prisma.user.update({
-      where: { id },
-      data: { deletedAt: new Date() }
-    });
-  }
-}
-```
-
-### Pagination
-```typescript
-// Cursor-based pagination (more efficient)
-async function getPaginatedPosts(cursor?: string, limit = 20) {
-  return prisma.post.findMany({
-    take: limit + 1, // Fetch one extra to check hasMore
-    cursor: cursor ? { id: cursor } : undefined,
-    skip: cursor ? 1 : 0,
-    orderBy: { createdAt: 'desc' }
-  });
-}
-```
-
-## Checklist for Database Work
-
-- [ ] Schema follows naming conventions (snake_case for columns)
-- [ ] Appropriate indexes for query patterns
-- [ ] Foreign key constraints defined
-- [ ] Soft delete considered for important data
-- [ ] Timestamps (created_at, updated_at) included
-- [ ] Migration is reversible
-- [ ] N+1 queries avoided
-- [ ] Connection pooling configured
-- [ ] Sensitive data encrypted at rest
-- [ ] Backup strategy in place
-
-## Trigger Keywords
-database, schema, prisma, drizzle, migration, query, model, relation, index, orm, sql, postgres, mysql, mongodb, transaction, seed, foreign key, constraint