create-forgeapi 1.0.0

package/template/src/base/BaseResponse.ts

@@ -0,0 +1,45 @@
+import {Response} from "express";
+import {SuccessResponseData} from "@shared/interfaces/HttpInterface";
+
+export default class BaseResponse {
+
+    static async ok<T>(
+        res: Response,
+        serviceFunction: () => Promise<T>,
+        message: string = 'Success'
+    ): Promise<Response> {
+        const data = await serviceFunction();
+
+        const response: SuccessResponseData<T> = {
+            success: true,
+            message,
+            data,
+        };
+
+        return res.status(200).json(response);
+    }
+
+    static async created<T>(
+        res: Response,
+        serviceFunction: () => Promise<T>,
+        message: string = 'Resource created successfully'
+    ): Promise<Response> {
+        const data = await serviceFunction();
+
+        const response: SuccessResponseData<T> = {
+            success: true,
+            message,
+            data,
+        };
+
+        return res.status(201).json(response);
+    }
+
+    static async noContent(
+        res: Response,
+        serviceFunction: () => Promise<void>
+    ): Promise<Response> {
+        await serviceFunction();
+        return res.status(204).send();
+    }
+}

package/template/src/base/BaseResponseError.ts

@@ -0,0 +1,12 @@
+
+export default class BaseResponseError extends Error {
+    public statusCode: number;
+    public errors?: Record<string, unknown>[];
+    constructor(statusCode: number, message: string, errors?: Record<string, unknown>[]) {
+        super(message);
+        this.statusCode = statusCode;
+        this.errors = errors;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}

package/template/src/base/BaseSchema.ts

@@ -0,0 +1,82 @@
+import {Schema} from "mongoose";
+
+export default class BaseSchema {
+    public static create <T>(schemaDefinition: any, options?: any): Schema<T> {
+        const baseFields = {
+            createdAt: {
+                type: Number,
+                required: false,
+                index: true
+            },
+            updatedAt: {
+                type: Number,
+                required: false
+            },
+            createdBy: {
+                type: Schema.Types.ObjectId,
+                ref: 'users',
+                required: false,
+                index: true
+            },
+            modifiedBy: {
+                type: Schema.Types.ObjectId,
+                ref: 'users',
+                required: false
+            },
+            deletedAt: {
+                type: Number,
+                required: false
+            },
+            deletedBy: {
+                type: Schema.Types.ObjectId,
+                ref: 'users',
+                required: false
+            }
+        };
+        const mergedDefinition = {
+            ...schemaDefinition,
+            ...baseFields
+        };
+        const mergedOptions = {
+            timestamps: false,
+            versionKey: false,
+            ...options
+        };
+
+        const schema = new Schema<T>(mergedDefinition, mergedOptions);
+
+        schema.pre('save', function(next) {
+            const now = Date.now();
+            const doc = this as any;
+            if (doc.isNew) {
+                doc.createdAt = now;
+            }
+            doc.updatedAt = now;
+            next();
+        });
+
+        schema.pre(['findOneAndUpdate', 'updateOne', 'updateMany'], function(next) {
+            this.set({ updatedAt: Date.now() });
+            next();
+        });
+
+        return schema;
+    }
+    public static addSoftDelete<T>(schema: Schema<T>): void {
+        schema.methods.delete = async function(deletedBy: any) {
+            this.deletedAt = Date.now();
+            this.deletedBy = deletedBy;
+            return await this.save();
+        };
+
+        schema.methods.restore = async function() {
+            this.deletedAt = undefined;
+            this.deletedBy = undefined;
+            return await this.save();
+        };
+
+        schema.methods.isDeleted = function() {
+            return !!this.deletedAt;
+        };
+    }
+}

package/template/src/config/DateTimeConfig.ts

@@ -0,0 +1,4 @@
+import {DayEnum, MonthEnum} from "@shared/models/enum/DateTimeEnum";
+
+export const DAY_VALUES   = Object.values(DayEnum)   as DayEnum[];
+export const MONTH_VALUES = Object.values(MonthEnum) as MonthEnum[];

package/template/src/config/GlobalHandlerError.ts

@@ -0,0 +1,81 @@
+import {Response, Request, NextFunction} from "express";
+import BaseResponseError from "@base/BaseResponseError";
+import {ErrorContext, ErrorResponseData, NotFoundResponse} from "@shared/interfaces/HttpInterface";
+import {log} from "@config/LoggerConfig";
+import TimeUtil from "@shared/utils/TimeUtil";
+
+const findSimilarRoute = (requestedPath: string, routes: string[]): string | null => {
+    // Simple similarity check - bisa diganti dengan library seperti 'string-similarity'
+    for (const route of routes) {
+        if (requestedPath.toLowerCase().includes(route.toLowerCase().split('/')[2])) {
+            return route;
+        }
+    }
+    return null;
+}
+
+export default class {
+    static error(
+        err: Error | BaseResponseError,
+        req: Request,
+        res: Response,
+        next: NextFunction
+    ) {
+        const context: ErrorContext = {
+            endpoint: req.path,
+            method: req.method,
+            userId: (req as any).user?.id, // jika ada authentication
+            body: req.body,
+            query: req.query,
+            params: req.params
+        };
+        log.server(err, context);
+
+        // Jika error adalah BaseResponseError
+        if (err instanceof BaseResponseError) {
+            const response: ErrorResponseData = {
+                success: false,
+                message: err.message,
+                ...(err.errors && { errors: err.errors }),
+                ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
+            };
+            res.status(err.statusCode).json(response);
+            return;
+        }
+
+        // Default error (500)
+        const response: ErrorResponseData = {
+            success: false,
+            message: err.message || 'Internal server error',
+            ...(process.env.NODE_ENV === 'development' && {
+                error: err.toString(),
+                stack: err.stack
+            })
+        };
+        res.status(500).json(response);
+    };
+
+    static notFound(
+        req: Request,
+        res: Response,
+        next: NextFunction
+    ) {
+        const response: NotFoundResponse = {
+            success: false,
+            message: 'API endpoint not found',
+            path: req.originalUrl || req.url,
+            method: req.method,
+            timestamp: TimeUtil.getReadableDayDateTime(new Date())
+        };
+
+        // Optional: Tambahkan suggestion untuk typo umum
+        const availableRoutes = [''];
+        const similarRoute = findSimilarRoute(req.path, availableRoutes);
+
+        if (similarRoute) {
+            response.suggestion = `Did you mean ${similarRoute}?`;
+        }
+
+        res.status(404).json(response);
+    };
+}

package/template/src/config/LoggerConfig.ts

@@ -0,0 +1,157 @@
+import TimeUtil from "@shared/utils/TimeUtil";
+import {LogData, LoggerOptions} from "@shared/interfaces/LoggerOptionsInterface";
+import path from "node:path";
+import FolderUtil from "@shared/utils/FolderUtil";
+import {NextFunction, Request, Response} from "express";
+import {getStatusColor, getStatusEmoji} from "@shared/utils/ColorUtil";
+import fs from "node:fs";
+import {ErrorContext, ErrorLogData} from "@shared/interfaces/HttpInterface";
+import BaseResponseError from "@base/BaseResponseError";
+import {Color} from "@shared/models/enum/ColorEnum";
+
+export const serverLogger = (options: LoggerOptions = {}) => {
+    const {
+        enableFileLog = true,
+        enableConsoleLog = true,
+        logFileName = `app-${new Date().toISOString().split('T')[0]}.log`,
+        folderPath = 'logs'
+    } = options;
+
+    const logFilePath = path.join(FolderUtil.mkdir(folderPath), logFileName);
+
+    return (req: Request, res: Response, next: NextFunction): void => {
+        const startTime = Date.now();
+
+        // Capture response
+        const originalSend = res.send;
+        let responseBody: any;
+
+        res.send = function (data: any): Response {
+            responseBody = data;
+            return originalSend.apply(res, [data]);
+        };
+
+        // Log ketika response selesai
+        res.on('finish', () => {
+            const duration = Date.now() - startTime;
+            const timestamp = TimeUtil.getTimestamp();
+
+            // Data log
+            const logData: LogData = {
+                timestamp,
+                method: req.method,
+                url: req.originalUrl || req.url,
+                status: res.statusCode,
+                duration: `${duration}ms`,
+                ip: req.ip || req.socket.remoteAddress || 'Unknown',
+                userAgent: req.get('user-agent') || 'Unknown'
+            };
+
+            // Console log dengan warna dan emoji
+            if (enableConsoleLog) {
+                const statusColor = getStatusColor(res.statusCode);
+                const emoji = getStatusEmoji(res.statusCode);
+
+                console.log(
+                    `${Color.GRAY}[${timestamp}]${Color.RESET} ` +
+                    `${emoji} ` +
+                    `${Color.BRIGHT}${req.method}${Color.RESET} ` +
+                    `${Color.CYAN}${req.originalUrl || req.url}${Color.RESET} ` +
+                    `${statusColor}${res.statusCode}${Color.RESET} ` +
+                    `${Color.MAGENTA}${TimeUtil.formatDuration(duration)}${Color.RESET} ` +
+                    `${Color.GRAY}(${logData.ip})${Color.RESET}`
+                );
+            }
+
+            // File log (format yang lebih mudah dibaca)
+            if (enableFileLog) {
+                const logEntry = [
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+                    `Timestamp    : ${timestamp}`,
+                    `Method       : ${logData.method}`,
+                    `URL          : ${logData.url}`,
+                    `Status       : ${logData.status}`,
+                    `Duration     : ${logData.duration}`,
+                    `IP Address   : ${logData.ip}`,
+                    `User Agent   : ${logData.userAgent}`,
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`
+                ].join('\n');
+
+                fs.appendFile(logFilePath, logEntry, (err) => {
+                    if (err) console.error('Error writing to log file:', err);
+                });
+            }
+        });
+
+        next();
+    };
+};
+
+export class log {
+    static info (...message: unknown[]) {
+        const text = message
+            .map(item =>
+                typeof item === 'string'
+                    ? item
+                    : JSON.stringify(item)
+            )
+            .join(' ');
+
+        const log = `${Color.BLUE}ℹ️  INFO${Color.RESET} [${TimeUtil.getTimeString()}] ${text}`;
+        console.log(log);
+        // const log = `${Color.BLUE}ℹ️  INFO${Color.RESET} [${TimeUtil.getTimestamp()}] ${message}`;
+        // console.log(log);
+    }
+
+    static success(message: string) {
+        const log = `${Color.GREEN}✅ SUCCESS${Color.RESET} [${TimeUtil.getTimeString()}] ${message}`;
+        console.log(log);
+    }
+
+    static warning(message: string) {
+        const log = `${Color.YELLOW}⚠️  WARNING${Color.RESET} [${TimeUtil.getTimeString()}] ${message}`;
+        console.log(log);
+    }
+
+    static error(...message: unknown[]) {
+        const text = message
+            .map(item =>
+                typeof item === 'string'
+                    ? item
+                    : JSON.stringify(item)
+            )
+            .join(' ');
+
+        const log =
+            `${Color.YELLOW}❌ ERROR${Color.RED} ` +
+            `[${TimeUtil.getTimeString()}] ${text}`;
+
+        console.log(log);
+    }
+
+    static server(
+        error: Error,
+        context?: ErrorContext
+    ) {
+        const errorLog: ErrorLogData = {
+            timestamp: TimeUtil.getTimeString(),
+            error: error,
+            context: context,
+        };
+        log.error('Time:', errorLog.timestamp);
+        log.error('Error Name:', error.name);
+        log.error('Message:', error.message);
+        log.error('Stack:', error.stack);
+
+        if (error instanceof BaseResponseError) {
+            log.error('Status Code:', error.statusCode);
+            if (error.errors) {
+                log.error('Validation Errors:', JSON.stringify(error.errors, null, 2));
+            }
+        }
+
+        if (context) {
+            log.error('Context:', JSON.stringify(context, null, 2));
+        }
+    }
+}

package/template/src/config/LookupConfig.ts

@@ -0,0 +1,68 @@
+import {ILookupConfig} from "@shared/interfaces/DatabaseInterface";
+import {log} from "@config/LoggerConfig";
+
+export default class LookupConfig {
+    private static lookups: Map<string, ILookupConfig> = new Map();
+
+    static register(prefix: string, config: ILookupConfig): void {
+        this.lookups.set(prefix, config);
+    }
+
+    static get(prefix: string): ILookupConfig | undefined {
+        return this.lookups.get(prefix);
+    }
+
+    static getLookupForPath(path: string): { prefix: string; config: ILookupConfig } | null {
+        for (const [prefix, config] of this.lookups.entries()) {
+            if (path.startsWith(prefix + '.')) {
+                return { prefix, config };
+            }
+        }
+        return null;
+    }
+
+    static getAll(): Map<string, ILookupConfig> {
+        return this.lookups;
+    }
+
+    static init(entities: any[]) {
+        log.info("━".repeat(60));
+        log.info('🚀 Initializing lookups...');
+
+        // Auto-register dari decorators
+        for (const entity of entities) {
+            if (typeof entity.registerLookups === 'function') {
+                entity.registerLookups();
+            }
+        }
+
+        // Register lookup untuk audit fields (GLOBAL - untuk semua entity)
+        LookupConfig.register('creatorUser', {
+            from: 'users',
+            localField: 'createdBy',
+            foreignField: '_id',
+            as: 'creatorUser',
+            unwind: true
+        });
+
+        LookupConfig.register('modifierUser', {
+            from: 'users',
+            localField: 'modifiedBy',
+            foreignField: '_id',
+            as: 'modifierUser',
+            unwind: true
+        });
+
+        LookupConfig.register('deleterUser', {
+            from: 'users',
+            localField: 'deletedBy',
+            foreignField: '_id',
+            as: 'deleterUser',
+            unwind: true
+        });
+
+        log.info('✅ All lookups initialized');
+        log.info('📋 Registered lookups:', Array.from(LookupConfig.getAll().keys()));
+        log.info("━".repeat(60));
+    }
+}

package/template/src/config/MetaDataConfig.ts

@@ -0,0 +1,25 @@
+import {LookupDecoratorOptions, VirtualFieldConfig} from "@shared/interfaces/DatabaseInterface";
+
+export default class MetaDataConfig {
+    public static lookupMetadata = new Map<string, Map<string, LookupDecoratorOptions>>();
+
+    public static virtualMetadata = new Map<string, Map<string, VirtualFieldConfig>>();
+
+    public static lookupGetMetadata(className: string): Map<string, LookupDecoratorOptions> {
+        return this.lookupMetadata.get(className) || new Map();
+    }
+
+    public static lookupGetKeys(className: string): string[] {
+        const metadata = this.lookupMetadata.get(className);
+        return metadata ? Array.from(metadata.keys()) : [];
+    }
+
+    public static virtualGetMetadata(className: string): Map<string, VirtualFieldConfig> {
+        return this.virtualMetadata.get(className) || new Map();
+    }
+
+    public static virtualGetFields(className: string): VirtualFieldConfig[] {
+        const metadata = this.virtualMetadata.get(className);
+        return metadata ? Array.from(metadata.values()) : [];
+    }
+}

package/template/src/config/RouteConfig.ts

@@ -0,0 +1,98 @@
+import {Router, Request, Response, NextFunction} from "express";
+import {GetControllerMetadata} from "@shared/decorators/ApiDecorator";
+import AuthMiddleware from "@api/middlewares/AuthMiddleware";
+import {IRouteDefinition} from "@shared/interfaces/RouteMetadataInterface";
+
+export default class RouteConfig {
+    protected static controllers: any[] = [];
+
+    static register(...controller: any) {
+        console.log('📝 Registering controllers:', controller.map((c: any) => c.name));
+        this.controllers.push(...controller);
+        console.log('📝 Total controllers:', this.controllers.length);
+    }
+
+    static getControllers() {
+        return this.controllers;
+    }
+
+    static buildRoutes(router: Router) {
+        console.log('🔷 buildRoutes called, controllers count:', this.controllers.length);
+
+        try {
+            this.controllers.forEach((ControllerClass, index) => {
+                console.log(`🔷 Processing controller ${index+1}:`, ControllerClass.name);
+
+                try {
+                    const instance = new ControllerClass();
+                    const metadata = GetControllerMetadata(ControllerClass);
+
+                    // console.log('🔷 Metadata:', metadata);
+
+                    if (!metadata) {
+                        console.error('❌ No metadata found for controller:', ControllerClass.name);
+                        return;
+                    }
+
+                    if (!metadata.routes || !Array.isArray(metadata.routes)) {
+                        console.error('❌ No routes found in metadata for controller:', ControllerClass.name);
+                        return;
+                    }
+
+                    metadata.routes.forEach((route: IRouteDefinition) => {
+                        const fullPath = `${metadata.basePath}${route.path}`;
+                        const handler = (instance as any)[route.handlerName as string].bind(instance);
+
+                        console.log(`🔷 Registering route: ${route.method.toString().toUpperCase()} ${fullPath}`);
+
+                        // requireAuth: true hanya jika authenticate.authenticate === true (default: false)
+                        const requireAuth = route.authenticate?.authenticate === true;
+
+                        const middleware = requireAuth
+                            ? [
+                                // Inject route.authenticate ke req sebelum AuthMiddleware berjalan
+                                (req: Request, _res: Response, next: NextFunction) => {
+                                    req.authenticate = route.authenticate;
+                                    next();
+                                },
+                                AuthMiddleware,
+                                async (req: Request, res: Response, next: NextFunction) => {
+                                    try {
+                                        const result = await handler(req, res, next);
+                                        if (result !== undefined && !res.headersSent) {
+                                            res.json(result);
+                                        }
+                                    } catch (error) {
+                                        next(error);
+                                    }
+                                }
+                            ]
+                            : [async (req: Request, res: Response, next: NextFunction) => {
+                                try {
+                                    const result = await handler(req, res, next);
+                                    if (result !== undefined && !res.headersSent) {
+                                        res.json(result);
+                                    }
+                                } catch (error) {
+                                    console.log('🟡 Error caught in RouteConfig (no auth):', error);
+                                    next(error);
+                                }
+                            }];
+
+                        (router as any)[route.method](fullPath, ...middleware);
+                    });
+                } catch (controllerError) {
+                    console.error('❌ Error processing controller:', ControllerClass.name, controllerError);
+                    throw controllerError;
+                }
+            });
+
+            console.log('✅ All routes registered successfully');
+        } catch (error) {
+            console.error('❌ Error in buildRoutes:', error);
+            throw error;
+        }
+
+        return router;
+    }
+}