create-fullstack-scaffold 0.4.9 → 0.4.11

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

@@ -0,0 +1,200 @@
+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 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) => {
+      const p = params as {
+        username: string
+        email: string
+        password: string
+        role: 'super_admin' | 'customer_service' | 'user'
+      }
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users.$post({
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          json: {
+            username: p.username,
+            email: p.email,
+            password: p.password,
+            role: p.role,
+          } as any,
+        })
+        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) => {
+      const p = params as {
+        id: string
+        username?: string
+        email?: string
+        role?: 'super_admin' | 'customer_service' | 'user'
+      }
+      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 as Record<string, string | null | undefined> })
+        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,144 @@
+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,150 @@
+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,55 @@
+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')
+      }
+    },
+  })
+}

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

@@ -4,15 +4,20 @@ import { registerNotificationCommands } from './notification'
 import { registerConfigCommands } from './config'
 import { registerPluginCommands } from './plugin'
 import { registerAuthCommands } from './auth'
+import { registerAdminCommands } from './admin'
+import { registerCaptchaCommands } from './captcha'
+import { registerChatCommands } from './chat'
+import { registerContentCommands } from './content'
+import { registerDisputeCommands } from './dispute'
+import { registerFileCommands } from './file'
+import { registerOrderCommands } from './order'
+import { registerPermissionCommands } from './permission'
+import { registerTenantCommands } from './tenant'
+import { registerTicketCommands } from './ticket'
 
-/**
- * Register all builtin CLI commands to xcli-core.
- * Each register function receives a SiteInstance for command registration.
- */
 export function registerBuiltinCommands(app: Core) {
   const api = app.loader.getAPI()
 
-  // Create a builtin site representing the local server
   const site = api.createSite({
     name: 'local-server',
     url: 'http://localhost:3010',
@@ -23,6 +28,16 @@ export function registerBuiltinCommands(app: Core) {
   registerConfigCommands(site)
   registerPluginCommands(site)
   registerAuthCommands(site)
+  registerAdminCommands(site)
+  registerCaptchaCommands(site)
+  registerChatCommands(site)
+  registerContentCommands(site)
+  registerDisputeCommands(site)
+  registerFileCommands(site)
+  registerOrderCommands(site)
+  registerPermissionCommands(site)
+  registerTenantCommands(site)
+  registerTicketCommands(site)
 }
 
 export {
@@ -31,4 +46,14 @@ export {
   registerConfigCommands,
   registerPluginCommands,
   registerAuthCommands,
+  registerAdminCommands,
+  registerCaptchaCommands,
+  registerChatCommands,
+  registerContentCommands,
+  registerDisputeCommands,
+  registerFileCommands,
+  registerOrderCommands,
+  registerPermissionCommands,
+  registerTenantCommands,
+  registerTicketCommands,
 }