nodejs-quickstart-structure 1.18.1 → 1.19.1

package/templates/clean-architecture/js/src/usecases/UpdateUser.spec.js.ejs

@@ -0,0 +1,48 @@
+const UpdateUser = require('@/usecases/UpdateUser');
+const UserRepository = require('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
+<%_ } -%>
+
+jest.mock('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } -%>
+
+describe('UpdateUser UseCase', () => {
+    let updateUser;
+    let mockUserRepository;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository();
+        updateUser = new UpdateUser(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should update and return the user', async () => {
+        const id = 1;
+        const data = { name: 'Updated Name' };
+        const expectedUser = { id, name: 'Updated Name', email: 'test@test.com' };
+
+        mockUserRepository.update.mockResolvedValue(expectedUser);
+
+        const result = await updateUser.execute(id, data);
+
+        expect(mockUserRepository.update).toHaveBeenCalledWith(id, data);
+        expect(result).toEqual(expectedUser);
+<%_ if (caching !== 'None') { -%>
+        expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } %>
+    });
+
+    it('should throw an error if repository fails', async () => {
+        const error = new Error('Database error');
+        mockUserRepository.update.mockRejectedValue(error);
+
+        await expect(updateUser.execute(1, { name: 'Test' })).rejects.toThrow(error);
+    });
+});

package/templates/clean-architecture/js/src/utils/errorMessages.js

@@ -0,0 +1,14 @@
+const ERROR_MESSAGES = {
+    USER_NOT_FOUND: 'User not found',
+    RESOURCE_NOT_FOUND: 'Resource not found',
+    INVALID_USER_DATA: 'Invalid user event data',
+    INTERNAL_SERVER_ERROR: 'Internal Server Error',
+    BAD_REQUEST: 'Bad Request',
+    FETCH_USERS_ERROR: 'Error fetching users',
+    CREATE_USER_ERROR: 'Error creating user',
+    UPDATE_USER_ERROR: 'Error updating user',
+    DELETE_USER_ERROR: 'Error deleting user',
+    DATABASE_PING_FAILED: 'Health Check Database Ping Failed',
+};
+
+module.exports = ERROR_MESSAGES;

package/templates/clean-architecture/js/src/utils/httpCodes.js

@@ -1,9 +1,9 @@
-const HTTP_STATUS = {
-    OK: 200,
-    CREATED: 201,
-    BAD_REQUEST: 400,
-    NOT_FOUND: 404,
-    INTERNAL_SERVER_ERROR: 500
-};
-
-module.exports = HTTP_STATUS;
+const HTTP_STATUS = {
+    OK: 200,
+    CREATED: 201,
+    BAD_REQUEST: 400,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500
+};
+
+module.exports = HTTP_STATUS;

package/templates/clean-architecture/ts/src/config/env.ts.ejs

@@ -1,46 +1,46 @@
-import dotenv from 'dotenv';
-import { z } from 'zod';
-import logger from '@/infrastructure/log/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 '@/infrastructure/log/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/clean-architecture/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/clean-architecture/ts/src/domain/user.ts

@@ -1,7 +1,7 @@
-export class User {
-    constructor(
-        public id: number | string | null,
-        public name: string,
-        public email: string
-    ) { }
-}
+export class User {
+    constructor(
+        public id: number | string | null,
+        public name: string,
+        public email: string
+    ) { }
+}

package/templates/clean-architecture/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/clean-architecture/ts/src/errors/BadRequestError.spec.ts.ejs

@@ -1,21 +1,22 @@
-import { BadRequestError } from '@/errors/BadRequestError';
-import { ApiError } from '@/errors/ApiError';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-
-describe('BadRequestError', () => {
-    it('should extend ApiError', () => {
-        const error = new BadRequestError();
-        expect(error).toBeInstanceOf(ApiError);
-    });
-
-    it('should have default message "Bad request"', () => {
-        const error = new BadRequestError();
-        expect(error.message).toBe('Bad request');
-        expect(error.statusCode).toBe(HTTP_STATUS.BAD_REQUEST);
-    });
-
-    it('should accept a custom message', () => {
-        const error = new BadRequestError('Custom bad request');
-        expect(error.message).toBe('Custom bad request');
-    });
-});
+import { BadRequestError } from '@/errors/BadRequestError';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+
+describe('BadRequestError', () => {
+    it('should extend ApiError', () => {
+        const error = new BadRequestError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Bad Request"', () => {
+        const error = new BadRequestError();
+        expect(error.message).toBe(ERROR_MESSAGES.BAD_REQUEST);
+        expect(error.statusCode).toBe(HTTP_STATUS.BAD_REQUEST);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new BadRequestError('Custom bad request');
+        expect(error.message).toBe('Custom bad request');
+    });
+});

package/templates/clean-architecture/ts/src/errors/BadRequestError.ts

@@ -1,8 +1,9 @@
-import { ApiError } from '@/errors/ApiError';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-
-export class BadRequestError extends ApiError {
-  constructor(message = 'Bad request') {
-    super(HTTP_STATUS.BAD_REQUEST, message);
-  }
-}
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+
+export class BadRequestError extends ApiError {
+  constructor(message: string = ERROR_MESSAGES.BAD_REQUEST) {
+    super(HTTP_STATUS.BAD_REQUEST, message);
+  }
+}

package/templates/clean-architecture/ts/src/errors/NotFoundError.spec.ts.ejs

@@ -1,21 +1,22 @@
-import { NotFoundError } from '@/errors/NotFoundError';
-import { ApiError } from '@/errors/ApiError';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-
-describe('NotFoundError', () => {
-    it('should extend ApiError', () => {
-        const error = new NotFoundError();
-        expect(error).toBeInstanceOf(ApiError);
-    });
-
-    it('should have default message "Resource not found"', () => {
-        const error = new NotFoundError();
-        expect(error.message).toBe('Resource not found');
-        expect(error.statusCode).toBe(HTTP_STATUS.NOT_FOUND);
-    });
-
-    it('should accept a custom message', () => {
-        const error = new NotFoundError('User not found');
-        expect(error.message).toBe('User not found');
-    });
-});
+import { NotFoundError } from '@/errors/NotFoundError';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+
+describe('NotFoundError', () => {
+    it('should extend ApiError', () => {
+        const error = new NotFoundError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Resource not found"', () => {
+        const error = new NotFoundError();
+        expect(error.message).toBe(ERROR_MESSAGES.RESOURCE_NOT_FOUND);
+        expect(error.statusCode).toBe(HTTP_STATUS.NOT_FOUND);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new NotFoundError(ERROR_MESSAGES.USER_NOT_FOUND);
+        expect(error.message).toBe(ERROR_MESSAGES.USER_NOT_FOUND);
+    });
+});

package/templates/clean-architecture/ts/src/errors/NotFoundError.ts

@@ -1,8 +1,9 @@
-import { ApiError } from '@/errors/ApiError';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-
-export class NotFoundError extends ApiError {
-  constructor(message = 'Resource not found') {
-    super(HTTP_STATUS.NOT_FOUND, message);
-  }
-}
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+
+export class NotFoundError extends ApiError {
+  constructor(message: string = ERROR_MESSAGES.RESOURCE_NOT_FOUND) {
+    super(HTTP_STATUS.NOT_FOUND, message);
+  }
+}

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();
 <%_ } -%>