create-rebe 1.0.0

package/template/config/index.js

@@ -0,0 +1,19 @@
+'use strict'
+
+module.exports = {
+	app: require('@config/app.config'),
+	cors: require('@config/cors.config'),
+	socket: require('@config/socket.config'),
+	db: require('@config/database.config'),
+	jwt: require('@config/jwt.config'),
+	bcrypt: require('@config/bcrypt.config'),
+	storage: require('@config/storage.config'),
+	logger: require('@config/logger.config'),
+	runtime: require('@config/runtime.config'),
+	cache: require('@config/cache.config'),
+	redis: require('@config/redis.config'),
+	cron: require('@config/cron.config'),
+	queue: require('@config/queue.config'),
+	mail: require('@config/mail.config'),
+	express: require('@config/express.config'),
+}

package/template/config/jwt.config.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const Common = require('@core/common.core')
+
+module.exports = {
+	secret: Common.getEnv('JWT_SECRET', null),
+	expiresIn: Common.getEnv('JWT_EXPIRES_IN', '1d'),
+	refreshSecret: Common.getEnv('JWT_REFRESH_SECRET', null),
+	refreshExpiresIn: Common.getEnv('JWT_REFRESH_EXPIRES_IN', '7d'),
+}

package/template/config/logger.config.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const Common = require('@core/common.core')
+
+module.exports = {
+	level: Common.getEnv('LOG_LEVEL', 'debug'),
+	file: Common.getEnv('LOG_FILE', 'logs'),
+	maxSize: Common.getEnv('LOG_MAX_SIZE', '20m'),
+	maxFiles: Common.getEnv('LOG_MAX_FILES', '14d'),
+}

package/template/config/mail.config.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const Common = require('@core/common.core')
+
+module.exports = {
+	enabled: Common.getEnvBool('MAIL_ENABLED', false),
+	host: Common.getEnv('MAIL_HOST', null),
+	port: Common.getEnvInt('MAIL_PORT', 587),
+	secure: Common.getEnvBool('MAIL_SECURE', false),
+	username: Common.getEnv('MAIL_USERNAME', null),
+	password: Common.getEnv('MAIL_PASSWORD', null),
+	fromAddress: Common.getEnv('MAIL_FROM_ADDRESS', null),
+	fromName: Common.getEnv('MAIL_FROM_NAME', null),
+}

package/template/config/queue.config.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const Common = require('@core/common.core')
+
+module.exports = {
+	enabled: Common.getEnvBool('QUEUE_ENABLED', true),
+	concurrency: Common.getEnvInt('QUEUE_CONCURRENCY', 5),
+	maxRetries: Common.getEnvInt('QUEUE_MAX_RETRIES', 3),
+	retryDelay: Common.getEnvInt('QUEUE_RETRY_DELAY', 1000),
+	persist: Common.getEnvBool('QUEUE_PERSIST', true),
+}

package/template/config/redis.config.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const Common = require('@core/common.core')
+
+// Konfigurasi Redis (standalone). `redis.core` membuat koneksi hanya bila
+// `enabled=true`. Pemakaian Redis oleh fitur lain bersifat OPSIONAL dan diatur
+// lewat flag `use.*` — masing-masing core (cache/queue/socket/session) memeriksa
+// `config.redis.enabled && config.redis.use.<fitur>` sebelum memakai Redis,
+// dan jatuh ke implementasi in-memory/default bila false.
+module.exports = {
+	enabled: Common.getEnvBool('REDIS_ENABLED', false),
+
+	host: Common.getEnv('REDIS_HOST', '127.0.0.1'),
+	port: Common.getEnvInt('REDIS_PORT', 6379),
+	username: Common.getEnv('REDIS_USERNAME', null),
+	password: Common.getEnv('REDIS_PASSWORD', null),
+	db: Common.getEnvInt('REDIS_DB', 0),
+	keyPrefix: Common.getEnv('REDIS_KEY_PREFIX', ''),
+	tls: Common.getEnvBool('REDIS_TLS', false),
+
+	// Reconnect/retry (dipakai ioredis)
+	maxRetriesPerRequest: Common.getEnvInt('REDIS_MAX_RETRIES', 3),
+	connectTimeout: Common.getEnvInt('REDIS_CONNECT_TIMEOUT', 10000),
+
+	// Toggle pemakaian Redis per fitur (hanya berlaku bila enabled=true)
+	use: {
+		cache: Common.getEnvBool('REDIS_USE_CACHE', false),
+		queue: Common.getEnvBool('REDIS_USE_QUEUE', false),
+		socket: Common.getEnvBool('REDIS_USE_SOCKET', false),
+		session: Common.getEnvBool('REDIS_USE_SESSION', false),
+	},
+}

package/template/config/runtime.config.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const Common = require('@core/common.core')
+
+module.exports = {
+	maxListeners: Common.getEnvInt('RUNTIME_MAX_LISTENERS', 50),
+	stackTraceLimit: Common.getEnvInt('RUNTIME_STACK_TRACE_LIMIT', 50),
+	uvThreadpoolSize: Common.getEnvInt('RUNTIME_UV_THREADPOOL_SIZE', 4),
+	bigintJson: Common.getEnvBool('RUNTIME_BIGINT_JSON', true),
+	deprecationWarnings: Common.getEnvBool('RUNTIME_DEPRECATION_WARNINGS', true),
+}

package/template/config/socket.config.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const Common = require('@core/common.core')
+
+module.exports = {
+	enabled: Common.getEnvBool('SOCKET_ENABLED', true),
+	path: Common.getEnv('SOCKET_PATH', '/socket.io/'),
+	serveClient: Common.getEnvBool('SOCKET_SERVE_CLIENT', false),
+	connectTimeout: Common.getEnvInt('SOCKET_CONNECT_TIMEOUT', 45000),
+	pingInterval: Common.getEnvInt('SOCKET_PING_INTERVAL', 25000),
+	pingTimeout: Common.getEnvInt('SOCKET_PING_TIMEOUT', 20000),
+	transports: Common.getEnvArray('SOCKET_TRANSPORTS', ['polling', 'websocket']),
+	allowUpgrades: Common.getEnvBool('SOCKET_ALLOW_UPGRADES', true),
+	maxHttpBufferSize: Common.getEnvInt('SOCKET_MAX_HTTP_BUFFER_SIZE', 1e6),
+}

package/template/config/storage.config.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const Common = require('@core/common.core')
+
+module.exports = {
+	root: Common.getEnv('STORAGE_ROOT', 'storage'),
+	uploadPath: Common.getEnv('STORAGE_UPLOAD_PATH', 'storage/uploads'),
+	maxSizeMb: Common.getEnvInt('STORAGE_UPLOAD_MAX_SIZE_MB', 50),
+	allowedTypes: Common.getEnvArray('STORAGE_UPLOAD_ALLOWED_TYPES', ['image/jpeg', 'image/png', 'image/webp', 'application/pdf']),
+}

package/template/core/bootstrap.core.js

@@ -0,0 +1,92 @@
+'use strict'
+
+const config = require('@config/index')
+const logger = require('@core/logger.core')
+const ErrorHandler = require('@core/error.core')
+const Hooks = require('@core/hooks.core')
+const Express = require('@core/express.core')
+const Socket = require('@core/socket.core')
+const Cron = require('@core/cron.core')
+const Queue = require('@core/queue.core')
+
+// Orchestrates the boot sequence in a deterministic order and wires graceful
+// shutdown. Optional subsystems (Redis, Database) are required lazily so a project
+// that never enables them does not pay their load cost.
+class Bootstrap {
+	static _shuttingDown = false
+
+	static async run() {
+		ErrorHandler.setExceptionHandler()
+		ErrorHandler.setRejectionHandler()
+
+		Bootstrap._banner()
+
+		try {
+			await Hooks.before({ config })
+
+			if (config.redis.enabled) {
+				await require('@core/redis.core').connect()
+			}
+
+			if (config.db.enabled) {
+				await require('@core/database.core').connect()
+			}
+
+			const { server } = await Express.create()
+			await Socket.attach(server)
+			await Cron.start()
+			await Queue.start()
+			await Express.listen()
+
+			await Hooks.after({ config })
+
+			logger.info(`${config.app.name} ready`)
+			Bootstrap._registerShutdown()
+		} catch (err) {
+			logger.error('Bootstrap failed', err)
+			process.exit(1)
+		}
+	}
+
+	static _banner() {
+		logger.info(`Starting ${config.app.name}`)
+		logger.debug(`env=${config.app.env} tz=${config.app.timezone} port=${config.app.port}`)
+	}
+
+	static _registerShutdown() {
+		const shutdown = async (signal) => {
+			if (Bootstrap._shuttingDown) return
+			Bootstrap._shuttingDown = true
+			logger.info(`Received ${signal}, shutting down`)
+
+			await Bootstrap._safe('hooks.shutdown', () => Hooks.shutdown({ config }))
+			await Bootstrap._safe('cron.stop', () => Cron.stop())
+			await Bootstrap._safe('queue.stop', () => Queue.stop())
+			await Bootstrap._safe('socket.close', () => Socket.close())
+			await Bootstrap._safe('express.close', () => Express.close())
+
+			if (config.db.enabled) {
+				await Bootstrap._safe('database.disconnect', () => require('@core/database.core').disconnect())
+			}
+			if (config.redis.enabled) {
+				await Bootstrap._safe('redis.disconnect', () => require('@core/redis.core').disconnect())
+			}
+
+			logger.info('Shutdown complete')
+			process.exit(0)
+		}
+
+		process.on('SIGINT', () => shutdown('SIGINT'))
+		process.on('SIGTERM', () => shutdown('SIGTERM'))
+	}
+
+	static async _safe(label, fn) {
+		try {
+			await fn()
+		} catch (err) {
+			logger.error(`Shutdown step "${label}" failed`, err)
+		}
+	}
+}
+
+module.exports = Bootstrap

package/template/core/common/array.js

@@ -0,0 +1,144 @@
+'use strict'
+
+// Array helpers — small, predictable utilities for everyday list work.
+class Arr {
+	// Wrap any value into an array. null/undefined become an empty array.
+	static wrap(value) {
+		if (value === null || value === undefined) return []
+		return Array.isArray(value) ? value : [value]
+	}
+
+	// Return the first element, or the value matching a predicate.
+	static first(arr, predicate = null, fallback = null) {
+		if (!Array.isArray(arr)) return fallback
+		if (typeof predicate === 'function') {
+			const found = arr.find(predicate)
+			return found === undefined ? fallback : found
+		}
+		return arr.length ? arr[0] : fallback
+	}
+
+	// Return the last element, or the value matching a predicate.
+	static last(arr, predicate = null, fallback = null) {
+		if (!Array.isArray(arr)) return fallback
+		if (typeof predicate === 'function') {
+			for (let i = arr.length - 1; i >= 0; i--) {
+				if (predicate(arr[i], i)) return arr[i]
+			}
+			return fallback
+		}
+		return arr.length ? arr[arr.length - 1] : fallback
+	}
+
+	// Remove duplicate values. With a key/selector, dedupe objects by that key.
+	static unique(arr, key = null) {
+		if (!Array.isArray(arr)) return []
+		if (!key) return [...new Set(arr)]
+		const selector = typeof key === 'function' ? key : (item) => item[key]
+		const seen = new Set()
+		return arr.filter((item) => {
+			const id = selector(item)
+			if (seen.has(id)) return false
+			seen.add(id)
+			return true
+		})
+	}
+
+	// Flatten nested arrays up to the given depth.
+	static flatten(arr, depth = Infinity) {
+		return Array.isArray(arr) ? arr.flat(depth) : []
+	}
+
+	// Split an array into chunks of the given size.
+	static chunk(arr, size = 1) {
+		if (!Array.isArray(arr) || size < 1) return []
+		const out = []
+		for (let i = 0; i < arr.length; i += size) {
+			out.push(arr.slice(i, i + size))
+		}
+		return out
+	}
+
+	// Group items into an object keyed by the result of a selector.
+	static groupBy(arr, key) {
+		const selector = typeof key === 'function' ? key : (item) => item[key]
+		return (arr || []).reduce((acc, item) => {
+			const group = selector(item)
+			;(acc[group] = acc[group] || []).push(item)
+			return acc
+		}, {})
+	}
+
+	// Turn an array of objects into a lookup keyed by a property.
+	static keyBy(arr, key) {
+		const selector = typeof key === 'function' ? key : (item) => item[key]
+		return (arr || []).reduce((acc, item) => {
+			acc[selector(item)] = item
+			return acc
+		}, {})
+	}
+
+	// Pluck a single property out of each object.
+	static pluck(arr, key) {
+		return (arr || []).map((item) => item?.[key])
+	}
+
+	// Sum a numeric array, optionally via a selector.
+	static sum(arr, key = null) {
+		const selector = key ? (typeof key === 'function' ? key : (i) => i[key]) : (i) => i
+		return (arr || []).reduce((total, item) => total + (Number(selector(item)) || 0), 0)
+	}
+
+	// Average of a numeric array, optionally via a selector.
+	static avg(arr, key = null) {
+		if (!arr || !arr.length) return 0
+		return Arr.sum(arr, key) / arr.length
+	}
+
+	// Shuffle a copy of the array (Fisher–Yates).
+	static shuffle(arr) {
+		const copy = [...(arr || [])]
+		for (let i = copy.length - 1; i > 0; i--) {
+			const j = Math.floor(Math.random() * (i + 1))
+			;[copy[i], copy[j]] = [copy[j], copy[i]]
+		}
+		return copy
+	}
+
+	// Pick one or more random elements.
+	static random(arr, count = 1) {
+		const shuffled = Arr.shuffle(arr)
+		return count === 1 ? shuffled[0] : shuffled.slice(0, count)
+	}
+
+	// Everything in `a` that is not in `b`.
+	static difference(a, b) {
+		const set = new Set(b || [])
+		return (a || []).filter((item) => !set.has(item))
+	}
+
+	// Values present in both arrays.
+	static intersect(a, b) {
+		const set = new Set(b || [])
+		return (a || []).filter((item) => set.has(item))
+	}
+
+	// Strip out null/undefined/false/empty-string entries.
+	static compact(arr) {
+		return (arr || []).filter((item) => item !== null && item !== undefined && item !== false && item !== '')
+	}
+
+	// A range of numbers, inclusive of both ends.
+	static range(start, end, step = 1) {
+		const out = []
+		if (step === 0) return out
+		if (start <= end) {
+			for (let i = start; i <= end; i += step) out.push(i)
+		} else {
+			for (let i = start; i >= end; i -= Math.abs(step)) out.push(i)
+		}
+		return out
+	}
+}
+
+module.exports = Arr

package/template/core/common/cache.js

@@ -0,0 +1,100 @@
+'use strict'
+
+// Process-local key/value cache with per-entry TTL. Suitable for hot data that
+// can be safely recomputed; swap in a Redis driver later if you outgrow it.
+const store = new Map()
+
+// Lazily-started sweeper that drops expired keys so the Map does not grow.
+let sweeper = null
+
+function startSweeper() {
+	if (sweeper) return
+	sweeper = setInterval(() => {
+		const now = Date.now()
+		for (const [key, entry] of store) {
+			if (entry.expires !== 0 && entry.expires <= now) store.delete(key)
+		}
+	}, 60 * 1000)
+	// Do not keep the event loop alive solely for cache cleanup.
+	if (sweeper.unref) sweeper.unref()
+}
+
+function resolveTtl(ttlSeconds) {
+	if (ttlSeconds === null || ttlSeconds === undefined) {
+		const config = require('@config/index')
+		ttlSeconds = config.cache.ttl
+	}
+	return ttlSeconds === 0 ? 0 : Date.now() + ttlSeconds * 1000
+}
+
+class Cache {
+	// Store a value for ttlSeconds (0 = never expires; null = config default).
+	static set(key, value, ttlSeconds = null) {
+		startSweeper()
+		store.set(key, { value, expires: resolveTtl(ttlSeconds) })
+		return value
+	}
+
+	// Read a value, or fallback when missing/expired.
+	static get(key, fallback = null) {
+		const entry = store.get(key)
+		if (!entry) return fallback
+		if (entry.expires !== 0 && entry.expires <= Date.now()) {
+			store.delete(key)
+			return fallback
+		}
+		return entry.value
+	}
+
+	static has(key) {
+		return Cache.get(key, Symbol.for('miss')) !== Symbol.for('miss')
+	}
+
+	static forget(key) {
+		return store.delete(key)
+	}
+
+	static flush() {
+		store.clear()
+	}
+
+	// Return the cached value, or compute it via the resolver and cache it.
+	static async remember(key, ttlSeconds, resolver) {
+		const cached = Cache.get(key, Symbol.for('miss'))
+		if (cached !== Symbol.for('miss')) return cached
+		const value = await resolver()
+		Cache.set(key, value, ttlSeconds)
+		return value
+	}
+
+	// remember() with no expiry.
+	static async rememberForever(key, resolver) {
+		return Cache.remember(key, 0, resolver)
+	}
+
+	// Get and delete in one step.
+	static pull(key, fallback = null) {
+		const value = Cache.get(key, fallback)
+		store.delete(key)
+		return value
+	}
+
+	// Atomically increment/decrement a numeric entry.
+	static increment(key, amount = 1) {
+		const current = Number(Cache.get(key, 0)) || 0
+		const next = current + amount
+		const entry = store.get(key)
+		Cache.set(key, next, entry ? null : 0)
+		return next
+	}
+
+	static decrement(key, amount = 1) {
+		return Cache.increment(key, -amount)
+	}
+
+	static keys() {
+		return [...store.keys()]
+	}
+}
+
+module.exports = Cache

package/template/core/common/collection.js

@@ -0,0 +1,173 @@
+'use strict'
+
+// A fluent, chainable wrapper over an array — inspired by Laravel collections.
+// Every transforming method returns a new Collection so chains stay immutable.
+class Collection {
+	constructor(items = []) {
+		this.items = Array.isArray(items) ? [...items] : Object.values(items || {})
+	}
+
+	static make(items = []) {
+		return new Collection(items)
+	}
+
+	all() {
+		return this.items
+	}
+
+	count() {
+		return this.items.length
+	}
+
+	isEmpty() {
+		return this.items.length === 0
+	}
+
+	isNotEmpty() {
+		return this.items.length > 0
+	}
+
+	map(fn) {
+		return new Collection(this.items.map(fn))
+	}
+
+	filter(fn = (v) => Boolean(v)) {
+		return new Collection(this.items.filter(fn))
+	}
+
+	reject(fn) {
+		return new Collection(this.items.filter((v, i) => !fn(v, i)))
+	}
+
+	each(fn) {
+		this.items.forEach(fn)
+		return this
+	}
+
+	reduce(fn, initial) {
+		return this.items.reduce(fn, initial)
+	}
+
+	// Filter by a field/value pair: where('status', 'active').
+	where(key, value) {
+		return new Collection(this.items.filter((item) => item?.[key] === value))
+	}
+
+	whereIn(key, values) {
+		const set = new Set(values)
+		return new Collection(this.items.filter((item) => set.has(item?.[key])))
+	}
+
+	first(fn = null, fallback = null) {
+		if (fn) {
+			const found = this.items.find(fn)
+			return found === undefined ? fallback : found
+		}
+		return this.items.length ? this.items[0] : fallback
+	}
+
+	last(fallback = null) {
+		return this.items.length ? this.items[this.items.length - 1] : fallback
+	}
+
+	pluck(key) {
+		return new Collection(this.items.map((item) => item?.[key]))
+	}
+
+	unique(key = null) {
+		if (!key) return new Collection([...new Set(this.items)])
+		const seen = new Set()
+		return new Collection(
+			this.items.filter((item) => {
+				const id = item?.[key]
+				if (seen.has(id)) return false
+				seen.add(id)
+				return true
+			}),
+		)
+	}
+
+	sortBy(key, direction = 'asc') {
+		const selector = typeof key === 'function' ? key : (item) => item?.[key]
+		const sorted = [...this.items].sort((a, b) => {
+			const va = selector(a)
+			const vb = selector(b)
+			if (va < vb) return direction === 'asc' ? -1 : 1
+			if (va > vb) return direction === 'asc' ? 1 : -1
+			return 0
+		})
+		return new Collection(sorted)
+	}
+
+	groupBy(key) {
+		const selector = typeof key === 'function' ? key : (item) => item?.[key]
+		const groups = {}
+		for (const item of this.items) {
+			const g = selector(item)
+			;(groups[g] = groups[g] || []).push(item)
+		}
+		return groups
+	}
+
+	take(count) {
+		return new Collection(count < 0 ? this.items.slice(count) : this.items.slice(0, count))
+	}
+
+	skip(count) {
+		return new Collection(this.items.slice(count))
+	}
+
+	chunk(size) {
+		const out = []
+		for (let i = 0; i < this.items.length; i += size) {
+			out.push(new Collection(this.items.slice(i, i + size)))
+		}
+		return new Collection(out)
+	}
+
+	sum(key = null) {
+		const selector = key ? (item) => item?.[key] : (item) => item
+		return this.items.reduce((total, item) => total + (Number(selector(item)) || 0), 0)
+	}
+
+	avg(key = null) {
+		return this.items.length ? this.sum(key) / this.items.length : 0
+	}
+
+	min(key = null) {
+		const selector = key ? (item) => item?.[key] : (item) => item
+		return this.items.length ? Math.min(...this.items.map(selector)) : null
+	}
+
+	max(key = null) {
+		const selector = key ? (item) => item?.[key] : (item) => item
+		return this.items.length ? Math.max(...this.items.map(selector)) : null
+	}
+
+	contains(value) {
+		return this.items.includes(value)
+	}
+
+	reverse() {
+		return new Collection([...this.items].reverse())
+	}
+
+	values() {
+		return new Collection([...this.items])
+	}
+
+	toArray() {
+		return this.items
+	}
+
+	toJson() {
+		return JSON.stringify(this.items)
+	}
+
+	// Make the collection itself iterable (for...of, spread).
+	[Symbol.iterator]() {
+		return this.items[Symbol.iterator]()
+	}
+}
+
+module.exports = Collection