create-rebe 1.0.0 → 3.0.0

package/template/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rebe",
-    "version": "1.0.0",
+    "version": "3.0.0",
     "description": "Ready-to-use Node.js backend framework. One process serves a JSON API, Socket.IO, cron jobs, and an in-process queue on a layered config/core/app architecture, with JWT auth, Sequelize, Winston logging, and centralized configuration.",
     "license": "MIT",
     "author": "Refkinscallv <refkinscallv@gmail.com>",
@@ -36,7 +36,9 @@
         "cli": "node ./scripts/cli.js",
         "start": "node .",
         "dev": "nodemon",
-        "format": "prettier --write ."
+        "format": "prettier --write .",
+        "lint": "eslint .",
+        "audit:prod": "npm audit --omit=dev --audit-level=high"
     },
     "_moduleAliases": {
         "@config": "config",
@@ -52,13 +54,18 @@
         "@storage": "storage"
     },
     "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "eslint": "^10.5.0",
+        "eslint-plugin-n": "^18.1.0",
+        "eslint-plugin-security": "^4.0.1",
+        "globals": "^17.6.0",
         "jest": "^30.4.2",
         "nodemon": "^3.1.14",
-        "prettier": "^3.8.4"
+        "prettier": "^3.8.4",
+        "supertest": "^7.2.2"
     },
     "dependencies": {
-        "@refkinscallv/express-routing": "^3.2.0",
-        "axios": "^1.17.0",
+        "axios": "^1.18.0",
         "bcrypt": "^6.0.0",
         "compression": "^1.8.1",
         "cors": "^2.8.6",
@@ -69,10 +76,10 @@
         "ioredis": "^5.11.1",
         "jsonwebtoken": "^9.0.3",
         "module-alias": "^2.3.4",
-        "multer": "^2.1.1",
+        "multer": "^2.2.0",
         "mysql2": "^3.22.5",
-        "node-cron": "^4.2.1",
-        "nodemailer": "^8.0.10",
+        "node-cron": "^4.4.1",
+        "nodemailer": "^9.0.1",
         "sequelize": "^6.37.8",
         "socket.io": "^4.8.3",
         "winston": "^3.19.0",

package/template/scripts/cli/args.js

@@ -0,0 +1,39 @@
+'use strict'
+
+// Tiny argv parser for CLI commands. Splits a raw args array into positionals and
+// flags/options:
+//   --seed            -> options.seed = true
+//   --step=2          -> options.step = '2'
+//   --module blog     -> options.module = 'blog'
+//   --class=UserSeed  -> options.class = 'UserSeed'
+function parseArgs(argv = []) {
+	const positionals = []
+	const options = {}
+
+	for (let i = 0; i < argv.length; i++) {
+		const token = argv[i]
+		if (!token.startsWith('--')) {
+			positionals.push(token)
+			continue
+		}
+
+		const body = token.slice(2)
+		const eq = body.indexOf('=')
+		if (eq !== -1) {
+			options[body.slice(0, eq)] = body.slice(eq + 1)
+			continue
+		}
+
+		const next = argv[i + 1]
+		if (next !== undefined && !next.startsWith('--')) {
+			options[body] = next
+			i++
+		} else {
+			options[body] = true
+		}
+	}
+
+	return { positionals, options }
+}
+
+module.exports = { parseArgs }

package/template/scripts/cli/bootstrap.js

@@ -0,0 +1,16 @@
+'use strict'
+
+// Lazily prepare the runtime for commands that touch the application cores
+// (migrations, seeders). Registers module-alias so @core/@config resolve exactly as
+// they do at app boot, then loads .env. Kept out of the top-level dispatcher so
+// pure-scaffolding and key commands stay dependency-free and fast.
+let prepared = false
+
+function prepareRuntime() {
+	if (prepared) return
+	require('module-alias/register')
+	require('dotenv').config()
+	prepared = true
+}
+
+module.exports = { prepareRuntime }

package/template/scripts/cli/db.js

@@ -0,0 +1,79 @@
+'use strict'
+
+const Log = require('./log')
+const { parseArgs } = require('./args')
+
+// Database commands. The dispatcher calls prepareRuntime() and closes the connection
+// for these, so handlers can require the cores directly and stay focused on intent.
+function migrator() {
+	return require('@core/migrator.core')
+}
+function seeder() {
+	return require('@core/seeder.core')
+}
+
+async function maybeSeed(options) {
+	if (options.seed) {
+		Log.info('Seeding…')
+		await seeder().seed(typeof options.seed === 'string' ? options.seed : undefined)
+	}
+}
+
+async function migrate() {
+	await migrator().up()
+}
+
+async function rollback(argv) {
+	const { options } = parseArgs(argv)
+	const step = Math.max(1, Number(options.step) || 1)
+	await migrator().down({ step })
+}
+
+// reset / fresh: drop every table, then migrate from scratch (optionally seed).
+async function reset(argv) {
+	const { options } = parseArgs(argv)
+	await migrator().dropAllTables()
+	await migrator().up()
+	await maybeSeed(options)
+}
+
+// refresh: roll every migration back via down(), then migrate up again (optionally seed).
+async function refresh(argv) {
+	const { options } = parseArgs(argv)
+	await migrator().rollbackAll()
+	await migrator().up()
+	await maybeSeed(options)
+}
+
+async function wipe() {
+	await migrator().dropAllTables()
+}
+
+async function status() {
+	const rows = await migrator().status()
+	Log.banner()
+	console.log(Log.color('yellow', 'Migrations'))
+	Log.line()
+	if (!rows.length) {
+		console.log(Log.color('gray', '  (none found)'))
+	} else {
+		for (const r of rows) {
+			const tag = r.applied ? Log.color('green', `[applied · batch ${r.batch}]`) : Log.color('gray', '[pending]')
+			console.log(`  ${tag} ${r.name}`)
+		}
+	}
+	console.log()
+}
+
+// db:seed [--all] [--class=Name]
+async function seed(argv) {
+	const { options } = parseArgs(argv)
+	if (options.all) return seeder().seedAll()
+	return seeder().seed(options.class)
+}
+
+async function seedAll() {
+	await seeder().seedAll()
+}
+
+module.exports = { migrate, rollback, reset, fresh: reset, refresh, wipe, status, seed, seedAll }

package/template/scripts/cli/help.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const Log = require('./log')
+
+function row(name, desc) {
+	console.log(`  ${name}`)
+	console.log(Log.color('gray', `      ${desc}`))
+	console.log()
+}
+
+function help() {
+	Log.banner()
+
+	console.log(Log.color('yellow', 'Usage'))
+	Log.line()
+	console.log('  npm run cli -- <command> [options]')
+	console.log()
+
+	console.log(Log.color('yellow', 'Project'))
+	Log.line()
+	row('setup [--upgrade]', 'Create .env, install deps, generate keys (--upgrade runs npm-check-updates)')
+	row('help', 'Show this help')
+
+	console.log(Log.color('yellow', 'Keys'))
+	Log.line()
+	row('key:generate', 'Generate APP_KEY')
+	row('key:jwt [--refresh]', 'Generate JWT_SECRET (or JWT_REFRESH_SECRET with --refresh)')
+
+	console.log(Log.color('yellow', 'Scaffolding') + Log.color('gray', '   (all support --module=<name>)'))
+	Log.line()
+	row('make:model <Name> [--table=t] [--no-migration]', 'Model + matching create-table migration')
+	row('make:migration <name>', 'Blank up/down migration')
+	row('make:seed <Name>', 'Seeder')
+	row('make:controller <Name> [--resource] [--api]', 'HTTP controller (plain, or RESTful resource)')
+	row('make:middleware <Name>', 'Route middleware (handle() class)')
+	row('make:validator <Name>', 'Zod validator schemas')
+	row('make:route <name>', 'Route group file')
+	row('make:job <Name>', 'Cron job module')
+	row('make:queue <Name>', 'Queue worker module')
+	row('make:socket <Name>', 'Socket handler module')
+	row('make:hook [name]', 'Lifecycle hooks ({ before, after, shutdown })')
+	row('make:resource <Name> [--api]', 'Vertical slice: controller + model + migration + validator + route')
+	row('make:module <name>', 'Full mini-app module (http/, routes, jobs, queue, socket, hooks, models, migrations, seeders)')
+
+	console.log(Log.color('yellow', 'Database'))
+	Log.line()
+	row('db:migrate            (alias: migrate)', 'Run all pending migrations')
+	row('db:rollback [--step=N] (alias: rollback)', 'Roll back the last batch (or last N batches)')
+	row('db:reset [--seed]     (alias: reset)', 'Drop all tables, then migrate (optionally seed)')
+	row('db:refresh [--seed]', 'Roll back everything via down(), then migrate (optionally seed)')
+	row('db:fresh [--seed]', 'Alias of db:reset')
+	row('db:status', 'List applied and pending migrations')
+	row('db:wipe', 'Drop all tables (no migrate)')
+	row('db:seed [--all] [--class=Name] (alias: seed)', 'Run the default/named seeder, or all with --all')
+	row('db:seed-all           (alias: seed-all)', 'Run every seeder')
+}
+
+module.exports = { help }

package/template/scripts/cli/keys.js

@@ -0,0 +1,100 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+const { execSync } = require('child_process')
+
+const Log = require('./log')
+const { parseArgs } = require('./args')
+
+function generateKey(bytes = 32) {
+	return crypto.randomBytes(bytes).toString('hex')
+}
+
+function getEnvPath() {
+	return path.join(process.cwd(), '.env')
+}
+
+function updateEnv(key, value) {
+	const envPath = getEnvPath()
+	if (!fs.existsSync(envPath)) {
+		Log.error('.env file not found')
+		process.exit(1)
+	}
+
+	let content = fs.readFileSync(envPath, 'utf8')
+	const regex = new RegExp(`^${key}=.*$`, 'm')
+	content = regex.test(content) ? content.replace(regex, `${key}=${value}`) : `${content}\n${key}=${value}`
+	fs.writeFileSync(envPath, content)
+	return value
+}
+
+function printKey(label, key) {
+	Log.success(`${label} generated`)
+	console.log()
+	console.log(Log.color('cyan', key))
+	console.log()
+}
+
+function generateAppKey() {
+	printKey('APP_KEY', updateEnv('APP_KEY', generateKey(32)))
+}
+
+function generateJwtSecret() {
+	printKey('JWT_SECRET', updateEnv('JWT_SECRET', generateKey(64)))
+}
+
+function generateJwtRefreshSecret() {
+	printKey('JWT_REFRESH_SECRET', updateEnv('JWT_REFRESH_SECRET', generateKey(64)))
+}
+
+function keyJwt(argv) {
+	const { options } = parseArgs(argv)
+	if (options.refresh) generateJwtRefreshSecret()
+	else generateJwtSecret()
+}
+
+// setup: copy .env, install deps, generate keys. Dependency upgrades are opt-in via
+// --upgrade: blindly running `npm-check-updates -u` on every setup is what pulls in
+// fresh, sometimes-vulnerable versions, so the default installs the pinned versions.
+function setup(argv) {
+	Log.banner()
+	const { options } = parseArgs(argv)
+
+	const examplePath = path.join(process.cwd(), '.env.example')
+	const envPath = path.join(process.cwd(), '.env')
+
+	if (!fs.existsSync(examplePath)) {
+		Log.error('.env.example not found')
+		process.exit(1)
+	}
+
+	if (!fs.existsSync(envPath)) {
+		fs.copyFileSync(examplePath, envPath)
+		Log.success('.env created')
+	} else {
+		Log.warn('.env already exists')
+	}
+
+	try {
+		if (options.upgrade) {
+			Log.info('Upgrading package.json dependencies (--upgrade)...')
+			execSync('npx npm-check-updates -u', { stdio: 'inherit' })
+		}
+
+		Log.info('Installing dependencies...')
+		execSync('npm install', { stdio: 'inherit' })
+
+		generateAppKey()
+		generateJwtSecret()
+		generateJwtRefreshSecret()
+
+		Log.success('Setup completed')
+	} catch (error) {
+		Log.error(error.message)
+		process.exit(1)
+	}
+}
+
+module.exports = { setup, generateAppKey, keyJwt }

package/template/scripts/cli/log.js

@@ -0,0 +1,58 @@
+'use strict'
+
+// Shared CLI logger. Display name is driven by APP_NAME (no hardcoded brand); falls
+// back to 'rebe' when .env is not present yet (e.g. before `setup`).
+const APP_NAME = (process.env.APP_NAME || 'rebe').toUpperCase()
+
+class Log {
+	static colors = {
+		reset: '\x1b[0m',
+		red: '\x1b[31m',
+		green: '\x1b[32m',
+		yellow: '\x1b[33m',
+		blue: '\x1b[34m',
+		cyan: '\x1b[36m',
+		white: '\x1b[37m',
+		gray: '\x1b[90m',
+	}
+
+	static color(color, message) {
+		return `${this.colors[color] || ''}${message}${this.colors.reset}`
+	}
+
+	static info(message) {
+		console.log(this.color('blue', `[INFO] ${message}`))
+	}
+
+	static success(message) {
+		console.log(this.color('green', `[ OK ] ${message}`))
+	}
+
+	static warn(message) {
+		console.log(this.color('yellow', `[WARN] ${message}`))
+	}
+
+	static error(message) {
+		console.log(this.color('red', `[FAIL] ${message}`))
+	}
+
+	static line() {
+		console.log(this.color('gray', '────────────────────────────────────────'))
+	}
+
+	static banner() {
+		const width = 38
+		const title = `${APP_NAME} CLI`
+		const padTotal = Math.max(0, width - title.length)
+		const left = Math.floor(padTotal / 2)
+		const centered = ' '.repeat(left) + title + ' '.repeat(padTotal - left)
+
+		console.log()
+		console.log(this.color('cyan', `╔${'═'.repeat(width)}╗`))
+		console.log(this.color('cyan', `║${centered}║`))
+		console.log(this.color('cyan', `╚${'═'.repeat(width)}╝`))
+		console.log()
+	}
+}
+
+module.exports = Log

package/template/scripts/cli/make.js

@@ -0,0 +1,249 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+const Log = require('./log')
+const { parseArgs } = require('./args')
+const { toKebab, toSnake, tableName, timestamp } = require('./names')
+const tpl = require('./templates')
+
+const ROOT = process.cwd()
+
+// Directory layout per artifact kind, for the flat app and for a module subfolder.
+const FLAT_DIRS = {
+	models: ['database', 'models'],
+	migrations: ['database', 'migrations'],
+	seeders: ['database', 'seeders'],
+	controllers: ['app', 'http', 'controllers'],
+	middlewares: ['app', 'http', 'middlewares'],
+	validators: ['app', 'http', 'validators'],
+	routes: ['app', 'routes'],
+	jobs: ['app', 'jobs'],
+	queue: ['app', 'queue'],
+	socket: ['app', 'socket'],
+	hooks: ['app', 'hooks'],
+}
+
+const MODULE_DIRS = {
+	models: ['models'],
+	migrations: ['migrations'],
+	seeders: ['seeders'],
+	controllers: ['http', 'controllers'],
+	middlewares: ['http', 'middlewares'],
+	validators: ['http', 'validators'],
+	routes: ['routes'],
+	jobs: ['jobs'],
+	queue: ['queue'],
+	socket: ['socket'],
+	hooks: ['hooks'],
+}
+
+// Resolve a base directory for generated files: the flat layout by default, or a
+// module subfolder when --module=<name> is given.
+function baseDir(kind, moduleName) {
+	if (moduleName) return path.join(ROOT, 'modules', toKebab(moduleName), ...(MODULE_DIRS[kind] || [kind]))
+	return path.join(ROOT, ...(FLAT_DIRS[kind] || [kind]))
+}
+
+// Write a file, creating parent dirs. Refuses to overwrite unless --force.
+function writeFile(target, content, force) {
+	if (fs.existsSync(target) && !force) {
+		Log.error(`Already exists: ${path.relative(ROOT, target)} (use --force to overwrite)`)
+		process.exit(1)
+	}
+	fs.mkdirSync(path.dirname(target), { recursive: true })
+	fs.writeFileSync(target, content)
+	Log.success(`Created ${path.relative(ROOT, target)}`)
+}
+
+function gitkeep(dir) {
+	const keep = path.join(dir, '.gitkeep')
+	fs.mkdirSync(dir, { recursive: true })
+	if (!fs.existsSync(keep)) fs.writeFileSync(keep, '')
+}
+
+function requireName(positionals, what) {
+	const name = positionals[0]
+	if (!name) {
+		Log.error(`Missing name. Usage: npm run cli -- ${what} <Name>`)
+		process.exit(1)
+	}
+	return name
+}
+
+// Print a "now wire it up" hint for layers loaded via a single register file.
+function wireHint(options, flatMsg) {
+	if (options.module) {
+		Log.info(`Wire it into modules/${toKebab(options.module)}/${toKebab(options.module)}.module.js`)
+	} else {
+		Log.info(flatMsg)
+	}
+}
+
+// Route files in a module's routes/ dir are auto-loaded; flat route files must be
+// required from app/routes/register.route.js.
+function routeWireHint(options, slug) {
+	if (options.module) {
+		Log.info(`Auto-loaded from modules/${toKebab(options.module)}/routes/`)
+	} else {
+		Log.info(`Add  require('@routes/${slug}.route')  to app/routes/register.route.js`)
+	}
+}
+
+// ── Data layer ───────────────────────────────────────────────────────────────
+
+// make:model <Name> [--module=m] [--table=t] [--no-migration]
+function makeModel(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:model')
+	const table = options.table || tableName(name)
+
+	writeFile(path.join(baseDir('models', options.module), `${toKebab(name)}.model.js`), tpl.modelTemplate(name, table), options.force)
+
+	if (options.migration !== false && !options['no-migration']) {
+		writeFile(path.join(baseDir('migrations', options.module), `${timestamp()}_create_${table}.js`), tpl.createMigrationTemplate(table), options.force)
+	}
+}
+
+// make:migration <name> [--module=m]
+function makeMigration(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:migration')
+	writeFile(path.join(baseDir('migrations', options.module), `${timestamp()}_${toSnake(name)}.js`), tpl.blankMigrationTemplate(toSnake(name)), options.force)
+}
+
+// make:seed <Name> [--module=m]
+function makeSeed(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:seed')
+	writeFile(path.join(baseDir('seeders', options.module), `${toKebab(name)}.js`), tpl.seederTemplate(name), options.force)
+}
+
+// ── HTTP layer ───────────────────────────────────────────────────────────────
+
+// make:controller <Name> [--resource] [--api] [--module=m]
+function makeController(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:controller')
+	const resource = Boolean(options.resource || options.api)
+	writeFile(path.join(baseDir('controllers', options.module), `${toKebab(name)}.controller.js`), tpl.controllerTemplate(name, { resource, api: Boolean(options.api) }), options.force)
+}
+
+// make:middleware <Name> [--module=m]
+function makeMiddleware(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:middleware')
+	writeFile(path.join(baseDir('middlewares', options.module), `${toKebab(name)}.middleware.js`), tpl.middlewareTemplate(name), options.force)
+}
+
+// make:validator <Name> [--module=m]
+function makeValidator(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:validator')
+	writeFile(path.join(baseDir('validators', options.module), `${toKebab(name)}.validator.js`), tpl.validatorTemplate(name), options.force)
+}
+
+// make:route <name> [--module=m]
+function makeRoute(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:route')
+	writeFile(path.join(baseDir('routes', options.module), `${toKebab(name)}.route.js`), tpl.routeTemplate(name), options.force)
+	routeWireHint(options, toKebab(name))
+}
+
+// ── Background / lifecycle ─────────────────────────────────────────────────────
+
+// make:job <Name> [--module=m]
+function makeJob(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:job')
+	writeFile(path.join(baseDir('jobs', options.module), `${toKebab(name)}.job.js`), tpl.jobTemplate(name), options.force)
+	wireHint(options, `Require + invoke it from app/jobs/register.job.js: require('./${toKebab(name)}.job')(Cron)`)
+}
+
+// make:queue <Name> [--module=m]
+function makeQueue(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:queue')
+	writeFile(path.join(baseDir('queue', options.module), `${toKebab(name)}.queue.js`), tpl.queueTemplate(name), options.force)
+	wireHint(options, `Require + invoke it from app/queue/register.queue.js: require('./${toKebab(name)}.queue')(Queue)`)
+}
+
+// make:socket <Name> [--module=m]
+function makeSocket(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:socket')
+	writeFile(path.join(baseDir('socket', options.module), `${toKebab(name)}.socket.js`), tpl.socketTemplate(name), options.force)
+	wireHint(options, `Require + invoke it from app/socket/register.socket.js: require('./${toKebab(name)}.socket')(io, Socket)`)
+}
+
+// make:hook [name] [--module=m]
+function makeHook(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const fileName = positionals[0] ? `${toKebab(positionals[0])}.hook.js` : 'register.hook.js'
+	writeFile(path.join(baseDir('hooks', options.module), fileName), tpl.hookTemplate(), options.force)
+}
+
+// ── Bundles ────────────────────────────────────────────────────────────────────
+
+// make:resource <Name> [--api] [--module=m] — a wired vertical slice.
+function makeResource(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:resource')
+	const api = Boolean(options.api)
+	const table = options.table || tableName(name)
+	const force = options.force
+
+	writeFile(path.join(baseDir('controllers', options.module), `${toKebab(name)}.controller.js`), tpl.controllerTemplate(name, { resource: true, api }), force)
+	writeFile(path.join(baseDir('models', options.module), `${toKebab(name)}.model.js`), tpl.modelTemplate(name, table), force)
+	writeFile(path.join(baseDir('migrations', options.module), `${timestamp()}_create_${table}.js`), tpl.createMigrationTemplate(table), force)
+	writeFile(path.join(baseDir('validators', options.module), `${toKebab(name)}.validator.js`), tpl.validatorTemplate(name), force)
+
+	// The route requires the controller: alias path for flat, relative for a module.
+	const controllerRequire = options.module ? `../http/controllers/${toKebab(name)}.controller` : `@http/controllers/${toKebab(name)}.controller`
+	writeFile(path.join(baseDir('routes', options.module), `${toKebab(name)}.route.js`), tpl.resourceRouteTemplate(name, { api, controllerRequire }), force)
+
+	routeWireHint(options, toKebab(name))
+	Log.info('Then run: npm run cli -- db:migrate')
+}
+
+// ── Module skeleton ──────────────────────────────────────────────────────────
+
+// make:module <name> — a self-contained mini-app mirroring the full app layout.
+function makeModule(argv) {
+	const { positionals, options } = parseArgs(argv)
+	const name = requireName(positionals, 'make:module')
+	const slug = toKebab(name)
+	const dir = path.join(ROOT, 'modules', slug)
+
+	writeFile(path.join(dir, `${slug}.module.js`), tpl.moduleEntryTemplate(slug), options.force)
+	writeFile(path.join(dir, 'routes', 'index.js'), tpl.moduleRouteTemplate(slug), options.force)
+	writeFile(path.join(dir, 'http', 'middlewares', 'register.middleware.js'), tpl.appMiddlewareTemplate(slug), options.force)
+	writeFile(path.join(dir, 'jobs', 'register.job.js'), tpl.jobTemplate(slug), options.force)
+	writeFile(path.join(dir, 'queue', 'register.queue.js'), tpl.queueTemplate(slug), options.force)
+	writeFile(path.join(dir, 'socket', 'register.socket.js'), tpl.socketTemplate(slug), options.force)
+	writeFile(path.join(dir, 'hooks', 'register.hook.js'), tpl.hookTemplate(), options.force)
+
+	for (const sub of [['http', 'controllers'], ['http', 'validators'], ['models'], ['migrations'], ['seeders']]) {
+		gitkeep(path.join(dir, ...sub))
+	}
+
+	Log.success(`Module "${slug}" scaffolded at ${path.relative(ROOT, dir)} (full mini-app layout)`)
+}
+
+module.exports = {
+	makeModel,
+	makeMigration,
+	makeSeed,
+	makeController,
+	makeMiddleware,
+	makeValidator,
+	makeRoute,
+	makeJob,
+	makeQueue,
+	makeSocket,
+	makeHook,
+	makeResource,
+	makeModule,
+}