create-skweb 1.1.0

package/templates/mjs/src/commands/seed.js

@@ -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() {
+  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 || '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()
+
+  const seedsDir = path.join(__dirname, '..', 'seeds')
+  const fs = await import('fs/promises')
+  let files
+  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/mjs/src/controllers/hello.js

@@ -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) {
+      return {
+        message: 'Echo received',
+        data: req.body
+      }
+    }
+  }
+]

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

@@ -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) {
+      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/mjs/src/cronActions/cleanup.js

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

package/templates/mjs/src/cronWorker.js

@@ -0,0 +1,91 @@
+import 'dotenv/config'
+
+import path from 'path'
+import { fileURLToPath } from 'url'
+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() {
+  logger.info('[cron-worker] Starting cron worker process...')
+
+  if (!checkRequiredEnv()) {
+    logger.error('[cron-worker] Configuration validation failed, exiting...')
+    process.exit(1)
+  }
+
+  const { CronFramework } = await import('skweb-framework')
+
+  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)
+  })
+}
+
+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/mjs/src/index.js

@@ -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/mjs/src/models/SysUser.js

@@ -0,0 +1,40 @@
+import { Model, DataTypes } from 'sequelize'
+
+export default (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/mjs/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/mjs/src/services/database.js

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

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

@@ -0,0 +1,63 @@
+import logger from './logger.js'
+
+export 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
+  }
+}
+
+export 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
+}

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

@@ -0,0 +1,52 @@
+/**
+ * Winston 日志配置
+ */
+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}`
+})
+
+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,
+      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)
+    })
+  )
+}
+
+export default logger

package/templates/mjs/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/ecosystem.config.js

@@ -0,0 +1,36 @@
+module.exports = {
+  apps: [
+    {
+      name: '{{name}}-web',
+      script: 'src/index.ts',
+      interpreter: 'npx',
+      interpreter_args: 'tsx',
+      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.ts',
+      interpreter: 'npx',
+      interpreter_args: 'tsx',
+      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/ts/eslint.config.js

@@ -0,0 +1,17 @@
+import tseslint from 'typescript-eslint'
+import js from '@eslint/js'
+
+export default tseslint.config(
+  { ignores: ['dist', 'node_modules', 'logs', 'test'] },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.recommended],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module'
+    },
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }]
+    }
+  }
+)

package/templates/ts/package.json

@@ -0,0 +1,57 @@
+{
+  "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 -- tsx watch src/index.ts",
+    "cron:dev": "npx dotenvx run -- tsx watch src/cronWorker.ts",
+    "seed": "npx dotenvx run -- tsx src/commands/seed.ts",
+    "migrate": "npx dotenvx run -- tsx src/commands/migrate.ts",
+    "build": "tsc && rollup -c rollup.config.mjs",
+    "build:dev": "rollup -c rollup.config.mjs --environment NODE_ENV:development",
+    "lint": "eslint --fix --ext .ts src",
+    "check": "tsc --noEmit",
+    "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": {
+    "@types/node": "^25.0.1",
+    "@types/mocha": "^10.0.10",
+    "@types/http-errors": "^2.0.4",
+    "chai": "^6.2.1",
+    "mocha": "^11.7.5",
+    "tsx": "^4.22.4",
+    "typescript": "^5.9.3",
+    "rollup": "^2.79.2",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "eslint": "^9.39.1",
+    "typescript-eslint": "^8.49.0"
+  },
+  "engines": {
+    "node": ">=20.18.1"
+  }
+}

package/templates/ts/rollup.config.mjs

@@ -0,0 +1,39 @@
+import resolve from '@rollup/plugin-node-resolve'
+import commonjs from '@rollup/plugin-commonjs'
+import typescript from '@rollup/plugin-typescript'
+import terser from '@rollup/plugin-terser'
+
+const isProduction = process.env.NODE_ENV === 'production'
+
+export default {
+  input: 'src/index.ts',
+  output: {
+    file: 'dist/index.js',
+    format: 'es',
+    sourcemap: true
+  },
+  plugins: [
+    resolve(),
+    commonjs(),
+    typescript({ tsconfig: './tsconfig.json' }),
+    isProduction && terser()
+  ],
+  external: [
+    'skweb-express',
+    'skweb-express-jwt',
+    'skweb-express-logger',
+    'skweb-sequelize',
+    'skweb-redis',
+    'skweb-cron',
+    'skweb-framework',
+    'skweb-plugin',
+    'skweb-util',
+    '@dotenvx/dotenvx',
+    'http-errors',
+    'express',
+    'sequelize',
+    'ioredis',
+    'path',
+    'fs'
+  ]
+}