create-skweb 1.1.0

package/templates/cjs/src/controllers/user.js

@@ -0,0 +1,101 @@
+const createHttpError = require('http-errors')
+const { db } = require('../services/database.js')
+
+const { SysUser } = db.sequelize.models
+
+module.exports = [
+  {
+    method: 'get',
+    path: '/api/users',
+    async handler(req) {
+      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) {
+      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) {
+      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) {
+      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) {
+      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/cjs/src/cronActions/cleanup.js

@@ -0,0 +1,12 @@
+const { logger } = require('../utils/logger.js')
+
+/**
+ * 清理任务示例
+ */
+async function cleanup() {
+  logger.info(`[cron] Running cleanup task at ${new Date().toISOString()}`)
+  logger.info('[cron] Cleanup task completed')
+}
+
+module.exports = cleanup
+module.exports.default = cleanup

package/templates/cjs/src/cronWorker.js

@@ -0,0 +1,85 @@
+require('dotenv/config')
+
+const path = require('path')
+const { CronFramework } = require('skweb-framework')
+const { logger } = require('./utils/logger.js')
+const { checkRequiredEnv } = require('./utils/config.js')
+
+async function startCronWorker() {
+  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 || 'mysql',
+      charset: process.env.DB_CHARSET || 'utf8mb4',
+      underscored: true,
+      logging: process.env.DEBUG_DB === 'true' ? (msg) => 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) => {
+      const SysCronTask = framework.db?.sequelize?.models.SysCronTask
+      if (SysCronTask) {
+        await SysCronTask.update(
+          { cache: taskData.cache, data: taskData.data },
+          { where: { id: taskData.taskId } }
+        )
+      }
+    },
+    loadTasks: async () => {
+      const SysCronTask = framework.db?.sequelize?.models.SysCronTask
+      if (!SysCronTask) return []
+      return (await SysCronTask.findAll()).map((t) => ({
+        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)
+  })
+}
+
+if (require.main === module) {
+  startCronWorker().catch((err) => {
+    logger.error('[cron-worker] Fatal error:', err)
+    process.exit(1)
+  })
+}
+
+module.exports = { startCronWorker }

package/templates/cjs/src/index.js

@@ -0,0 +1,7 @@
+require('dotenv/config')
+
+const { bootstrap } = require('./app.js')
+
+if (require.main === module) {
+  bootstrap()
+}

package/templates/cjs/src/models/SysUser.js

@@ -0,0 +1,38 @@
+const { Model, DataTypes } = require('sequelize')
+
+module.exports = (sequelize) => {
+  class SysUser extends Model {}
+  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/cjs/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/cjs/src/services/database.js

@@ -0,0 +1,15 @@
+const { Database } = require('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 || 'mysql',
+  charset: process.env.DB_CHARSET || 'utf8mb4',
+  underscored: true,
+  logging: process.env.DEBUG_DB === 'true'
+})
+
+module.exports = { db }

package/templates/cjs/src/utils/config.js

@@ -0,0 +1,65 @@
+const { logger } = require('./logger.js')
+
+function validateConfig() {
+  const errors = []
+
+  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
+  }
+}
+
+function checkRequiredEnv() {
+  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
+}
+
+module.exports = { validateConfig, checkRequiredEnv }

package/templates/cjs/src/utils/logger.js

@@ -0,0 +1,53 @@
+/**
+ * Winston 日志配置
+ */
+const winston = require('winston')
+const path = require('path')
+const fs = require('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}`
+})
+
+const fileFormat = combine(timestamp(), errors({ stack: true }), splat(), json())
+
+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,
+      maxFiles: 10
+    }),
+    new winston.transports.File({
+      filename: path.join(LOG_DIR, 'combined.log'),
+      format: fileFormat,
+      maxsize: 10 * 1024 * 1024,
+      maxFiles: 10
+    })
+  ]
+})
+
+if (LOG_CONSOLE) {
+  logger.add(
+    new winston.transports.Console({
+      format: combine(colorize(), consoleFormat)
+    })
+  )
+}
+
+module.exports = { logger }
+module.exports.default = logger

package/templates/cjs/test/index.js

@@ -0,0 +1,13 @@
+const { expect } = require('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/mjs/ecosystem.config.js

@@ -0,0 +1,32 @@
+module.exports = {
+  apps: [
+    {
+      name: '{{name}}-web',
+      script: 'src/index.js',
+      instances: 'max',
+      exec_mode: 'cluster',
+      env: {
+        NODE_ENV: 'production',
+        PORT: 3000
+      },
+      max_memory_restart: '512M',
+      error_file: 'logs/web-err.log',
+      out_file: 'logs/web-out.log',
+      log_date_format: 'YYYY-MM-DD HH:mm:ss Z'
+    },
+    {
+      name: '{{name}}-cron',
+      script: 'src/cronWorker.js',
+      instances: 1,
+      exec_mode: 'fork',
+      autorestart: true,
+      env: {
+        NODE_ENV: 'production'
+      },
+      max_memory_restart: '512M',
+      error_file: 'logs/cron-err.log',
+      out_file: 'logs/cron-out.log',
+      log_date_format: 'YYYY-MM-DD HH:mm:ss Z'
+    }
+  ]
+}

package/templates/mjs/eslint.config.js

@@ -0,0 +1,25 @@
+import js from '@eslint/js'
+
+export default [
+  { ignores: ['dist', 'node_modules', 'logs', 'test'] },
+  js.configs.recommended,
+  {
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      globals: {
+        process: 'readonly',
+        console: 'readonly',
+        Buffer: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        require: 'readonly',
+        module: 'readonly',
+        exports: 'writable'
+      }
+    },
+    rules: {
+      'no-unused-vars': ['warn', { argsIgnorePattern: '^_' }]
+    }
+  }
+]

package/templates/mjs/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "{{name}}",
+  "version": "1.0.0",
+  "description": "{{description}}",
+  "type": "module",
+  "scripts": {
+    "start": "pm2 start ecosystem.config.js",
+    "stop": "pm2 stop all",
+    "restart": "pm2 restart all",
+    "delete": "pm2 delete all",
+    "logs": "pm2 logs",
+    "web:dev": "npx dotenvx run -- node --watch src/index.js",
+    "cron:dev": "npx dotenvx run -- node --watch src/cronWorker.js",
+    "seed": "npx dotenvx run -- node src/commands/seed.js",
+    "migrate": "npx dotenvx run -- node src/commands/migrate.js",
+    "build": "cp -r src dist",
+    "lint": "eslint --fix --ext .js src",
+    "test": "npx dotenvx run -- mocha test/**/*.mjs",
+    "clean": "rm -rf dist",
+    "clean:temp": "rm -rf .rollup.cache"
+  },
+  "dependencies": {
+    "@dotenvx/dotenvx": "^1.71.0",
+    "http-errors": "^2.0.0",
+    "skweb-express": "^1.0.0",
+    "skweb-express-jwt": "^1.0.0",
+    "skweb-express-logger": "^1.0.0",
+    "skweb-sequelize": "^1.0.0",
+    "skweb-redis": "^1.0.0",
+    "skweb-cron": "^1.0.0",
+    "skweb-framework": "^1.0.0",
+    "skweb-plugin": "^1.0.0",
+    "skweb-util": "^1.0.0",
+    "winston": "^3.17.0",
+    "sequelize": "^6.37.7"
+  },
+  "devDependencies": {
+    "chai": "^6.2.1",
+    "mocha": "^11.7.5",
+    "eslint": "^9.39.1",
+    "@eslint/js": "^9.39.1"
+  },
+  "engines": {
+    "node": ">=20.18.1"
+  }
+}

package/templates/mjs/src/app.js

@@ -0,0 +1,97 @@
+import 'dotenv/config'
+
+import path from 'path'
+import { fileURLToPath } from 'url'
+import express from 'skweb-express'
+import expressLogger from 'skweb-express-logger'
+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() {
+  logger.info('[app] Initializing web process...')
+
+  if (!checkRequiredEnv()) {
+    logger.error('[app] Configuration validation failed, exiting...')
+    process.exit(1)
+  }
+
+  const { WebFramework } = await import('skweb-framework')
+
+  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 || 'mysql',
+      charset: process.env.DB_CHARSET || 'utf8mb4',
+      underscored: true,
+      logging: process.env.DEBUG_DB === 'true' ? (msg) => 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()
+
+  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/mjs/src/commands/migrate.js

@@ -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() {
+  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 || 'mysql',
+    charset: process.env.DB_CHARSET || 'utf8mb4',
+    underscored: true,
+    logging: process.env.DEBUG_DB === 'true' ? (msg) => 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)
+  })
+}