ai-qakit 1.0.0

package/templates/.cursor/commands/devkit/backend/create-schema.md

@@ -0,0 +1,183 @@
+# Create Database Schema
+
+Generate a database model/entity definition.
+
+## ⚠️ Plan Before Executing
+
+**Always create a structured plan and get user approval before making changes.**
+
+1. Show the schema that will be created
+2. Display relationships with existing models
+3. Highlight indexes and constraints
+4. Ask for confirmation before generating
+
+## Ask for Clarification
+
+If anything is unclear, **ask the user**:
+- "What are all the required fields for this model?"
+- "What relationships does this model have with other entities?"
+- "Should this model support soft deletes?"
+- "Are there any unique constraints or indexes needed?"
+- "What default values should fields have?"
+
+---
+
+## Step 1: Reference Project Profile
+
+Read `@.cursor/rules/project-profile.mdc` to understand:
+- ORM (Prisma, TypeORM, Sequelize, etc.)
+- Database type
+- Naming conventions
+- Existing models
+
+## Step 2: Parse Request
+
+Extract from description:
+- Model/entity name
+- Fields and their types
+- Relationships to other models
+- Constraints (unique, required, etc.)
+- Indexes needed
+
+## Step 3: Review Existing Models
+
+```bash
+# Prisma
+cat prisma/schema.prisma
+
+# TypeORM
+find . -name "*.entity.ts" | head -5
+
+# Sequelize
+find . -name "*.model.ts" | head -5
+```
+
+## Step 4: Present Schema Plan
+
+```
+═══════════════════════════════════════════════
+📋 SCHEMA PLAN
+═══════════════════════════════════════════════
+
+Model: [name]
+
+Fields:
+├── id: UUID (primary key)
+├── [field1]: [type] [constraints]
+├── [field2]: [type] [constraints]
+└── timestamps (createdAt, updatedAt)
+
+Relationships:
+├── belongsTo: [Model] (via [field])
+└── hasMany: [Model]
+
+Indexes:
+├── [field1] (unique)
+└── [field2, field3] (composite)
+
+Proceed with creating schema? (Y/n)
+═══════════════════════════════════════════════
+```
+
+## Step 5: Map Field Types
+
+| Concept | Prisma | TypeORM | SQL |
+|---------|--------|---------|-----|
+| String | String | string | VARCHAR |
+| Integer | Int | number | INT |
+| BigInt | BigInt | bigint | BIGINT |
+| Float | Float | number | FLOAT |
+| Decimal | Decimal | decimal | DECIMAL |
+| Boolean | Boolean | boolean | BOOLEAN |
+| DateTime | DateTime | Date | TIMESTAMP |
+| JSON | Json | jsonb | JSONB |
+| UUID | String @db.Uuid | uuid | UUID |
+
+## Step 6: Generate Schema
+
+### Prisma
+
+```prisma
+model User {
+  id        String   @id @default(uuid())
+  email     String   @unique
+  name      String
+  password  String
+  role      Role     @default(USER)
+  posts     Post[]
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@index([email])
+}
+
+enum Role {
+  USER
+  ADMIN
+}
+```
+
+### TypeORM
+
+```typescript
+@Entity('users')
+export class User {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @Column({ unique: true })
+  email: string
+
+  @Column()
+  name: string
+
+  @Column()
+  password: string
+
+  @Column({ type: 'enum', enum: Role, default: Role.USER })
+  role: Role
+
+  @OneToMany(() => Post, (post) => post.user)
+  posts: Post[]
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+}
+```
+
+## Step 7: Relationship Patterns
+
+| Relationship | Prisma | TypeORM |
+|--------------|--------|---------|
+| One-to-One | `profile Profile?` | `@OneToOne` |
+| One-to-Many | `posts Post[]` | `@OneToMany` |
+| Many-to-One | `author User @relation` | `@ManyToOne` |
+| Many-to-Many | `tags Tag[]` | `@ManyToMany` |
+
+## Step 8: Summary
+
+```
+═══════════════════════════════════════════════
+✅ SCHEMA CREATED
+═══════════════════════════════════════════════
+
+File: [schema file path]
+
+Model: [name]
+Fields: [count]
+Relationships: [count]
+
+Next steps:
+1. Review the schema file
+2. Generate migration:
+   [migration command]
+3. Generate client (if applicable):
+   [generate command]
+4. Create related files:
+   - Service layer
+   - DTOs for API
+═══════════════════════════════════════════════
+```

package/templates/.cursor/commands/devkit/backend/design-graphql-api.md

@@ -0,0 +1,287 @@
+# Design GraphQL API
+
+Design comprehensive GraphQL API with schema, resolvers, and real-time subscriptions.
+
+## ⚠️ Plan Before Executing
+
+**Always create a structured plan and get user approval before making changes.**
+
+1. Present complete schema design
+2. Show all types, queries, and mutations
+3. Display resolver architecture
+4. Ask for confirmation before generating files
+
+## Ask for Clarification
+
+If anything is unclear, **ask the user**:
+- "What are the core types and their relationships?"
+- "Are there any real-time subscription requirements?"
+- "Should we use schema-first or code-first approach?"
+- "What are the desired query complexity limits?"
+- "Which DataLoader patterns should we implement?"
+
+---
+
+## Step 1: Reference Project Profile
+
+Read `@.cursor/rules/project-profile.mdc` to understand:
+- Framework (Apollo, GraphQL Yoga, etc.)
+- Existing schema patterns
+- Authentication setup
+- Code generation tools
+
+## Step 2: Analyze Requirements
+
+**Extract from request:**
+- Core types and relationships
+- Query operations needed
+- Mutation operations needed
+- Real-time subscription needs
+- Authentication requirements
+
+## Step 3: Present Schema Design
+
+```
+═══════════════════════════════════════════════
+📋 GRAPHQL API DESIGN
+═══════════════════════════════════════════════
+
+Approach: [Schema-first / Code-first]
+
+Types:
+├── User
+├── Post
+├── Comment
+└── [Custom scalars]
+
+Operations:
+├── Queries: [count]
+├── Mutations: [count]
+└── Subscriptions: [count]
+
+Features:
+├── DataLoader: Yes
+├── Subscriptions: WebSocket
+└── Complexity Limit: 100
+
+Proceed with detailed design? (Y/n)
+═══════════════════════════════════════════════
+```
+
+## Step 4: Design Schema
+
+### Type Definitions
+
+```graphql
+type User {
+  id: ID!
+  email: String!
+  name: String!
+  posts: [Post!]!
+  createdAt: DateTime!
+}
+
+type Post {
+  id: ID!
+  title: String!
+  content: String!
+  author: User!
+  comments: [Comment!]!
+  publishedAt: DateTime
+}
+
+type Query {
+  user(id: ID!): User
+  users(filter: UserFilter, pagination: PaginationInput): UserConnection!
+  post(id: ID!): Post
+  posts(filter: PostFilter): [Post!]!
+}
+
+type Mutation {
+  createUser(input: CreateUserInput!): User!
+  updateUser(id: ID!, input: UpdateUserInput!): User!
+  deleteUser(id: ID!): Boolean!
+  createPost(input: CreatePostInput!): Post!
+}
+
+type Subscription {
+  postCreated: Post!
+  userUpdated(id: ID!): User!
+}
+```
+
+### Input Types
+
+```graphql
+input CreateUserInput {
+  email: String!
+  name: String!
+  password: String!
+}
+
+input UpdateUserInput {
+  email: String
+  name: String
+}
+
+input UserFilter {
+  email: String
+  name: String
+  role: Role
+}
+
+input PaginationInput {
+  page: Int = 1
+  limit: Int = 20
+}
+```
+
+## Step 5: Resolver Architecture
+
+### Query Resolver
+
+```typescript
+@Resolver(() => User)
+export class UserResolver {
+  constructor(
+    private readonly userService: UserService,
+    private readonly postLoader: DataLoader<string, Post[]>
+  ) {}
+
+  @Query(() => User, { nullable: true })
+  async user(@Args('id') id: string) {
+    return this.userService.findOne(id)
+  }
+
+  @ResolveField(() => [Post])
+  async posts(@Parent() user: User) {
+    return this.postLoader.load(user.id)
+  }
+}
+```
+
+### Mutation Resolver
+
+```typescript
+@Mutation(() => User)
+async createUser(@Args('input') input: CreateUserInput) {
+  return this.userService.create(input)
+}
+```
+
+## Step 6: DataLoader Integration
+
+**Prevent N+1 queries:**
+
+```typescript
+@Injectable()
+export class PostLoader {
+  constructor(private readonly postService: PostService) {}
+
+  createLoader() {
+    return new DataLoader<string, Post[]>(async (userIds) => {
+      const posts = await this.postService.findByUserIds(userIds)
+      return userIds.map(id => posts.filter(p => p.userId === id))
+    })
+  }
+}
+```
+
+## Step 7: Security & Performance
+
+### Query Complexity
+
+```typescript
+GraphQLModule.forRoot({
+  validationRules: [
+    depthLimit(5),
+    queryComplexity({
+      maximumComplexity: 100,
+      estimators: [simpleEstimator({ defaultComplexity: 1 })]
+    })
+  ]
+})
+```
+
+### Authentication
+
+```typescript
+@UseGuards(GqlAuthGuard)
+@Query(() => User)
+async me(@CurrentUser() user: User) {
+  return user
+}
+```
+
+## Step 8: Subscriptions
+
+```typescript
+@Subscription(() => Post)
+postCreated() {
+  return this.pubSub.asyncIterator('POST_CREATED')
+}
+
+// In mutation
+async createPost(input: CreatePostInput) {
+  const post = await this.postService.create(input)
+  this.pubSub.publish('POST_CREATED', { postCreated: post })
+  return post
+}
+```
+
+## Step 9: Summary
+
+```
+═══════════════════════════════════════════════
+✅ GRAPHQL API DESIGNED
+═══════════════════════════════════════════════
+
+Types: [count]
+Queries: [count]
+Mutations: [count]
+Subscriptions: [count]
+
+Files to Create:
+├── schema.graphql
+├── resolvers/
+│   ├── user.resolver.ts
+│   └── post.resolver.ts
+├── models/
+├── dataloaders/
+└── guards/
+
+Example Queries:
+
+# Query
+query GetUser($id: ID!) {
+  user(id: $id) {
+    id
+    name
+    posts { id title }
+  }
+}
+
+# Mutation
+mutation CreateUser($input: CreateUserInput!) {
+  createUser(input: $input) {
+    id
+    email
+  }
+}
+
+# Subscription
+subscription OnPostCreated {
+  postCreated {
+    id
+    title
+    author { name }
+  }
+}
+
+Next steps:
+1. Review schema design
+2. Generate resolver files
+3. Set up DataLoaders
+4. Configure subscriptions
+═══════════════════════════════════════════════
+```

package/templates/.cursor/commands/devkit/backend/design-rest-api.md

@@ -0,0 +1,219 @@
+# Design REST API
+
+Design comprehensive RESTful API architecture with endpoints, authentication, and documentation.
+
+## ⚠️ Plan Before Executing
+
+**Always create a structured plan and get user approval before making changes.**
+
+1. Present complete API design
+2. Show all endpoints with request/response schemas
+3. Display authentication flow
+4. Ask for confirmation before generating files
+
+## Ask for Clarification
+
+If anything is unclear, **ask the user**:
+- "What are the primary resources for this API?"
+- "Which authentication method should be prioritized (JWT, OAuth, API keys)?"
+- "Are there specific rate limiting requirements?"
+- "What is the desired versioning strategy (URL, header, query)?"
+- "Should I include OpenAPI/Swagger documentation?"
+
+---
+
+## Step 1: Reference Project Profile
+
+Read `@.cursor/rules/project-profile.mdc` to understand:
+- Framework (NestJS, Express, FastAPI, etc.)
+- Existing API patterns
+- Authentication setup
+- Documentation format
+
+## Step 2: Analyze Requirements
+
+**Extract from request:**
+- Primary resources
+- Required operations (CRUD, custom)
+- Authentication requirements
+- Special features (pagination, filtering, versioning)
+
+## Step 3: Present API Design
+
+```
+═══════════════════════════════════════════════
+📋 REST API DESIGN
+═══════════════════════════════════════════════
+
+Base URL: /api/v1
+
+Resources:
+├── /users
+├── /products
+└── /orders
+
+Authentication: JWT Bearer Token
+
+Endpoints:
+┌────────┬──────────────────┬─────────────────────┐
+│ Method │ Path             │ Description         │
+├────────┼──────────────────┼─────────────────────┤
+│ GET    │ /users           │ List users          │
+│ GET    │ /users/:id       │ Get user            │
+│ POST   │ /users           │ Create user         │
+│ PUT    │ /users/:id       │ Update user         │
+│ DELETE │ /users/:id       │ Delete user         │
+└────────┴──────────────────┴─────────────────────┘
+
+Proceed with detailed design? (Y/n)
+═══════════════════════════════════════════════
+```
+
+## Step 4: Design Endpoints
+
+### RESTful Conventions
+
+| Method | Path | Description | Auth |
+|--------|------|-------------|------|
+| GET | /resources | List all (paginated) | Optional |
+| GET | /resources/:id | Get single resource | Optional |
+| POST | /resources | Create new resource | Required |
+| PUT | /resources/:id | Full update | Required |
+| PATCH | /resources/:id | Partial update | Required |
+| DELETE | /resources/:id | Delete resource | Required |
+
+### Nested Resources
+```
+GET  /users/:userId/orders        # User's orders
+POST /users/:userId/orders        # Create order for user
+GET  /users/:userId/orders/:id    # Specific user's order
+```
+
+## Step 5: Request/Response Design
+
+### Standard Response Format
+
+```json
+{
+  "data": { },
+  "meta": {
+    "pagination": {
+      "page": 1,
+      "limit": 20,
+      "total": 100,
+      "totalPages": 5
+    }
+  }
+}
+```
+
+### Error Response Format
+
+```json
+{
+  "error": {
+    "code": "VALIDATION_ERROR",
+    "message": "Validation failed",
+    "details": [
+      { "field": "email", "message": "Invalid email format" }
+    ]
+  }
+}
+```
+
+## Step 6: HTTP Status Codes
+
+| Status | When to Use |
+|--------|-------------|
+| 200 | Successful GET, PUT, PATCH |
+| 201 | Successful POST (created) |
+| 204 | Successful DELETE (no content) |
+| 400 | Bad request / validation error |
+| 401 | Unauthorized (not authenticated) |
+| 403 | Forbidden (not authorized) |
+| 404 | Resource not found |
+| 409 | Conflict (duplicate resource) |
+| 422 | Unprocessable entity |
+| 429 | Too many requests |
+| 500 | Internal server error |
+
+## Step 7: Authentication Design
+
+### JWT Authentication
+
+```typescript
+// Header
+Authorization: Bearer <token>
+
+// Token payload
+{
+  "sub": "user-id",
+  "role": "admin",
+  "exp": 1234567890
+}
+```
+
+### Endpoints
+
+| Endpoint | Description |
+|----------|-------------|
+| POST /auth/login | Get tokens |
+| POST /auth/refresh | Refresh access token |
+| POST /auth/logout | Invalidate tokens |
+
+## Step 8: Generate OpenAPI Spec
+
+```yaml
+openapi: 3.0.0
+info:
+  title: API Name
+  version: 1.0.0
+
+paths:
+  /resources:
+    get:
+      summary: List resources
+      parameters:
+        - name: page
+          in: query
+          schema:
+            type: integer
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ResourceList'
+```
+
+## Step 9: Summary
+
+```
+═══════════════════════════════════════════════
+✅ REST API DESIGNED
+═══════════════════════════════════════════════
+
+Resources: [count]
+Endpoints: [count]
+Authentication: [type]
+
+Files to Create:
+├── [controller files]
+├── [service files]
+├── [dto files]
+└── openapi.yaml
+
+curl Examples:
+├── List: curl -X GET /api/v1/resources
+├── Get:  curl -X GET /api/v1/resources/:id
+├── Create: curl -X POST /api/v1/resources -d '{}'
+└── Auth: curl -X POST /api/v1/auth/login
+
+Next steps:
+1. Review API design
+2. Generate endpoint files
+3. Set up authentication
+4. Create OpenAPI documentation
+═══════════════════════════════════════════════
+```