sdd-workflow 1.1.0

package/templates/specify/templates/plan-modular-template/backend-impl.md

@@ -0,0 +1,134 @@
+# Backend Implementation Details
+
+> This document describes backend Service and Repository implementation
+
+## 1. Service Layer Implementation
+
+### 1.1 Service Interface
+
+**File Path**: `{backend_source_path}/services/{Name}Service.{ext}`
+
+```{backend_language}
+// {Name}Service interface
+// - list(keyword, status, pageNum, pageSize) -> PageInfo
+// - getById(id) -> DTO
+// - create(request) -> id
+// - update(id, request)
+// - delete(id)
+```
+
+### 1.2 Service Implementation
+
+**File Path**: `{backend_source_path}/services/impl/{Name}ServiceImpl.{ext}`
+
+```{backend_language}
+// {Name}ServiceImpl
+//
+// list():
+//   1. Build query conditions
+//   2. Execute paginated query
+//   3. Convert to DTOs
+//
+// create():
+//   1. Validate parameters
+//   2. Convert to entity
+//   3. Save to database
+//   4. Return ID
+//
+// update():
+//   1. Check resource exists
+//   2. Validate parameters
+//   3. Business rule validation
+//   4. Convert and update
+//
+// delete():
+//   1. Check resource exists
+//   2. Check can delete (dependency check)
+//   3. Execute delete
+```
+
+## 2. Repository/Data Access Layer Implementation
+
+### 2.1 Repository Interface
+
+**File Path**: `{backend_source_path}/repositories/{Name}Repository.{ext}`
+
+```{backend_language}
+// {Name}Repository interface
+// - selectByQuery(query) -> List<Entity>
+// - selectById(id) -> Entity
+// - insert(entity) -> int
+// - updateById(entity) -> int
+// - deleteById(id) -> int
+```
+
+### 2.2 Query Mapping
+
+**File Path**: `{backend_source_path}/mappers/{Name}Mapper.{ext}`
+
+```{mapper_language}
+<!-- Result mapping for {table_name} -->
+<!-- Base columns: id, name, description, status, created_by, created_time, updated_by, updated_time -->
+
+<!-- Query list with dynamic conditions (keyword search, status filter) -->
+<!-- Query by ID -->
+<!-- Insert -->
+<!-- Update (dynamic set) -->
+<!-- Delete -->
+```
+
+## 3. Entity/Model Classes
+
+**File Path**: `{backend_source_path}/models/{Name}Entity.{ext}`
+
+```{backend_language}
+// {Name}Entity - maps to {table_name} table
+// Fields:
+// - id: primary key
+// - name: name
+// - description: description
+// - status: status
+// - createdBy: creator
+// - createdTime: creation time
+// - updatedBy: updater
+// - updatedTime: update time
+```
+
+## 4. Business Logic Notes
+
+### 4.1 Core Business Flows
+
+1. **Create Flow**:
+   - Parameter validation
+   - Business rule validation
+   - Data conversion
+   - Save to database
+   - Return ID
+
+2. **Update Flow**:
+   - Check resource exists
+   - Parameter validation
+   - Business rule validation
+   - Data conversion
+   - Update database
+
+3. **Delete Flow**:
+   - Check resource exists
+   - Check can delete (dependency check)
+   - Execute delete
+
+### 4.2 Transaction Management
+
+- All write operations (create, update, delete) use transactions
+- Query operations do not use transactions
+- Use default transaction propagation
+
+### 4.3 Exception Handling
+
+- Parameter errors: Throw validation exceptions
+- Business errors: Throw business exceptions
+- System errors: Throw system exceptions
+
+---
+
+Back to [Plan Index](./README.md)

package/templates/specify/templates/plan-modular-template/changelog.md

@@ -0,0 +1,34 @@
+# Change Log
+
+> This document records version change history for the implementation plan
+
+## Version History
+
+| Version | Date | Change | Changed By |
+|---------|------|--------|------------|
+| 1.0 | {date} | Initial version | {author} |
+
+## Detailed Changes
+
+### v1.0 (Initial Version)
+
+**Architecture Design**:
+- Frontend-backend separation architecture
+- Technology stack selected per constitution.md
+
+**Data Model**:
+- New table: {table_name}
+- DTO design complete
+
+**API Design**:
+- RESTful API
+- Unified response format
+
+**Implementation Details**:
+- Service layer implementation
+- Repository layer implementation
+- Frontend component implementation
+
+---
+
+Back to [Plan Index](./README.md)

package/templates/specify/templates/plan-modular-template/data-model.md

@@ -0,0 +1,130 @@
+# Data Model
+
+> This document describes database design (DDL) and data transfer objects (DTO)
+
+## 1. Database Design
+
+### 1.1 New Tables
+
+#### Table: {table_name}
+
+**Description**: {table_purpose}
+
+**DDL**:
+
+```sql
+CREATE TABLE {table_name} (
+    id BIGSERIAL PRIMARY KEY,
+    {column_name} VARCHAR(100) NOT NULL,
+    created_by VARCHAR(50) NOT NULL,
+    created_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_by VARCHAR(50),
+    updated_time TIMESTAMP,
+    CONSTRAINT uk_{table_name}_{column} UNIQUE ({column_name})
+);
+
+CREATE INDEX idx_{table_name}_{column} ON {table_name}({column_name});
+
+COMMENT ON TABLE {table_name} IS '{table_description}';
+COMMENT ON COLUMN {table_name}.{column_name} IS '{column_description}';
+```
+
+### 1.2 Modified Tables
+
+#### Table: {existing_table}
+
+**Change Description**: {change_reason}
+
+**DDL**:
+
+```sql
+ALTER TABLE {existing_table} ADD COLUMN {new_column} VARCHAR(100);
+COMMENT ON COLUMN {existing_table}.{new_column} IS '{column_description}';
+```
+
+### 1.3 Entity Relationship Diagram
+
+```
+┌─────────────┐         ┌─────────────┐
+│   Table A   │ 1     N │   Table B   │
+│─────────────│─────────│─────────────│
+│ id (PK)     │         │ id (PK)     │
+│ name        │         │ a_id (FK)   │
+└─────────────┘         └─────────────┘
+```
+
+## 2. DTO Design
+
+### 2.1 Request DTO
+
+#### {Name}RequestDTO
+
+**Purpose**: {purpose_description}
+
+```{dto_language}
+class {Name}RequestDTO {
+    /** {field_description} */
+    {field1}: {type}  // required
+
+    /** {field_description} */
+    {field2}: {type}  // optional
+}
+```
+
+### 2.2 Response DTO
+
+#### {Name}ResponseDTO
+
+**Purpose**: {purpose_description}
+
+```{dto_language}
+class {Name}ResponseDTO {
+    {id}: {type}
+    {field1}: {type}
+    {field2}: {type}
+}
+```
+
+### 2.3 DTO Conversion
+
+```{dto_language}
+// Entity -> DTO
+function toDTO(entity) {
+    return {
+        id: entity.id,
+        field1: entity.field1,
+        // ...
+    };
+}
+
+// DTO -> Entity
+function toEntity(dto) {
+    return {
+        field1: dto.field1,
+        // ...
+    };
+}
+```
+
+## 3. Data Dictionary
+
+### 3.1 Enum Types
+
+#### {EnumName}
+
+| Value | Description | Notes |
+|-------|-------------|-------|
+| VALUE1 | Description 1 | Notes 1 |
+| VALUE2 | Description 2 | Notes 2 |
+
+### 3.2 State Transitions
+
+```
+Initial -> Processing -> Complete
+         |
+       Failed
+```
+
+---
+
+Back to [Plan Index](./README.md)

package/templates/specify/templates/plan-modular-template/frontend-api.md

@@ -0,0 +1,126 @@
+# Frontend API Integration
+
+> This document describes how the frontend integrates with backend APIs
+
+## 1. API Service Layer
+
+### 1.1 API File Structure
+
+```
+{frontend_source_path}/api/
+├── index.{ext}              # API unified exports
+├── {module}.{ext}           # Module API definitions
+└── request.{ext}            # Request wrapper (existing)
+```
+
+### 1.2 API Definition
+
+**File Path**: `{frontend_source_path}/api/{module}.{ext}`
+
+```{frontend_language}
+import { request } from '{http_client_path}';
+
+/**
+ * Query list
+ */
+export const list = (params) => {
+  return request({
+    url: '/v1/{module}/{resource}',
+    method: 'GET',
+    params
+  });
+};
+
+/**
+ * Query detail
+ */
+export const getById = (id) => {
+  return request({
+    url: `/v1/{module}/${id}`,
+    method: 'GET'
+  });
+};
+
+/**
+ * Create
+ */
+export const create = (data) => {
+  return request({
+    url: '/v1/{module}/{resource}',
+    method: 'POST',
+    data
+  });
+};
+
+/**
+ * Update
+ */
+export const update = (id, data) => {
+  return request({
+    url: `/v1/{module}/${id}`,
+    method: 'PUT',
+    data
+  });
+};
+
+/**
+ * Delete
+ */
+export const deleteById = (id) => {
+  return request({
+    url: `/v1/{module}/${id}`,
+    method: 'DELETE'
+  });
+};
+```
+
+## 2. Request Response Handling
+
+### 2.1 Success Response
+
+```{frontend_language}
+// Backend response format (adjust to match your API contract)
+{
+  status: '0',    // Check your project's actual convention (string vs number)
+  message: 'success',
+  data: {}
+}
+
+// Frontend handling
+const response = await list({ keyword: 'test' });
+if (response.status === '0') {  // Adjust status check to match your project
+  console.log(response.data);
+}
+```
+
+### 2.2 Error Handling
+
+```{frontend_language}
+try {
+  const response = await create(data);
+  if (response.status === '0') {
+    // Success handling
+  } else {
+    // Business error handling
+  }
+} catch (error) {
+  // Network error handling
+  console.error(error);
+}
+```
+
+## 3. Notes
+
+### 3.1 Response Status Check
+
+**Important**: Check your project's API response convention for the status field type and success value.
+
+### 3.2 Error Handling
+
+- Network errors: catch with try-catch
+- Business errors: check response status
+- User notification: use appropriate UI feedback
+
+---
+
+Back to [Plan Index](./README.md)

package/templates/specify/templates/plan-modular-template/frontend-impl.md

@@ -0,0 +1,108 @@
+# Frontend Implementation Details
+
+> This document describes frontend component, Store and routing implementation
+
+## 1. Store/State Management Design
+
+### 1.1 Store File
+
+**File Path**: `{frontend_source_path}/stores/{Name}Store.{ext}`
+
+```{frontend_language}
+// {Name}Store - State management for {feature}
+//
+// State:
+// - list: Array
+// - loading: boolean
+// - total: number
+// - currentPage: number
+// - pageSize: number
+//
+// Actions:
+// - fetchList(params): Fetch paginated list
+// - create(data): Create new item
+// - setPage(page, pageSize): Update pagination state
+```
+
+## 2. Page Components
+
+### 2.1 List Page
+
+**File Path**: `{frontend_source_path}/pages/{module}/{feature}/List.{ext}`
+
+```{frontend_language}
+// {Name}List component
+//
+// Features:
+// - Search bar with keyword input
+// - Data table with pagination
+// - Action buttons (edit, delete)
+// - Create button
+//
+// Dependencies:
+// - {Name}Store for state management
+// - UI table component for data display
+```
+
+### 2.2 Detail Page
+
+**File Path**: `{frontend_source_path}/pages/{module}/{feature}/Detail.{ext}`
+
+```{frontend_language}
+// {Name}Detail component
+//
+// Features:
+// - Display item details
+// - Loading state
+// - Empty state handling
+//
+// Props:
+// - id: Item ID to display
+```
+
+## 3. Route Configuration
+
+### 3.1 Route Definition
+
+**File Path**: `{frontend_source_path}/routes/{module}/index.{ext}`
+
+```{frontend_language}
+// Route configuration for {feature}
+//
+// Routes:
+// - /{feature}/list -> List page
+// - /{feature}/detail/:id -> Detail page
+```
+
+## 4. Style Files
+
+### 4.1 Styles
+
+**File Path**: `{frontend_source_path}/pages/{module}/{feature}/List.{style_ext}`
+
+```{style_language}
+// Styles for {module}-{feature}-list
+// - Container padding
+// - Toolbar layout
+// - Table styling
+```
+
+## 5. Component Communication
+
+### 5.1 Parent-Child Communication
+
+```{frontend_language}
+// Parent passes data and callbacks to child
+// Child triggers callbacks to notify parent of changes
+```
+
+### 5.2 Store Sharing
+
+```{frontend_language}
+// Multiple components import the same Store instance
+// Shared state across components
+```
+
+---
+
+Back to [Plan Index](./README.md)

package/templates/specify/templates/plan-modular-template/performance.md

@@ -0,0 +1,112 @@
+# Performance Optimization
+
+> This document describes performance optimization strategies
+
+## 1. Database Optimization
+
+### 1.1 Index Design
+
+```sql
+-- Single column index
+CREATE INDEX idx_{table}_{column} ON {table}({column});
+
+-- Composite index
+CREATE INDEX idx_{table}_{col1}_{col2} ON {table}({col1}, {col2});
+
+-- Unique index
+CREATE UNIQUE INDEX uk_{table}_{column} ON {table}({column});
+```
+
+### 1.2 Query Optimization
+
+- Avoid SELECT *
+- Use pagination
+- Avoid N+1 queries
+- Use batch operations
+
+```
+// Bad: N+1 query
+for each item in items:
+    query database for item details
+
+// Good: Batch query
+collect all item IDs
+query database for all item details at once
+use Map for lookup
+```
+
+## 2. Caching Strategy
+
+### 2.1 Application Cache
+
+```
+// Cache frequently accessed data
+// Invalidate cache on update/delete
+// Set appropriate TTL
+```
+
+### 2.2 Cache Invalidation Strategy
+
+- Active invalidation: Clear cache on update/delete
+- Passive invalidation: Set expiration time (TTL)
+- Cache warmup: Load hot data on system startup
+
+## 3. Frontend Optimization
+
+### 3.1 Code Splitting
+
+```
+// Route-level lazy loading
+// Load components on demand
+```
+
+### 3.2 List Optimization
+
+- Virtual scrolling (for large data sets)
+- Pagination
+- Debounce/throttle user input
+
+```
+// Debounce search input
+const debouncedSearch = debounce(handleSearch, 300);
+
+// Throttle scroll handler
+const throttledScroll = throttle(handleScroll, 100);
+```
+
+## 4. API Optimization
+
+### 4.1 Batch APIs
+
+```
+// Batch query endpoint
+// POST /batch with list of IDs
+// Returns map of ID to data
+```
+
+### 4.2 Async Processing
+
+```
+// Long-running operations processed asynchronously
+// Return task ID, poll for completion
+```
+
+## 5. Performance Monitoring
+
+### 5.1 Slow Query Monitoring
+
+```sql
+-- Enable slow query log
+-- Set appropriate threshold
+-- Monitor and optimize slow queries
+```
+
+### 5.2 API Performance Monitoring
+
+- Response time monitoring
+- QPS monitoring
+- Error rate monitoring
+
+---
+
+Back to [Plan Index](./README.md)