nodejs-quickstart-structure 1.19.0 → 1.19.1

package/templates/clean-architecture/ts/src/index.ts.ejs

@@ -1,140 +1,140 @@
-import { env } from '@/config/env';
-import express from 'express';
-import cors from 'cors';
-import helmet from 'helmet';
-import hpp from 'hpp';
-import rateLimit from 'express-rate-limit';
-import logger from '@/infrastructure/log/logger';
-import morgan from 'morgan';
-import { errorMiddleware } from '@/utils/errorMiddleware';
-import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
-import healthRoutes from '@/interfaces/routes/healthRoute';
-<% if (communication === 'REST APIs' || communication === 'Kafka') { -%>
-import userRoutes from '@/interfaces/routes/userRoutes';
-import swaggerUi from 'swagger-ui-express';
-import swaggerSpecs from '@/config/swagger';<% } %>
-<%_ if (communication === 'Kafka') { -%>import { kafkaService } from '@/infrastructure/messaging/kafkaClient';<%_ } -%>
-<%_ if (communication === 'GraphQL') { -%>
-import { ApolloServer } from '@apollo/server';
-import { expressMiddleware } from '@as-integrations/express4';
-import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
-import { unwrapResolverError } from '@apollo/server/errors';
-import { ApiError } from '@/errors/ApiError';
-import { typeDefs, resolvers } from '@/interfaces/graphql';
-import { gqlContext, MyContext } from '@/interfaces/graphql/context';
-<%_ } -%>
-
-const app = express();
-const port = env.PORT;
-
-// Security Middleware
-<%_ if (communication === 'GraphQL') { -%>
-app.use(helmet({
-  crossOriginEmbedderPolicy: false,
-  contentSecurityPolicy: {
-    directives: {
-      imgSrc: [`'self'`, 'data:', 'apollo-server-landing-page.cdn.apollographql.com'],
-      scriptSrc: [`'self'`, `https: 'unsafe-inline'`],
-      manifestSrc: [`'self'`, 'apollo-server-landing-page.cdn.apollographql.com'],
-      frameSrc: [`'self'`, 'sandbox.embed.apollographql.com'],
-    },
-  },
-}));
-<%_ } else { -%>
-app.use(helmet());
-<%_ } -%>
-app.use(hpp());
-app.use(cors({ origin: '*', methods: ['GET', 'POST', 'PUT', 'DELETE'] }));
-const limiter = rateLimit({ windowMs: 10 * 60 * 1000, max: 100 });
-app.use(limiter);
-
-app.use(express.json());
-app.use(morgan('combined', { stream: { write: (message) => logger.info(message.trim()) } }));
-
-<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
-app.use('/api/users', userRoutes);
-<%_ } -%>
-<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
-app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
-<%_ } -%>
-app.use('/health', healthRoutes);
-
-// Start Server Logic
-const startServer = async () => {
-<%_ if (communication === 'GraphQL') { -%>
-    // GraphQL Setup
-    const apolloServer = new ApolloServer<MyContext>({
-      typeDefs,
-      resolvers,
-      plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
-      formatError: (formattedError, error) => {
-        const originalError = unwrapResolverError(error);
-        if (originalError instanceof ApiError) {
-          return {
-            ...formattedError,
-            message: originalError.message,
-            extensions: {
-              ...formattedError.extensions,
-              code: originalError.statusCode.toString(),
-            }
-          };
-        }
-        
-        logger.error(`GraphQL Error: ${formattedError.message}`);
-        if (originalError instanceof Error && originalError.stack && process.env.NODE_ENV === 'development') {
-           logger.error(originalError.stack);
-        }
-        return formattedError;
-      },
-    });
-    await apolloServer.start();
-    app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
-<%_ } -%>
-    app.use(errorMiddleware);
-    const server = app.listen(port, () => {
-        logger.info(`Server running on port ${port}`);
-<%_ if (communication === 'Kafka') { -%>
-        kafkaService.connect()
-            .then(async () => {
-                logger.info('Kafka connected');
-            })
-            .catch(err => {
-                logger.error('Failed to connect to Kafka after retries:', (err as Error).message);
-            });
-<%_ } -%>
-    });
-
-    setupGracefulShutdown(server<% if(communication === 'Kafka') { %>, kafkaService<% } %>);
-};
-
-<%_ if (database !== 'None') { -%>
-// Database Sync
-<%_ if (database !== 'None') { -%>
-import <% if (database === 'MongoDB') { %>connectDB<% } else { %>sequelize<% } %> from '@/infrastructure/database/database';
-<%_ } -%>
-
-const syncDatabase = async () => {
-    let retries = 30;
-    while (retries) {
-        try {
-            <%_ if (database === 'MongoDB') { -%>
-            await connectDB();
-            <%_ } else { -%>
-            await sequelize.sync();
-            <%_ } -%>
-            logger.info('Database synced');
-            await startServer();
-            break;
-        } catch (error) {
-            logger.error('Error syncing database:', error);
-            retries -= 1;
-            logger.info(`Retries left: ${retries}`);
-            await new Promise(res => setTimeout(res, 5000));
-        }
-    }
-};
-
-syncDatabase();
-<%_ } else { -%>
-startServer();
+import { env } from '@/config/env';
+import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import hpp from 'hpp';
+import rateLimit from 'express-rate-limit';
+import logger from '@/infrastructure/log/logger';
+import morgan from 'morgan';
+import { errorMiddleware } from '@/utils/errorMiddleware';
+import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
+import healthRoutes from '@/interfaces/routes/healthRoute';
+<% if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+import userRoutes from '@/interfaces/routes/userRoutes';
+import swaggerUi from 'swagger-ui-express';
+import swaggerSpecs from '@/config/swagger';<% } %>
+<%_ if (communication === 'Kafka') { -%>import { kafkaService } from '@/infrastructure/messaging/kafkaClient';<%_ } -%>
+<%_ if (communication === 'GraphQL') { -%>
+import { ApolloServer } from '@apollo/server';
+import { expressMiddleware } from '@as-integrations/express4';
+import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
+import { unwrapResolverError } from '@apollo/server/errors';
+import { ApiError } from '@/errors/ApiError';
+import { typeDefs, resolvers } from '@/interfaces/graphql';
+import { gqlContext, MyContext } from '@/interfaces/graphql/context';
+<%_ } -%>
+
+const app = express();
+const port = env.PORT;
+
+// Security Middleware
+<%_ if (communication === 'GraphQL') { -%>
+app.use(helmet({
+  crossOriginEmbedderPolicy: false,
+  contentSecurityPolicy: {
+    directives: {
+      imgSrc: [`'self'`, 'data:', 'apollo-server-landing-page.cdn.apollographql.com'],
+      scriptSrc: [`'self'`, `https: 'unsafe-inline'`],
+      manifestSrc: [`'self'`, 'apollo-server-landing-page.cdn.apollographql.com'],
+      frameSrc: [`'self'`, 'sandbox.embed.apollographql.com'],
+    },
+  },
+}));
+<%_ } else { -%>
+app.use(helmet());
+<%_ } -%>
+app.use(hpp());
+app.use(cors({ origin: '*', methods: ['GET', 'POST', 'PUT', 'DELETE'] }));
+const limiter = rateLimit({ windowMs: 10 * 60 * 1000, max: 100 });
+app.use(limiter);
+
+app.use(express.json());
+app.use(morgan('combined', { stream: { write: (message) => logger.info(message.trim()) } }));
+
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+app.use('/api/users', userRoutes);
+<%_ } -%>
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
+<%_ } -%>
+app.use('/health', healthRoutes);
+
+// Start Server Logic
+const startServer = async () => {
+<%_ if (communication === 'GraphQL') { -%>
+    // GraphQL Setup
+    const apolloServer = new ApolloServer<MyContext>({
+      typeDefs,
+      resolvers,
+      plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
+      formatError: (formattedError, error) => {
+        const originalError = unwrapResolverError(error);
+        if (originalError instanceof ApiError) {
+          return {
+            ...formattedError,
+            message: originalError.message,
+            extensions: {
+              ...formattedError.extensions,
+              code: originalError.statusCode.toString(),
+            }
+          };
+        }
+        
+        logger.error(`GraphQL Error: ${formattedError.message}`);
+        if (originalError instanceof Error && originalError.stack && process.env.NODE_ENV === 'development') {
+           logger.error(originalError.stack);
+        }
+        return formattedError;
+      },
+    });
+    await apolloServer.start();
+    app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
+<%_ } -%>
+    app.use(errorMiddleware);
+    const server = app.listen(port, () => {
+        logger.info(`Server running on port ${port}`);
+<%_ if (communication === 'Kafka') { -%>
+        kafkaService.connect()
+            .then(async () => {
+                logger.info('Kafka connected');
+            })
+            .catch(err => {
+                logger.error('Failed to connect to Kafka after retries:', (err as Error).message);
+            });
+<%_ } -%>
+    });
+
+    setupGracefulShutdown(server<% if(communication === 'Kafka') { %>, kafkaService<% } %>);
+};
+
+<%_ if (database !== 'None') { -%>
+// Database Sync
+<%_ if (database !== 'None') { -%>
+import <% if (database === 'MongoDB') { %>connectDB<% } else { %>sequelize<% } %> from '@/infrastructure/database/database';
+<%_ } -%>
+
+const syncDatabase = async () => {
+    let retries = 30;
+    while (retries) {
+        try {
+            <%_ if (database === 'MongoDB') { -%>
+            await connectDB();
+            <%_ } else { -%>
+            await sequelize.sync();
+            <%_ } -%>
+            logger.info('Database synced');
+            await startServer();
+            break;
+        } catch (error) {
+            logger.error('Error syncing database:', error);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+
+syncDatabase();
+<%_ } else { -%>
+startServer();
 <%_ } -%>

package/templates/clean-architecture/ts/src/infrastructure/log/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/clean-architecture/ts/src/infrastructure/log/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;

package/templates/clean-architecture/ts/src/interfaces/graphql/context.spec.ts.ejs

@@ -1,32 +1,32 @@
-import { gqlContext } from '@/interfaces/graphql/context';
-import { Request } from 'express';
-import { resolvers } from '@/interfaces/graphql/resolvers';
-import { typeDefs } from '@/interfaces/graphql/typeDefs';
-
-jest.mock('@/infrastructure/repositories/UserRepository');
-
-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.token).toBe('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.token).toBe('');
-  });
-});
+import { gqlContext } from '@/interfaces/graphql/context';
+import { Request } from 'express';
+import { resolvers } from '@/interfaces/graphql/resolvers';
+import { typeDefs } from '@/interfaces/graphql/typeDefs';
+
+jest.mock('@/infrastructure/repositories/UserRepository');
+
+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.token).toBe('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.token).toBe('');
+  });
+});

package/templates/clean-architecture/ts/src/interfaces/graphql/context.ts.ejs

@@ -1,17 +1,17 @@
-import { Request } from 'express';
-import { UserRepository } from '@/infrastructure/repositories/UserRepository';
-
-export interface MyContext {
-  token?: string;
-  userRepository: UserRepository;
-}
-
-export const gqlContext = async ({ req }: { req: Request }): Promise<MyContext> => {
-  const token = req.headers.authorization || '';
-  const userRepository = new UserRepository();
-  
-  return { 
-    token, 
-    userRepository 
-  };
-};
+import { Request } from 'express';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+
+export interface MyContext {
+  token?: string;
+  userRepository: UserRepository;
+}
+
+export const gqlContext = async ({ req }: { req: Request }): Promise<MyContext> => {
+  const token = req.headers.authorization || '';
+  const userRepository = new UserRepository();
+  
+  return { 
+    token, 
+    userRepository 
+  };
+};

package/templates/clean-architecture/ts/src/interfaces/graphql/index.ts.ejs

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

package/templates/clean-architecture/ts/src/interfaces/graphql/resolvers/index.ts.ejs

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

package/templates/clean-architecture/ts/src/interfaces/graphql/typeDefs/index.ts.ejs

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