@robsun/create-keystone-app 0.1.18 → 0.2.1

package/template/apps/server/internal/modules/demo/bootstrap/seeds/task.go

@@ -1,33 +0,0 @@
-package seeds
-
-import (
-	"log"
-
-	"gorm.io/gorm"
-
-	"__APP_NAME__/apps/server/internal/modules/demo/domain/models"
-)
-
-func Seed(db *gorm.DB) error {
-	if db == nil {
-		return nil
-	}
-
-	var count int64
-	if err := db.Model(&models.DemoTask{}).Count(&count).Error; err != nil {
-		return err
-	}
-	if count > 0 {
-		return nil
-	}
-
-	log.Println("[demo] Seeding initial data...")
-	tasks := []models.DemoTask{
-		{Title: "Set up project", Status: models.StatusTodo},
-		{Title: "Review UI states", Status: models.StatusDone},
-	}
-	for i := range tasks {
-		tasks[i].TenantID = 1
-	}
-	return db.Create(&tasks).Error
-}

package/template/apps/server/internal/modules/demo/domain/models/task.go

@@ -1,30 +0,0 @@
-package models
-
-import "github.com/robsuncn/keystone/domain/models"
-
-type TaskStatus string
-
-const (
-	StatusTodo       TaskStatus = "todo"
-	StatusInProgress TaskStatus = "in_progress"
-	StatusDone       TaskStatus = "done"
-)
-
-func (s TaskStatus) IsValid() bool {
-	switch s {
-	case StatusTodo, StatusInProgress, StatusDone:
-		return true
-	default:
-		return false
-	}
-}
-
-type DemoTask struct {
-	models.BaseModel
-	Title  string     `gorm:"size:200;not null" json:"title"`
-	Status TaskStatus `gorm:"size:20;not null;default:'todo'" json:"status"`
-}
-
-func (DemoTask) TableName() string {
-	return "demo_tasks"
-}

package/template/apps/server/internal/modules/demo/domain/service/task_service.go

@@ -1,95 +0,0 @@
-package service
-
-import (
-	"context"
-	"strings"
-
-	"__APP_NAME__/apps/server/internal/modules/demo/domain/models"
-)
-
-type TaskRepository interface {
-	List(ctx context.Context, tenantID uint) ([]models.DemoTask, error)
-	FindByID(tenantID, id uint) (*models.DemoTask, error)
-	Create(ctx context.Context, task *models.DemoTask) error
-	Update(ctx context.Context, task *models.DemoTask) error
-	Delete(ctx context.Context, task *models.DemoTask) error
-}
-
-type TaskService struct {
-	tasks TaskRepository
-}
-
-type TaskInput struct {
-	Title  string
-	Status models.TaskStatus
-}
-
-type TaskUpdateInput struct {
-	Title  string
-	Status models.TaskStatus
-}
-
-func NewTaskService(tasks TaskRepository) *TaskService {
-	return &TaskService{tasks: tasks}
-}
-
-func (s *TaskService) List(ctx context.Context, tenantID uint) ([]models.DemoTask, error) {
-	return s.tasks.List(ctx, tenantID)
-}
-
-func (s *TaskService) Create(ctx context.Context, tenantID uint, input TaskInput) (*models.DemoTask, error) {
-	title := strings.TrimSpace(input.Title)
-	if title == "" {
-		return nil, ErrTitleRequired
-	}
-
-	status := input.Status
-	if status == "" {
-		status = models.StatusTodo
-	}
-	if !status.IsValid() {
-		return nil, ErrStatusInvalid
-	}
-
-	task := &models.DemoTask{
-		Title:  title,
-		Status: status,
-	}
-	task.TenantID = tenantID
-
-	if err := s.tasks.Create(ctx, task); err != nil {
-		return nil, err
-	}
-	return task, nil
-}
-
-func (s *TaskService) Update(ctx context.Context, tenantID, id uint, input TaskUpdateInput) (*models.DemoTask, error) {
-	task, err := s.tasks.FindByID(tenantID, id)
-	if err != nil {
-		return nil, err
-	}
-
-	if title := strings.TrimSpace(input.Title); title != "" {
-		task.Title = title
-	}
-
-	if input.Status != "" {
-		if !input.Status.IsValid() {
-			return nil, ErrStatusInvalid
-		}
-		task.Status = input.Status
-	}
-
-	if err := s.tasks.Update(ctx, task); err != nil {
-		return nil, err
-	}
-	return task, nil
-}
-
-func (s *TaskService) Delete(ctx context.Context, tenantID, id uint) error {
-	task, err := s.tasks.FindByID(tenantID, id)
-	if err != nil {
-		return err
-	}
-	return s.tasks.Delete(ctx, task)
-}

package/template/apps/server/internal/modules/demo/infra/repository/task_repository.go

@@ -1,49 +0,0 @@
-package repository
-
-import (
-	"context"
-	"errors"
-
-	"gorm.io/gorm"
-
-	"__APP_NAME__/apps/server/internal/modules/demo/domain/models"
-	"__APP_NAME__/apps/server/internal/modules/demo/domain/service"
-)
-
-type TaskRepository struct {
-	db *gorm.DB
-}
-
-func NewTaskRepository(db *gorm.DB) *TaskRepository {
-	return &TaskRepository{db: db}
-}
-
-func (r *TaskRepository) List(ctx context.Context, tenantID uint) ([]models.DemoTask, error) {
-	var tasks []models.DemoTask
-	err := r.db.WithContext(ctx).
-		Where("tenant_id = ?", tenantID).
-		Order("created_at desc").
-		Find(&tasks).Error
-	return tasks, err
-}
-
-func (r *TaskRepository) FindByID(tenantID, id uint) (*models.DemoTask, error) {
-	var task models.DemoTask
-	err := r.db.Where("tenant_id = ? AND id = ?", tenantID, id).First(&task).Error
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, service.ErrTaskNotFound
-	}
-	return &task, err
-}
-
-func (r *TaskRepository) Create(ctx context.Context, task *models.DemoTask) error {
-	return r.db.WithContext(ctx).Create(task).Error
-}
-
-func (r *TaskRepository) Update(ctx context.Context, task *models.DemoTask) error {
-	return r.db.WithContext(ctx).Save(task).Error
-}
-
-func (r *TaskRepository) Delete(ctx context.Context, task *models.DemoTask) error {
-	return r.db.WithContext(ctx).Delete(task).Error
-}

package/template/apps/server/internal/modules/demo/module.go

@@ -1,91 +0,0 @@
-package demo
-
-import (
-	"github.com/gin-gonic/gin"
-	"gorm.io/gorm"
-
-	"github.com/robsuncn/keystone/domain/permissions"
-	"github.com/robsuncn/keystone/infra/jobs"
-
-	demohandler "__APP_NAME__/apps/server/internal/modules/demo/api/handler"
-	demomigrations "__APP_NAME__/apps/server/internal/modules/demo/bootstrap/migrations"
-	demoseeds "__APP_NAME__/apps/server/internal/modules/demo/bootstrap/seeds"
-	demomodels "__APP_NAME__/apps/server/internal/modules/demo/domain/models"
-	demoservice "__APP_NAME__/apps/server/internal/modules/demo/domain/service"
-	demorepository "__APP_NAME__/apps/server/internal/modules/demo/infra/repository"
-)
-
-type Module struct {
-	tasks *demoservice.TaskService
-}
-
-func NewModule() *Module {
-	return &Module{}
-}
-
-func (m *Module) Name() string {
-	return "demo"
-}
-
-func (m *Module) RegisterRoutes(rg *gin.RouterGroup) {
-	if rg == nil || m == nil {
-		return
-	}
-	handler := demohandler.NewTaskHandler(m.tasks)
-	if handler == nil {
-		return
-	}
-	group := rg.Group("/demo")
-	group.GET("/tasks", handler.List)
-	group.POST("/tasks", handler.Create)
-	group.PATCH("/tasks/:id", handler.Update)
-	group.DELETE("/tasks/:id", handler.Delete)
-}
-
-func (m *Module) RegisterModels() []interface{} {
-	return []interface{}{&demomodels.DemoTask{}}
-}
-
-func (m *Module) RegisterPermissions(reg *permissions.Registry) error {
-	if reg == nil {
-		return nil
-	}
-	if err := reg.CreateMenu("demo:task", "Demo Tasks", "demo", 10); err != nil {
-		return err
-	}
-	if err := reg.CreateAction("demo:task:view", "View Tasks", "demo", "demo:task"); err != nil {
-		return err
-	}
-	if err := reg.CreateAction("demo:task:manage", "Manage Tasks", "demo", "demo:task"); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (m *Module) RegisterJobs(_ *jobs.Registry) error {
-	return nil
-}
-
-func (m *Module) Migrate(db *gorm.DB) error {
-	if db == nil {
-		return nil
-	}
-	m.ensureServices(db)
-	return demomigrations.Migrate(db)
-}
-
-func (m *Module) Seed(db *gorm.DB) error {
-	if db == nil {
-		return nil
-	}
-	m.ensureServices(db)
-	return demoseeds.Seed(db)
-}
-
-func (m *Module) ensureServices(db *gorm.DB) {
-	if m == nil || db == nil || m.tasks != nil {
-		return
-	}
-	repo := demorepository.NewTaskRepository(db)
-	m.tasks = demoservice.NewTaskService(repo)
-}

package/template/apps/server/internal/modules/example/handlers.go

@@ -1,19 +0,0 @@
-package example
-
-import (
-	"github.com/gin-gonic/gin"
-
-	"github.com/robsuncn/keystone/api/response"
-)
-
-type HelloResponse struct {
-	Message string `json:"message"`
-	Module  string `json:"module"`
-}
-
-func handleHello(c *gin.Context) {
-	response.Success(c, HelloResponse{
-		Message: "Hello from Example module!",
-		Module:  "example",
-	})
-}

package/template/apps/web/src/modules/demo/help/overview.md

@@ -1,12 +0,0 @@
----
-helpKey: "demo/tasks"
-title: "Demo Tasks"
-description: "Manage sample tasks in the scaffold."
-category: "demo"
-tags: ["demo", "tasks"]
----
-
-# Demo Tasks
-
-Use this module as a reference for list + create + update flows. Replace it
-with real business logic when you build new modules.

package/template/apps/web/src/modules/demo/index.ts

@@ -1,7 +0,0 @@
-import { registerModule } from '@robsun/keystone-web-core'
-import { demoRoutes } from './routes'
-
-registerModule({
-  name: 'demo',
-  routes: demoRoutes,
-})

package/template/apps/web/src/modules/demo/pages/DemoTasksPage.tsx

@@ -1,185 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react'
-import { App, Button, Card, Form, Input, Popconfirm, Select, Space, Table, Tag } from 'antd'
-import type { ColumnsType } from 'antd/es/table'
-import dayjs from 'dayjs'
-import { createDemoTask, deleteDemoTask, listDemoTasks, updateDemoTask } from '../services/demoTasks'
-import type { DemoTask, DemoTaskStatus } from '../types'
-
-type CreateValues = {
-  title: string
-  status?: DemoTaskStatus
-}
-
-const statusMeta: Record<DemoTaskStatus, { label: string; color: string }> = {
-  todo: { label: 'Todo', color: 'default' },
-  in_progress: { label: 'In Progress', color: 'processing' },
-  done: { label: 'Done', color: 'success' },
-}
-
-const statusOptions = [
-  { value: 'todo', label: 'Todo' },
-  { value: 'in_progress', label: 'In Progress' },
-  { value: 'done', label: 'Done' },
-]
-
-export function DemoTasksPage() {
-  const { message } = App.useApp()
-  const [items, setItems] = useState<DemoTask[]>([])
-  const [loading, setLoading] = useState(false)
-  const [submitting, setSubmitting] = useState(false)
-  const [form] = Form.useForm<CreateValues>()
-
-  const fetchTasks = useCallback(async () => {
-    setLoading(true)
-    try {
-      const data = await listDemoTasks()
-      setItems(data)
-    } catch (err) {
-      const detail = err instanceof Error ? err.message : 'Failed to load tasks'
-      message.error(detail)
-    } finally {
-      setLoading(false)
-    }
-  }, [message])
-
-  useEffect(() => {
-    void fetchTasks()
-  }, [fetchTasks])
-
-  const handleCreate = useCallback(
-    async (values: CreateValues) => {
-      const title = values.title?.trim()
-      if (!title) {
-        message.error('Title is required')
-        return
-      }
-      setSubmitting(true)
-      try {
-        await createDemoTask({ title, status: values.status })
-        form.resetFields()
-        await fetchTasks()
-        message.success('Task created')
-      } catch (err) {
-        const detail = err instanceof Error ? err.message : 'Failed to create task'
-        message.error(detail)
-      } finally {
-        setSubmitting(false)
-      }
-    },
-    [fetchTasks, form, message]
-  )
-
-  const handleStatusChange = useCallback(
-    async (id: number, status: DemoTaskStatus) => {
-      try {
-        await updateDemoTask(id, { status })
-        await fetchTasks()
-        message.success('Task updated')
-      } catch (err) {
-        const detail = err instanceof Error ? err.message : 'Failed to update task'
-        message.error(detail)
-      }
-    },
-    [fetchTasks, message]
-  )
-
-  const handleDelete = useCallback(
-    async (id: number) => {
-      try {
-        await deleteDemoTask(id)
-        await fetchTasks()
-        message.success('Task deleted')
-      } catch (err) {
-        const detail = err instanceof Error ? err.message : 'Failed to delete task'
-        message.error(detail)
-      }
-    },
-    [fetchTasks, message]
-  )
-
-  const columns: ColumnsType<DemoTask> = useMemo(
-    () => [
-      { title: 'Title', dataIndex: 'title', key: 'title' },
-      {
-        title: 'Status',
-        dataIndex: 'status',
-        key: 'status',
-        render: (value: DemoTaskStatus) => {
-          const meta = statusMeta[value]
-          return <Tag color={meta.color}>{meta.label}</Tag>
-        },
-      },
-      {
-        title: 'Updated',
-        dataIndex: 'updated_at',
-        key: 'updated_at',
-        render: (value: string) => (value ? dayjs(value).format('YYYY-MM-DD HH:mm') : '-'),
-      },
-      {
-        title: 'Actions',
-        key: 'actions',
-        render: (_, record) => (
-          <Space>
-            <Select
-              size="small"
-              value={record.status}
-              options={statusOptions}
-              style={{ width: 140 }}
-              onChange={(value) => handleStatusChange(record.id, value as DemoTaskStatus)}
-            />
-            <Popconfirm
-              title="Delete this task?"
-              onConfirm={() => handleDelete(record.id)}
-              okText="Delete"
-            >
-              <Button size="small" danger>
-                Delete
-              </Button>
-            </Popconfirm>
-          </Space>
-        ),
-      },
-    ],
-    [handleDelete, handleStatusChange]
-  )
-
-  return (
-    <Card
-      title="Demo Tasks"
-      extra={
-        <Button onClick={fetchTasks} loading={loading}>
-          Refresh
-        </Button>
-      }
-    >
-      <Space direction="vertical" size="middle" style={{ width: '100%' }}>
-        <Form
-          form={form}
-          layout="inline"
-          onFinish={handleCreate}
-          initialValues={{ status: 'todo' }}
-        >
-          <Form.Item name="title" rules={[{ required: true, message: 'Title is required' }]}>
-            <Input placeholder="Task title" allowClear style={{ width: 240 }} />
-          </Form.Item>
-          <Form.Item name="status">
-            <Select options={statusOptions} style={{ width: 160 }} />
-          </Form.Item>
-          <Form.Item>
-            <Button type="primary" htmlType="submit" loading={submitting}>
-              Add Task
-            </Button>
-          </Form.Item>
-        </Form>
-
-        <Table<DemoTask>
-          rowKey="id"
-          loading={loading}
-          columns={columns}
-          dataSource={items}
-          pagination={false}
-        />
-      </Space>
-    </Card>
-  )
-}

package/template/apps/web/src/modules/demo/routes.tsx

@@ -1,43 +0,0 @@
-import { lazy, Suspense, type ComponentType, type ReactElement } from 'react'
-import type { RouteObject } from 'react-router-dom'
-import { AppstoreOutlined } from '@ant-design/icons'
-import { Spin } from 'antd'
-
-const lazyNamed = <T extends Record<string, ComponentType>, K extends keyof T>(
-  factory: () => Promise<T>,
-  name: K
-) =>
-  lazy(async () => {
-    const module = await factory()
-    return { default: module[name] }
-  })
-
-const withSuspense = (element: ReactElement) => (
-  <Suspense
-    fallback={
-      <div style={{ padding: 24, display: 'flex', justifyContent: 'center' }}>
-        <Spin />
-      </div>
-    }
-  >
-    {element}
-  </Suspense>
-)
-
-const DemoTasksPage = lazyNamed(() => import('./pages/DemoTasksPage'), 'DemoTasksPage')
-
-export const demoRoutes: RouteObject[] = [
-  {
-    path: 'demo',
-    element: <DemoTasksPage />,
-    handle: {
-      menu: { label: 'Demo Tasks', icon: <AppstoreOutlined /> },
-      breadcrumb: 'Demo Tasks',
-      permission: 'demo:task:view',
-      helpKey: 'demo/tasks',
-    },
-  },
-].map((route) => ({
-  ...route,
-  element: route.element ? withSuspense(route.element) : route.element,
-}))

package/template/apps/web/src/modules/demo/services/demoTasks.ts

@@ -1,28 +0,0 @@
-import { api, type ApiResponse } from '@robsun/keystone-web-core'
-import type { DemoTask, DemoTaskStatus } from '../types'
-
-type TaskListResponse = {
-  items: DemoTask[]
-}
-
-export const listDemoTasks = async () => {
-  const { data } = await api.get<ApiResponse<TaskListResponse>>('/demo/tasks')
-  return data.data.items
-}
-
-export const createDemoTask = async (payload: { title: string; status?: DemoTaskStatus }) => {
-  const { data } = await api.post<ApiResponse<DemoTask>>('/demo/tasks', payload)
-  return data.data
-}
-
-export const updateDemoTask = async (
-  id: number,
-  payload: { title?: string; status?: DemoTaskStatus }
-) => {
-  const { data } = await api.patch<ApiResponse<DemoTask>>(`/demo/tasks/${id}`, payload)
-  return data.data
-}
-
-export const deleteDemoTask = async (id: number) => {
-  await api.delete<ApiResponse<{ id: number }>>(`/demo/tasks/${id}`)
-}

package/template/apps/web/src/modules/demo/types.ts

@@ -1,9 +0,0 @@
-export type DemoTaskStatus = 'todo' | 'in_progress' | 'done'
-
-export interface DemoTask {
-  id: number
-  title: string
-  status: DemoTaskStatus
-  created_at: string
-  updated_at: string
-}

package/template/apps/web/src/modules/example/pages/ExamplePage.tsx

@@ -1,41 +0,0 @@
-import { useCallback, useEffect, useState } from 'react'
-import { App, Button, Card, Space, Typography } from 'antd'
-import { getHello } from '../services/api'
-
-export function ExamplePage() {
-  const { message } = App.useApp()
-  const [data, setData] = useState<{ message: string; module: string } | null>(null)
-  const [loading, setLoading] = useState(false)
-
-  const fetchData = useCallback(async () => {
-    setLoading(true)
-    try {
-      setData(await getHello())
-    } catch (err) {
-      message.error(err instanceof Error ? err.message : 'Failed')
-    } finally {
-      setLoading(false)
-    }
-  }, [message])
-
-  useEffect(() => {
-    void fetchData()
-  }, [fetchData])
-
-  return (
-    <Card title="Example Module">
-      <Space direction="vertical">
-        <Typography.Title level={4}>Welcome!</Typography.Title>
-        <Typography.Text>This module demonstrates core Keystone patterns.</Typography.Text>
-        {data && (
-          <Card size="small">
-            <pre>{JSON.stringify(data, null, 2)}</pre>
-          </Card>
-        )}
-        <Button onClick={fetchData} loading={loading}>
-          Refresh
-        </Button>
-      </Space>
-    </Card>
-  )
-}

package/template/apps/web/src/modules/example/services/api.ts

@@ -1,8 +0,0 @@
-import { api, type ApiResponse } from '@robsun/keystone-web-core'
-
-export const getHello = async () => {
-  const { data } = await api.get<ApiResponse<{ message: string; module: string }>>(
-    '/example/hello'
-  )
-  return data.data
-}