@etus/bhono-app 0.1.5 → 0.1.6

package/templates/base/{src/server/routes/health/__tests__ → tests/unit/server/routes/health}/handlers.test.ts

@@ -1,9 +1,9 @@
 // src/server/routes/health/__tests__/handlers.test.ts
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { Hono } from 'hono'
-import type { HonoEnv } from '../../../types'
-import { health } from '../index'
-import { createMockEnv } from '../../../__tests__/setup'
+import type { HonoEnv } from '@server/types'
+import { health } from '@server/routes/index'
+import { createMockEnv } from '@tests/helpers/server'
 
 describe('Health Routes', () => {
   let mockEnv: ReturnType<typeof createMockEnv>
@@ -13,19 +13,15 @@ describe('Health Routes', () => {
     mockEnv = createMockEnv()
   })
 
-  // Helper to create app with specific db mock
-  function createApp(dbMock?: any) {
+  // Helper to create app with environment overrides
+  function createApp(envOverrides?: Partial<typeof mockEnv>) {
     const app = new Hono<HonoEnv>()
 
     // Setup middleware to inject mock environment
     app.use('*', async (c, next) => {
+      const env = { ...mockEnv, ...(envOverrides ?? {}) }
       // Set environment bindings by mutating c.env
-      ;(c as any).env = mockEnv
-      // Create mock db that supports sql template literal
-      const mockDb = dbMock ?? {
-        run: vi.fn().mockResolvedValue({ rows: [{ 1: 1 }] }),
-      }
-      c.set('db', mockDb)
+      ;(c as any).env = env
       await next()
     })
 
@@ -64,9 +60,11 @@ describe('Health Routes', () => {
 
       // Create app with failing db
       const failingDb = {
-        run: vi.fn().mockRejectedValue(new Error('DB connection failed')),
-      }
-      const app = createApp(failingDb)
+        prepare: vi.fn(() => {
+          throw new Error('DB connection failed')
+        }),
+      } as D1Database
+      const app = createApp({ DB: failingDb })
 
       const res = await app.request('/health', {
         method: 'GET',
@@ -125,9 +123,11 @@ describe('Health Routes', () => {
 
       // Create app with failing db
       const failingDb = {
-        run: vi.fn().mockRejectedValue(new Error('DB connection failed')),
-      }
-      const app = createApp(failingDb)
+        prepare: vi.fn(() => {
+          throw new Error('DB connection failed')
+        }),
+      } as D1Database
+      const app = createApp({ DB: failingDb })
 
       const res = await app.request('/health', {
         method: 'GET',
@@ -156,9 +156,11 @@ describe('Health Routes', () => {
     it('returns 503 when db is down', async () => {
       // Create app with failing db
       const failingDb = {
-        run: vi.fn().mockRejectedValue(new Error('DB connection failed')),
-      }
-      const app = createApp(failingDb)
+        prepare: vi.fn(() => {
+          throw new Error('DB connection failed')
+        }),
+      } as D1Database
+      const app = createApp({ DB: failingDb })
 
       const res = await app.request('/health/ready', {
         method: 'GET',
@@ -196,9 +198,11 @@ describe('Health Routes', () => {
     it('returns alive even when db is down', async () => {
       // Create app with failing db
       const failingDb = {
-        run: vi.fn().mockRejectedValue(new Error('DB connection failed')),
-      }
-      const app = createApp(failingDb)
+        prepare: vi.fn(() => {
+          throw new Error('DB connection failed')
+        }),
+      } as D1Database
+      const app = createApp({ DB: failingDb })
 
       const res = await app.request('/health/live', {
         method: 'GET',

package/templates/base/{src/server/routes/invitations/__tests__ → tests/unit/server/routes/invitations}/handlers.test.ts

@@ -1,11 +1,11 @@
 // src/server/routes/invitations/__tests__/handlers.test.ts
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { Hono } from 'hono'
-import type { HonoEnv } from '../../../types'
-import { invitationsRouter } from '../index'
-import { createMockEnv } from '../../../__tests__/setup'
-import { createUserFixture, createAccountFixture } from '../../../__tests__/fixtures'
-import { NotFoundError, ConflictError, ForbiddenError } from '../../../lib/errors'
+import type { HonoEnv } from '@server/types'
+import { invitationsRouter } from '@server/routes/index'
+import { createMockEnv } from '@tests/helpers/server'
+import { createUserFixture, createAccountFixture } from '@tests/fixtures/server'
+import { NotFoundError, ConflictError, ForbiddenError } from '@server/lib/errors'
 
 // Test UUIDs
 const TEST_USER_ID = '550e8400-e29b-41d4-a716-446655440001'
@@ -14,7 +14,7 @@ const TEST_INVITATION_ID = '550e8400-e29b-41d4-a716-446655440201'
 const NON_EXISTENT_ID = '550e8400-e29b-41d4-a716-446655440999'
 
 // Mock the invitations service
-vi.mock('../../../services/invitations', () => ({
+vi.mock('@server/services/invitations', () => ({
   invitationsService: {
     create: vi.fn(),
     list: vi.fn(),
@@ -22,7 +22,7 @@ vi.mock('../../../services/invitations', () => ({
   },
 }))
 
-import { invitationsService } from '../../../services/invitations'
+import { invitationsService } from '@server/services/invitations'
 
 describe('Invitations Routes', () => {
   let mockEnv: ReturnType<typeof createMockEnv>
@@ -214,7 +214,7 @@ describe('Invitations Routes', () => {
       })
 
       expect(invitationsService.create).toHaveBeenCalledWith(
-        mockDb,
+        mockEnv.DB,
         mockEnv,
         expect.objectContaining({
           accountId: testAccount.id,
@@ -289,7 +289,7 @@ describe('Invitations Routes', () => {
       })
 
       expect(invitationsService.list).toHaveBeenCalledWith(
-        mockDb,
+        mockEnv.DB,
         expect.objectContaining({
           accountId: testAccount.id,
           user: expect.objectContaining({ id: testUser.id }),
@@ -311,7 +311,7 @@ describe('Invitations Routes', () => {
 
       expect(res.status).toBe(204)
       expect(invitationsService.revoke).toHaveBeenCalledWith(
-        mockDb,
+        mockEnv.DB,
         expect.objectContaining({
           accountId: testAccount.id,
           user: expect.objectContaining({ id: testUser.id }),
@@ -363,9 +363,11 @@ describe('Invitations Routes', () => {
       const brokenApp = new Hono<HonoEnv>()
       const testUser = createUserFixture({ id: TEST_USER_ID })
       const testAccount = createAccountFixture({ id: TEST_ACCOUNT_ID })
+      const mockEnv = createMockEnv()
+      ;(mockEnv as any).DB = undefined
 
       brokenApp.use('*', async (c, next) => {
-        ;(c as any).env = createMockEnv()
+        ;(c as any).env = mockEnv
         c.set('db', null) // No database
         c.set('transactionId', 'test-transaction-id')
         c.set('ip', '127.0.0.1')
@@ -388,12 +390,7 @@ describe('Invitations Routes', () => {
 
       brokenApp.use('*', async (c, next) => {
         ;(c as any).env = mockEnv
-        c.set('db', {
-          select: vi.fn().mockReturnThis(),
-          from: vi.fn().mockReturnThis(),
-          where: vi.fn().mockReturnThis(),
-          limit: vi.fn().mockResolvedValue([]),
-        })
+        c.set('db', mockEnv.DB)
         c.set('transactionId', 'test-transaction-id')
         c.set('ip', '127.0.0.1')
         c.set('userAgent', 'TestAgent/1.0')

package/templates/base/{src/server/routes/storage/__tests__ → tests/unit/server/routes/storage}/handlers.test.ts

@@ -1,13 +1,13 @@
 // src/server/routes/storage/__tests__/handlers.test.ts
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { Hono } from 'hono'
-import type { HonoEnv } from '../../../types'
-import { storage } from '../index'
-import { createMockEnv } from '../../../__tests__/setup'
-import { createUserFixture, createAccountFixture } from '../../../__tests__/fixtures'
+import type { HonoEnv } from '@server/types'
+import { storage } from '@server/routes/index'
+import { createMockEnv } from '@tests/helpers/server'
+import { createUserFixture, createAccountFixture } from '@tests/fixtures/server'
 
 // Mock the r2-storage lib
-vi.mock('../../../lib/r2-storage', () => ({
+vi.mock('@server/lib/r2-storage', () => ({
   generateUploadUrl: vi.fn(),
   uploadFile: vi.fn(),
   deleteFile: vi.fn(),
@@ -19,7 +19,7 @@ import {
   uploadFile,
   deleteFile,
   getFileMetadata,
-} from '../../../lib/r2-storage'
+} from '@server/lib/r2-storage'
 
 // Test UUIDs
 const TEST_USER_ID = '550e8400-e29b-41d4-a716-446655440001'

package/templates/base/{src/server/routes/users/__tests__ → tests/unit/server/routes/users}/handlers.test.ts

@@ -1,15 +1,15 @@
 // src/server/routes/users/__tests__/handlers.test.ts
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { Hono } from 'hono'
-import type { HonoEnv } from '../../../types'
-import { users } from '../index'
-import { createMockEnv } from '../../../__tests__/setup'
+import type { HonoEnv } from '@server/types'
+import { users } from '@server/routes/index'
+import { createMockEnv } from '@tests/helpers/server'
 import {
   createUserFixture,
   createAccountFixture,
   createDeletedUserFixture,
-} from '../../../__tests__/fixtures'
-import { NotFoundError } from '../../../lib/errors'
+} from '@tests/fixtures/server'
+import { NotFoundError } from '@server/lib/errors'
 
 // Test UUIDs
 const TEST_USER_ID = '550e8400-e29b-41d4-a716-446655440001'
@@ -18,7 +18,7 @@ const TEST_ACCOUNT_ID = '550e8400-e29b-41d4-a716-446655440101'
 const NON_EXISTENT_ID = '550e8400-e29b-41d4-a716-446655440999'
 
 // Mock the users service
-vi.mock('../../../services', () => ({
+vi.mock('@server/services', () => ({
   usersService: {
     findAll: vi.fn(),
     findById: vi.fn(),
@@ -30,7 +30,7 @@ vi.mock('../../../services', () => ({
   },
 }))
 
-import { usersService } from '../../../services'
+import { usersService } from '@server/services'
 
 describe('Users Routes', () => {
   let app: Hono<HonoEnv>
@@ -162,7 +162,7 @@ describe('Users Routes', () => {
 
       expect(res.status).toBe(200)
       expect(usersService.findAll).toHaveBeenCalledWith(
-        mockDb,
+        mockEnv.DB,
         expect.objectContaining({
           accountId: testAccount.id,
         }),
@@ -212,7 +212,7 @@ describe('Users Routes', () => {
 
       expect(res.status).toBe(200)
       expect(usersService.findAll).toHaveBeenCalledWith(
-        mockDb,
+        mockEnv.DB,
         expect.anything(),
         expect.objectContaining({
           query: 'search',
@@ -270,7 +270,7 @@ describe('Users Routes', () => {
       })
 
       expect(usersService.findById).toHaveBeenCalledWith(
-        mockDb,
+        mockEnv.DB,
         expect.objectContaining({
           accountId: testAccount.id,
           user: expect.objectContaining({ id: testUser.id }),
@@ -328,7 +328,7 @@ describe('Users Routes', () => {
 
       expect(res.status).toBe(200)
       expect(usersService.update).toHaveBeenCalledWith(
-        mockDb,
+        mockEnv.DB,
         expect.anything(),
         TEST_USER_ID,
         expect.objectContaining({ status: 'inactive' })
@@ -373,7 +373,7 @@ describe('Users Routes', () => {
 
       expect(res.status).toBe(204)
       expect(usersService.delete).toHaveBeenCalledWith(
-        mockDb,
+        mockEnv.DB,
         expect.anything(),
         TEST_USER_ID
       )

package/templates/base/tests/unit/server/services/accounts.test.ts

@@ -0,0 +1,258 @@
+// src/server/services/__tests__/accounts.test.ts
+import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest'
+import { accountsService } from '@server/services/accounts'
+import { NotFoundError, ForbiddenError, ConflictError } from '@server/lib/errors'
+import type { ServiceContext, PaginationQuery } from '@server/types'
+import {
+  createUserFixture,
+  createSuperAdminFixture,
+  createAccountFixture,
+  createDeletedAccountFixture,
+} from '@tests/fixtures/server'
+
+vi.mock('@server/lib/audited-db', () => ({
+  auditedInsert: vi.fn(),
+  auditedUpdate: vi.fn(),
+  auditedDelete: vi.fn(),
+}))
+
+vi.mock('@server/db/sql', () => ({
+  queryOne: vi.fn(),
+  queryAll: vi.fn(),
+  execute: vi.fn(),
+}))
+
+import { auditedInsert, auditedUpdate, auditedDelete } from '@server/lib/audited-db'
+import { queryOne, queryAll } from '@server/db/sql'
+
+const db = {} as D1Database
+
+function createMockContext(overrides: Partial<ServiceContext> = {}): ServiceContext {
+  const user = createUserFixture({
+    id: 'ctx-user-123',
+    email: 'context@example.com',
+    name: 'Context User',
+  })
+
+  return {
+    accountId: 'account-123',
+    user,
+    userRole: 'ADMIN',
+    transactionId: 'tx-123',
+    ip: '127.0.0.1',
+    userAgent: 'TestAgent/1.0',
+    ...overrides,
+  }
+}
+
+function createSuperAdminContext(overrides: Partial<ServiceContext> = {}): ServiceContext {
+  const user = createSuperAdminFixture({
+    id: 'super-admin-123',
+    email: 'superadmin@example.com',
+    name: 'Super Admin',
+  })
+
+  return {
+    accountId: 'account-123',
+    user,
+    userRole: 'ADMIN',
+    transactionId: 'tx-123',
+    ip: '127.0.0.1',
+    userAgent: 'TestAgent/1.0',
+    ...overrides,
+  }
+}
+
+describe('accountsService', () => {
+  let ctx: ServiceContext
+  let superAdminCtx: ServiceContext
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    ctx = createMockContext()
+    superAdminCtx = createSuperAdminContext()
+  })
+
+  describe('findAll', () => {
+    const defaultPagination: PaginationQuery = { page: 1, limit: 10 }
+
+    it('should return paginated accounts for super admin', async () => {
+      const account1 = createAccountFixture({ id: 'account-1', name: 'Account One' })
+      const account2 = createAccountFixture({ id: 'account-2', name: 'Account Two' })
+
+      ;(queryOne as Mock).mockResolvedValueOnce({ count: 2 })
+      ;(queryAll as Mock).mockResolvedValueOnce([
+        { ...account1, created_at: account1.createdAt, updated_at: account1.updatedAt, deleted_at: account1.deletedAt },
+        { ...account2, created_at: account2.createdAt, updated_at: account2.updatedAt, deleted_at: account2.deletedAt },
+      ])
+
+      const result = await accountsService.findAll(db, superAdminCtx, defaultPagination)
+
+      expect(result.data).toHaveLength(2)
+      expect(result.meta.totalItems).toBe(2)
+    })
+
+    it('should include user filter for non-super-admin', async () => {
+      const account = createAccountFixture({ id: 'account-1', name: 'User Account' })
+
+      ;(queryOne as Mock).mockResolvedValueOnce({ count: 1 })
+      ;(queryAll as Mock).mockResolvedValueOnce([
+        { ...account, created_at: account.createdAt, updated_at: account.updatedAt, deleted_at: account.deletedAt },
+      ])
+
+      await accountsService.findAll(db, ctx, defaultPagination)
+
+      expect((queryOne as Mock).mock.calls[0][2]).toContain(ctx.user.id)
+    })
+  })
+
+  describe('findById', () => {
+    it('should return account for super admin', async () => {
+      const account = createAccountFixture({ id: 'account-1' })
+      ;(queryOne as Mock).mockResolvedValueOnce({
+        ...account,
+        created_at: account.createdAt,
+        updated_at: account.updatedAt,
+        deleted_at: account.deletedAt,
+      })
+
+      const result = await accountsService.findById(db, superAdminCtx, account.id)
+
+      expect(result.id).toBe(account.id)
+    })
+
+    it('should throw NotFound when account missing', async () => {
+      ;(queryOne as Mock).mockResolvedValueOnce(null)
+
+      await expect(accountsService.findById(db, superAdminCtx, 'missing')).rejects.toThrow(NotFoundError)
+    })
+
+    it('should enforce membership for non-super-admin', async () => {
+      const account = createAccountFixture({ id: 'account-1' })
+      ;(queryOne as Mock)
+        .mockResolvedValueOnce({
+          ...account,
+          created_at: account.createdAt,
+          updated_at: account.updatedAt,
+          deleted_at: account.deletedAt,
+        })
+        .mockResolvedValueOnce(null)
+
+      await expect(accountsService.findById(db, ctx, account.id)).rejects.toThrow(NotFoundError)
+    })
+  })
+
+  describe('create', () => {
+    it('should reject non-super-admin users', async () => {
+      await expect(accountsService.create(db, ctx, { name: 'New' })).rejects.toThrow(ForbiddenError)
+    })
+
+    it('should reject duplicate domain', async () => {
+      ;(queryOne as Mock).mockResolvedValueOnce({ ok: 1 })
+
+      await expect(
+        accountsService.create(db, superAdminCtx, { name: 'Dup', domain: 'acme.com' })
+      ).rejects.toThrow(ConflictError)
+    })
+
+    it('should create account and return record', async () => {
+      const account = createAccountFixture({ id: 'account-1', name: 'New Account' })
+      ;(auditedInsert as Mock).mockResolvedValueOnce([
+        { ...account, created_at: account.createdAt, updated_at: account.updatedAt, deleted_at: account.deletedAt },
+      ])
+
+      const result = await accountsService.create(db, superAdminCtx, { name: 'New Account' })
+
+      expect(result.name).toBe('New Account')
+      expect(auditedInsert).toHaveBeenCalled()
+    })
+  })
+
+  describe('update', () => {
+    it('should reject non-super-admin users', async () => {
+      await expect(accountsService.update(db, ctx, 'account-1', { name: 'Updated' })).rejects.toThrow(ForbiddenError)
+    })
+
+    it('should reject duplicate domain', async () => {
+      const account = createAccountFixture({ id: 'account-1' })
+      ;(queryOne as Mock)
+        .mockResolvedValueOnce({
+          ...account,
+          created_at: account.createdAt,
+          updated_at: account.updatedAt,
+          deleted_at: account.deletedAt,
+        })
+        .mockResolvedValueOnce({ ok: 1 })
+
+      await expect(
+        accountsService.update(db, superAdminCtx, account.id, { domain: 'dup.com' })
+      ).rejects.toThrow(ConflictError)
+    })
+
+    it('should update account and return record', async () => {
+      const account = createAccountFixture({ id: 'account-1', name: 'Original' })
+      ;(queryOne as Mock)
+        .mockResolvedValueOnce({
+          ...account,
+          created_at: account.createdAt,
+          updated_at: account.updatedAt,
+          deleted_at: account.deletedAt,
+        })
+
+      const updated = { ...account, name: 'Updated' }
+      ;(auditedUpdate as Mock).mockResolvedValueOnce([
+        { ...updated, created_at: updated.createdAt, updated_at: updated.updatedAt, deleted_at: updated.deletedAt },
+      ])
+
+      const result = await accountsService.update(db, superAdminCtx, account.id, { name: 'Updated' })
+
+      expect(result.name).toBe('Updated')
+      expect(auditedUpdate).toHaveBeenCalled()
+    })
+  })
+
+  describe('delete', () => {
+    it('should reject non-super-admin users', async () => {
+      await expect(accountsService.delete(db, ctx, 'account-1')).rejects.toThrow(ForbiddenError)
+    })
+
+    it('should delete account for super admin', async () => {
+      const account = createAccountFixture({ id: 'account-1' })
+      ;(queryOne as Mock).mockResolvedValueOnce({
+        ...account,
+        created_at: account.createdAt,
+        updated_at: account.updatedAt,
+        deleted_at: account.deletedAt,
+      })
+
+      await accountsService.delete(db, superAdminCtx, account.id)
+
+      expect(auditedDelete).toHaveBeenCalled()
+    })
+  })
+
+  describe('restore', () => {
+    it('should reject non-super-admin users', async () => {
+      await expect(accountsService.restore(db, ctx, 'account-1')).rejects.toThrow(ForbiddenError)
+    })
+
+    it('should restore soft-deleted account', async () => {
+      const deleted = createDeletedAccountFixture({ id: 'account-1' })
+      ;(queryOne as Mock).mockResolvedValueOnce({
+        ...deleted,
+        created_at: deleted.createdAt,
+        updated_at: deleted.updatedAt,
+        deleted_at: deleted.deletedAt,
+      })
+
+      const restored = createAccountFixture({ id: 'account-1' })
+      ;(auditedUpdate as Mock).mockResolvedValueOnce([
+        { ...restored, created_at: restored.createdAt, updated_at: restored.updatedAt, deleted_at: restored.deletedAt },
+      ])
+
+      const result = await accountsService.restore(db, superAdminCtx, deleted.id)
+
+      expect(result.deletedAt).toBeNull()
+    })
+  })
+})