create-fullstack-scaffold 0.4.10 → 0.4.12

package/template/src/admin/pages/UsersPage.tsx

@@ -1,4 +1,4 @@
-import { useState, useEffect } from 'react'
+import { useState, useEffect, useCallback } from 'react'
 import {
   Table,
   Card,
@@ -37,18 +37,20 @@ export const UsersPage: React.FC = () => {
   const [form] = Form.useForm<UserFormData>()
   const { roleLabels } = useRoleLabels()
 
-  const fetchUsers = async () => {
+  const fetchUsers = useCallback(async () => {
     try {
-      const data = await api(apiClient.api.admin.users.$get()).withLoading(t('users.loading')).json()
+      const data = await api(apiClient.api.admin.users.$get())
+        .withLoading(t('users.loading'))
+        .json()
       setUsers(data)
     } catch {
       // handled by api-request
     }
-  }
+  }, [t])
 
   useEffect(() => {
     fetchUsers()
-  }, [])
+  }, [fetchUsers])
 
   const handleCreate = () => {
     setEditingUser(null)
@@ -271,7 +273,9 @@ export const UsersPage: React.FC = () => {
           >
             <Select placeholder={t('users.rolePlaceholder')}>
               <Select.Option value={Role.SUPER_ADMIN}>{t('users.superAdmin')}</Select.Option>
-              <Select.Option value={Role.CUSTOMER_SERVICE}>{t('users.customerService')}</Select.Option>
+              <Select.Option value={Role.CUSTOMER_SERVICE}>
+                {t('users.customerService')}
+              </Select.Option>
               <Select.Option value={Role.USER}>{t('users.normalUser')}</Select.Option>
             </Select>
           </Form.Item>

package/template/src/admin/stores/themeStore.ts

@@ -21,7 +21,7 @@ export const useThemeStore = create<ThemeState>()(
     {
       name: 'admin-theme',
       onRehydrateStorage: () => {
-        return (state) => {
+        return state => {
           if (state) {
             document.documentElement.setAttribute('data-theme', state.mode)
           }

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

@@ -0,0 +1,192 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+import type { Role } from '@shared/modules/permission'
+
+export function registerAdminCommands(site: SiteInstance) {
+  site.command('dashboard', {
+    description: 'Get dashboard statistics',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.admin.dashboard.stats.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get dashboard stats')
+      }
+    },
+  })
+
+  site.command('stats', {
+    description: 'Get system statistics',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.admin.stats.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get system stats')
+      }
+    },
+  })
+
+  site.command('health', {
+    description: 'Check system health',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.admin.health.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to check health')
+      }
+    },
+  })
+
+  site.command('list-users', {
+    description: 'List all users',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list users')
+      }
+    },
+  })
+
+  site.command('get-user', {
+    description: 'Get a user by ID',
+    parameters: z.object({
+      id: z.string().describe('User ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users[':id'].$get({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get user')
+      }
+    },
+  })
+
+  site.command('create-user', {
+    description: 'Create a new user',
+    parameters: z.object({
+      username: z.string().min(1).describe('Username'),
+      email: z.string().email().describe('Email'),
+      password: z.string().min(6).describe('Password'),
+      role: z.enum(['super_admin', 'customer_service', 'user']).default('user').describe('Role'),
+    }),
+    handler: async (params: unknown) => {
+      type CreateParams = { username: string; email: string; password: string; role: 'super_admin' | 'customer_service' | 'user' }
+      const p = params as CreateParams
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users.$post({
+          json: {
+            username: p.username,
+            email: p.email,
+            password: p.password,
+            role: p.role as Role,
+          },
+        })
+        const data = await res.json()
+        return ok(data, ['User created'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to create user')
+      }
+    },
+  })
+
+  site.command('update-user', {
+    description: 'Update a user',
+    parameters: z.object({
+      id: z.string().describe('User ID'),
+      username: z.string().optional().describe('New username'),
+      email: z.string().email().optional().describe('New email'),
+      role: z.enum(['super_admin', 'customer_service', 'user']).optional().describe('New role'),
+    }),
+    handler: async (params: unknown) => {
+      type UpdateParams = { id: string; username?: string; email?: string; role?: 'super_admin' | 'customer_service' | 'user' }
+      const p = params as UpdateParams
+      const { id, ...rest } = p
+      const body: Record<string, string | undefined> = {}
+      if (rest.username) body.username = rest.username
+      if (rest.email) body.email = rest.email
+      if (rest.role) body.role = rest.role
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users[':id'].$put({ param: { id }, json: body })
+        const data = await res.json()
+        return ok(data, ['User updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update user')
+      }
+    },
+  })
+
+  site.command('delete-user', {
+    description: 'Delete a user',
+    parameters: z.object({
+      id: z.string().describe('User ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users[':id'].$delete({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['User deleted'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to delete user')
+      }
+    },
+  })
+
+  site.command('activity', {
+    description: 'Get recent activity',
+    parameters: z.object({
+      limit: z.coerce.number().default(10).describe('Limit results'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { limit: number }
+      try {
+        const client = getClient()
+        const res = await client.api.admin.activity.$get({ query: { limit: String(p.limit) } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get activity')
+      }
+    },
+  })
+
+  site.command('clear-todos', {
+    description: 'Clear all todos (dangerous)',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.admin.todos.all.$delete()
+        const data = await res.json()
+        return ok(data, ['All todos cleared'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to clear todos')
+      }
+    },
+  })
+}

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

@@ -0,0 +1,40 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerCaptchaCommands(site: SiteInstance) {
+  site.command('get', {
+    description: 'Get a new captcha',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.captcha.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get captcha')
+      }
+    },
+  })
+
+  site.command('verify', {
+    description: 'Verify a captcha code',
+    parameters: z.object({
+      id: z.string().describe('Captcha ID'),
+      code: z.string().min(1).describe('Captcha code'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; code: string }
+      try {
+        const client = getClient()
+        const res = await client.api['verify-captcha'].$post({ json: p })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to verify captcha')
+      }
+    },
+  })
+}

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

@@ -0,0 +1,21 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerChatCommands(site: SiteInstance) {
+  site.command('status', {
+    description: 'Get WebSocket connection status',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.chat.ws.status.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get chat status')
+      }
+    },
+  })
+}

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

@@ -0,0 +1,152 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerContentCommands(site: SiteInstance) {
+  site.command('list', {
+    description: 'List all contents',
+    parameters: z.object({
+      limit: z.coerce.number().default(20).describe('Limit results'),
+      offset: z.coerce.number().default(0).describe('Offset'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { limit: number; offset: number }
+      try {
+        const client = getClient()
+        const res = await client.api.contents.$get({
+          query: { limit: String(p.limit), offset: String(p.offset) },
+        })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list contents')
+      }
+    },
+  })
+
+  site.command('get', {
+    description: 'Get content by ID',
+    parameters: z.object({
+      id: z.string().describe('Content ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.contents[':id'].$get({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get content')
+      }
+    },
+  })
+
+  site.command('create', {
+    description: 'Create new content',
+    parameters: z.object({
+      title: z.string().min(1).describe('Content title'),
+      content: z.string().min(1).describe('Content body'),
+      category: z
+        .enum(['article', 'announcement', 'tutorial', 'news', 'policy'])
+        .default('article')
+        .describe('Category'),
+      tags: z.string().optional().describe('Comma-separated tags'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { title: string; content: string; category: string; tags?: string }
+      try {
+        const client = getClient()
+        const tags = p.tags ? p.tags.split(',') : undefined
+        const res = await client.api.contents.$post({
+          json: {
+            title: p.title,
+            content: p.content,
+            category: p.category as 'article' | 'announcement' | 'tutorial' | 'news' | 'policy',
+            tags,
+          },
+        })
+        const data = await res.json()
+        return ok(data, ['Content created'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to create content')
+      }
+    },
+  })
+
+  site.command('update', {
+    description: 'Update content',
+    parameters: z.object({
+      id: z.string().describe('Content ID'),
+      title: z.string().optional().describe('New title'),
+      content: z.string().optional().describe('New body'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; title?: string; content?: string }
+      const { id, ...body } = p
+      try {
+        const client = getClient()
+        const res = await client.api.contents[':id'].$put({ param: { id }, json: body })
+        const data = await res.json()
+        return ok(data, ['Content updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update content')
+      }
+    },
+  })
+
+  site.command('delete', {
+    description: 'Delete content',
+    parameters: z.object({
+      id: z.string().describe('Content ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.contents[':id'].$delete({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Content deleted'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to delete content')
+      }
+    },
+  })
+
+  site.command('publish', {
+    description: 'Publish content',
+    parameters: z.object({
+      id: z.string().describe('Content ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.contents[':id'].publish.$put({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Content published'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to publish content')
+      }
+    },
+  })
+
+  site.command('archive', {
+    description: 'Archive content',
+    parameters: z.object({
+      id: z.string().describe('Content ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.contents[':id'].archive.$put({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Content archived'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to archive content')
+      }
+    },
+  })
+}

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

@@ -0,0 +1,156 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerDisputeCommands(site: SiteInstance) {
+  site.command('list', {
+    description: 'List all disputes',
+    parameters: z.object({
+      limit: z.coerce.number().default(20).describe('Limit results'),
+      offset: z.coerce.number().default(0).describe('Offset'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { limit: number; offset: number }
+      try {
+        const client = getClient()
+        const res = await client.api.disputes.$get({
+          query: { limit: String(p.limit), offset: String(p.offset) },
+        })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list disputes')
+      }
+    },
+  })
+
+  site.command('get', {
+    description: 'Get dispute by ID',
+    parameters: z.object({
+      id: z.string().describe('Dispute ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.disputes[':id'].$get({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get dispute')
+      }
+    },
+  })
+
+  site.command('create', {
+    description: 'Create a new dispute',
+    parameters: z.object({
+      'order-id': z.string().describe('Order ID'),
+      'order-no': z.string().describe('Order number'),
+      'customer-name': z.string().describe('Customer name'),
+      'customer-email': z.string().email().describe('Customer email'),
+      type: z
+        .enum(['refund', 'product_quality', 'service_quality', 'delivery', 'other'])
+        .default('other')
+        .describe('Type'),
+      description: z.string().min(1).describe('Description'),
+      amount: z.coerce.number().positive().describe('Amount'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as {
+        'order-id': string
+        'order-no': string
+        'customer-name': string
+        'customer-email': string
+        type: string
+        description: string
+        amount: number
+      }
+      try {
+        const client = getClient()
+        const res = await client.api.disputes.$post({
+          json: {
+            orderId: p['order-id'],
+            orderNo: p['order-no'],
+            customerName: p['customer-name'],
+            customerEmail: p['customer-email'],
+            type: p.type as 'refund' | 'product_quality' | 'service_quality' | 'delivery' | 'other',
+            description: p.description,
+            amount: p.amount,
+          },
+        })
+        const data = await res.json()
+        return ok(data, ['Dispute created'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to create dispute')
+      }
+    },
+  })
+
+  site.command('update', {
+    description: 'Update a dispute status',
+    parameters: z.object({
+      id: z.string().describe('Dispute ID'),
+      status: z
+        .enum(['pending', 'resolved', 'investigating', 'rejected'])
+        .optional()
+        .describe('New status'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; status?: string }
+      const { id, ...rest } = p
+      const body: Record<string, string | null> = {}
+      if (rest.status) body.status = rest.status
+      try {
+        const client = getClient()
+        const res = await client.api.disputes[':id'].$put({ param: { id }, json: body })
+        const data = await res.json()
+        return ok(data, ['Dispute updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update dispute')
+      }
+    },
+  })
+
+  site.command('delete', {
+    description: 'Delete a dispute',
+    parameters: z.object({
+      id: z.string().describe('Dispute ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.disputes[':id'].$delete({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Dispute deleted'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to delete dispute')
+      }
+    },
+  })
+
+  site.command('resolve', {
+    description: 'Resolve a dispute',
+    parameters: z.object({
+      id: z.string().describe('Dispute ID'),
+      resolution: z.string().min(1).describe('Resolution notes'),
+      'resolved-by': z.string().describe('Resolver name'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; resolution: string; 'resolved-by': string }
+      try {
+        const client = getClient()
+        const res = await client.api.disputes[':id'].resolve.$put({
+          param: { id: p.id },
+          json: { resolution: p.resolution, resolvedBy: p['resolved-by'] },
+        })
+        const data = await res.json()
+        return ok(data, ['Dispute resolved'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to resolve dispute')
+      }
+    },
+  })
+}

package/template/src/cli/modules/file/index.ts

@@ -0,0 +1,60 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerFileCommands(site: SiteInstance) {
+  site.command('generate-url', {
+    description: 'Generate a file URL',
+    parameters: z.object({
+      namespace: z.string().describe('File namespace'),
+      filename: z.string().describe('File name'),
+      private: z.boolean().default(false).describe('Generate private URL'),
+      'expiry-seconds': z.coerce.number().default(3600).describe('URL expiry in seconds'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as {
+        namespace: string
+        filename: string
+        private: boolean
+        'expiry-seconds': number
+      }
+      try {
+        const client = getClient()
+        const res = await client.api['generate-url'].$post({
+          json: {
+            namespace: p.namespace,
+            filename: p.filename,
+            isPrivate: p.private,
+            expirySeconds: p['expiry-seconds'],
+          },
+        })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to generate URL')
+      }
+    },
+  })
+
+  site.command('info', {
+    description: 'Check if a public file exists',
+    parameters: z.object({
+      namespace: z.string().describe('File namespace'),
+      filename: z.string().describe('File name'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { namespace: string; filename: string }
+      try {
+        const client = getClient()
+        const res = await client.api.public[':namespace'][':filename'].$get({
+          param: { namespace: p.namespace, filename: p.filename },
+        })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get file info')
+      }
+    },
+  })
+}