create-fullstack-scaffold 0.1.0

package/template/src/shared/hooks/useWebSocket.ts

@@ -0,0 +1,66 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { WSClient, WSProtocol, WSStatus } from '@shared/schemas'
+
+interface UseWebSocketReturn<T extends WSProtocol> {
+  status: WSStatus
+  connect: () => void
+  disconnect: () => void
+  call: WSClient<T>['call']
+  emit: WSClient<T>['emit']
+  on: WSClient<T>['on']
+  client: WSClient<T> | null
+}
+
+export function useWebSocket<T extends WSProtocol>(route: {
+  $ws: () => WSClient<T>
+}): UseWebSocketReturn<T> {
+  const [status, setStatus] = useState<WSStatus>('closed')
+  const clientRef = useRef<WSClient<T> | null>(null)
+
+  const connect = useCallback(() => {
+    if (clientRef.current) return
+
+    const client = route.$ws()
+    clientRef.current = client
+
+    client.onStatusChange(setStatus)
+  }, [route])
+
+  const disconnect = useCallback(() => {
+    if (clientRef.current) {
+      clientRef.current.close()
+      clientRef.current = null
+      setStatus('closed')
+    }
+  }, [])
+
+  const call = useCallback(async (method: keyof T['rpc'], params: unknown) => {
+    if (!clientRef.current) throw new Error('WebSocket not connected')
+    return clientRef.current.call(method as never, params as never)
+  }, []) as WSClient<T>['call']
+
+  const emit = useCallback((type: keyof T['events'], payload: unknown) => {
+    clientRef.current?.emit(type as never, payload as never)
+  }, []) as WSClient<T>['emit']
+
+  const on = useCallback((type: keyof T['events'], handler: (payload: unknown) => void) => {
+    if (!clientRef.current) return () => {}
+    return clientRef.current.on(type as never, handler as never)
+  }, []) as WSClient<T>['on']
+
+  useEffect(() => {
+    return () => {
+      disconnect()
+    }
+  }, [disconnect])
+
+  return {
+    status,
+    connect,
+    disconnect,
+    call,
+    emit,
+    on,
+    client: clientRef.current,
+  }
+}

package/template/src/shared/index.ts

@@ -0,0 +1,5 @@
+export * from './constants'
+export * from './core'
+export * from './hooks'
+export * from './modules'
+export * from './schemas'

package/template/src/shared/modules/admin/index.ts

@@ -0,0 +1 @@
+export * from './schemas'

package/template/src/shared/modules/admin/schemas.ts

@@ -0,0 +1,100 @@
+import { z } from '@hono/zod-openapi'
+import { RoleEnum, PermissionEnum } from '@shared/modules/permission'
+
+export const SystemStatsSchema = z.object({
+  totalTodos: z.number(),
+  pendingTodos: z.number(),
+  completedTodos: z.number(),
+  lastUpdated: z.string(),
+})
+
+export const HealthCheckSchema = z.object({
+  database: z.enum(['connected', 'disconnected']),
+  timestamp: z.string(),
+})
+
+export const RecentActivityItemSchema = z.object({
+  id: z.number(),
+  title: z.string(),
+  status: z.string(),
+  updatedAt: z.string(),
+})
+
+export const RecentActivitySchema = z.array(RecentActivityItemSchema)
+
+export const AuthUserSchema = z.object({
+  id: z.string(),
+  username: z.string(),
+  email: z.string(),
+  role: RoleEnum,
+  avatar: z.string().nullish(),
+  permissions: z.array(PermissionEnum),
+})
+
+export const LoginRequestSchema = z.object({
+  username: z.string().min(1),
+  password: z.string().min(6),
+})
+
+export const LoginResponseSchema = z.object({
+  user: AuthUserSchema,
+  token: z.string(),
+})
+
+export const RegisterRequestSchema = z.object({
+  username: z.string().min(1),
+  email: z.string().email(),
+  password: z.string().min(6),
+})
+
+export const UserSchema = z.object({
+  id: z.string(),
+  username: z.string(),
+  email: z.string(),
+  role: RoleEnum,
+  status: z.enum(['active', 'inactive', 'locked']),
+  avatar: z.string().nullish(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+})
+
+export const UserListSchema = z.array(UserSchema)
+
+export const UpdateUserRequestSchema = z.object({
+  username: z.string().nullish(),
+  email: z.string().email().nullish(),
+  role: RoleEnum.nullish(),
+  status: z.enum(['active', 'inactive', 'locked']).nullish(),
+})
+
+export const CreateUserRequestSchema = z.object({
+  username: z.string().min(1),
+  email: z.string().email(),
+  password: z.string().min(6),
+  role: RoleEnum,
+  status: z.enum(['active', 'inactive', 'locked']).nullish().default('active'),
+})
+
+export const ClearTodosResultSchema = z.object({
+  deletedCount: z.number(),
+})
+
+export const SuccessSchema = z.object({})
+
+export const DownloadTokenSchema = z.object({
+  token: z.string(),
+  downloadUrl: z.string(),
+  expiresIn: z.number(),
+})
+
+export type SystemStats = z.infer<typeof SystemStatsSchema>
+export type HealthCheck = z.infer<typeof HealthCheckSchema>
+export type RecentActivityItem = z.infer<typeof RecentActivityItemSchema>
+export type AuthUserResponse = z.infer<typeof AuthUserSchema>
+export type CreateUserRequest = z.infer<typeof CreateUserRequestSchema>
+export type LoginRequest = z.infer<typeof LoginRequestSchema>
+export type LoginResponse = z.infer<typeof LoginResponseSchema>
+export type RegisterRequest = z.infer<typeof RegisterRequestSchema>
+export type User = z.infer<typeof UserSchema>
+export type UpdateUserRequest = z.infer<typeof UpdateUserRequestSchema>
+export type ClearTodosResult = z.infer<typeof ClearTodosResultSchema>

package/template/src/shared/modules/audit/index.ts

@@ -0,0 +1 @@
+export * from './schemas'

package/template/src/shared/modules/audit/schemas.ts

@@ -0,0 +1,24 @@
+import { z } from '@hono/zod-openapi'
+import { RESOURCE_TYPES, ACTION_TYPES, type ResourceType, type ActionType } from '@shared/constants'
+
+export const ResourceTypeSchema = z.enum(
+  Object.values(RESOURCE_TYPES) as [ResourceType, ...ResourceType[]]
+)
+export const ActionTypeSchema = z.enum(Object.values(ACTION_TYPES) as [ActionType, ...ActionType[]])
+
+export const AuditLogSchema = z.object({
+  id: z.string(),
+  userId: z.string(),
+  action: ActionTypeSchema,
+  resourceType: ResourceTypeSchema,
+  resourceId: z.string().nullable(),
+  oldValue: z.string().nullable(),
+  newValue: z.string().nullable(),
+  ipAddress: z.string().nullable(),
+  userAgent: z.string().nullable(),
+  createdAt: z
+    .union([z.string(), z.date()])
+    .transform(v => (v instanceof Date ? v.toISOString() : v)),
+})
+
+export type AuditLogType = z.infer<typeof AuditLogSchema>

package/template/src/shared/modules/captcha/index.ts

@@ -0,0 +1 @@
+export * from './schemas'

package/template/src/shared/modules/captcha/schemas.ts

@@ -0,0 +1,19 @@
+import { z } from '@hono/zod-openapi'
+
+export const CaptchaResponseSchema = z.object({
+  id: z.string(),
+  image: z.string(),
+})
+
+export const VerifyCaptchaRequestSchema = z.object({
+  id: z.string(),
+  code: z.string(),
+})
+
+export const CaptchaVerifyResponseSchema = z.object({
+  message: z.string(),
+})
+
+export type CaptchaResponse = z.infer<typeof CaptchaResponseSchema>
+export type VerifyCaptchaRequest = z.infer<typeof VerifyCaptchaRequestSchema>
+export type CaptchaVerifyResponse = z.infer<typeof CaptchaVerifyResponseSchema>

package/template/src/shared/modules/chat/index.ts

@@ -0,0 +1,38 @@
+import { z } from '@hono/zod-openapi'
+
+export const ChatProtocolSchema = z.object({
+  rpc: z.object({
+    echo: z.object({
+      in: z.object({ message: z.string() }),
+      out: z.object({ message: z.string(), timestamp: z.number() }),
+    }),
+    ping: z.object({
+      in: z.object({}),
+      out: z.object({ pong: z.boolean(), timestamp: z.number() }),
+    }),
+  }),
+  events: z.object({
+    notification: z.object({
+      title: z.string(),
+      body: z.string(),
+      timestamp: z.number(),
+    }),
+    broadcast: z.object({
+      message: z.string(),
+      timestamp: z.number(),
+    }),
+    connected: z.object({
+      timestamp: z.number(),
+    }),
+    disconnected: z.object({
+      timestamp: z.number(),
+    }),
+  }),
+})
+
+export const WebSocketStatusSchema = z.object({
+  connectedClients: z.number(),
+})
+
+export type ChatProtocol = z.infer<typeof ChatProtocolSchema>
+export type WebSocketStatus = z.infer<typeof WebSocketStatusSchema>

package/template/src/shared/modules/content/index.ts

@@ -0,0 +1 @@
+export * from './schemas'

package/template/src/shared/modules/content/schemas.ts

@@ -0,0 +1,53 @@
+import { z } from '@hono/zod-openapi'
+
+export const ContentCategorySchema = z.enum([
+  'article',
+  'announcement',
+  'tutorial',
+  'news',
+  'policy',
+])
+export const ContentStatusSchema = z.enum(['draft', 'published', 'archived'])
+
+export const ContentSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  content: z.string(),
+  category: ContentCategorySchema,
+  status: ContentStatusSchema,
+  author: z.string(),
+  tags: z.array(z.string()),
+  viewCount: z.number(),
+  likeCount: z.number(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  publishedAt: z.string().nullish(),
+})
+
+export const CreateContentSchema = z.object({
+  title: z.string(),
+  content: z.string(),
+  category: ContentCategorySchema,
+  tags: z.array(z.string()).nullish(),
+})
+
+export const UpdateContentSchema = z.object({
+  title: z.string().nullish(),
+  content: z.string().nullish(),
+  category: ContentCategorySchema.nullish(),
+  tags: z.array(z.string()).nullish(),
+  status: ContentStatusSchema.nullish(),
+})
+
+export const ContentListSchema = z.array(ContentSchema)
+
+export const DeleteResultSchema = z.object({
+  message: z.string(),
+})
+
+export type ContentCategory = z.infer<typeof ContentCategorySchema>
+export type ContentStatus = z.infer<typeof ContentStatusSchema>
+export type Content = z.infer<typeof ContentSchema>
+export type CreateContentInput = z.infer<typeof CreateContentSchema>
+export type UpdateContentInput = z.infer<typeof UpdateContentSchema>
+export type DeleteResult = z.infer<typeof DeleteResultSchema>

package/template/src/shared/modules/dispute/index.ts

@@ -0,0 +1 @@
+export * from './schemas'

package/template/src/shared/modules/dispute/schemas.ts

@@ -0,0 +1,62 @@
+import { z } from '@hono/zod-openapi'
+
+export const DisputeTypeSchema = z.enum([
+  'refund',
+  'product_quality',
+  'service_quality',
+  'delivery',
+  'other',
+])
+export const DisputeStatusSchema = z.enum(['pending', 'investigating', 'resolved', 'rejected'])
+
+export const DisputeSchema = z.object({
+  id: z.string(),
+  disputeNo: z.string(),
+  orderId: z.string(),
+  orderNo: z.string(),
+  customerName: z.string(),
+  customerEmail: z.string(),
+  type: DisputeTypeSchema,
+  status: DisputeStatusSchema,
+  description: z.string(),
+  resolution: z.string().nullish(),
+  amount: z.number(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  resolvedAt: z.string().nullish(),
+  resolvedBy: z.string().nullish(),
+})
+
+export const CreateDisputeSchema = z.object({
+  orderId: z.string(),
+  orderNo: z.string(),
+  customerName: z.string(),
+  customerEmail: z.string().email(),
+  type: DisputeTypeSchema,
+  description: z.string(),
+  amount: z.number().positive(),
+})
+
+export const UpdateDisputeSchema = z.object({
+  status: DisputeStatusSchema.nullish(),
+  resolution: z.string().nullish(),
+})
+
+export const ResolveDisputeSchema = z.object({
+  resolution: z.string(),
+  resolvedBy: z.string(),
+})
+
+export const DisputeListSchema = z.array(DisputeSchema)
+
+export const DeleteResultSchema = z.object({
+  message: z.string(),
+})
+
+export type DisputeType = z.infer<typeof DisputeTypeSchema>
+export type DisputeStatus = z.infer<typeof DisputeStatusSchema>
+export type Dispute = z.infer<typeof DisputeSchema>
+export type CreateDisputeInput = z.infer<typeof CreateDisputeSchema>
+export type UpdateDisputeInput = z.infer<typeof UpdateDisputeSchema>
+export type ResolveDisputeInput = z.infer<typeof ResolveDisputeSchema>
+export type DeleteResult = z.infer<typeof DeleteResultSchema>

package/template/src/shared/modules/files/index.ts

@@ -0,0 +1,11 @@
+export {
+  FileDownloadSchema,
+  PrivateFileQuerySchema,
+  PublicFileUrlSchema,
+  PrivateFileUrlSchema,
+  GenerateUrlRequestSchema,
+  FileUrlResponseSchema,
+  EmptySchema,
+  UploadResultSchema,
+  UploadFileBodySchema,
+} from './schemas'

package/template/src/shared/modules/files/schemas.ts

@@ -0,0 +1,44 @@
+import { z } from '@hono/zod-openapi'
+
+export const FileDownloadSchema = z.object({
+  namespace: z.string(),
+  filename: z.string(),
+})
+
+export const PrivateFileQuerySchema = z.object({
+  expiry: z.string().transform(Number),
+  signature: z.string(),
+})
+
+export const PublicFileUrlSchema = z.object({
+  url: z.string(),
+})
+
+export const PrivateFileUrlSchema = z.object({
+  url: z.string(),
+  expiry: z.number(),
+})
+
+export const GenerateUrlRequestSchema = z.object({
+  namespace: z.string(),
+  filename: z.string(),
+  isPrivate: z.boolean().nullish().default(false),
+  expirySeconds: z.number().nullish(),
+})
+
+export const FileUrlResponseSchema = z.union([PublicFileUrlSchema, PrivateFileUrlSchema])
+
+export const EmptySchema = z.object({})
+
+export const UploadResultSchema = z.object({
+  filename: z.string(),
+  originalName: z.string(),
+  mimeType: z.string(),
+  size: z.number(),
+  url: z.string(),
+})
+
+export const UploadFileBodySchema = z.object({
+  file: z.instanceof(File),
+  namespace: z.string().nullish().default('uploads'),
+})

package/template/src/shared/modules/index.ts

@@ -0,0 +1,70 @@
+export { ChatProtocolSchema, type ChatProtocol } from './chat'
+export {
+  TodoSchema,
+  TodoStatusSchema,
+  CreateTodoSchema,
+  UpdateTodoSchema,
+  TodoIdSchema,
+  type Todo,
+  type TodoStatus,
+  type CreateTodoInput,
+  type UpdateTodoInput,
+} from './todos'
+export {
+  FileDownloadSchema,
+  PrivateFileQuerySchema,
+  PublicFileUrlSchema,
+  PrivateFileUrlSchema,
+  GenerateUrlRequestSchema,
+  FileUrlResponseSchema,
+  EmptySchema,
+} from './files'
+export {
+  NotificationSchema,
+  NotificationTypeSchema,
+  CreateNotificationSchema,
+  NotificationListQuerySchema,
+  SSEEventSchema,
+  AppSSEProtocolSchema,
+  type AppNotification,
+  type NotificationType,
+  type CreateNotificationInput,
+  type NotificationListQuery,
+  type SSEEvent,
+  type AppSSEProtocol,
+} from './notifications'
+export {
+  SystemStatsSchema,
+  HealthCheckSchema,
+  RecentActivityItemSchema,
+  RecentActivitySchema,
+  AuthUserSchema,
+  ClearTodosResultSchema,
+  type SystemStats,
+  type HealthCheck,
+  type RecentActivityItem,
+  type AuthUserResponse,
+  type ClearTodosResult,
+} from './admin'
+export {
+  RoleEnum,
+  RoleInfoSchema,
+  PermissionInfoSchema,
+  UserPermissionsSchema,
+  RoleListSchema,
+  PermissionListSchema,
+  Role,
+  Permission,
+  ROLE_PERMISSIONS,
+  ROLE_LABELS,
+  PERMISSION_LABELS,
+  PERMISSION_CATEGORIES,
+  getPermissionsByRole,
+  hasPermission,
+  hasAnyPermission,
+  hasAllPermissions,
+  type RoleType,
+  type RoleInfo,
+  type PermissionInfo,
+  type UserPermissions,
+} from './permission'

package/template/src/shared/modules/notifications/index.ts

@@ -0,0 +1,26 @@
+export {
+  NotificationSchema,
+  NotificationTypeSchema,
+  CreateNotificationSchema,
+  NotificationListQuerySchema,
+  SSEEventSchema,
+  AppSSEProtocolSchema,
+  UnreadCountSchema,
+  NotificationIdSchema,
+  UnreadCountEventSchema,
+  NotificationListSchema,
+  MarkAllReadResultSchema,
+  TestNotificationRequestSchema,
+  type AppNotification,
+  type NotificationType,
+  type CreateNotificationInput,
+  type NotificationListQuery,
+  type SSEEvent,
+  type AppSSEProtocol,
+  type UnreadCount,
+  type NotificationId,
+  type UnreadCountEvent,
+  type NotificationList,
+  type MarkAllReadResult,
+  type TestNotificationRequest,
+} from './schemas'

package/template/src/shared/modules/notifications/schemas.ts

@@ -0,0 +1,73 @@
+import { z } from '@hono/zod-openapi'
+
+export const NotificationTypeSchema = z.enum(['info', 'warning', 'success', 'error'])
+
+export const NotificationSchema = z.object({
+  id: z.string().uuid(),
+  type: NotificationTypeSchema,
+  title: z.string().min(1).max(200),
+  message: z.string().max(2000),
+  read: z.boolean().default(false),
+  createdAt: z.string().datetime(),
+})
+
+export const CreateNotificationSchema = z.object({
+  type: NotificationTypeSchema,
+  title: z.string().min(1, 'Title is required').max(200, 'Title too long'),
+  message: z.string().min(1, 'Message is required').max(2000, 'Message too long'),
+})
+
+export const NotificationListQuerySchema = z.object({
+  unreadOnly: z.coerce.boolean().nullish().default(false),
+  limit: z.coerce.number().int().min(1).max(100).nullish().default(20),
+  cursor: z.string().nullish(),
+})
+
+export const SSEEventSchema = z.object({
+  event: z.enum(['notification', 'ping', 'connected']),
+  data: z.union([NotificationSchema, z.object({ timestamp: z.number() })]),
+})
+
+export const UnreadCountEventSchema = z.object({
+  count: z.number(),
+})
+
+export const AppSSEProtocolSchema = z.object({
+  events: z.object({
+    notification: NotificationSchema,
+    'unread-count': UnreadCountEventSchema,
+    ping: z.object({ timestamp: z.number() }),
+    connected: z.object({ timestamp: z.number() }),
+  }),
+})
+
+export const UnreadCountSchema = z.object({
+  count: z.number(),
+})
+
+export const NotificationIdSchema = z.object({
+  id: z.string(),
+})
+
+export const NotificationListSchema = z.array(NotificationSchema)
+
+export const MarkAllReadResultSchema = z.object({
+  count: z.number(),
+})
+
+export const TestNotificationRequestSchema = z.object({
+  type: NotificationTypeSchema.nullish().default('info'),
+})
+
+export type NotificationType = z.infer<typeof NotificationTypeSchema>
+export type AppNotification = z.infer<typeof NotificationSchema>
+export type CreateNotificationInput = z.infer<typeof CreateNotificationSchema>
+export type NotificationListQuery = z.infer<typeof NotificationListQuerySchema>
+export type SSEEvent = z.infer<typeof SSEEventSchema>
+export type UnreadCountEvent = z.infer<typeof UnreadCountEventSchema>
+export type AppSSEProtocol = z.infer<typeof AppSSEProtocolSchema>
+export type UnreadCount = z.infer<typeof UnreadCountSchema>
+export type NotificationId = z.infer<typeof NotificationIdSchema>
+export type NotificationList = z.infer<typeof NotificationListSchema>
+export type MarkAllReadResult = z.infer<typeof MarkAllReadResultSchema>
+export type TestNotificationRequest = z.infer<typeof TestNotificationRequestSchema>

package/template/src/shared/modules/order/index.ts

@@ -0,0 +1 @@
+export * from './schemas'

package/template/src/shared/modules/order/schemas.ts

@@ -0,0 +1,63 @@
+import { z } from '@hono/zod-openapi'
+
+export const OrderStatusSchema = z.enum([
+  'pending',
+  'processing',
+  'completed',
+  'cancelled',
+  'disputed',
+])
+
+export const OrderSchema = z.object({
+  id: z.string(),
+  orderNo: z.string(),
+  customerName: z.string(),
+  customerEmail: z.string(),
+  productName: z.string(),
+  amount: z.number(),
+  status: OrderStatusSchema,
+  createdAt: z.string(),
+  updatedAt: z.string(),
+})
+
+export const CreateOrderSchema = z.object({
+  customerName: z.string(),
+  customerEmail: z.string().email(),
+  productName: z.string(),
+  amount: z.number().positive(),
+})
+
+export const UpdateOrderSchema = z.object({
+  status: OrderStatusSchema.nullish(),
+})
+
+export const OrderListSchema = z.array(OrderSchema)
+
+export const OrderQuerySchema = z.object({
+  status: OrderStatusSchema.nullish(),
+  customerName: z.string().nullish(),
+  limit: z.coerce.number().int().positive().max(100).default(20),
+  offset: z.coerce.number().int().min(0).default(0),
+})
+
+export const DeleteResultSchema = z.object({
+  message: z.string(),
+})
+
+export const ProcessOrderSchema = z.object({
+  orderId: z.string(),
+})
+
+export const CancelOrderSchema = z.object({
+  orderId: z.string(),
+  reason: z.string().nullish(),
+})
+
+export type OrderStatus = z.infer<typeof OrderStatusSchema>
+export type Order = z.infer<typeof OrderSchema>
+export type CreateOrderInput = z.infer<typeof CreateOrderSchema>
+export type UpdateOrderInput = z.infer<typeof UpdateOrderSchema>
+export type DeleteResult = z.infer<typeof DeleteResultSchema>
+export type ProcessOrderInput = z.infer<typeof ProcessOrderSchema>
+export type CancelOrderInput = z.infer<typeof CancelOrderSchema>
+export type OrderQueryInput = z.infer<typeof OrderQuerySchema>