create-simo-api 0.0.0-stage → 1.1.0

package/README.md

@@ -1,3 +1,34 @@
-# Temporary Holding Version
+# create-simo-api
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Scaffold an Express 5 + PostgreSQL API pre-configured with:
+
+- **JWT auth**: access token + refresh token in an `httpOnly` cookie, stored hashed, rotated on every refresh, reuse detection
+- **Role permissions** with `authorize('PERMISSION')`
+- **Zod** validation for request bodies, params and `.env`
+- **Service layer** (routes → controllers → services → models)
+- Central **error handling** (`AppError`, JSON 404, PostgreSQL errors)
+- **Migrations** (`node-pg-migrate`), admin **seed**, **rate limiting**, **morgan** logs
+- **Tests** with Supertest
+- Example resources: users and products
+
+## Usage
+
+```bash
+npm create simo-api@latest my-api
+cd my-api
+# set DATABASE_URL in .env
+npm run migrate:up
+npm run seed
+npm run dev
+```
+
+`.env` is generated with random JWT secrets and a random admin password.
+
+## Requirements
+
+- Node.js 20+
+- PostgreSQL
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { dirname, join, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { spawn } from 'node:child_process'
+import { randomBytes } from 'node:crypto'
+import { styleText } from 'node:util'
+import { createInterface } from 'node:readline/promises'
+import { createRequire } from 'node:module'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const TEMPLATE_DIR = join(__dirname, 'template')
+
+const RENAME = {
+  _gitignore: '.gitignore',
+  '_env.example': '.env.example',
+}
+
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+
+let createdDir = null
+
+function removeProject() {
+  if (!createdDir) return
+  rmSync(createdDir, { recursive: true, force: true })
+  console.error(styleText('gray', `   Project folder removed: ${relative(process.cwd(), createdDir)}\n`))
+  createdDir = null
+}
+
+function fail(msg) {
+  console.error(`\n${styleText(['red', 'bold'], '✖')}  ${styleText('red', msg)}\n`)
+  removeProject()
+  process.exit(1)
+}
+
+function cancel() {
+  console.log(`\n\n${styleText('gray', 'Cancelled.')}\n`)
+  removeProject()
+  process.exit(130)
+}
+
+process.on('SIGINT', cancel)
+
+function listFiles(dir) {
+  return readdirSync(dir, { recursive: true })
+    .map((file) => join(dir, file))
+    .filter((file) => statSync(file).isFile())
+    .sort()
+}
+
+function installDependencies(cwd) {
+  return new Promise((resolvePromise) => {
+    let frame = 0
+    const label = 'Installation in progress... ☕'
+    const timer = setInterval(() => {
+      process.stdout.write(`\r${styleText('cyan', SPINNER[frame++ % SPINNER.length])} ${label}`)
+    }, 80)
+
+    let output = ''
+    const child = spawn('npm', ['install'], { cwd })
+    child.stdout.on('data', (data) => { output += data })
+    child.stderr.on('data', (data) => { output += data })
+
+    child.on('close', (code) => {
+      clearInterval(timer)
+      const icon = code === 0 ? styleText('green', '✔') : styleText('red', '✖')
+      process.stdout.write(`\r${icon} ${label}\n`)
+      resolvePromise({ code, output })
+    })
+  })
+}
+
+function runCommand(cwd, args) {
+  console.log(`\n${styleText('gray', '$')} ${styleText('cyan', `npm ${args.join(' ')}`)}`)
+  return new Promise((resolvePromise) => {
+    const child = spawn('npm', args, { cwd, stdio: 'inherit' })
+    child.on('close', (code) => resolvePromise(code))
+  })
+}
+
+async function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  rl.on('SIGINT', cancel)
+  try {
+    const answer = await rl.question(question)
+    return answer.trim()
+  } catch {
+    cancel()
+  } finally {
+    rl.close()
+  }
+}
+
+const validators = {
+  identifier: (value) => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)
+    ? null
+    : 'Only letters, numbers and _ are allowed, and it cannot start with a number.',
+  host: (value) => /^[^\s/:@]+$/.test(value) ? null : 'Enter a valid host, for example localhost.',
+  port: (value) => {
+    const port = Number(value)
+    return Number.isInteger(port) && port > 0 && port <= 65535 ? null : 'Enter a number between 1 and 65535.'
+  },
+}
+
+async function askWithDefault(label, defaultValue, validate) {
+  const hint = defaultValue ? styleText('gray', ` (${defaultValue})`) : ''
+
+  while (true) {
+    const value = (await ask(`${styleText('bold', label)}${hint}: `)) || defaultValue
+    const error = validate?.(value)
+    if (!error) return value
+    console.log(`  ${styleText('red', '✖')} ${styleText('red', error)}`)
+  }
+}
+
+function printRetry(message) {
+  console.log(`\n${styleText('red', '✖')}  ${styleText('red', message)} ${styleText('gray', 'Try again.')}\n`)
+}
+
+async function askConnection(previous) {
+  return {
+    user: await askWithDefault('User', previous.user, validators.identifier),
+    password: await askWithDefault('Password', ''),
+    host: await askWithDefault('Host', previous.host, validators.host),
+    port: Number(await askWithDefault('Port', String(previous.port), validators.port)),
+  }
+}
+
+async function createDatabase(targetDir, db) {
+  const pg = createRequire(join(targetDir, 'package.json'))('pg')
+  const client = new pg.Client({ ...db, database: 'postgres' })
+
+  try {
+    await client.connect()
+    const { rowCount } = await client.query('SELECT 1 FROM pg_database WHERE datname = $1', [db.database])
+    if (rowCount > 0) return 'exists'
+    await client.query(`CREATE DATABASE "${db.database}"`)
+    return 'created'
+  } catch (error) {
+    if (error.code === '42P04') return 'exists'
+    if (error.code === '42501') return 'denied'
+    if (error.code === '28P01' || error.code === '28000') return 'auth'
+    if (['ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT', 'EAI_AGAIN'].includes(error.code)) return 'unreachable'
+    fail(`Could not create the database: ${error.message}`)
+  } finally {
+    await client.end().catch(() => {})
+  }
+}
+
+async function createDatabaseAsAdmin(targetDir, db) {
+  console.log(`\n${styleText('gray', 'Enter a PostgreSQL admin account (the one created when PostgreSQL was installed).')}`)
+  const pg = createRequire(join(targetDir, 'package.json'))('pg')
+  let adminUser = 'postgres'
+
+  while (true) {
+    adminUser = await askWithDefault('Admin user', adminUser, validators.identifier)
+    const password = await askWithDefault('Admin password', '')
+    const client = new pg.Client({ host: db.host, port: db.port, database: 'postgres', user: adminUser, password })
+
+    try {
+      await client.connect()
+      await client.query(`CREATE DATABASE "${db.database}" OWNER "${db.user}"`)
+      return
+    } catch (error) {
+      if (error.code === '28P01' || error.code === '28000') printRetry(`Wrong password for PostgreSQL admin "${adminUser}".`)
+      else if (error.code === '42501') printRetry(`"${adminUser}" is not allowed to create databases either.`)
+      else fail(`Could not create the database: ${error.message}`)
+    } finally {
+      await client.end().catch(() => {})
+    }
+  }
+}
+
+function createDatabaseWithSudo(db) {
+  console.log(`\n${styleText('gray', '$')} ${styleText('cyan', `sudo -u postgres psql -c 'CREATE DATABASE "${db.database}" OWNER "${db.user}";'`)}`)
+  return new Promise((resolvePromise) => {
+    const child = spawn('sudo', ['-u', 'postgres', 'psql', '-c', `CREATE DATABASE "${db.database}" OWNER "${db.user}";`], { stdio: 'inherit' })
+    child.on('close', (code) => resolvePromise(code))
+  })
+}
+
+async function setupDatabase(targetDir, projectName) {
+  console.log(`\n${styleText('magenta', '🐘')}  PostgreSQL setup\n`)
+
+  const defaultName = projectName.toLowerCase().replace(/[^a-z0-9_]/g, '_')
+  const database = await askWithDefault('Database name', defaultName, validators.identifier)
+
+  let db = { database, user: 'postgres', host: 'localhost', port: 5432 }
+  let status
+
+  while (true) {
+    db = { database, ...(await askConnection(db)) }
+    status = await createDatabase(targetDir, db)
+
+    if (status === 'auth') printRetry(`Wrong user or password for "${db.user}".`)
+    else if (status === 'unreachable') printRetry(`Cannot reach PostgreSQL on ${db.host}:${db.port}. Is it running?`)
+    else break
+  }
+
+  if (status === 'denied') {
+    console.log(`\n${styleText('yellow', '⚠')}  User "${db.user}" is not allowed to create databases.`)
+
+    const useSudo = process.platform === 'linux'
+      && ['', 'y', 'yes'].includes((await ask(`${styleText('yellow', '?')} Create it with the "postgres" system user (sudo)? ${styleText('gray', '(Y/n)')} `)).toLowerCase())
+
+    const createdWithSudo = useSudo && (await createDatabaseWithSudo(db)) === 0
+
+    if (!createdWithSudo) {
+      await createDatabaseAsAdmin(targetDir, db)
+    }
+    status = 'created'
+  }
+
+  const url = `postgres://${encodeURIComponent(db.user)}:${encodeURIComponent(db.password)}@${db.host}:${db.port}/${db.database}`
+  const envPath = join(targetDir, '.env')
+  writeFileSync(envPath, readFileSync(envPath, 'utf8').replace(/^DATABASE_URL=.*$/m, `DATABASE_URL=${url}`))
+
+  const maskedUrl = url.replace(`:${encodeURIComponent(db.password)}@`, ':****@')
+  console.log(`
+${styleText('green', '✔')}  Database ${styleText('cyan', db.database)} ${status === 'exists' ? 'already exists, using it' : 'created'}
+
+   ${styleText('gray', 'Host     ')} ${db.host}:${db.port}
+   ${styleText('gray', 'Database ')} ${db.database}
+   ${styleText('gray', 'User     ')} ${db.user}
+   ${styleText('gray', 'URL      ')} ${maskedUrl}
+   ${styleText('gray', 'Saved in ')} .env`)
+}
+
+async function runSetup(targetDir, projectName) {
+  await setupDatabase(targetDir, projectName)
+
+  for (const args of [['run', 'migrate:up'], ['run', 'seed']]) {
+    const code = await runCommand(targetDir, args)
+    if (code !== 0) {
+      fail(`"npm ${args.join(' ')}" failed. Fix the error above, then create the project again.`)
+    }
+  }
+
+  createdDir = null
+  await runCommand(targetDir, ['run', 'dev'])
+}
+
+async function main() {
+  const projectName = process.argv[2]
+
+  if (!projectName) {
+    fail('Usage: npm create simo-api@latest <project-name>')
+  }
+
+  const targetDir = resolve(process.cwd(), projectName)
+
+  if (existsSync(targetDir) && readdirSync(targetDir).length > 0) {
+    fail(`Directory "${projectName}" already exists and is not empty.`)
+  }
+
+  console.log(`\n${styleText('yellow', '⚡')}  We will scaffold your app in a few seconds..\n`)
+
+  mkdirSync(targetDir, { recursive: true })
+  createdDir = targetDir
+  cpSync(TEMPLATE_DIR, targetDir, { recursive: true })
+
+  for (const [from, to] of Object.entries(RENAME)) {
+    const src = join(targetDir, from)
+    if (existsSync(src)) renameSync(src, join(targetDir, to))
+  }
+
+  const pkgPath = join(targetDir, 'package.json')
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+  pkg.name = projectName
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+
+  const env = readFileSync(join(targetDir, '.env.example'), 'utf8')
+    .replace(/^ACCESS_TOKEN_SECRET=$/m, `ACCESS_TOKEN_SECRET=${randomBytes(64).toString('hex')}`)
+    .replace(/^REFRESH_TOKEN_SECRET=$/m, `REFRESH_TOKEN_SECRET=${randomBytes(64).toString('hex')}`)
+    .replace(/^ADMIN_PASSWORD=$/m, `ADMIN_PASSWORD=${randomBytes(12).toString('base64url')}`)
+  writeFileSync(join(targetDir, '.env'), env)
+
+  for (const file of listFiles(targetDir)) {
+    const path = relative(process.cwd(), file)
+    console.log(`${styleText('green', 'CREATE')} ${path} ${styleText('gray', `(${statSync(file).size} bytes)`)}`)
+  }
+
+  console.log()
+  const install = await installDependencies(targetDir)
+
+  if (install.code !== 0) {
+    console.error(styleText('gray', install.output))
+    fail('Dependency installation failed. Check your internet connection and npm, then try again.')
+  }
+
+  console.log(`
+${styleText('magenta', '🚀')}  Successfully created project ${styleText('cyan', projectName)}
+${styleText('green', '   Welcome to Simo Express App. Happy coding!')}
+
+👉  Get started with the following commands:
+
+${styleText('gray', '$')} ${styleText('cyan', `cd ${projectName}`)}
+${styleText('gray', '$ # set DATABASE_URL in .env')}
+${styleText('gray', '$')} ${styleText('cyan', 'npm run migrate:up')}
+${styleText('gray', '$')} ${styleText('cyan', 'npm run seed')}
+${styleText('gray', '$')} ${styleText('cyan', 'npm run dev')}
+`)
+
+  if (!process.stdin.isTTY) {
+    createdDir = null
+    return
+  }
+
+  const answer = await ask(`${styleText('yellow', '?')} Do you want me to run these commands for you? ${styleText('gray', '(Y/n)')} `)
+
+  if (answer === '' || answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+    await runSetup(targetDir, projectName)
+  } else {
+    createdDir = null
+  }
+}
+
+main()

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "create-simo-api",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.0",
+  "description": "Scaffold an Express 5 + PostgreSQL API with JWT auth (access + refresh rotation), role permissions, Zod validation, service layer, migrations, seed and tests.",
+  "type": "module",
+  "bin": {
+    "create-simo-api": "index.js"
+  },
+  "files": [
+    "index.js",
+    "template"
+  ],
+  "keywords": [
+    "express",
+    "postgresql",
+    "jwt",
+    "api",
+    "boilerplate",
+    "scaffold",
+    "create"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  }
+}

package/template/README.md

@@ -0,0 +1,61 @@
+# Simo API
+
+API Express 5 + PostgreSQL.
+
+## Démarrage
+
+```bash
+npm install
+cp .env.example .env      # si .env n'existe pas, puis remplir DATABASE_URL
+npm run migrate:up
+npm run seed              # crée l'admin du .env
+npm run dev
+```
+
+Générer un secret JWT :
+
+```bash
+node -e "console.log(require('crypto').randomBytes(64).toString('hex'))"
+```
+
+## Structure
+
+```
+app.js           app Express (middlewares, routes)
+index.js         lance le serveur
+config/          env (validé avec Zod), db, permissions
+routes/          auth, user, product
+controllers/     req/res seulement
+services/        logique métier
+models/          requêtes SQL
+middlewares/     auth, authorize, validate, rateLimit, errors
+validations/     schémas Zod
+utils/           AppError, verifyToken
+migrations/
+seeds/
+tests/
+```
+
+## Routes
+
+| Route | Accès |
+|---|---|
+| `POST /api/auth/register` · `login` | public |
+| `POST /api/auth/refresh` · `logout` | cookie `refreshToken` |
+| `GET /api/user/me` | connecté |
+| `GET /api/user/getAll` | admin |
+| `POST /api/user/create` | connecté (seul l'admin choisit le rôle) |
+| `GET /api/product/getAll` · `/:id` | public |
+| `POST /api/product/create` | admin |
+| `PATCH /api/product/update/:id` | admin |
+| `DELETE /api/product/delete/:id` | admin |
+
+## Fonctionnement
+
+- **Auth** : access token JWT (`ACCESS_TOKEN_EXPIRES_IN`, 15m par défaut) dans `Authorization: Bearer`, refresh token (`REFRESH_TOKEN_EXPIRES_DAYS`, 7 j par défaut) en cookie `httpOnly`, stocké hashé dans `refresh_tokens`. Rotation à chaque refresh ; un token réutilisé révoque toutes les sessions de l'utilisateur.
+- **Permissions** : `authorize('PERMISSION')` sur la route, rôles autorisés dans `config/permissions.js`.
+- **Validation** : `validate(schema)` pour le body, `validate(schema, 'params')` pour les paramètres.
+- **Erreurs** : `throw new AppError(message, status)` dans les controllers (pas de try/catch). `errorHandler` renvoie du JSON, convertit les erreurs PostgreSQL (doublon → 409) et renvoie 404 pour les routes inconnues.
+- **Env** : le serveur refuse de démarrer si une variable manque ou est invalide.
+- **Logs** : morgan (`dev` en développement, `combined` en production).
+- **Rate limit** : 100 requêtes / 15 min par IP sur `/api`.

package/template/_env.example

@@ -0,0 +1,15 @@
+NODE_ENV=development
+PORT=3000
+
+DATABASE_URL=postgres://user:password@localhost:5432/dbname
+
+CORS_ORIGIN=http://localhost:5173
+
+ACCESS_TOKEN_SECRET=
+REFRESH_TOKEN_SECRET=
+ACCESS_TOKEN_EXPIRES_IN=15m
+REFRESH_TOKEN_EXPIRES_DAYS=7
+
+ADMIN_NAME=Admin
+ADMIN_EMAIL=admin@example.com
+ADMIN_PASSWORD=

package/template/_gitignore

@@ -0,0 +1,4 @@
+node_modules
+.env
+*.log
+coverage

package/template/app.js

@@ -0,0 +1,29 @@
+import express from 'express';
+import cors from 'cors';
+import cookieParser from 'cookie-parser';
+import morgan from 'morgan';
+import env from './config/env.js';
+import routes from './routes/index.js';
+import { notFound, errorHandler } from './middlewares/errorMiddleware.js';
+import { apiLimiter } from './middlewares/rateLimitMiddleware.js';
+
+const app = express();
+
+if (env.NODE_ENV !== 'test') {
+    app.use(morgan(env.NODE_ENV === 'production' ? 'combined' : 'dev'));
+}
+app.use(express.json());
+app.use(cookieParser());
+
+app.use(cors({ origin: env.CORS_ORIGIN, credentials: true }));
+
+app.get('/', (req, res) => {
+    res.send('API is running...');
+});
+
+app.use('/api', apiLimiter, routes);
+
+app.use(notFound);
+app.use(errorHandler);
+
+export default app;

package/template/config/db.js

@@ -0,0 +1,6 @@
+import pg from 'pg';
+import env from './env.js';
+
+const { Pool } = pg;
+
+export default new Pool({ connectionString: env.DATABASE_URL });

package/template/config/env.js

@@ -0,0 +1,27 @@
+import 'dotenv/config';
+import { z } from 'zod';
+
+const envSchema = z.object({
+    NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+    PORT: z.coerce.number().int().positive().default(3000),
+    DATABASE_URL: z.url(),
+    ACCESS_TOKEN_SECRET: z.string().min(32),
+    REFRESH_TOKEN_SECRET: z.string().min(32),
+    ACCESS_TOKEN_EXPIRES_IN: z.string().regex(/^\d+(ms|s|m|h|d)$/, 'Use a duration like 15m, 1h or 1d').default('15m'),
+    REFRESH_TOKEN_EXPIRES_DAYS: z.coerce.number().int().positive().default(7),
+    CORS_ORIGIN: z.string().min(1).transform((value) => value.split(',').map((origin) => origin.trim())),
+});
+
+const result = envSchema.safeParse(process.env);
+
+if (!result.success) {
+    console.error('Invalid environment variables:');
+    for (const issue of result.error.issues) {
+        console.error(`  - ${issue.path.join('.')}: ${issue.message}`);
+    }
+    process.exit(1);
+}
+
+const env = result.data;
+
+export default env;

package/template/config/permissions.js

@@ -0,0 +1,15 @@
+export const ROLES = {
+  ADMIN: 'admin',
+  USER: 'user'
+};
+
+
+export const PERMISSIONS = {
+    USER_CREATE: [ROLES.ADMIN, ROLES.USER],
+    USER_DELETE: [ROLES.ADMIN],
+    USER_GETALL: [ROLES.ADMIN],
+    PRODUCT_CREATE: [ROLES.ADMIN],
+    PRODUCT_UPDATE: [ROLES.ADMIN],
+    PRODUCT_DELETE: [ROLES.ADMIN],
+    PRODUCT_GETALL: [ROLES.ADMIN, ROLES.USER]
+}

package/template/controllers/authController.js

@@ -0,0 +1,53 @@
+import authService, { REFRESH_TOKEN_MAX_AGE } from '../services/authService.js';
+import env from '../config/env.js';
+
+const refreshCookieOptions = {
+    httpOnly: true,
+    secure: env.NODE_ENV === "production",
+    sameSite: "strict",
+    path: "/api/auth",
+};
+
+const sendRefreshCookie = (res, token) => {
+    res.cookie("refreshToken", token, {
+        ...refreshCookieOptions,
+        maxAge: REFRESH_TOKEN_MAX_AGE
+    });
+};
+
+const login = async (req, res) => {
+    const { accessToken, refreshToken, user } = await authService.login(req.body.email, req.body.password);
+    sendRefreshCookie(res, refreshToken);
+    res.status(200).json({ message: 'Login successful', accessToken, user });
+};
+
+const register = async (req, res) => {
+    const userId = await authService.register(req.body);
+    res.status(201).json({ message: 'User registered successfully', userId });
+};
+
+const refresh = async (req, res) => {
+    const { accessToken, refreshToken } = await authService.refresh(req.cookies.refreshToken);
+    sendRefreshCookie(res, refreshToken);
+    res.status(200).json({ accessToken });
+};
+
+const clearRefreshCookieOnError = (err, req, res, next) => {
+    res.clearCookie("refreshToken", refreshCookieOptions);
+    next(err);
+};
+
+const logout = async (req, res) => {
+    await authService.logout(req.cookies.refreshToken);
+    res.clearCookie("refreshToken", refreshCookieOptions);
+    res.status(200).json({ message: 'Logged out' });
+};
+
+
+export default {
+    login,
+    register,
+    refresh,
+    clearRefreshCookieOnError,
+    logout
+};

package/template/controllers/productController.js

@@ -0,0 +1,34 @@
+import productService from '../services/productService.js';
+
+const getAllProducts = async (req, res) => {
+    const products = await productService.getAll();
+    res.status(200).json({ products });
+};
+
+const getProductById = async (req, res) => {
+    const product = await productService.getById(req.params.id);
+    res.status(200).json({ product });
+};
+
+const createProduct = async (req, res) => {
+    const product = await productService.create(req.body);
+    res.status(201).json({ message: 'Product created successfully', product });
+};
+
+const updateProduct = async (req, res) => {
+    const product = await productService.update(req.params.id, req.body);
+    res.status(200).json({ message: 'Product updated successfully', product });
+};
+
+const deleteProduct = async (req, res) => {
+    await productService.remove(req.params.id);
+    res.status(200).json({ message: 'Product deleted successfully' });
+};
+
+export default {
+    getAllProducts,
+    getProductById,
+    createProduct,
+    updateProduct,
+    deleteProduct
+};

package/template/controllers/userController.js

@@ -0,0 +1,22 @@
+import userService from '../services/userService.js';
+
+const getAllUsers = async (req, res) => {
+    const users = await userService.getAll();
+    res.status(200).json({ users });
+};
+
+const getMe = async (req, res) => {
+    const user = await userService.getById(req.user.id);
+    res.status(200).json({ user });
+};
+
+const createUser = async (req, res) => {
+    const userId = await userService.create(req.body, req.user);
+    res.status(201).json({ message: 'User created successfully', userId });
+};
+
+export default {
+    getAllUsers,
+    getMe,
+    createUser
+};

package/template/index.js

@@ -0,0 +1,6 @@
+import env from './config/env.js';
+import app from './app.js';
+
+app.listen(env.PORT, () => {
+    console.log(`Server is running on port ${env.PORT}`);
+});