nodejs-quickstart-structure 1.19.0 → 1.19.1

package/templates/mvc/ts/src/config/env.ts.ejs

@@ -1,45 +1,45 @@
-import dotenv from 'dotenv';
-import { z } from 'zod';
-import logger from '@/utils/logger';
-
-if (process.env.NODE_ENV !== 'production') {
-  dotenv.config();
-}
-const envSchema = z.object({
-  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
-  PORT: z.string().transform(Number).default('3000'),
-<%_ if (database !== 'None') { -%>
-  DB_HOST: z.string(),
-<%_ if (database === 'MySQL') { -%>
-  DB_USER: z.string(),
-  DB_PASSWORD: z.string(),
-  DB_NAME: z.string(),
-  DB_PORT: z.string().transform(Number),
-<%_ } else if (database === 'PostgreSQL') { -%>
-  DB_USER: z.string(),
-  DB_PASSWORD: z.string(),
-  DB_NAME: z.string(),
-  DB_PORT: z.string().transform(Number),
-<%_ } else if (database === 'MongoDB') { -%>
-  DB_NAME: z.string(),
-  DB_PORT: z.string().transform(Number),
-<%_ } -%>
-<%_ } -%>
-<%_ if (caching === 'Redis') { -%>
-  REDIS_HOST: z.string(),
-  REDIS_PORT: z.string().transform(Number),
-  REDIS_PASSWORD: z.string().optional(),
-<%_ } -%>
-<%_ if (communication === 'Kafka') { -%>
-  KAFKA_BROKER: z.string(),
-<%_ } -%>
-});
-
-const _env = envSchema.safeParse(process.env);
-
-if (!_env.success) {
-  logger.error('❌ Invalid environment variables:', _env.error.format());
-  process.exit(1);
-}
-
-export const env = _env.data;
+import dotenv from 'dotenv';
+import { z } from 'zod';
+import logger from '@/utils/logger';
+
+if (process.env.NODE_ENV !== 'production') {
+  dotenv.config();
+}
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  PORT: z.string().transform(Number).default('3000'),
+<%_ if (database !== 'None') { -%>
+  DB_HOST: z.string(),
+<%_ if (database === 'MySQL') { -%>
+  DB_USER: z.string(),
+  DB_PASSWORD: z.string(),
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } else if (database === 'PostgreSQL') { -%>
+  DB_USER: z.string(),
+  DB_PASSWORD: z.string(),
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } else if (database === 'MongoDB') { -%>
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+  REDIS_HOST: z.string(),
+  REDIS_PORT: z.string().transform(Number),
+  REDIS_PASSWORD: z.string().optional(),
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+  KAFKA_BROKER: z.string(),
+<%_ } -%>
+});
+
+const _env = envSchema.safeParse(process.env);
+
+if (!_env.success) {
+  logger.error('❌ Invalid environment variables:', _env.error.format());
+  process.exit(1);
+}
+
+export const env = _env.data;

package/templates/mvc/ts/src/config/swagger.ts.ejs

@@ -1,6 +1,6 @@
-<% if (communication === 'REST APIs' || communication === 'Kafka') { %>import path from 'path';
-import YAML from 'yamljs';
-
-const swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));
-
-export default swaggerDocument;<% } %>
+<% if (communication === 'REST APIs' || communication === 'Kafka') { %>import path from 'path';
+import YAML from 'yamljs';
+
+const swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));
+
+export default swaggerDocument;<% } %>

package/templates/mvc/ts/src/errors/ApiError.ts

@@ -1,15 +1,15 @@
-export class ApiError extends Error {
-  statusCode: number;
-  isOperational: boolean;
-
-  constructor(statusCode: number, message: string, isOperational = true, stack = '') {
-    super(message);
-    this.statusCode = statusCode;
-    this.isOperational = isOperational;
-    if (stack) {
-      this.stack = stack;
-    } else {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-}
+export class ApiError extends Error {
+  statusCode: number;
+  isOperational: boolean;
+
+  constructor(statusCode: number, message: string, isOperational = true, stack = '') {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    if (stack) {
+      this.stack = stack;
+    } else {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}

package/templates/mvc/ts/src/graphql/context.spec.ts.ejs

@@ -1,30 +1,30 @@
-import { gqlContext } from '@/graphql/context';
-import { Request } from 'express';
-import { resolvers } from '@/graphql/resolvers';
-import { typeDefs } from '@/graphql/typeDefs';
-
-describe('GraphQL Context', () => {
-  it('should exercise GraphQL index entry points', () => {
-    expect(resolvers).toBeDefined();
-    expect(typeDefs).toBeDefined();
-  });
-  it('should return context with token when authorization header is present', async () => {
-    const mockRequest = {
-      headers: {
-        authorization: 'Bearer token123',
-      },
-    } as Request;
-
-    const context = await gqlContext({ req: mockRequest });
-    expect(context).toEqual({ token: 'Bearer token123' });
-  });
-
-  it('should return context with empty token when authorization header is missing', async () => {
-    const mockRequest = {
-      headers: {},
-    } as Request;
-
-    const context = await gqlContext({ req: mockRequest });
-    expect(context).toEqual({ token: '' });
-  });
-});
+import { gqlContext } from '@/graphql/context';
+import { Request } from 'express';
+import { resolvers } from '@/graphql/resolvers';
+import { typeDefs } from '@/graphql/typeDefs';
+
+describe('GraphQL Context', () => {
+  it('should exercise GraphQL index entry points', () => {
+    expect(resolvers).toBeDefined();
+    expect(typeDefs).toBeDefined();
+  });
+  it('should return context with token when authorization header is present', async () => {
+    const mockRequest = {
+      headers: {
+        authorization: 'Bearer token123',
+      },
+    } as Request;
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context).toEqual({ token: 'Bearer token123' });
+  });
+
+  it('should return context with empty token when authorization header is missing', async () => {
+    const mockRequest = {
+      headers: {},
+    } as Request;
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context).toEqual({ token: '' });
+  });
+});

package/templates/mvc/ts/src/graphql/context.ts.ejs

@@ -1,12 +1,12 @@
-import { Request } from 'express';
-
-export interface MyContext {
-  token?: string;
-  // user?: User;
-}
-
-export const gqlContext = async ({ req }: { req: Request }): Promise<MyContext> => {
-  // Setup authorization or context here
-  const token = req.headers.authorization || '';
-  return { token };
-};
+import { Request } from 'express';
+
+export interface MyContext {
+  token?: string;
+  // user?: User;
+}
+
+export const gqlContext = async ({ req }: { req: Request }): Promise<MyContext> => {
+  // Setup authorization or context here
+  const token = req.headers.authorization || '';
+  return { token };
+};

package/templates/mvc/ts/src/graphql/index.ts.ejs

@@ -1,3 +1,3 @@
-export { typeDefs } from '@/graphql/typeDefs';
-export { resolvers } from '@/graphql/resolvers';
-export { gqlContext, MyContext } from '@/graphql/context';
+export { typeDefs } from '@/graphql/typeDefs';
+export { resolvers } from '@/graphql/resolvers';
+export { gqlContext, MyContext } from '@/graphql/context';

package/templates/mvc/ts/src/graphql/resolvers/index.ts.ejs

@@ -1,4 +1,4 @@
-import { mergeResolvers } from '@graphql-tools/merge';
-import { userResolvers } from '@/graphql/resolvers/user.resolvers';
-
-export const resolvers = mergeResolvers([userResolvers]);
+import { mergeResolvers } from '@graphql-tools/merge';
+import { userResolvers } from '@/graphql/resolvers/user.resolvers';
+
+export const resolvers = mergeResolvers([userResolvers]);

package/templates/mvc/ts/src/graphql/typeDefs/index.ts.ejs

@@ -1,4 +1,4 @@
-import { mergeTypeDefs } from '@graphql-tools/merge';
-import { userTypes } from '@/graphql/typeDefs/user.types';
-
-export const typeDefs = mergeTypeDefs([userTypes]);
+import { mergeTypeDefs } from '@graphql-tools/merge';
+import { userTypes } from '@/graphql/typeDefs/user.types';
+
+export const typeDefs = mergeTypeDefs([userTypes]);

package/templates/mvc/ts/src/utils/errorMiddleware.ts.ejs

@@ -1,27 +1,27 @@
-import { Request, Response } from 'express';
-import logger from '@/utils/logger';
-import { ApiError } from '@/errors/ApiError';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-
-export const errorMiddleware = (err: Error, req: Request, res: Response, _next: unknown) => {
-  let error = err;
-
-  if (!(error instanceof ApiError)) {
-    const statusCode = HTTP_STATUS.INTERNAL_SERVER_ERROR;
-    const message = error.message || 'Internal Server Error';
-    error = new ApiError(statusCode, message, false, err.stack);
-  }
-
-  const { statusCode, message } = error as ApiError;
-
-  if (statusCode === HTTP_STATUS.INTERNAL_SERVER_ERROR) {
-    logger.error(`${statusCode} - ${message} - ${req.originalUrl} - ${req.method} - ${req.ip}`);
-    logger.error(error.stack || 'No stack trace');
-  }
-
-  res.status(statusCode).json({
-    statusCode,
-    message,
-    ...(process.env.NODE_ENV === 'development' && { stack: error.stack }),
-  });
-};
+import { Request, Response } from 'express';
+import logger from '@/utils/logger';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+
+export const errorMiddleware = (err: Error, req: Request, res: Response, _next: unknown) => {
+  let error = err;
+
+  if (!(error instanceof ApiError)) {
+    const statusCode = HTTP_STATUS.INTERNAL_SERVER_ERROR;
+    const message = error.message || 'Internal Server Error';
+    error = new ApiError(statusCode, message, false, err.stack);
+  }
+
+  const { statusCode, message } = error as ApiError;
+
+  if (statusCode === HTTP_STATUS.INTERNAL_SERVER_ERROR) {
+    logger.error(`${statusCode} - ${message} - ${req.originalUrl} - ${req.method} - ${req.ip}`);
+    logger.error(error.stack || 'No stack trace');
+  }
+
+  res.status(statusCode).json({
+    statusCode,
+    message,
+    ...(process.env.NODE_ENV === 'development' && { stack: error.stack }),
+  });
+};

package/templates/mvc/ts/src/utils/httpCodes.ts

@@ -1,7 +1,7 @@
-export const HTTP_STATUS = {
-    OK: 200,
-    CREATED: 201,
-    BAD_REQUEST: 400,
-    NOT_FOUND: 404,
-    INTERNAL_SERVER_ERROR: 500
-} as const;
+export const HTTP_STATUS = {
+    OK: 200,
+    CREATED: 201,
+    BAD_REQUEST: 400,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500
+} as const;

package/templates/mvc/ts/src/utils/logger.spec.ts.ejs

@@ -1,63 +1,63 @@
-jest.mock('winston-daily-rotate-file');
-jest.mock('winston', () => {
-    const mockLogger = {
-        add: jest.fn(),
-        info: jest.fn(),
-        error: jest.fn(),
-        warn: jest.fn()
-    };
-    const format = {
-        combine: jest.fn(),
-        timestamp: jest.fn(),
-        json: jest.fn(),
-        simple: jest.fn()
-    };
-    const transports = {
-        Console: jest.fn(),
-        DailyRotateFile: jest.fn()
-    };
-    return {
-        format,
-        transports,
-        createLogger: jest.fn().mockReturnValue(mockLogger)
-    };
-});
-
-<% if (architecture === 'MVC') { -%>
-import logger from '@/utils/logger';
-<% } else { -%>
-import logger from '@/infrastructure/log/logger';
-<% } -%>
-
-describe('Logger', () => {
-    it('should export a logger instance', () => {
-        expect(logger).toBeDefined();
-    });
-
-    it('should have info method', () => {
-        expect(typeof logger.info).toBe('function');
-    });
-
-    it('should have error method', () => {
-        expect(typeof logger.error).toBe('function');
-    });
-
-    it('should call info', () => {
-        logger.info('test message');
-        expect(logger.info).toHaveBeenCalledWith('test message');
-    });
-
-    it('should call error', () => {
-        logger.error('test error');
-        expect(logger.error).toHaveBeenCalledWith('test error');
-    });
-
-    it('should use JSON format in production environment', () => {
-        const winston = require('winston');
-        jest.resetModules();
-        process.env.NODE_ENV = 'production';
-        require('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
-        expect(winston.format.json).toHaveBeenCalled();
-        process.env.NODE_ENV = 'test';
-    });
-});
+jest.mock('winston-daily-rotate-file');
+jest.mock('winston', () => {
+    const mockLogger = {
+        add: jest.fn(),
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn()
+    };
+    const format = {
+        combine: jest.fn(),
+        timestamp: jest.fn(),
+        json: jest.fn(),
+        simple: jest.fn()
+    };
+    const transports = {
+        Console: jest.fn(),
+        DailyRotateFile: jest.fn()
+    };
+    return {
+        format,
+        transports,
+        createLogger: jest.fn().mockReturnValue(mockLogger)
+    };
+});
+
+<% if (architecture === 'MVC') { -%>
+import logger from '@/utils/logger';
+<% } else { -%>
+import logger from '@/infrastructure/log/logger';
+<% } -%>
+
+describe('Logger', () => {
+    it('should export a logger instance', () => {
+        expect(logger).toBeDefined();
+    });
+
+    it('should have info method', () => {
+        expect(typeof logger.info).toBe('function');
+    });
+
+    it('should have error method', () => {
+        expect(typeof logger.error).toBe('function');
+    });
+
+    it('should call info', () => {
+        logger.info('test message');
+        expect(logger.info).toHaveBeenCalledWith('test message');
+    });
+
+    it('should call error', () => {
+        logger.error('test error');
+        expect(logger.error).toHaveBeenCalledWith('test error');
+    });
+
+    it('should use JSON format in production environment', () => {
+        const winston = require('winston');
+        jest.resetModules();
+        process.env.NODE_ENV = 'production';
+        require('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
+        expect(winston.format.json).toHaveBeenCalled();
+        process.env.NODE_ENV = 'test';
+    });
+});

package/templates/mvc/ts/src/utils/logger.ts

@@ -1,36 +1,36 @@
-import winston from 'winston';
-import 'winston-daily-rotate-file';
-
-const logger = winston.createLogger({
-  level: 'info',
-  format: winston.format.combine(
-    winston.format.timestamp(),
-    winston.format.json()
-  ),
-  defaultMeta: { service: 'user-service' },
-  transports: [
-    new winston.transports.DailyRotateFile({
-      filename: 'logs/error-%DATE%.log',
-      datePattern: 'YYYY-MM-DD',
-      zippedArchive: true,
-      maxSize: '20m',
-      maxFiles: '14d',
-      level: 'error',
-    }),
-    new winston.transports.DailyRotateFile({
-      filename: 'logs/combined-%DATE%.log',
-      datePattern: 'YYYY-MM-DD',
-      zippedArchive: true,
-      maxSize: '20m',
-      maxFiles: '14d',
-    }),
-  ],
-});
-
-logger.add(new winston.transports.Console({
-  format: process.env.NODE_ENV !== 'production'
-    ? winston.format.simple()
-    : winston.format.json(),
-}));
-
-export default logger;
+import winston from 'winston';
+import 'winston-daily-rotate-file';
+
+const logger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'user-service' },
+  transports: [
+    new winston.transports.DailyRotateFile({
+      filename: 'logs/error-%DATE%.log',
+      datePattern: 'YYYY-MM-DD',
+      zippedArchive: true,
+      maxSize: '20m',
+      maxFiles: '14d',
+      level: 'error',
+    }),
+    new winston.transports.DailyRotateFile({
+      filename: 'logs/combined-%DATE%.log',
+      datePattern: 'YYYY-MM-DD',
+      zippedArchive: true,
+      maxSize: '20m',
+      maxFiles: '14d',
+    }),
+  ],
+});
+
+logger.add(new winston.transports.Console({
+  format: process.env.NODE_ENV !== 'production'
+    ? winston.format.simple()
+    : winston.format.json(),
+}));
+
+export default logger;