create-rebe 1.0.0 → 3.0.0

package/template/scripts/cli/names.js

@@ -0,0 +1,51 @@
+'use strict'
+
+// Name + timestamp helpers shared by the scaffolding commands.
+
+// Split an arbitrary identifier (PascalCase, camelCase, snake_case, kebab-case,
+// "space separated") into lowercase words.
+function words(input) {
+	return String(input)
+		.replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+		.replace(/[_\-./\\]+/g, ' ')
+		.trim()
+		.split(/\s+/)
+		.filter(Boolean)
+		.map((w) => w.toLowerCase())
+}
+
+function toPascal(input) {
+	return words(input)
+		.map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+		.join('')
+}
+
+function toSnake(input) {
+	return words(input).join('_')
+}
+
+function toKebab(input) {
+	return words(input).join('-')
+}
+
+// Naive English pluralizer — enough for table names; override with --table when wrong.
+function pluralize(word) {
+	if (/[^aeiou]y$/i.test(word)) return word.replace(/y$/i, 'ies')
+	if (/(s|x|z|ch|sh)$/i.test(word)) return `${word}es`
+	return `${word}s`
+}
+
+function tableName(input) {
+	const parts = words(input)
+	if (!parts.length) return ''
+	const last = parts.pop()
+	return [...parts, pluralize(last)].join('_')
+}
+
+// Filesystem timestamp prefix: YYYYMMDDHHmmss (local time).
+function timestamp(date = new Date()) {
+	const pad = (n) => String(n).padStart(2, '0')
+	return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`
+}
+
+module.exports = { words, toPascal, toSnake, toKebab, pluralize, tableName, timestamp }

package/template/scripts/cli/templates.js

@@ -0,0 +1,358 @@
+'use strict'
+
+const { toPascal, toKebab } = require('./names')
+
+// Scaffolding templates. Each returns a file's contents as a string. Output mirrors
+// the hand-written examples in database/models and the framework's code style
+// (tabs, single quotes, no semicolons).
+
+function modelTemplate(name, table) {
+	const Model = toPascal(name)
+	return `'use strict'
+
+// Sequelize model. database.core loads every file in database/models/*.js (and each
+// module's models/ dir) when DB_ENABLED=true; files prefixed with "_" are ignored.
+// The factory receives (sequelize, DataTypes) and returns the model; associations
+// are wired in a second pass via the static associate(models).
+module.exports = (sequelize, DataTypes) => {
+	const ${Model} = sequelize.define(
+		'${Model}',
+		{
+			id: { type: DataTypes.BIGINT.UNSIGNED, primaryKey: true, autoIncrement: true },
+			// TODO: declare columns
+		},
+		{
+			tableName: '${table}',
+			underscored: true,
+		},
+	)
+
+	${Model}.associate = (models) => {
+		// e.g. ${Model}.belongsTo(models.User, { foreignKey: 'user_id', as: 'user' })
+	}
+
+	return ${Model}
+}
+`
+}
+
+function createMigrationTemplate(table) {
+	return `'use strict'
+
+// Auto-generated create-table migration. Edit the column definitions to match the
+// model. Run with: npm run cli -- db:migrate   /   roll back: db:rollback
+module.exports = {
+	async up(queryInterface, Sequelize) {
+		await queryInterface.createTable(
+			'${table}',
+			{
+				id: { type: Sequelize.BIGINT.UNSIGNED, primaryKey: true, autoIncrement: true },
+				// TODO: declare columns to match the model
+				created_at: { type: Sequelize.DATE, allowNull: false, defaultValue: Sequelize.fn('NOW') },
+				updated_at: { type: Sequelize.DATE, allowNull: false, defaultValue: Sequelize.fn('NOW') },
+			},
+			{ charset: 'utf8mb4' },
+		)
+	},
+
+	async down(queryInterface) {
+		await queryInterface.dropTable('${table}')
+	},
+}
+`
+}
+
+function blankMigrationTemplate(name) {
+	return `'use strict'
+
+// Migration: ${name}
+// up() applies the change, down() reverts it. queryInterface is the Sequelize
+// QueryInterface; Sequelize exposes DataTypes (Sequelize.STRING, etc.).
+module.exports = {
+	async up(queryInterface, Sequelize) {
+		// e.g. await queryInterface.addColumn('users', 'status', { type: Sequelize.STRING(20) })
+	},
+
+	async down(queryInterface, Sequelize) {
+		// e.g. await queryInterface.removeColumn('users', 'status')
+	},
+}
+`
+}
+
+function seederTemplate(name) {
+	return `'use strict'
+
+// Seeder: ${name}
+// Seeders are not tracked and may run repeatedly — write them idempotently
+// (findOrCreate / upsert). Receives { sequelize, Database, Sequelize, models }.
+// Run with: npm run cli -- db:seed --class=${name}   /   all: db:seed --all
+module.exports = async ({ models, sequelize, Database }) => {
+	// const User = Database.model('User')
+	// await User.findOrCreate({ where: { email: 'admin@example.com' }, defaults: { name: 'Admin' } })
+}
+`
+}
+
+// Full module entry — a self-contained mini-app. Discovered by modules.core at
+// runtime; the flat layout (database/models, app/routes…) keeps working alongside it.
+// Dir fields (models/migrations/seeders/routes) are scanned; the function/object
+// fields (middlewares/jobs/queue/socket/hooks) mirror the app/.../register.*.js shapes.
+// Remove any field — and its file — for a layer this module does not need.
+function moduleEntryTemplate(name) {
+	return `'use strict'
+
+module.exports = {
+	name: '${name}',
+
+	// Scanned directories
+	models: './models', // (sequelize, DataTypes) factories
+	migrations: './migrations', // up/down migration files
+	seeders: './seeders', // seeder files
+	routes: './routes', // required for its routing side-effect
+
+	// Register hooks (same facades as app/.../register.*.js)
+	middlewares: require('./http/middlewares/register.middleware'), // (app) => {}
+	jobs: require('./jobs/register.job'), // (Cron) => {}
+	queue: require('./queue/register.queue'), // (Queue) => {}
+	socket: require('./socket/register.socket'), // (io, Socket) => {}
+	hooks: require('./hooks/register.hook'), // { before, after, shutdown }
+}
+`
+}
+
+// Global middleware register — (app) => {}. Mirrors app/http/middlewares/register.middleware.js.
+function appMiddlewareTemplate(name) {
+	return `'use strict'
+
+// Global middleware for the "${name}" module. Receives the Express app, applied
+// during boot after the security/parsing stack.
+module.exports = (app) => {
+	// app.use((req, res, next) => next())
+}
+`
+}
+
+function moduleRouteTemplate(name) {
+	return `'use strict'
+
+// Routes for the "${name}" module. Uses the same Routes facade as app/routes.
+const Routes = require('@core/routing.core')
+
+Routes.group('${name}', () => {
+	Routes.get('', ({ res }) => {
+		res.json({ status: true, code: 200, message: '${name} module ready', data: null, meta: null })
+	})
+})
+
+module.exports = Routes
+`
+}
+
+// ── App-layer scaffolds ──────────────────────────────────────────────────────
+
+function controllerTemplate(name, { resource = false, api = false } = {}) {
+	const Ctrl = `${toPascal(name)}Controller`
+	const ok = (message, data = 'null') => `res.json({ status: true, code: 200, message: '${message}', data: ${data}, meta: null })`
+
+	if (!resource) {
+		return `'use strict'
+
+// HTTP controller. Static methods receive the context { req, res } and return the
+// manual response envelope. Wire it in a route file, e.g.:
+//   Routes.get('${toKebab(name)}', ${Ctrl}.index)
+class ${Ctrl} {
+	static async index({ req, res }) {
+		return ${ok('OK', '[]')}
+	}
+}
+
+module.exports = ${Ctrl}
+`
+	}
+
+	const methods = []
+	methods.push(`	// GET /${toKebab(name)}
+	static async index({ req, res }) {
+		return ${ok('OK', '[]')}
+	}`)
+	if (!api) {
+		methods.push(`	// GET /${toKebab(name)}/create
+	static async create({ req, res }) {
+		return ${ok('OK')}
+	}`)
+	}
+	methods.push(`	// POST /${toKebab(name)}
+	static async store({ req, res }) {
+		return res.status(201).json({ status: true, code: 201, message: 'Created', data: req.body, meta: null })
+	}`)
+	methods.push(`	// GET /${toKebab(name)}/:id
+	static async show({ req, res }) {
+		return ${ok('OK', '{ id: req.params.id }')}
+	}`)
+	if (!api) {
+		methods.push(`	// GET /${toKebab(name)}/:id/edit
+	static async edit({ req, res }) {
+		return ${ok('OK', '{ id: req.params.id }')}
+	}`)
+	}
+	methods.push(`	// PUT|PATCH /${toKebab(name)}/:id
+	static async update({ req, res }) {
+		return ${ok('Updated', '{ id: req.params.id, ...req.body }')}
+	}`)
+	methods.push(`	// DELETE /${toKebab(name)}/:id
+	static async destroy({ req, res }) {
+		return ${ok('Deleted')}
+	}`)
+
+	return `'use strict'
+
+// RESTful resource controller. Register every action at once with:
+//   Routes.${api ? 'apiResource' : 'resource'}('${toKebab(name)}', ${Ctrl})
+// Only the actions present here are mounted; rename/remove as needed.
+class ${Ctrl} {
+${methods.join('\n\n')}
+}
+
+module.exports = ${Ctrl}
+`
+}
+
+function middlewareTemplate(name) {
+	const Mw = toPascal(name)
+	return `'use strict'
+
+// Route middleware. Implements handle({ req, res, next, error }); call next() to pass
+// control on, or send a response to short-circuit. Use per-route or as an alias:
+//   Routes.get('path', Controller.action, [${Mw}])
+//   Routes.registerMiddleware('${toKebab(name)}', ${Mw})
+class ${Mw} {
+	static handle({ req, res, next }) {
+		// TODO: guard logic
+		next()
+	}
+}
+
+module.exports = ${Mw}
+`
+}
+
+function validatorTemplate(name) {
+	const base = toPascal(name)
+	return `'use strict'
+
+const { z } = require('zod')
+
+// Zod schemas. Apply per-route via the validator core:
+//   Routes.post('${toKebab(name)}', ${base}Controller.store, [Validator.make(create${base}Schema)])
+const create${base}Schema = z.object({
+	// name: z.string().min(1),
+})
+
+const update${base}Schema = create${base}Schema.partial()
+
+module.exports = { create${base}Schema, update${base}Schema }
+`
+}
+
+function routeTemplate(name) {
+	return moduleRouteTemplate(toKebab(name))
+}
+
+// Resource route file wiring a controller to Routes.resource/apiResource. The
+// controllerRequire path differs for flat (@http alias) vs module (relative) layouts.
+function resourceRouteTemplate(name, { api = false, controllerRequire } = {}) {
+	const Ctrl = `${toPascal(name)}Controller`
+	const slug = toKebab(name)
+	return `'use strict'
+
+const Routes = require('@core/routing.core')
+const ${Ctrl} = require('${controllerRequire}')
+
+// Registers index/show/store/update/destroy${api ? '' : '/create/edit'} for any of those
+// actions the controller implements.
+Routes.${api ? 'apiResource' : 'resource'}('${slug}', ${Ctrl})
+
+module.exports = Routes
+`
+}
+
+function jobTemplate(name) {
+	return `'use strict'
+
+const logger = require('@core/logger.core')
+
+// Cron job module. Receives the Cron facade. Register with Cron.define(name, expr, fn).
+// Expression: second? minute hour day-of-month month day-of-week
+module.exports = (Cron) => {
+	Cron.define('${toKebab(name)}', '0 * * * *', async () => {
+		logger.debug('${toKebab(name)} tick')
+	})
+}
+`
+}
+
+function queueTemplate(name) {
+	return `'use strict'
+
+const logger = require('@core/logger.core')
+
+// Queue worker module. Receives the Queue facade. Register handlers with
+// Queue.define(name, handler, options); dispatch jobs with Queue.dispatch(name, payload).
+module.exports = (Queue) => {
+	Queue.define('${toKebab(name)}', async (payload, job) => {
+		logger.debug(\`${toKebab(name)} processing job \${job.id}\`)
+	})
+}
+`
+}
+
+function socketTemplate(name) {
+	return `'use strict'
+
+const logger = require('@core/logger.core')
+
+// Socket handlers. Receives (io, Socket). Register connection logic here.
+module.exports = (io, Socket) => {
+	io.on('connection', (socket) => {
+		logger.debug(\`[${toKebab(name)}] socket connected: \${socket.id}\`)
+
+		socket.on('${toKebab(name)}:ping', (data, ack) => {
+			if (typeof ack === 'function') ack({ ok: true, data })
+		})
+	})
+}
+`
+}
+
+function hookTemplate() {
+	return `'use strict'
+
+// Lifecycle hooks. before() runs before the server starts, after() once it is ready,
+// and shutdown() during graceful shutdown. Each receives { config }.
+module.exports = {
+	async before({ config }) {},
+	async after({ config }) {},
+	async shutdown({ config }) {},
+}
+`
+}
+
+module.exports = {
+	modelTemplate,
+	createMigrationTemplate,
+	blankMigrationTemplate,
+	seederTemplate,
+	moduleEntryTemplate,
+	moduleRouteTemplate,
+	controllerTemplate,
+	middlewareTemplate,
+	validatorTemplate,
+	routeTemplate,
+	jobTemplate,
+	queueTemplate,
+	socketTemplate,
+	hookTemplate,
+	resourceRouteTemplate,
+	appMiddlewareTemplate,
+}