@malamute/ai-rules 1.4.0 → 1.5.1

package/configs/adonisjs/rules/testing.md

@@ -0,0 +1,170 @@
+---
+paths:
+  - "tests/**/*.ts"
+---
+
+# AdonisJS Testing (Japa)
+
+## Test Structure
+
+```
+tests/
+├── bootstrap.ts      # Test setup
+├── unit/
+│   └── services/
+├── functional/
+│   └── controllers/
+└── integration/
+```
+
+## Unit Test
+
+```typescript
+import { test } from '@japa/runner'
+import UserService from '#services/user_service'
+
+test.group('UserService', () => {
+  test('creates a user with valid data', async ({ assert }) => {
+    const service = new UserService()
+    const user = await service.create({
+      email: 'test@example.com',
+      password: 'password123',
+    })
+
+    assert.exists(user.id)
+    assert.equal(user.email, 'test@example.com')
+  })
+})
+```
+
+## Functional Test (HTTP)
+
+```typescript
+import { test } from '@japa/runner'
+import { UserFactory } from '#database/factories/user_factory'
+
+test.group('Users Controller', (group) => {
+  group.each.setup(async () => {
+    // Runs before each test
+    await Database.beginGlobalTransaction()
+    return () => Database.rollbackGlobalTransaction()
+  })
+
+  test('list all users', async ({ client, assert }) => {
+    await UserFactory.createMany(3)
+
+    const response = await client.get('/users')
+
+    response.assertStatus(200)
+    assert.lengthOf(response.body(), 3)
+  })
+
+  test('create a user', async ({ client }) => {
+    const response = await client.post('/users').json({
+      email: 'new@example.com',
+      password: 'password123',
+      name: 'New User',
+    })
+
+    response.assertStatus(201)
+    response.assertBodyContains({ email: 'new@example.com' })
+  })
+
+  test('requires authentication', async ({ client }) => {
+    const response = await client.get('/profile')
+    response.assertStatus(401)
+  })
+})
+```
+
+## Authenticated Requests
+
+```typescript
+test('authenticated user can view profile', async ({ client }) => {
+  const user = await UserFactory.create()
+
+  const response = await client
+    .get('/profile')
+    .loginAs(user)
+
+  response.assertStatus(200)
+  response.assertBodyContains({ id: user.id })
+})
+```
+
+## Database Helpers
+
+```typescript
+import Database from '@adonisjs/lucid/services/db'
+import { test } from '@japa/runner'
+
+test.group('Database tests', (group) => {
+  // Transaction per test (auto rollback)
+  group.each.setup(async () => {
+    await Database.beginGlobalTransaction()
+    return () => Database.rollbackGlobalTransaction()
+  })
+
+  // Or truncate tables
+  group.each.setup(async () => {
+    await Database.truncate('users')
+  })
+})
+```
+
+## Assertions
+
+```typescript
+test('response assertions', async ({ client, assert }) => {
+  const response = await client.get('/users/1')
+
+  // Status
+  response.assertStatus(200)
+  response.assertStatus(201)
+  response.assertStatus(404)
+
+  // Body
+  response.assertBody({ id: 1, name: 'John' })
+  response.assertBodyContains({ name: 'John' })
+
+  // Headers
+  response.assertHeader('content-type', 'application/json')
+
+  // Custom assertions
+  assert.equal(response.body().email, 'test@example.com')
+  assert.lengthOf(response.body().users, 3)
+  assert.isTrue(response.body().isActive)
+})
+```
+
+## Mocking
+
+```typescript
+import { test } from '@japa/runner'
+import mail from '@adonisjs/mail/services/main'
+
+test('sends welcome email on registration', async ({ client, assert }) => {
+  const { mails } = mail.fake()
+
+  await client.post('/auth/register').json({
+    email: 'test@example.com',
+    password: 'password123',
+  })
+
+  assert.lengthOf(mails.sent, 1)
+  mails.assertSent(WelcomeMail, (mail) => {
+    return mail.to[0].address === 'test@example.com'
+  })
+
+  mail.restore()
+})
+```
+
+## Running Tests
+
+```bash
+node ace test              # All tests
+node ace test --files="tests/functional/**"
+node ace test --tags="@slow"
+node ace test --watch      # Watch mode
+```

package/configs/adonisjs/rules/validation.md

@@ -0,0 +1,130 @@
+---
+paths:
+  - "app/validators/**/*.ts"
+---
+
+# VineJS Validation
+
+## Basic Validator
+
+```typescript
+import vine from '@vinejs/vine'
+
+export const createUserValidator = vine.compile(
+  vine.object({
+    email: vine.string().email().normalizeEmail(),
+    password: vine.string().minLength(8),
+    name: vine.string().minLength(2).maxLength(100),
+  })
+)
+
+export const updateUserValidator = vine.compile(
+  vine.object({
+    email: vine.string().email().normalizeEmail().optional(),
+    name: vine.string().minLength(2).maxLength(100).optional(),
+  })
+)
+```
+
+## Common Rules
+
+```typescript
+vine.object({
+  // Strings
+  name: vine.string().minLength(2).maxLength(100),
+  email: vine.string().email(),
+  url: vine.string().url(),
+  slug: vine.string().regex(/^[a-z0-9-]+$/),
+
+  // Numbers
+  age: vine.number().min(0).max(150),
+  price: vine.number().positive().decimal(2),
+
+  // Booleans
+  isActive: vine.boolean(),
+
+  // Dates
+  birthDate: vine.date({ formats: ['YYYY-MM-DD'] }),
+
+  // Arrays
+  tags: vine.array(vine.string()).minLength(1).maxLength(10),
+
+  // Enums
+  status: vine.enum(['draft', 'published', 'archived']),
+
+  // Optional & Nullable
+  bio: vine.string().optional(),
+  deletedAt: vine.date().nullable(),
+})
+```
+
+## Custom Error Messages
+
+```typescript
+export const createUserValidator = vine.compile(
+  vine.object({
+    email: vine.string().email(),
+    password: vine.string().minLength(8),
+  })
+)
+
+createUserValidator.messagesProvider = new SimpleMessagesProvider({
+  'email.required': 'Email is required',
+  'email.email': 'Invalid email format',
+  'password.minLength': 'Password must be at least 8 characters',
+})
+```
+
+## Unique Validation
+
+```typescript
+import vine from '@vinejs/vine'
+import { FieldContext } from '@vinejs/vine/types'
+import User from '#models/user'
+
+const uniqueEmail = vine.createRule(async (value: unknown, _options: undefined, field: FieldContext) => {
+  if (typeof value !== 'string') return
+
+  const user = await User.findBy('email', value)
+  if (user) {
+    field.report('Email already exists', 'unique', field)
+  }
+})
+
+export const createUserValidator = vine.compile(
+  vine.object({
+    email: vine.string().email().use(uniqueEmail()),
+  })
+)
+```
+
+## Conditional Validation
+
+```typescript
+vine.object({
+  accountType: vine.enum(['personal', 'business']),
+  companyName: vine
+    .string()
+    .minLength(2)
+    .requiredWhen('accountType', '=', 'business'),
+  taxId: vine
+    .string()
+    .optional()
+    .requiredWhen('accountType', '=', 'business'),
+})
+```
+
+## Usage in Controller
+
+```typescript
+import { createUserValidator } from '#validators/user'
+
+export default class UsersController {
+  async store({ request, response }: HttpContext) {
+    const payload = await request.validateUsing(createUserValidator)
+    // payload is fully typed: { email: string, password: string, name: string }
+    const user = await User.create(payload)
+    return response.created(user)
+  }
+}
+```

package/configs/adonisjs/settings.json

@@ -0,0 +1,34 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(node ace serve --watch)",
+      "Bash(node ace build)",
+      "Bash(node ace test*)",
+      "Bash(node ace make:*)",
+      "Bash(node ace migration:*)",
+      "Bash(node ace db:*)",
+      "Bash(node ace generate:*)",
+      "Bash(node ace list)",
+      "Bash(npm run dev)",
+      "Bash(npm run build)",
+      "Bash(npm run test*)",
+      "Bash(npm run lint*)",
+      "Bash(npm install *)",
+      "Bash(npm ci)",
+      "Read",
+      "Edit",
+      "Write"
+    ],
+    "deny": [
+      "Bash(git push *)",
+      "Bash(git push)",
+      "Bash(rm -rf *)",
+      "Read(.env)",
+      "Read(.env.*)",
+      "Read(**/secrets/**)"
+    ]
+  },
+  "env": {
+    "NODE_ENV": "development"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malamute/ai-rules",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Claude Code configuration boilerplates for Angular, Next.js, NestJS, .NET, Python and more",
   "type": "module",
   "main": "src/index.js",

package/src/tech-config.json

@@ -23,6 +23,10 @@
     "flask": {
       "type": "backend",
       "language": "python"
+    },
+    "adonisjs": {
+      "type": "backend",
+      "language": "typescript"
     }
   },
   "ruleMapping": {