@etus/bhono-app 0.1.1

package/templates/base/src/server/routes/users/handlers.ts

@@ -0,0 +1,228 @@
+import type { RouteHandler } from '@hono/zod-openapi'
+import type { ServiceContext, HonoEnv } from '../../types'
+import { usersService } from '../../services'
+import type {
+  listUsersRoute,
+  getUserRoute,
+  updateUserRoute,
+  deleteUserRoute,
+  createBulkUserAccountsRoute,
+  deleteBulkUserAccountsRoute,
+  restoreUserRoute,
+} from './routes'
+
+export const listUsersHandler: RouteHandler<typeof listUsersRoute, HonoEnv> = async (c) => {
+  const query = c.req.valid('query')
+  const db = c.get('db')
+  const accountId = c.get('accountId')
+  const user = c.get('user')
+  const transactionId = c.get('transactionId')
+  const ip = c.get('ip')
+  const userAgent = c.get('userAgent')
+
+  if (!db || !accountId || !user) {
+    throw new Error('Missing required context')
+  }
+
+  const ctx: ServiceContext = {
+    accountId,
+    user,
+    transactionId,
+    ip,
+    userAgent,
+  }
+
+  const result = await usersService.findAll(db, ctx, {
+    page: query.page,
+    limit: query.limit,
+    sortBy: query.sortBy,
+    sortOrder: query.sortOrder,
+    query: query.query,
+  })
+
+  return c.json(result, 200)
+}
+
+export const getUserHandler: RouteHandler<typeof getUserRoute, HonoEnv> = async (c) => {
+  const { id } = c.req.valid('param')
+  const db = c.get('db')
+  const accountId = c.get('accountId')
+  const user = c.get('user')
+  const transactionId = c.get('transactionId')
+  const ip = c.get('ip')
+  const userAgent = c.get('userAgent')
+
+  if (!db || !accountId || !user) {
+    throw new Error('Missing required context')
+  }
+
+  const ctx: ServiceContext = {
+    accountId,
+    user,
+    transactionId,
+    ip,
+    userAgent,
+  }
+
+  const foundUser = await usersService.findById(db, ctx, id)
+  return c.json({ data: foundUser }, 200)
+}
+
+// NOTE: User creation is disabled - users should only be created through Google OAuth
+/*
+export async function createUserHandler(c: any) {
+  const data = c.req.valid('json')
+  const accountId = c.get('accountId')
+  const user = c.get('user')!
+  const transactionId = c.get('transactionId')
+  const ip = c.get('ip')
+  const userAgent = c.get('userAgent')
+
+  const ctx: ServiceContext = {
+    accountId,
+    user,
+    transactionId,
+    ip,
+    userAgent,
+  }
+
+  const newUser = await usersService.create(ctx, {
+    email: data.email,
+    name: data.name,
+    role: data.role,
+  })
+
+  return c.json({ data: newUser }, 201)
+}
+*/
+
+export const updateUserHandler: RouteHandler<typeof updateUserRoute, HonoEnv> = async (c) => {
+  const { id } = c.req.valid('param')
+  const data = c.req.valid('json')
+  const db = c.get('db')
+  const accountId = c.get('accountId')
+  const user = c.get('user')
+  const transactionId = c.get('transactionId')
+  const ip = c.get('ip')
+  const userAgent = c.get('userAgent')
+
+  if (!db || !accountId || !user) {
+    throw new Error('Missing required context')
+  }
+
+  const ctx: ServiceContext = {
+    accountId,
+    user,
+    transactionId,
+    ip,
+    userAgent,
+  }
+
+  const updatedUser = await usersService.update(db, ctx, id, {
+    name: data.name,
+    status: data.status,
+  })
+
+  return c.json({ data: updatedUser }, 200)
+}
+
+export const deleteUserHandler: RouteHandler<typeof deleteUserRoute, HonoEnv> = async (c) => {
+  const { id } = c.req.valid('param')
+  const db = c.get('db')
+  const accountId = c.get('accountId')
+  const user = c.get('user')
+  const transactionId = c.get('transactionId')
+  const ip = c.get('ip')
+  const userAgent = c.get('userAgent')
+
+  if (!db || !accountId || !user) {
+    throw new Error('Missing required context')
+  }
+
+  const ctx: ServiceContext = {
+    accountId,
+    user,
+    transactionId,
+    ip,
+    userAgent,
+  }
+
+  await usersService.delete(db, ctx, id)
+  return c.body(null, 204)
+}
+
+// Bulk User-Account Operations
+export const createBulkUserAccountsHandler: RouteHandler<typeof createBulkUserAccountsRoute, HonoEnv> = async (c) => {
+  const data = c.req.valid('json')
+  const db = c.get('db')
+  const accountId = c.get('accountId')
+  const user = c.get('user')
+  const transactionId = c.get('transactionId')
+  const ip = c.get('ip')
+  const userAgent = c.get('userAgent')
+
+  if (!db || !accountId || !user) {
+    throw new Error('Missing required context')
+  }
+
+  const ctx: ServiceContext = {
+    accountId,
+    user,
+    transactionId,
+    ip,
+    userAgent,
+  }
+
+  const result = await usersService.createUserAccounts(db, ctx, data)
+  return c.json(result, 201)
+}
+
+export const deleteBulkUserAccountsHandler: RouteHandler<typeof deleteBulkUserAccountsRoute, HonoEnv> = async (c) => {
+  const data = c.req.valid('json')
+  const db = c.get('db')
+  const accountId = c.get('accountId')
+  const user = c.get('user')
+  const transactionId = c.get('transactionId')
+  const ip = c.get('ip')
+  const userAgent = c.get('userAgent')
+
+  if (!db || !accountId || !user) {
+    throw new Error('Missing required context')
+  }
+
+  const ctx: ServiceContext = {
+    accountId,
+    user,
+    transactionId,
+    ip,
+    userAgent,
+  }
+
+  const result = await usersService.deleteUserAccounts(db, ctx, data)
+  return c.json(result, 200)
+}
+
+export const restoreUserHandler: RouteHandler<typeof restoreUserRoute, HonoEnv> = async (c) => {
+  const { id } = c.req.valid('param')
+  const db = c.get('db')
+  const accountId = c.get('accountId')
+  const user = c.get('user')
+  const transactionId = c.get('transactionId')
+  const ip = c.get('ip')
+  const userAgent = c.get('userAgent')
+
+  if (!db || !accountId || !user) {
+    throw new Error('Missing required context')
+  }
+
+  const ctx: ServiceContext = {
+    accountId,
+    user,
+    transactionId,
+    ip,
+    userAgent,
+  }
+
+  const result = await usersService.restore(db, ctx, id)
+  return c.json({ data: result }, 200)
+}

package/templates/base/src/server/routes/users/index.ts

@@ -0,0 +1,67 @@
+import { OpenAPIHono } from '@hono/zod-openapi'
+import type { HonoEnv } from '../../types'
+import { requireRole } from '../../auth/guards'
+import {
+  listUsersRoute,
+  getUserRoute,
+  // createUserRoute, // Disabled - users should only be created via OAuth
+  updateUserRoute,
+  deleteUserRoute,
+  createBulkUserAccountsRoute,
+  deleteBulkUserAccountsRoute,
+  restoreUserRoute,
+} from './routes'
+import {
+  listUsersHandler,
+  getUserHandler,
+  // createUserHandler, // Disabled - users should only be created via OAuth
+  updateUserHandler,
+  deleteUserHandler,
+  createBulkUserAccountsHandler,
+  deleteBulkUserAccountsHandler,
+  restoreUserHandler,
+} from './handlers'
+
+const users = new OpenAPIHono<HonoEnv>()
+
+/**
+ * Convert OpenAPI path syntax {param} to Hono path syntax :param
+ * This is needed because .use() requires Hono path syntax
+ */
+function toHonoPath(openApiPath: string): string {
+  return openApiPath.replaceAll(/{(\w+)}/g, ':$1')
+}
+
+// List users - requires VIEWER role or higher
+users.openapi(listUsersRoute, listUsersHandler)
+
+// NOTE: User creation route is disabled - users should only be created through Google OAuth
+// Create user - requires ADMIN role
+// users.use(toHonoPath(createUserRoute.path), requireRole('ADMIN'))
+// users.openapi(createUserRoute, createUserHandler)
+
+// Bulk User-Account Operations - register BEFORE /:id routes to prevent wildcard matching
+// Create user-account relationships - requires MANAGER role or higher
+users.use(toHonoPath(createBulkUserAccountsRoute.path), requireRole('MANAGER'))
+users.openapi(createBulkUserAccountsRoute, createBulkUserAccountsHandler)
+
+// Delete user-account relationships - requires MANAGER role or higher
+users.use(toHonoPath(deleteBulkUserAccountsRoute.path), requireRole('MANAGER'))
+users.openapi(deleteBulkUserAccountsRoute, deleteBulkUserAccountsHandler)
+
+// Get user - requires VIEWER role or higher
+users.openapi(getUserRoute, getUserHandler)
+
+// Update user - requires MANAGER role or higher
+users.use(toHonoPath(updateUserRoute.path), requireRole('MANAGER'))
+users.openapi(updateUserRoute, updateUserHandler)
+
+// Delete user - requires ADMIN role
+users.use(toHonoPath(deleteUserRoute.path), requireRole('ADMIN'))
+users.openapi(deleteUserRoute, deleteUserHandler)
+
+// Restore soft-deleted user - requires ADMIN role
+users.use(toHonoPath(restoreUserRoute.path), requireRole('ADMIN'))
+users.openapi(restoreUserRoute, restoreUserHandler)
+
+export { users }

package/templates/base/src/server/routes/users/routes.ts

@@ -0,0 +1,265 @@
+import { createRoute, z } from '@hono/zod-openapi'
+import {
+  UserSchema,
+  PaginatedUsersSchema,
+  CreateUserSchema,
+  UpdateUserSchema,
+  BulkUserAccountsInputSchema,
+  BulkOperationSuccessSchema,
+} from './schemas'
+import {
+  ErrorResponseSchema,
+  PaginationQuerySchema,
+  IdParamSchema,
+} from '../schemas'
+
+export const listUsersRoute = createRoute({
+  method: 'get',
+  path: '/',
+  tags: ['Users'],
+  summary: 'List users in account',
+  request: {
+    query: PaginationQuerySchema,
+  },
+  responses: {
+    200: {
+      description: 'List of users',
+      content: { 'application/json': { schema: PaginatedUsersSchema } },
+    },
+    401: {
+      description: 'Unauthorized',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+})
+
+export const getUserRoute = createRoute({
+  method: 'get',
+  path: '/{id}',
+  tags: ['Users'],
+  summary: 'Get user by ID',
+  request: {
+    params: IdParamSchema,
+  },
+  responses: {
+    200: {
+      description: 'User details',
+      content: {
+        'application/json': {
+          schema: z.object({
+            data: UserSchema,
+          }),
+        },
+      },
+    },
+    401: {
+      description: 'Unauthorized',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    404: {
+      description: 'User not found',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+})
+
+export const createUserRoute = createRoute({
+  method: 'post',
+  path: '/',
+  tags: ['Users'],
+  summary: 'Create new user',
+  request: {
+    body: {
+      content: { 'application/json': { schema: CreateUserSchema } },
+    },
+  },
+  responses: {
+    201: {
+      description: 'User created',
+      content: {
+        'application/json': {
+          schema: z.object({
+            data: UserSchema,
+          }),
+        },
+      },
+    },
+    400: {
+      description: 'Invalid input',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    401: {
+      description: 'Unauthorized',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    409: {
+      description: 'Email already exists',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+})
+
+export const updateUserRoute = createRoute({
+  method: 'patch',
+  path: '/{id}',
+  tags: ['Users'],
+  summary: 'Update user',
+  request: {
+    params: IdParamSchema,
+    body: {
+      content: { 'application/json': { schema: UpdateUserSchema } },
+    },
+  },
+  responses: {
+    200: {
+      description: 'User updated',
+      content: {
+        'application/json': {
+          schema: z.object({
+            data: UserSchema,
+          }),
+        },
+      },
+    },
+    400: {
+      description: 'Invalid input',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    401: {
+      description: 'Unauthorized',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    404: {
+      description: 'User not found',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+})
+
+export const deleteUserRoute = createRoute({
+  method: 'delete',
+  path: '/{id}',
+  tags: ['Users'],
+  summary: 'Delete user (soft delete)',
+  request: {
+    params: IdParamSchema,
+  },
+  responses: {
+    204: {
+      description: 'User deleted',
+    },
+    401: {
+      description: 'Unauthorized',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    404: {
+      description: 'User not found',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+})
+
+// Bulk User-Account Operations
+export const createBulkUserAccountsRoute = createRoute({
+  method: 'post',
+  path: '/accounts',
+  tags: ['Users'],
+  summary: 'Create user-account relationships in bulk',
+  description: 'Assigns multiple users to accounts with specified roles. Requires MANAGER role or higher.',
+  request: {
+    body: {
+      content: { 'application/json': { schema: BulkUserAccountsInputSchema } },
+    },
+  },
+  responses: {
+    201: {
+      description: 'User accounts created successfully',
+      content: {
+        'application/json': {
+          schema: BulkOperationSuccessSchema,
+        },
+      },
+    },
+    400: {
+      description: 'Invalid input',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    401: {
+      description: 'Unauthorized',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    403: {
+      description: 'Forbidden - requires MANAGER role or higher',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+})
+
+export const deleteBulkUserAccountsRoute = createRoute({
+  method: 'delete',
+  path: '/accounts',
+  tags: ['Users'],
+  summary: 'Delete user-account relationships in bulk',
+  description: 'Removes multiple users from accounts. Requires MANAGER role or higher.',
+  request: {
+    body: {
+      content: { 'application/json': { schema: BulkUserAccountsInputSchema } },
+    },
+  },
+  responses: {
+    200: {
+      description: 'User accounts deleted successfully',
+      content: {
+        'application/json': {
+          schema: BulkOperationSuccessSchema,
+        },
+      },
+    },
+    400: {
+      description: 'Invalid input',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    401: {
+      description: 'Unauthorized',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    403: {
+      description: 'Forbidden - requires MANAGER role or higher',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+})
+
+export const restoreUserRoute = createRoute({
+  method: 'post',
+  path: '/{id}/restore',
+  tags: ['Users'],
+  summary: 'Restore a soft-deleted user',
+  request: {
+    params: IdParamSchema,
+  },
+  responses: {
+    200: {
+      description: 'User restored successfully',
+      content: {
+        'application/json': {
+          schema: z.object({
+            data: UserSchema,
+          }),
+        },
+      },
+    },
+    401: {
+      description: 'Unauthorized',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    403: {
+      description: 'Forbidden - requires ADMIN role',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    404: {
+      description: 'User not found or not deleted',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+})

package/templates/base/src/server/routes/users/schemas.ts

@@ -0,0 +1,67 @@
+import { z } from '@hono/zod-openapi'
+import { createPaginatedSchema } from '../schemas'
+
+export const UserSchema = z
+  .object({
+    id: z.uuid().openapi({ example: '550e8400-e29b-41d4-a716-446655440000' }),
+    email: z.email().openapi({ example: 'user@example.com' }),
+    name: z.string().openapi({ example: 'John Doe' }),
+    status: z.enum(['active', 'inactive']).openapi({ example: 'active' }),
+    isSuperAdmin: z.boolean().openapi({ example: false }),
+    createdAt: z.iso.datetime().openapi({ example: '2024-01-01T00:00:00Z' }),
+    updatedAt: z.iso.datetime().openapi({ example: '2024-01-01T00:00:00Z' }),
+  })
+  .openapi('User')
+
+export const CreateUserSchema = z
+  .object({
+    email: z.email().openapi({ example: 'newuser@example.com' }),
+    name: z.string().min(1).max(255).openapi({ example: 'Jane Doe' }),
+    role: z
+      .enum(['ADMIN', 'MANAGER', 'EDITOR', 'AUTHOR', 'VIEWER', 'BILLING', 'ANALYTICS'])
+      .default('VIEWER')
+      .openapi({ example: 'VIEWER' }),
+  })
+  .openapi('CreateUserInput')
+
+export const UpdateUserSchema = z
+  .object({
+    name: z.string().min(1).max(255).optional().openapi({ example: 'Updated Name' }),
+    status: z.enum(['active', 'inactive']).optional().openapi({ example: 'active' }),
+  })
+  .openapi('UpdateUserInput')
+
+export const PaginatedUsersSchema = createPaginatedSchema(UserSchema, 'Users')
+
+// Bulk User-Account Operations
+export const UserAccountSchema = z
+  .object({
+    userId: z.uuid().openapi({
+      example: '550e8400-e29b-41d4-a716-446655440000',
+      description: 'The ID of the user',
+    }),
+    accountId: z.uuid().openapi({
+      example: '550e8400-e29b-41d4-a716-446655440001',
+      description: 'The ID of the account',
+    }),
+    role: z
+      .enum(['ADMIN', 'MANAGER', 'EDITOR', 'AUTHOR', 'VIEWER', 'BILLING', 'ANALYTICS'])
+      .openapi({
+        example: 'VIEWER',
+        description: 'The role of the user in the account',
+      }),
+  })
+  .openapi('UserAccount')
+
+export const BulkUserAccountsInputSchema = z
+  .array(UserAccountSchema)
+  .min(1)
+  .max(100)
+  .openapi('BulkUserAccountsInput')
+
+export const BulkOperationSuccessSchema = z
+  .object({
+    success: z.boolean().openapi({ example: true }),
+    count: z.number().openapi({ example: 3, description: 'Number of records affected' }),
+  })
+  .openapi('BulkOperationSuccess')