@sundaysf/cli-v2 0.0.2 → 0.0.3

package/dist/templates/backend-db-sql/eslint.config.js

@@ -0,0 +1,20 @@
+const eslint = require('@eslint/js');
+const tseslint = require('typescript-eslint');
+
+module.exports = tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    languageOptions: {
+      parserOptions: {
+        project: './tsconfig.json',
+      },
+    },
+    rules: {},
+  },
+  {
+    ignores: ['dist/', 'node_modules/'],
+  }
+);
+
+//# sourceMappingURL=eslint.config.js.map

package/dist/templates/backend-db-sql/src/app.ts

@@ -0,0 +1,35 @@
+import dotenv from 'dotenv';
+import express, { type Express } from 'express';
+import logger from 'morgan';
+import cors from 'cors';
+import { IndexRouter } from './routes/index';
+import { errorMiddleware } from './middlewares/error/error.middleware';
+import { getAllowedOrigins } from './common/config/origins/origins.config';
+dotenv.config();
+
+const app: Express = express();
+
+app.use(
+    logger('tiny', {
+        skip: (req, _res) => {
+            return req.originalUrl.startsWith('/api/health');
+        },
+    })
+);
+
+app.use(
+    cors({
+        origin: getAllowedOrigins(),
+        credentials: true,
+        allowedHeaders: ['Content-Type', 'Authorization'],
+    })
+);
+
+app.use(express.urlencoded({ extended: true }));
+app.use(express.json());
+
+app.use('/api', new IndexRouter().router);
+
+app.use(errorMiddleware);
+
+export default app;

package/dist/templates/backend-db-sql/src/common/config/origins/origins.config.ts

@@ -0,0 +1,11 @@
+export const getAllowedOrigins = (): string[] => {
+  let origins: string = process.env.CORS_ALLOWED_ORIGINS || 'http://localhost:3098';
+  origins = origins
+    .split('\n')
+    .join('')
+    .split('\r')
+    .join('')
+    .split(' ')
+    .join('');
+  return origins.split(',');
+};

package/dist/templates/backend-db-sql/src/common/utils/environment.resolver.ts

@@ -0,0 +1,4 @@
+export const getServiceEnvironment = (): string => {
+    const serEnv: string = process.env.ENVIRONMENT || 'undefined';
+    return serEnv.charAt(0).toUpperCase() + serEnv.slice(1);
+};

package/dist/templates/backend-db-sql/src/common/utils/version.resolver.ts

@@ -0,0 +1,5 @@
+const pjson = require('../../../package.json');
+
+export const getServiceVersion = (): string => {
+    return pjson['version'];
+};

package/dist/templates/backend-db-sql/src/controllers/health/health.controller.ts

@@ -0,0 +1,24 @@
+import { NextFunction, Request, Response } from 'express';
+import { getServiceVersion } from '../../common/utils/version.resolver';
+import { getServiceEnvironment } from '../../common/utils/environment.resolver';
+
+export class HealthController {
+  public async getHealthStatus(
+    _req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<void> {
+    try {
+      const version: string = await getServiceVersion();
+      const environment: string = await getServiceEnvironment();
+      res.status(200).json({
+        success: true,
+        health: 'Up!',
+        version,
+        environment,
+      });
+    } catch (err: any) {
+      next(err);
+    }
+  }
+}

package/dist/templates/backend-db-sql/src/middlewares/error/error.middleware.ts

@@ -0,0 +1,21 @@
+import { NextFunction, Response, Request } from 'express';
+export const errorMiddleware = (
+  err: any,
+  req: Request | any,
+  res: Response,
+  _next: NextFunction
+) => {
+  console.error(err);
+  const statusError: number =
+    err.statusError ||
+    err.statusCode ||
+    err.status ||
+    req.statusCode ||
+    req.statusError ||
+    500;
+  const isProduction = process.env.ENVIRONMENT === 'production';
+  res.status(statusError).json({
+    success: false,
+    message: isProduction && statusError === 500 ? 'Internal server error' : err.message,
+  });
+};

package/dist/templates/backend-db-sql/src/routes/health/health.router.ts

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+import { HealthController } from '../../controllers/health/health.controller';
+
+export class HealthRouter {
+    public router: Router = Router();
+    private readonly healthController: HealthController = new HealthController();
+    constructor() {
+        this.initRoutes();
+    }
+    
+    private initRoutes(): void {
+        this.router.get(
+            '/',
+            this.healthController.getHealthStatus.bind(this.healthController)
+        );
+    }
+}

package/dist/templates/backend-db-sql/src/routes/index.ts

@@ -0,0 +1,57 @@
+import { Router } from 'express';
+import fs from 'fs';
+import path from 'path';
+
+export class IndexRouter {
+  private _router: Router;
+
+  constructor() {
+    this._router = Router();
+    this.loadRoutes();
+  }
+
+  private loadRoutes(): void {
+    const routesPath = path.join(__dirname);
+
+    const folders = fs.readdirSync(routesPath).filter(file =>
+      fs.statSync(path.join(routesPath, file)).isDirectory()
+    );
+
+    folders.forEach(folder => {
+      const baseName = `${folder}.router`;
+      const tsPath = path.join(routesPath, folder, `${baseName}.ts`);
+      const jsPath = path.join(routesPath, folder, `${baseName}.js`);
+
+      let filePath = '';
+      if (fs.existsSync(tsPath)) {
+        filePath = tsPath;
+      } else if (fs.existsSync(jsPath)) {
+        filePath = jsPath;
+      } else {
+        console.warn(`[⚠] No route file found for: ${folder}`);
+        return;
+      }
+
+      try {
+        const routeModule = require(filePath);
+        const RouterClass =
+          routeModule.default || Object.values(routeModule).find((e) => typeof e === 'function');
+
+        if (RouterClass) {
+          const instance = new (RouterClass as any)();
+          this._router.use(`/${folder}`, instance.router);
+          console.log(`[✔] Route mounted: /${folder} → ${path.basename(filePath)}`);
+        } else {
+          console.warn(`[⚠] No class exported in: ${filePath}`);
+        }
+      } catch (err) {
+        console.error(`[❌] Failed to load router at: ${filePath}`);
+        console.error(err);
+      }
+    });
+  }
+
+  public get router(): Router {
+    return this._router;
+  }
+}

package/dist/templates/backend-db-sql/src/server.ts

@@ -0,0 +1,18 @@
+import dotenv from 'dotenv';
+dotenv.config();
+import KnexManager from '../db/src/KnexConnection';
+
+const envPort: string = process.env.PORT || '3005';
+
+if (isNaN(parseInt(envPort))) {
+    throw new Error('The port must to be a number');
+}
+
+const PORT: number = parseInt(envPort);
+
+(async () => {
+    await KnexManager.connect();
+})().then(async () => {
+    const { default: app } = await import('./app');
+    app.listen(PORT, () => console.info(`Server up and running on port ${PORT}`));
+});

package/dist/templates/backend-db-sql/src/types.d.ts

@@ -0,0 +1,10 @@
+import { Request, Response, NextFunction } from 'express';
+
+export interface IBaseController {
+    getAll(req: Request, res: Response, next: NextFunction): Promise<void>;
+    getByUuid(req: Request, res: Response, next: NextFunction): Promise<void>;
+    create(req: Request, res: Response, next: NextFunction): Promise<void>;
+    update(req: Request, res: Response, next: NextFunction): Promise<void>;
+    patch(req: Request, res: Response, next: NextFunction): Promise<void>;
+    delete(req: Request, res: Response, next: NextFunction): Promise<void>;
+}

package/dist/templates/backend-db-sql/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "db"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaysf/cli-v2",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Sundays Framework CLI - Project scaffolding and CRUD code generation",
   "main": "./dist/bin/index.js",
   "scripts": {