typescript-mock-server 1.10.0 → 1.11.0

package/README.md

@@ -6,7 +6,7 @@ have to update your mock, otherwise you will receive compile errors.
 # Quickstart
 The easiest way to check out this stub/mock server is by installing it as a (dev)dependency and then 
 add a script to you scripts section: `npm run --prefix node_modules/typescript-mock-server start -- --path=$INIT_CWD/tms-models`. 
-Your models should export a data const and your file should be named as `^(get|post){1}(-\d)?.ts$`. 
+Your models should export a data const (or a function receiving `req` and `res`) and your file should be named as `^(get|post){1}(-\d)?.ts$`. 
 Changes are being picked up automatically, so no need for a restart. When you add files, you have to restart.
 
 Check out the [working example project](https://github.com/GuyT07/typescript-mock-server-examle) and [the source](https://github.com/GuyT07/typescript-mock-server/tree/main/tms-models/users).
@@ -38,7 +38,7 @@ You should have the following structure:
 
 Within the model file you can import/create your model:
 
-```
+```typescript
 export interface User {
     id: number;
     firstName: string;
@@ -48,6 +48,7 @@ export interface User {
 
 const newDate = () => new Date();
 
+// You can export a static object
 export const data: User[] = [{
     id: 1,
     firstName: 'Guy',
@@ -60,6 +61,12 @@ export const data: User[] = [{
     creationDate:  newDate()
 }];
 
+// OR you can export a function to access request/response context
+export const data = (req: Request, res: Response): User[] => {
+   console.log(req.query);
+   return [{ id: 1, firstName: 'Dynamic', lastName: 'User', creationDate: new Date() }];
+}
+
 export const config: RequestConfig = {
     delay: 2000, // or you can use an interval like {min: 2000, max: 5000}
     statusCode: 418
@@ -80,17 +87,20 @@ Following dependencies are being used:
 - [x] Improve paths/way to start
 - [x] Support different headers/configurations (delays, status codes, ...)
 - [x] Support most used HTTP methods
-- [ ] Add tests
+- [x] Add tests
 - [x] Refactor, split up in separate classes (first check if people actually want to use the tool)
 - [ ] Setup CI/CD (+code quality + coverage tooling)
 - [ ] Setup website
 - [ ] Create a JVM compatible version
 - [x] Create interface to force implementation of required properties and make it more stable
 - [x] Improve error handling (missing properties etc.)
+- [x] Support dynamic responses via request/response context
 - [ ] Create an optional persistent state
 
 
 ## Release notes (will be moved to GitHub in the future)
+- v1.11.0 - Support dynamic responses via request/response context, added comprehensive tests, and switched to a faster build-and-serve workflow
+- v1.10.0 - Improved path resolution and library usage support
 - v1.0.8 - Minor bugfixes
 - v1.0.7 - Minor bugfixes
 - v1.0.6 - Bugfix: accidentally included "npm" and "install" dependency, removed again

package/jest.config.js

@@ -0,0 +1,12 @@
+const { createDefaultPreset } = require("ts-jest");
+
+const tsJestTransformCfg = createDefaultPreset().transform;
+
+/** @type {import("jest").Config} **/
+module.exports = {
+  testEnvironment: "node",
+  testPathIgnorePatterns: ["/node_modules/", "/dist/"],
+  transform: {
+    ...tsJestTransformCfg,
+  },
+};

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "typescript-mock-server",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Simple mock server that can be used in front end development. Instead of creating json files you can just publish TypeScript objects as json",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "example": "ts-node-dev src/index.ts --path=$INIT_CWD/tms-models --port=5200 --cors=http://localhost:5200",
-    "start": "ts-node-dev src/index.ts",
+    "test": "jest",
+    "build": "tsc --outDir dist",
+    "example": "npm run build && node dist/src/index.js --path=tms-models --port=5200 --cors=http://localhost:5200",
+    "start": "npm run build && node dist/src/index.js",
     "update-deps": "npm update",
     "get-version": "echo $npm_package_version",
     "publish-to-npm": "git tag -a ${npm_package_version} -m \"v${npm_package_version}\" && git push origin ${npm_package_version} && npm publish"

package/src/impl/typescript-mock-server-impl.ts

@@ -9,7 +9,8 @@ import { opendir } from 'fs/promises';
 import { LoggerImpl } from './logger-impl';
 import { Logger } from '../logger';
 import { TypescriptMockServer } from '../typescript-mock-server';
-import { Interval } from '../models/config';
+import { Interval, MockModel, ServerConfig } from '../models/config';
+import path from 'path';
 
 export class TypescriptMockServerImpl implements TypescriptMockServer{
 
@@ -19,12 +20,21 @@ export class TypescriptMockServerImpl implements TypescriptMockServer{
   private readonly basePath;
   private registeredEndpoints: RegisteredEndpoint[] = [];
 
-  constructor() {
-    this.app = express();
-    this.basePath = this.getPath();
+  constructor(config?: ServerConfig | Express) {
+    if (config && 'use' in (config as any)) {
+      this.app = config as Express;
+      this.basePath = this.getPath();
+    } else {
+      const serverConfig = config as ServerConfig;
+      this.app = serverConfig?.app || express();
+      this.basePath = this.getPath(serverConfig?.path);
+    }
   }
 
   private static async loadModule(moduleName: string) {
+    if (moduleName.endsWith('.ts')) {
+      require('ts-node').register({ transpileOnly: true });
+    }
     return await import(moduleName);
   }
 
@@ -36,43 +46,55 @@ export class TypescriptMockServerImpl implements TypescriptMockServer{
     };
 
     this.app.use(cors(corsSetting))
+    // add started endpoint
+    this.addEndpoint('state', 'get', { data: { status: 'started' } });
+    
     await this.readRoutes(this.basePath).catch(error => this.log.error(error));
     this.app.listen(port, () => {
       this.log.info(`App is listening on port ${port}!`);
     });
 
-    // add started endpoint
-    this.addEndpoint('state', 'get', { data: "{\"status\": \"started\"}" });
-    this.log.info(`Started mock server on port ${this.commandLine.getCommand(Command.PORT)}`);
+    this.log.info(`Started mock server on port ${port}`);
   }
 
-  private async readRoutes(path: string) {
-    const dir = await opendir(path);
+  private async readRoutes(dirPath: string) {
+    const dir = await opendir(dirPath);
     for await (const dirent of dir) {
       if (dirent.isDirectory()) {
-        await this.readRoutes(`${path}/${dirent.name}`);
+        await this.readRoutes(`${dirPath}/${dirent.name}`);
       } else {
-        this.handleFile(path, dirent);
+        await this.handleFile(dirPath, dirent);
       }
     }
-    this.registeredEndpoints.forEach(endpoint => this.log.info(`${endpoint.httpVerb.toUpperCase()}   http://localhost:${this.commandLine.getCommand(Command.PORT)}${endpoint.endpoint}`));
+    const port = this.commandLine.getCommand(Command.PORT) || 3000;
+    this.registeredEndpoints.forEach(endpoint => this.log.info(`${endpoint.httpVerb.toUpperCase()}   http://localhost:${port}${endpoint.endpoint}`));
     this.registeredEndpoints = [];
   }
 
-  private handleFile(path: string, dirent: Dirent) {
+  private async handleFile(dirPath: string, dirent: Dirent) {
     const httpVerb = (dirent.name.indexOf('-') > -1 ? dirent.name.split('-')[0] : dirent.name.split('.')[0]) as HttpVerb;
-    this.handleRequest(path, dirent, httpVerb);
+    await this.handleRequest(dirPath, dirent, httpVerb);
   }
 
-  private addEndpoint(endpoint: string, httpVerb: HttpVerb, model: any) {
-    this.app[httpVerb](endpoint, (req, res) => {
-      if (model?.config?.statusCode) {
-        res.statusCode = model?.config?.statusCode;
+  private addEndpoint(endpoint: string, httpVerb: HttpVerb, model: MockModel) {
+    const route = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+    this.app[httpVerb](route, (req: any, res: any) => {
+      let responseData = model.data;
+      let statusCode = model?.config?.statusCode;
+      let delay = model?.config?.delay;
+
+      if (typeof model.data === 'function') {
+        responseData = model.data(req, res);
+      }
+
+      if (statusCode) {
+        res.statusCode = statusCode;
       }
-      if (model?.config?.delay) {
-        setTimeout(() => res.send(model.data), this.getDelayValue(model?.config?.delay));
+
+      if (delay) {
+        setTimeout(() => res.send(responseData), this.getDelayValue(delay));
       } else {
-        return res.send(model.data);
+        return res.send(responseData);
       }
     });
   }
@@ -86,17 +108,30 @@ export class TypescriptMockServerImpl implements TypescriptMockServer{
     return 0;
   }
 
-  private handleRequest(path: string, dirent: Dirent, httpVerb: HttpVerb) {
-    const endpoint = this.convertFileNameToEndpoint(path, dirent, httpVerb);
-    const modulePath = `${path}/${dirent.name}`;
+  private async handleRequest(dirPath: string, dirent: Dirent, httpVerb: HttpVerb) {
+    const endpoint = this.convertFileNameToEndpoint(dirPath, dirent, httpVerb);
+    let modulePath = `${dirPath}/${dirent.name}`;
     this.registeredEndpoints.push({ httpVerb, endpoint });
-    TypescriptMockServerImpl.loadModule(modulePath)
+
+    if (__filename.endsWith('.js') && modulePath.endsWith('.ts')) {
+      const distPath = path.join(process.cwd(), 'dist');
+      const potentialJsPath = modulePath
+        .replace(process.cwd(), distPath)
+        .replace(/\.ts$/, '.js');
+
+      const fs = require('fs');
+      if (fs.existsSync(potentialJsPath)) {
+        modulePath = potentialJsPath;
+      }
+    }
+
+    await TypescriptMockServerImpl.loadModule(modulePath)
       .then(model => this.addEndpoint(endpoint, httpVerb, model))
       .catch(error => this.log.error(error));
   }
 
-  private convertFileNameToEndpoint(path: string, dirent: Dirent, httpVerb: HttpVerb): string {
-    const endpoint = `${path.replace(this.basePath, '')}/${dirent.name}`
+  private convertFileNameToEndpoint(dirPath: string, dirent: Dirent, httpVerb: HttpVerb): string {
+    const endpoint = `${dirPath.replace(this.basePath, '')}/${dirent.name}`
       .replace('.ts', '')
       .replace(`${httpVerb}-`, '')
       .replace(httpVerb, '');
@@ -107,11 +142,17 @@ export class TypescriptMockServerImpl implements TypescriptMockServer{
     return endpoint;
   }
 
-  private getPath(): string {
+  private getPath(defaultPath: string = 'tms-models'): string {
+    let definedPath = defaultPath;
     if (!this.commandLine.getCommands().has(Command.PATH)) {
-      this.log.warn(`Path parameter not set, fallback to default tms-models`);
-      return 'tms-models';
+      this.log.warn(`Path parameter not set, fallback to default ${defaultPath}`);
+    } else {
+      definedPath = this.commandLine.getCommand(Command.PATH)!!;
+    }
+
+    if (path.isAbsolute(definedPath)) {
+      return definedPath;
     }
-    return this.commandLine.getCommand(Command.PATH)!!;
+    return path.join(process.cwd(), definedPath);
   }
 }

package/src/models/config.ts

@@ -7,7 +7,17 @@ export interface RequestConfig {
   statusCode?: number; // Status code of response
 }
 
+export interface MockModel {
+  data: any | ((req: any, res: any) => any);
+  config?: RequestConfig;
+}
+
 export interface Interval {
   min: number; // Minimum boundary, including the value
   max: number; // Maximum boundary, including the value
 }
+
+export interface ServerConfig {
+  app?: any; // Express app instance
+  path?: string; // Path to models folder
+}

package/test/impl/command-line-impl.spec.ts

@@ -0,0 +1,49 @@
+import { CommandLineImpl } from '../../src/impl/command-line-impl';
+import { Command } from '../../src/command-line';
+
+describe('CommandLineImpl', () => {
+  const originalArgv = process.argv;
+
+  beforeEach(() => {
+    jest.resetModules();
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+  });
+
+  it('should parse command line arguments correctly', () => {
+    process.argv = ['node', 'index.js', '--port=4000', '--path=./test-models', '--cors=http://localhost:3000'];
+    const commandLine = new CommandLineImpl();
+
+    expect(commandLine.getCommand(Command.PORT)).toBe('4000');
+    expect(commandLine.getCommand(Command.PATH)).toBe('./test-models');
+    expect(commandLine.getCommand(Command.CORS)).toBe('http://localhost:3000');
+  });
+
+  it('should handle arguments with quotes', () => {
+    process.argv = ['node', 'index.js', '--path="C:/Program Files/Models"', "--cors='*'", '--port=5000'];
+    const commandLine = new CommandLineImpl();
+
+    expect(commandLine.getCommand(Command.PATH)).toBe('C:/Program Files/Models');
+    expect(commandLine.getCommand(Command.CORS)).toBe('*');
+    expect(commandLine.getCommand(Command.PORT)).toBe('5000');
+  });
+
+  it('should return undefined for missing commands', () => {
+    process.argv = ['node', 'index.js'];
+    const commandLine = new CommandLineImpl();
+
+    expect(commandLine.getCommand(Command.PORT)).toBeUndefined();
+  });
+
+  it('should return all commands', () => {
+    process.argv = ['node', 'index.js', '--port=4000', '--path=./models'];
+    const commandLine = new CommandLineImpl();
+    const commands = commandLine.getCommands();
+
+    expect(commands.size).toBe(2);
+    expect(commands.get(Command.PORT)).toBe('4000');
+    expect(commands.get(Command.PATH)).toBe('./models');
+  });
+});

package/test/impl/typescript-mock-server-impl.spec.ts

@@ -0,0 +1,181 @@
+import request from 'supertest';
+import express, { Express } from 'express';
+import { TypescriptMockServerImpl } from '../../src/impl/typescript-mock-server-impl';
+import * as fsPromises from 'fs/promises';
+import { Command } from '../../src/command-line';
+import path from 'path';
+
+jest.mock('fs/promises');
+
+describe('TypescriptMockServerImpl', () => {
+  let server: TypescriptMockServerImpl;
+  let app: Express;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    app = express();
+    // Spy on listen to prevent it from actually starting
+    jest.spyOn(app, 'listen').mockImplementation((port: any, callback: any) => {
+      if (callback) callback();
+      return {} as any;
+    });
+    // Reset process.argv
+    process.argv = ['node', 'index.js'];
+  });
+
+  it('should start and have the state endpoint', async () => {
+    (fsPromises.opendir as jest.Mock).mockResolvedValue(async function* () {
+       // yield nothing
+    }());
+
+    server = new TypescriptMockServerImpl(app);
+    await server.start();
+
+    const response = await request(app).get('/state');
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({ status: 'started' });
+  });
+
+  it('should have the state endpoint even if other routes are loaded', async () => {
+    (fsPromises.opendir as jest.Mock).mockResolvedValue(async function* () {
+       // yield nothing
+    }());
+
+    server = new TypescriptMockServerImpl(app);
+    await server.start();
+
+    const response = await request(app).get('/state');
+    expect(response.status).toBe(200);
+  });
+
+  it('should load routes from directory', async () => {
+    const mockFiles = [
+      { name: 'get-test.ts', isDirectory: () => false },
+      { name: 'post-data.ts', isDirectory: () => false }
+    ];
+
+    (fsPromises.opendir as jest.Mock).mockResolvedValue(async function* () {
+      for (const file of mockFiles) {
+        yield file;
+      }
+    }());
+
+    // Mock loadModule
+    const loadModuleSpy = jest.spyOn(TypescriptMockServerImpl as any, 'loadModule');
+    loadModuleSpy.mockImplementation(async (...args: any[]) => {
+      const path = args[0] as string;
+      if (path.includes('get-test')) {
+        return { data: { message: 'get success' } };
+      }
+      if (path.includes('post-data')) {
+        return { data: { message: 'post success' } };
+      }
+      return {};
+    });
+
+    server = new TypescriptMockServerImpl(app);
+    await server.start();
+
+    const getResponse = await request(app).get('/test');
+    expect(getResponse.status).toBe(200);
+    expect(getResponse.body).toEqual({ message: 'get success' });
+
+    const postResponse = await request(app).post('/data');
+    expect(postResponse.status).toBe(200);
+    expect(postResponse.body).toEqual({ message: 'post success' });
+  });
+
+  it('should handle status codes and delay from config', async () => {
+    const mockFiles = [
+      { name: 'get-config.ts', isDirectory: () => false }
+    ];
+
+    (fsPromises.opendir as jest.Mock).mockResolvedValue(async function* () {
+      yield mockFiles[0];
+    }());
+
+    const loadModuleSpy = jest.spyOn(TypescriptMockServerImpl as any, 'loadModule');
+    loadModuleSpy.mockImplementation(async () => {
+      return { 
+        data: { message: 'custom' },
+        config: { statusCode: 201, delay: 10 }
+      } as any;
+    });
+
+    server = new TypescriptMockServerImpl(app);
+    await server.start();
+
+    const response = await request(app).get('/config');
+    expect(response.status).toBe(201);
+    expect(response.body).toEqual({ message: 'custom' });
+  });
+
+  it('should resolve absolute paths correctly', async () => {
+    (fsPromises.opendir as jest.Mock).mockResolvedValue(async function* () {
+       // yield nothing
+    }());
+
+    const absolutePath = path.resolve('/absolute/path/to/models');
+    process.argv = ['node', 'index.js', `--path=${absolutePath}`];
+
+    server = new TypescriptMockServerImpl(app);
+    // @ts-ignore
+    expect(server.basePath).toBe(absolutePath);
+  });
+
+  it('should resolve relative paths from process.cwd()', async () => {
+    (fsPromises.opendir as jest.Mock).mockResolvedValue(async function* () {
+       // yield nothing
+    }());
+
+    const relativePath = 'custom-models';
+    process.argv = ['node', 'index.js', `--path=${relativePath}`];
+
+    server = new TypescriptMockServerImpl(app);
+    // @ts-ignore
+    expect(server.basePath).toBe(path.join(process.cwd(), relativePath));
+  });
+
+  it('should use custom default path from config', async () => {
+    (fsPromises.opendir as jest.Mock).mockResolvedValue(async function* () {
+      // yield nothing
+    }());
+
+    const customDefault = 'my-custom-models';
+    server = new TypescriptMockServerImpl({ path: customDefault, app });
+    // @ts-ignore
+    expect(server.basePath).toBe(path.join(process.cwd(), customDefault));
+  });
+
+  it('should support dynamic data as a function receiving req and res', async () => {
+    const mockFiles = [
+      { name: 'get-dynamic.ts', isDirectory: () => false }
+    ];
+
+    (fsPromises.opendir as jest.Mock).mockResolvedValue(async function* () {
+      yield mockFiles[0];
+    }());
+
+    const loadModuleSpy = jest.spyOn(TypescriptMockServerImpl as any, 'loadModule');
+    loadModuleSpy.mockImplementation(async () => {
+      return {
+        data: (req: any, res: any) => {
+          return {
+            query: req.query.q,
+            method: req.method
+          };
+        }
+      };
+    });
+
+    server = new TypescriptMockServerImpl(app);
+    await server.start();
+
+    const response = await request(app).get('/dynamic?q=test');
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      query: 'test',
+      method: 'GET'
+    });
+  });
+});

package/tms-models/users/get-dynamic.ts

@@ -0,0 +1,22 @@
+import { Request, Response } from 'express';
+import { MockModel, RequestConfig } from '../../src/models/config';
+
+export interface User {
+    id: number;
+    username: string;
+    email: string;
+}
+
+export const data = (req: Request, res: Response): User => {
+    const userId = req.query.id ? parseInt(req.query.id as string) : 1;
+    
+    return {
+        id: userId,
+        username: `user_${userId}`,
+        email: `user_${userId}@example.com`
+    };
+};
+
+export const config: RequestConfig = {
+    statusCode: 200
+};

package/tsconfig.json

@@ -15,7 +15,11 @@
 
     "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
   },
+  "include": [
+    "src/**/*"
+  ],
   "exclude": [
-    "node_modules"
+    "node_modules",
+    "test"
   ]
 }