create-skweb 1.1.0

package/templates/ts/src/app.ts

@@ -0,0 +1,96 @@
+import 'dotenv/config'
+
+import path from 'path'
+import { fileURLToPath } from 'url'
+import express from 'skweb-express'
+import expressLogger from 'skweb-express-logger'
+import { WebFramework } from 'skweb-framework'
+import logger from './utils/logger.js'
+import { checkRequiredEnv } from './utils/config.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+async function bootstrap(): Promise<void> {
+  logger.info('[app] Initializing web process...')
+
+  if (!checkRequiredEnv()) {
+    logger.error('[app] Configuration validation failed, exiting...')
+    process.exit(1)
+  }
+
+  const framework = new WebFramework({
+    db: {
+      host: process.env.DB_HOST || '127.0.0.1',
+      port: Number(process.env.DB_PORT) || 3306,
+      username: process.env.DB_USER || 'root',
+      password: process.env.DB_PASS || '',
+      database: process.env.DB_NAME || 'test-project',
+      dialect: (process.env.DB_DIALECT as 'mysql' | 'postgres' | 'sqlite' | 'mariadb') || 'mysql',
+      charset: process.env.DB_CHARSET || 'utf8mb4',
+      underscored: true,
+      logging: process.env.DEBUG_DB === 'true' ? (msg: string) => logger.debug(msg) : false
+    },
+    redis: {
+      host: process.env.REDIS_HOST || '127.0.0.1',
+      port: Number(process.env.REDIS_PORT) || 6379,
+      password: process.env.REDIS_PASSWORD || undefined
+    }
+  })
+
+  await framework.runPluginBeforeSetup()
+  await framework.setupModels(path.join(__dirname, './models'))
+  await framework.loadPluginModels()
+  await framework.runPluginAfterSetup()
+
+  const app = framework.createApp() as express.Express & Record<string, any>
+
+  app.disable('x-powered-by')
+  app.disable('etag')
+
+  app.set('trust proxy', true)
+
+  app.set('wrap response', true)
+  app.setOkCode(0)
+  app.setOkMessage('success')
+
+  app.setJWT('default', {
+    secret: process.env.JWT_SECRET || 'please-change-this-in-production',
+    algorithms: ['HS256'],
+    sign: { expiresIn: process.env.JWT_EXPIRES_IN || '7d' },
+    requestProperty: 'resolvedToken'
+  })
+  app.setJwtHintHeader('JwtHint')
+
+  app.use(expressLogger())
+  app.use(express.static(path.join(__dirname, '..', 'public')))
+
+  await framework.loadControllers(path.join(__dirname, './controllers'))
+  await framework.loadPluginControllers()
+
+  framework.start(Number(process.env.PORT) || 3000)
+
+  logger.info('[app] Initialization complete (web process)')
+
+  process.on('SIGINT', async () => {
+    logger.info('[app] Received SIGINT, shutting down gracefully...')
+    await framework.stop()
+    process.exit(0)
+  })
+
+  process.on('SIGTERM', async () => {
+    logger.info('[app] Received SIGTERM, shutting down gracefully...')
+    await framework.stop()
+    process.exit(0)
+  })
+}
+
+const isMainModule = import.meta.url === `file://${process.argv[1]}`
+if (isMainModule) {
+  bootstrap().catch((err) => {
+    logger.error('[app] Fatal error:', err)
+    process.exit(1)
+  })
+}
+
+export { bootstrap }

package/templates/ts/src/commands/migrate.ts

@@ -0,0 +1,38 @@
+import 'dotenv/config'
+
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { Database } from 'skweb-sequelize'
+import logger from '../utils/logger.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+async function runMigrate(): Promise<void> {
+  logger.info('[migrate] Running database migrations...')
+
+  const db = new Database({
+    host: process.env.DB_HOST || '127.0.0.1',
+    port: Number(process.env.DB_PORT) || 3306,
+    username: process.env.DB_USER || 'root',
+    password: process.env.DB_PASS || '',
+    database: process.env.DB_NAME || 'test-project',
+    dialect: (process.env.DB_DIALECT as 'mysql' | 'postgres' | 'sqlite' | 'mariadb') || 'mysql',
+    charset: process.env.DB_CHARSET || 'utf8mb4',
+    underscored: true,
+    logging: process.env.DEBUG_DB === 'true' ? (msg: string) => logger.debug(msg) : false
+  })
+
+  await db.loadModelsDir(path.join(__dirname, '..', 'models'))
+  db.associateAllModels()
+  await db.sequelize.sync({ alter: true })
+  logger.info('[migrate] Database schema synced')
+}
+
+const isMainModule = import.meta.url === `file://${process.argv[1]}`
+if (isMainModule) {
+  runMigrate().catch((err) => {
+    logger.error('[migrate] Fatal error:', err)
+    process.exit(1)
+  })
+}

package/templates/ts/src/commands/seed.ts

@@ -0,0 +1,63 @@
+import 'dotenv/config'
+
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { Database } from 'skweb-sequelize'
+import logger from '../utils/logger.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+async function runSeed(): Promise<void> {
+  logger.info('[seed] Initializing database with seed data...')
+
+  const db = new Database({
+    host: process.env.DB_HOST || '127.0.0.1',
+    port: Number(process.env.DB_PORT) || 3306,
+    username: process.env.DB_USER || 'root',
+    password: process.env.DB_PASS || '',
+    database: process.env.DB_NAME || 'test-project',
+    dialect: (process.env.DB_DIALECT as 'mysql' | 'postgres' | 'sqlite' | 'mariadb') || 'mysql',
+    charset: process.env.DB_CHARSET || 'utf8mb4',
+    underscored: true,
+    logging: process.env.DEBUG_DB === 'true' ? (msg: string) => logger.debug(msg) : false
+  })
+
+  await db.loadModelsDir(path.join(__dirname, '..', 'models'))
+  db.associateAllModels()
+
+  const seedsDir = path.join(__dirname, '..', 'seeds')
+  const fs = await import('fs/promises')
+  let files: string[]
+  try {
+    files = await fs.readdir(seedsDir)
+  } catch {
+    logger.warn('[seed] No seeds directory found')
+    return
+  }
+
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue
+    const modelName = path.basename(file, '.json')
+    const Model = db.sequelize.models[modelName]
+    if (!Model) {
+      logger.warn(`[seed] Model ${modelName} not found`)
+      continue
+    }
+    const data = JSON.parse(await fs.readFile(path.join(seedsDir, file), 'utf-8'))
+    if (Array.isArray(data) && data.length > 0) {
+      await Model.bulkCreate(data, { ignoreDuplicates: true })
+      logger.info(`[seed] Seeded ${modelName} with ${data.length} records`)
+    }
+  }
+
+  logger.info('[seed] Database initialization complete')
+}
+
+const isMainModule = import.meta.url === `file://${process.argv[1]}`
+if (isMainModule) {
+  runSeed().catch((err) => {
+    logger.error('[seed] Fatal error:', err)
+    process.exit(1)
+  })
+}

package/templates/ts/src/controllers/hello.ts

@@ -0,0 +1,33 @@
+export default [
+  {
+    method: 'get',
+    path: '/',
+    async handler() {
+      return {
+        message: 'Welcome to SKWeb!',
+        version: '1.0.0',
+        timestamp: new Date().toISOString()
+      }
+    }
+  },
+  {
+    method: 'get',
+    path: '/health',
+    async handler() {
+      return {
+        status: 'ok',
+        timestamp: new Date().toISOString()
+      }
+    }
+  },
+  {
+    method: 'post',
+    path: '/echo',
+    async handler(req: any) {
+      return {
+        message: 'Echo received',
+        data: req.body
+      }
+    }
+  }
+]

package/templates/ts/src/controllers/user.ts

@@ -0,0 +1,101 @@
+import createHttpError from 'http-errors'
+import { db } from '../services/database.js'
+
+const { SysUser } = db.sequelize.models
+
+export default [
+  {
+    method: 'get',
+    path: '/api/users',
+    async handler(req: any) {
+      const { page = 1, limit = 10 } = req.query
+      const users = await SysUser.findAndCountAll({
+        offset: (Number(page) - 1) * Number(limit),
+        limit: Number(limit)
+      })
+      return {
+        list: users.rows,
+        total: users.count
+      }
+    }
+  },
+  {
+    method: 'get',
+    path: '/api/users/:id',
+    paramsSchema: {
+      type: 'object',
+      required: ['id'],
+      properties: { id: { type: 'integer', minimum: 1 } }
+    },
+    async handler(req: any) {
+      const { id } = req.validatedParams
+      const user = await SysUser.findByPk(id)
+      if (!user) {
+        throw new createHttpError.NotFound('User not found')
+      }
+      return user
+    }
+  },
+  {
+    method: 'post',
+    path: '/api/users',
+    bodySchema: {
+      type: 'object',
+      required: ['username', 'password'],
+      properties: {
+        username: { type: 'string', minLength: 3 },
+        password: { type: 'string', minLength: 6 },
+        email: { type: 'string', format: 'email' },
+        phone: { type: 'string' }
+      }
+    },
+    async handler(req: any) {
+      return await SysUser.create(req.validatedBody)
+    }
+  },
+  {
+    method: 'put',
+    path: '/api/users/:id',
+    paramsSchema: {
+      type: 'object',
+      required: ['id'],
+      properties: { id: { type: 'integer', minimum: 1 } }
+    },
+    bodySchema: {
+      type: 'object',
+      properties: {
+        password: { type: 'string', minLength: 6 },
+        email: { type: 'string', format: 'email' },
+        phone: { type: 'string' },
+        status: { type: 'integer' }
+      }
+    },
+    async handler(req: any) {
+      const { id } = req.validatedParams
+      const user = await SysUser.findByPk(id)
+      if (!user) {
+        throw new createHttpError.NotFound('User not found')
+      }
+      await user.update(req.validatedBody)
+      return user
+    }
+  },
+  {
+    method: 'delete',
+    path: '/api/users/:id',
+    paramsSchema: {
+      type: 'object',
+      required: ['id'],
+      properties: { id: { type: 'integer', minimum: 1 } }
+    },
+    async handler(req: any) {
+      const { id } = req.validatedParams
+      const user = await SysUser.findByPk(id)
+      if (!user) {
+        throw new createHttpError.NotFound('User not found')
+      }
+      await user.destroy()
+      return { message: 'User deleted' }
+    }
+  }
+]

package/templates/ts/src/cronActions/cleanup.ts

@@ -0,0 +1,10 @@
+import logger from '../utils/logger.js'
+
+/**
+ * 清理任务示例 - 每天凌晨3点清理过期数据
+ */
+export default async function cleanup(): Promise<void> {
+  logger.info(`[cron] Running cleanup task at ${new Date().toISOString()}`)
+  // 业务逻辑：清理 7 天前的临时文件、过期 token 等
+  logger.info('[cron] Cleanup task completed')
+}

package/templates/ts/src/cronWorker.ts

@@ -0,0 +1,90 @@
+import 'dotenv/config'
+
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { CronFramework } from 'skweb-framework'
+import logger from './utils/logger.js'
+import { checkRequiredEnv } from './utils/config.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+async function startCronWorker(): Promise<void> {
+  logger.info('[cron-worker] Starting cron worker process...')
+
+  if (!checkRequiredEnv()) {
+    logger.error('[cron-worker] Configuration validation failed, exiting...')
+    process.exit(1)
+  }
+
+  const framework = new CronFramework({
+    db: {
+      host: process.env.DB_HOST || '127.0.0.1',
+      port: Number(process.env.DB_PORT) || 3306,
+      username: process.env.DB_USER || 'root',
+      password: process.env.DB_PASS || '',
+      database: process.env.DB_NAME || 'test-project',
+      dialect: (process.env.DB_DIALECT as 'mysql' | 'postgres' | 'sqlite' | 'mariadb') || 'mysql',
+      charset: process.env.DB_CHARSET || 'utf8mb4',
+      underscored: true,
+      logging: process.env.DEBUG_DB === 'true' ? (msg: string) => logger.debug(msg) : false
+    },
+    redis: {
+      host: process.env.REDIS_HOST || '127.0.0.1',
+      port: Number(process.env.REDIS_PORT) || 6379,
+      password: process.env.REDIS_PASSWORD || undefined
+    },
+    channel: 'cron:task:cmd',
+    logger,
+    onSaveTask: async (taskData: { taskId: string; cache: unknown; data: unknown }) => {
+      const SysCronTask = framework.db?.sequelize?.models.SysCronTask as any
+      if (SysCronTask) {
+        await SysCronTask.update(
+          { cache: taskData.cache, data: taskData.data },
+          { where: { id: taskData.taskId } }
+        )
+      }
+    },
+    loadTasks: async () => {
+      const SysCronTask = framework.db?.sequelize?.models.SysCronTask as any
+      if (!SysCronTask) return []
+      return (await SysCronTask.findAll()).map((t: any) => ({
+        id: String(t.id),
+        cronTime: t.cronTime,
+        method: t.method
+      }))
+    }
+  })
+
+  await framework.runPluginBeforeSetup()
+  await framework.setupModels(path.join(__dirname, './models'))
+  await framework.loadPluginModels()
+  await framework.runPluginAfterSetup()
+
+  await framework.loadCronActions(path.join(__dirname, './cronActions'))
+  await framework.startWorker()
+  framework.start()
+  logger.info('[cron-worker] Cron worker started')
+
+  process.on('SIGINT', async () => {
+    logger.info('[cron-worker] Received SIGINT, shutting down...')
+    await framework.stop()
+    process.exit(0)
+  })
+
+  process.on('SIGTERM', async () => {
+    logger.info('[cron-worker] Received SIGTERM, shutting down...')
+    await framework.stop()
+    process.exit(0)
+  })
+}
+
+const isMainModule = import.meta.url === `file://${process.argv[1]}`
+if (isMainModule) {
+  startCronWorker().catch((err) => {
+    logger.error('[cron-worker] Fatal error:', err)
+    process.exit(1)
+  })
+}
+
+export { startCronWorker }

package/templates/ts/src/index.ts

@@ -0,0 +1,8 @@
+import 'dotenv/config'
+
+import { bootstrap } from './app.js'
+
+const isMainModule = import.meta.url === `file://${process.argv[1]}`
+if (isMainModule) {
+  bootstrap()
+}

package/templates/ts/src/models/SysUser.ts

@@ -0,0 +1,49 @@
+import { Model, DataTypes, type Sequelize, type ModelStatic } from 'sequelize'
+
+export default (sequelize: Sequelize): ModelStatic<Model> => {
+  class SysUser extends Model {
+    declare id: number
+    declare username: string
+    declare password: string
+    declare email: string
+    declare phone: string
+    declare status: number
+    declare createdAt: Date
+    declare updatedAt: Date
+  }
+
+  SysUser.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: true,
+      autoIncrement: true
+    },
+    username: {
+      type: DataTypes.STRING(50),
+      allowNull: false,
+      unique: true
+    },
+    password: {
+      type: DataTypes.STRING(255),
+      allowNull: false
+    },
+    email: {
+      type: DataTypes.STRING(100)
+    },
+    phone: {
+      type: DataTypes.STRING(20)
+    },
+    status: {
+      type: DataTypes.TINYINT,
+      defaultValue: 1
+    }
+  }, {
+    sequelize,
+    modelName: 'SysUser',
+    tableName: 'sys_users',
+    timestamps: true,
+    underscored: true
+  })
+
+  return SysUser
+}

package/templates/ts/src/seeds/SysUser.json

@@ -0,0 +1 @@
+[{"id": 1, "username": "admin", "password": "$2b$10$example", "email": "admin@example.com", "phone": "13800138000", "status": 1}]

package/templates/ts/src/services/database.ts

@@ -0,0 +1,16 @@
+import { Database } from 'skweb-sequelize'
+
+const db = new Database({
+  host: process.env.DB_HOST || '127.0.0.1',
+  port: Number(process.env.DB_PORT) || 3306,
+  username: process.env.DB_USER || 'root',
+  password: process.env.DB_PASS || '',
+  database: process.env.DB_NAME || '{{name}}',
+  dialect: (process.env.DB_DIALECT as any) || 'mysql',
+  charset: process.env.DB_CHARSET || 'utf8mb4',
+  underscored: true,
+  logging: process.env.DEBUG_DB === 'true'
+})
+
+export { db }
+export default db

package/templates/ts/src/utils/config.ts

@@ -0,0 +1,68 @@
+import logger from './logger.js'
+
+interface ConfigValidationResult {
+  isValid: boolean
+  errors: string[]
+}
+
+export function validateConfig(): ConfigValidationResult {
+  const errors: string[] = []
+
+  if (!process.env.DB_HOST) {
+    logger.warn('[config] DB_HOST not set, using default: 127.0.0.1')
+  }
+  if (!process.env.DB_NAME) {
+    logger.warn('[config] DB_NAME not set, using default: test-project')
+  }
+  if (!process.env.DB_USER) {
+    logger.warn('[config] DB_USER not set, using default: root')
+  }
+
+  if (process.env.JWT_SECRET === 'please-change-this-in-production') {
+    logger.warn('[config] WARNING: JWT_SECRET is using default value, please change in production!')
+  }
+
+  if (!process.env.REDIS_HOST) {
+    logger.warn('[config] REDIS_HOST not set, using default: 127.0.0.1')
+  }
+
+  const port = Number(process.env.PORT)
+  if (port && (port < 1 || port > 65535)) {
+    errors.push('PORT must be between 1 and 65535')
+  }
+
+  const dbPort = Number(process.env.DB_PORT)
+  if (dbPort && (dbPort < 1 || dbPort > 65535)) {
+    errors.push('DB_PORT must be between 1 and 65535')
+  }
+
+  const redisPort = Number(process.env.REDIS_PORT)
+  if (redisPort && (redisPort < 1 || redisPort > 65535)) {
+    errors.push('REDIS_PORT must be between 1 and 65535')
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors
+  }
+}
+
+export function checkRequiredEnv(): boolean {
+  const result = validateConfig()
+  
+  if (result.errors.length > 0) {
+    logger.error('[config] Configuration validation failed:')
+    result.errors.forEach((err) => logger.error(`  - ${err}`))
+    return false
+  }
+
+  if (process.env.NODE_ENV === 'production') {
+    if (!process.env.JWT_SECRET || process.env.JWT_SECRET === 'please-change-this-in-production') {
+      logger.error('[config] JWT_SECRET must be set in production!')
+      return false
+    }
+  }
+
+  logger.info('[config] Configuration validation passed')
+  return true
+}

package/templates/ts/src/utils/logger.ts

@@ -0,0 +1,63 @@
+/**
+ * Winston 日志配置
+ *
+ * 支持通过环境变量控制：
+ * - LOG_LEVEL: 日志级别 (debug/info/warn/error)，默认 info
+ * - LOG_DIR: 日志文件目录，默认 ./logs
+ * - LOG_CONSOLE: 是否同时输出到控制台 (true/false)，默认 true
+ */
+import winston from 'winston'
+import path from 'path'
+import fs from 'fs'
+
+const LOG_LEVEL = process.env.LOG_LEVEL || 'info'
+const LOG_DIR = process.env.LOG_DIR || path.join(process.cwd(), 'logs')
+const LOG_CONSOLE = process.env.LOG_CONSOLE !== 'false'
+
+// 确保日志目录存在
+if (!fs.existsSync(LOG_DIR)) {
+  fs.mkdirSync(LOG_DIR, { recursive: true })
+}
+
+const { combine, timestamp, printf, colorize, errors, splat, json } = winston.format
+
+// 控制台输出格式：带颜色 + 易读
+const consoleFormat = printf(({ level, message, timestamp: ts, stack }) => {
+  return `${ts} [${level}] ${stack || message}`
+})
+
+// 文件输出格式：JSON 结构（便于日志分析系统采集）
+const fileFormat = combine(timestamp(), errors({ stack: true }), splat(), json())
+
+export const logger = winston.createLogger({
+  level: LOG_LEVEL,
+  format: combine(timestamp({ format: 'YYYY-MM-DD HH:mm:ss.SSS' }), errors({ stack: true }), splat()),
+  transports: [
+    // 错误日志单独输出
+    new winston.transports.File({
+      filename: path.join(LOG_DIR, 'error.log'),
+      level: 'error',
+      format: fileFormat,
+      maxsize: 10 * 1024 * 1024, // 10MB
+      maxFiles: 10
+    }),
+    // 所有日志
+    new winston.transports.File({
+      filename: path.join(LOG_DIR, 'combined.log'),
+      format: fileFormat,
+      maxsize: 10 * 1024 * 1024, // 10MB
+      maxFiles: 10
+    })
+  ]
+})
+
+// 生产环境：输出到控制台
+if (LOG_CONSOLE) {
+  logger.add(
+    new winston.transports.Console({
+      format: combine(colorize(), consoleFormat)
+    })
+  )
+}
+
+export default logger

package/templates/ts/test/index.mjs

@@ -0,0 +1,13 @@
+import { expect } from 'chai'
+
+describe('SKWeb App Tests', function() {
+  describe('Basic Tests', function() {
+    it('should pass basic test', function() {
+      expect(true).to.equal(true)
+    })
+
+    it('should have correct package structure', function() {
+      expect('SKWeb').to.be.a('string')
+    })
+  })
+})

package/templates/ts/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020"],
+    "moduleResolution": "Node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": true,
+    "rootDir": "src",
+    "outDir": "dist",
+    "baseUrl": "."
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "test"]
+}