umpordez 0.0.2 → 1.0.0

package/template/server/apps/shared/middlewares/request-logger.ts

@@ -0,0 +1,40 @@
+import type { Request, Response, NextFunction } from 'express';
+import logger from '#core/logger.js';
+
+export default function requestLogger(
+    req: Request,
+    res: Response,
+    next: NextFunction
+): void {
+    const { ip, method, url } = req;
+    const started = Date.now();
+
+    const userId = req.user?.id;
+    let idsMsg = '';
+    if (userId) {
+        idsMsg = ` u=${userId}`;
+    }
+
+    if (process.env.DEBUG) {
+        logger.debug(`[${ip}] {${method}} Receiving ${url}${idsMsg}`);
+    }
+
+    res.on('finish', () => {
+        const usr = req.user?.id;
+        if (usr && !idsMsg) {
+            idsMsg = ` u=${usr}`;
+        }
+
+        const msg = `{req} [${ip}] ${method} ${url}${idsMsg} : http=${res.statusCode} ${Date.now() - started}ms`;
+
+        if (res.statusCode >= 500) {
+            logger.error(msg);
+        } else if (res.statusCode >= 400) {
+            logger.warn(msg);
+        } else {
+            logger.info(msg);
+        }
+    });
+
+    next();
+}

package/template/server/apps/shared/middlewares/try-set-user-by-token.ts

@@ -0,0 +1,26 @@
+import type { Request, Response, NextFunction } from 'express';
+
+export default async function trySetUserByToken(
+    req: Request,
+    _res: Response,
+    next: NextFunction
+): Promise<void> {
+    try {
+        const token = req.cookies?.auth_token;
+
+        if (!token) {
+            next();
+            return;
+        }
+
+        const user = await req.context.auth.getUserByToken(token);
+
+        if (user) {
+            req.user = user;
+        }
+    } catch {
+        // Token invalid or expired — continue without user
+    }
+
+    next();
+}

package/template/server/apps/shared/utils.ts

@@ -0,0 +1,71 @@
+import type { Request, Response, NextFunction } from 'express';
+import { AppError } from '#core/errors.js';
+import { ZodError } from 'zod';
+import logger from '#core/logger.js';
+
+type AsyncHandler = (req: Request, res: Response) => Promise<void>;
+
+export function buildHandler(handler: AsyncHandler) {
+    return async (req: Request, res: Response, next: NextFunction) => {
+        try {
+            await handler(req, res);
+        } catch (error) {
+            if (error instanceof ZodError) {
+                const messages = error.errors.map((e) => e.message).join(', ');
+                logger.warn(`{route} ValidationError: ${messages}`, {
+                    path: req.originalUrl,
+                    method: req.method,
+                    userId: req.user?.id
+                });
+                res.status(400).json({
+                    ok: false,
+                    message: messages,
+                    errors: error.errors.map((e) => ({
+                        field: e.path.join('.'),
+                        message: e.message
+                    }))
+                });
+                return;
+            }
+
+            if (error instanceof AppError) {
+                if (error.statusCode >= 500) {
+                    logger.error(error.message, {
+                        status: String(error.statusCode),
+                        path: req.originalUrl,
+                        method: req.method,
+                        userId: req.user?.id,
+                        ip: req.ip,
+                        stack: error.stack
+                    });
+                } else {
+                    logger.warn(`{route} ${error.name}: ${error.message}`, {
+                        status: String(error.statusCode),
+                        path: req.originalUrl,
+                        method: req.method,
+                        userId: req.user?.id
+                    });
+                }
+
+                res.status(error.statusCode).json({
+                    ok: false,
+                    message: error.message
+                });
+                return;
+            }
+
+            logger.error(
+                error instanceof Error ? error.message : String(error),
+                {
+                    path: req.originalUrl,
+                    method: req.method,
+                    userId: req.user?.id,
+                    ip: req.ip,
+                    stack: error instanceof Error ? error.stack : undefined
+                }
+            );
+
+            next(error);
+        }
+    };
+}

package/template/server/apps/site-api/app.ts

@@ -0,0 +1,42 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import express from 'express';
+import cors from 'cors';
+import cookieParser from 'cookie-parser';
+import Context from '#core/context.js';
+import logger from '#core/logger.js';
+import makeRoutes from './routes/index.js';
+import requestLoggerMiddleware from '#shared/middlewares/request-logger.js';
+import errorHandler from '#shared/middlewares/error-handler.js';
+
+const app = express();
+const port = parseInt(process.env.SITE_API_PORT || '{{SITE_API_PORT}}', 10);
+
+app.use(cors({
+    origin: process.env.SITE_DOMAIN || 'http://localhost:{{SITE_PORT}}',
+    credentials: true
+}));
+
+app.use(cookieParser());
+app.use(express.json({ limit: '10mb' }));
+app.use(express.urlencoded({ extended: true }));
+app.use(requestLoggerMiddleware);
+
+// Context injection — fresh Context per request
+app.use((req: express.Request, _res: express.Response, next: express.NextFunction) => {
+    req.context = new Context();
+    next();
+});
+
+// Mount all routes
+makeRoutes(app);
+
+// Error handler (must be last)
+app.use(errorHandler);
+
+app.listen(port, () => {
+    logger.info(`Site API server running on port ${port}`);
+});
+
+export default app;

package/template/server/apps/site-api/routes/index.ts

@@ -0,0 +1,10 @@
+import type { Express } from 'express';
+import makePublicRoute from './public.js';
+
+export default function makeRoutes(app: Express): void {
+    makePublicRoute(app);
+
+    // Add new site API route modules here as the project grows:
+    // makeCustomerRoute(app);
+    // makeCheckoutRoute(app);
+}

package/template/server/apps/site-api/routes/public.ts

@@ -0,0 +1,25 @@
+import type { Express, Request, Response } from 'express';
+import express from 'express';
+import { buildHandler } from '#shared/utils.js';
+
+const router = express.Router();
+
+async function handleHealthCheck(_req: Request, res: Response): Promise<void> {
+    res.json({ ok: true, message: 'Site API is running' });
+}
+
+async function handleGetPublicInfo(req: Request, res: Response): Promise<void> {
+    const accounts = await req.context.account.listPublic();
+    res.json({ ok: true, accounts });
+}
+
+router.get('/health', buildHandler(handleHealthCheck));
+router.get('/info', buildHandler(handleGetPublicInfo));
+
+// Add public routes for your site here:
+// router.get('/products', buildHandler(handleListProducts));
+// router.get('/products/:slug', buildHandler(handleGetProduct));
+
+export default function makeEndpoint(app: Express): void {
+    app.use('/site', router);
+}

package/template/server/console/index.ts

@@ -0,0 +1,26 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { parseArgs, runTask, listTasks, type ConsoleTask } from './runner.js';
+
+// Import all tasks
+import exampleTask from './tasks/example.js';
+import seedAdminTask from './tasks/seed-admin.js';
+
+// Register all tasks here
+const tasks: ConsoleTask[] = [
+    exampleTask,
+    seedAdminTask,
+    // Add new tasks here as they are created
+];
+
+const args = parseArgs(process.argv);
+
+if (!args.task) {
+    listTasks(tasks);
+    process.exit(0);
+}
+
+runTask(tasks, args.task as string, args).then(() => {
+    process.exit(0);
+});

package/template/server/console/runner.ts

@@ -0,0 +1,67 @@
+import Context from '#core/context.js';
+import logger from '#core/logger.js';
+
+export interface ConsoleTaskArgs {
+    [key: string]: string | boolean;
+}
+
+export interface ConsoleTask {
+    name: string;
+    description: string;
+    run: (context: Context, args: ConsoleTaskArgs) => Promise<void>;
+}
+
+export function parseArgs(argv: string[]): ConsoleTaskArgs {
+    const args: ConsoleTaskArgs = {};
+
+    for (const arg of argv.slice(2)) {
+        if (arg.startsWith('--')) {
+            const [key, value] = arg.substring(2).split('=');
+            args[key] = value ?? true;
+        }
+    }
+
+    return args;
+}
+
+export async function runTask(
+    tasks: ConsoleTask[],
+    taskName: string,
+    args: ConsoleTaskArgs
+): Promise<void> {
+    const task = tasks.find((t) => t.name === taskName);
+
+    if (!task) {
+        logger.error(`Task not found: ${taskName}`);
+        logger.info('Available tasks:');
+        for (const t of tasks) {
+            logger.info(`  --task=${t.name}  ${t.description}`);
+        }
+        process.exit(1);
+    }
+
+    const context = new Context();
+
+    logger.info(`Running task: ${task.name}`);
+    const start = Date.now();
+
+    try {
+        await task.run(context, args);
+        const duration = Date.now() - start;
+        logger.info(`Task completed in ${duration}ms`);
+    } catch (error) {
+        logger.error('Task failed', {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined
+        });
+        process.exit(1);
+    }
+}
+
+export function listTasks(tasks: ConsoleTask[]): void {
+    console.log('\nAvailable console tasks:\n');
+    for (const task of tasks) {
+        console.log(`  ${task.name.padEnd(25)} ${task.description}`);
+    }
+    console.log('\nUsage: npm run console -- --task=TASK_NAME [--arg=value]\n');
+}

package/template/server/console/tasks/example.ts

@@ -0,0 +1,29 @@
+import type { ConsoleTask } from '../runner.js';
+import logger from '#core/logger.js';
+
+const task: ConsoleTask = {
+    name: 'example',
+    description: 'Example task that demonstrates the console runner pattern',
+
+    async run(context, args) {
+        logger.info('Running example task', { args });
+
+        // Access all models via context, just like in route handlers
+        const knex = context.auth.knex;
+
+        const [result] = await knex('users').count('id as count');
+        logger.info(`Total users in database: ${result.count}`);
+
+        // Example: process with arguments
+        if (args.verbose) {
+            const users = await knex('users').select('id', 'email', 'name');
+            for (const user of users) {
+                logger.info(`  - ${user.name} (${user.email})`);
+            }
+        }
+
+        logger.info('Example task finished');
+    }
+};
+
+export default task;

package/template/server/console/tasks/seed-admin.ts

@@ -0,0 +1,71 @@
+import type { ConsoleTask } from '../runner.js';
+import logger from '#core/logger.js';
+import { sendEmail, isEmailConfigured } from '#core/email.js';
+
+const task: ConsoleTask = {
+    name: 'seed-admin',
+    description: 'Create the initial admin user and account',
+
+    async run(context, args) {
+        if (!args.email || !args.password) {
+            logger.error('Usage: npm run console -- --task=seed-admin --email=admin@example.com --password=yourpassword [--name=Admin]');
+            process.exit(1);
+        }
+
+        const email = args.email as string;
+        const password = args.password as string;
+        const name = (args.name as string) || 'Admin';
+
+        const knex = context.auth.knex;
+
+        const existing = await knex('users').where({ email }).first();
+        if (existing) {
+            logger.warn(`User ${email} already exists, skipping`);
+            return;
+        }
+
+        const user = await context.user.create({
+            email,
+            password,
+            name,
+            role: 'admin'
+        });
+
+        const [account] = await knex('accounts')
+            .insert({
+                name: 'Admin Account',
+                status: 'active',
+                settings: JSON.stringify({})
+            })
+            .returning('*');
+
+        await knex('user_in_accounts').insert({
+            user_id: user.id,
+            account_id: account.id,
+            role: 'owner'
+        });
+
+        logger.info('Admin user created', {
+            email,
+            userId: user.id,
+            accountId: account.id
+        });
+
+        if (isEmailConfigured()) {
+            try {
+                await sendEmail(email, 'Bem-vindo!', 'accountWelcome', {
+                    user: { name }
+                });
+                logger.info('Welcome email sent', { email });
+            } catch (error) {
+                logger.error('Failed to send welcome email', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        } else {
+            logger.warn('Email not configured, skipping welcome email');
+        }
+    }
+};
+
+export default task;

package/template/server/core/context.ts

@@ -0,0 +1,49 @@
+import AuthModel from './models/auth.js';
+import UserModel from './models/user.js';
+import AccountModel from './models/account.js';
+import BaseModel from './models/base.js';
+import Db from './db.js';
+
+class Context {
+    auth: AuthModel;
+    user: UserModel;
+    account: AccountModel;
+
+    // Add new models here as the project grows:
+    // company: CompanyModel;
+    // employee: EmployeeModel;
+    // document: DocumentModel;
+
+    constructor() {
+        this.auth = new AuthModel(this);
+        this.user = new UserModel(this);
+        this.account = new AccountModel(this);
+    }
+
+    async knexTransaction(fn: () => Promise<void>): Promise<void> {
+        const db = new Db();
+        const { knex } = db;
+
+        try {
+            await knex.transaction(async (trx) => {
+                for (const key in this) {
+                    const model = (this as any)[key];
+                    if (model instanceof BaseModel) {
+                        model.knex = trx;
+                    }
+                }
+
+                await fn();
+            });
+        } finally {
+            for (const key in this) {
+                const model = (this as any)[key];
+                if (model instanceof BaseModel) {
+                    model.knex = knex;
+                }
+            }
+        }
+    }
+}
+
+export default Context;

package/template/server/core/db.ts

@@ -0,0 +1,12 @@
+import knex, { type Knex } from 'knex';
+import knexConfig from './knexfile.js';
+
+class Db {
+    knex: Knex;
+
+    constructor() {
+        this.knex = knex(knexConfig);
+    }
+}
+
+export default Db;

package/template/server/core/email.ts

@@ -0,0 +1,87 @@
+import nodemailer from 'nodemailer';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import _ from 'lodash';
+import logger from './logger.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+let _transporter: nodemailer.Transporter | null = null;
+
+function getTransporter(): nodemailer.Transporter {
+    if (!_transporter) {
+        _transporter = nodemailer.createTransport({
+            host: process.env.EMAIL_HOST,
+            port: parseInt(process.env.EMAIL_PORT || '465', 10),
+            secure: process.env.EMAIL_SECURE === 'true',
+            auth: {
+                user: process.env.EMAIL_USER,
+                pass: process.env.EMAIL_PASSWORD
+            }
+        });
+    }
+
+    return _transporter;
+}
+
+function loadTemplate(templateName: string, variables: Record<string, unknown>): string {
+    const emailsDir = path.resolve(__dirname, '../emails');
+
+    const stylesPath = path.join(emailsDir, '_styles.css');
+    const styles = fs.existsSync(stylesPath)
+        ? fs.readFileSync(stylesPath, 'utf-8')
+        : '';
+
+    const basePath = path.join(emailsDir, '_template.html');
+    const baseTemplate = fs.existsSync(basePath)
+        ? fs.readFileSync(basePath, 'utf-8')
+        : '{{content}}';
+
+    const templatePath = path.join(emailsDir, `${templateName}.html`);
+    if (!fs.existsSync(templatePath)) {
+        throw new Error(`Email template not found: ${templateName}`);
+    }
+
+    const templateContent = fs.readFileSync(templatePath, 'utf-8');
+
+    const compiledContent = _.template(templateContent)(variables);
+    const fullHtml = baseTemplate
+        .replace('{{styles}}', styles)
+        .replace('{{content}}', compiledContent);
+
+    return fullHtml;
+}
+
+export function isEmailConfigured(): boolean {
+    return !!(process.env.EMAIL_HOST && process.env.EMAIL_USER && process.env.EMAIL_PASSWORD);
+}
+
+export async function sendEmail(
+    to: string,
+    subject: string,
+    templateName: string,
+    variables: Record<string, unknown>
+): Promise<void> {
+    try {
+        const html = loadTemplate(templateName, variables);
+
+        await getTransporter().sendMail({
+            from: `"${process.env.EMAIL_NAME}" <${process.env.EMAIL_FROM}>`,
+            replyTo: process.env.EMAIL_REPLY_TO,
+            to,
+            subject,
+            html
+        });
+
+        logger.info('Email sent', { to, subject, template: templateName });
+    } catch (error) {
+        logger.error('Failed to send email', {
+            error: error instanceof Error ? error.message : String(error),
+            to,
+            subject,
+            template: templateName
+        });
+        throw error;
+    }
+}

package/template/server/core/errors.ts

@@ -0,0 +1,44 @@
+export class AppError extends Error {
+    statusCode: number;
+
+    constructor(message: string, statusCode: number = 500) {
+        super(message);
+        this.name = 'AppError';
+        this.statusCode = statusCode;
+    }
+}
+
+export class ValidationError extends AppError {
+    constructor(message: string) {
+        super(message, 400);
+        this.name = 'ValidationError';
+    }
+}
+
+export class UnauthorizedError extends AppError {
+    constructor(message: string = 'Não autorizado') {
+        super(message, 401);
+        this.name = 'UnauthorizedError';
+    }
+}
+
+export class ForbiddenError extends AppError {
+    constructor(message: string = 'Acesso negado') {
+        super(message, 403);
+        this.name = 'ForbiddenError';
+    }
+}
+
+export class NotFoundError extends AppError {
+    constructor(message: string = 'Recurso não encontrado') {
+        super(message, 404);
+        this.name = 'NotFoundError';
+    }
+}
+
+export class ConflictError extends AppError {
+    constructor(message: string) {
+        super(message, 409);
+        this.name = 'ConflictError';
+    }
+}

package/template/server/core/knexfile.ts

@@ -0,0 +1,28 @@
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+dotenv.config({ path: path.resolve(__dirname, '../.env') });
+
+const config = {
+    client: 'pg',
+    connection: {
+        host: process.env.DB_HOST || 'localhost',
+        port: parseInt(process.env.DB_PORT || '5432', 10),
+        database: process.env.DB_NAME,
+        user: process.env.DB_USER || 'postgres',
+        password: process.env.DB_PASSWORD || 'postgres'
+    },
+    migrations: {
+        directory: path.resolve(__dirname, '../migrations'),
+        extension: 'ts'
+    },
+    pool: {
+        min: 2,
+        max: 10
+    }
+};
+
+export default config;