typescript-mock-server 0.0.11 → 0.0.12

package/package.json

@@ -1,35 +1,43 @@
 {
   "name": "typescript-mock-server",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "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=tms-models --port=5000",
-    "start": "ts-node-dev src/index.ts"
+    "start": "ts-node-dev src/index.ts",
+    "update-deps": "npm update",
+    "publish-to-npm": "npm publish"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/GuyT07/typescript-mock-server.git"
   },
-  "keywords": ["mock server", "testing", "stub", "typescript"],
+  "keywords": [
+    "mock server",
+    "testing",
+    "stub",
+    "typescript"
+  ],
   "author": "Guy Theuws",
   "license": "ISC",
   "bugs": {
     "url": "https://github.com/GuyT07/typescript-mock-server/issues"
   },
-  "homepage": "https://github.com/GuyT07/typescript-mock-server#readme",
+  "homepage": "https://genydev.nl",
   "funding": {
-    "url" : "https://genydev.nl"
+    "url": "https://genydev.nl"
   },
   "devDependencies": {
     "prettier": "^2.6.2"
   },
   "dependencies": {
+    "@types/express": "^4.17.9",
+    "@types/node": "^14.18.12",
     "express": "^4.17.3",
     "ts-node-dev": "^1.1.8",
-    "typescript": "^4.0.5",
-    "@types/express": "^4.17.9",
-    "@types/node": "^14.18.12"
+    "tslog": "^3.3.3",
+    "typescript": "^4.0.5"
   },
   "prettier": {
     "arrowParens": "avoid",

package/src/command-line.ts

@@ -0,0 +1,10 @@
+export interface CommandLine {
+  getCommands(): Map<Command, string>;
+
+  getCommand(command: Command): string | undefined;
+}
+
+export enum Command {
+  PATH = 'path',
+  PORT = 'port'
+}

package/src/impl/command-line-impl.ts

@@ -0,0 +1,33 @@
+import { Command, CommandLine } from '../command-line';
+import { Logger } from '../logger';
+import { LoggerImpl } from './logger-impl';
+
+export class CommandLineImpl implements CommandLine {
+
+  private arguments: Map<Command, string> = new Map<Command, string>();
+  private log: Logger = new LoggerImpl();
+
+  constructor() {
+    this.parseCommandLineArguments();
+  }
+
+  getCommands(): Map<Command, string> {
+    return this.arguments;
+  }
+
+  getCommand(command: Command): string | undefined {
+    return this.arguments.get(command);
+  }
+
+  private parseCommandLineArguments(): void {
+    process.argv.slice(2).map((element) => {
+      const matches = element.match('--([a-zA-Z0-9]+)=(.*)');
+      if (matches) {
+        const value = matches[2].replace(/^['"]/, '').replace(/['"]$/, '');
+        this.arguments.set(matches[1] as Command, value);
+      }
+    });
+
+    this.log.debug(`Passed arguments ${[...this.arguments.keys()].join(',')}`);
+  }
+}

package/src/impl/logger-impl.ts

@@ -0,0 +1,39 @@
+import { Logger as LoggerInterface } from '../logger';
+import { Logger } from 'tslog';
+
+export class LoggerImpl implements LoggerInterface {
+
+  private readonly log: Logger;
+
+  constructor() {
+    this.log = new Logger({ignoreStackLevels: 4, displayFunctionName: false});
+  }
+
+  private static getArgumentsToPass(args: unknown[]): unknown | unknown[] {
+    return LoggerImpl.getNumberOfArguments(args) === 1 ? args[0] : args;
+  }
+
+  private static getNumberOfArguments(args: unknown[]): number {
+    return args.length;
+  }
+
+  debug(...args: unknown[]): void {
+    this.log.debug(LoggerImpl.getArgumentsToPass(args));
+  }
+
+  error(...args: unknown[]): void {
+    this.log.error(LoggerImpl.getArgumentsToPass(args));
+  }
+
+  trace(...args: unknown[]): void {
+    this.log.trace(LoggerImpl.getArgumentsToPass(args));
+  }
+
+  warn(...args: unknown[]): void {
+    this.log.warn(LoggerImpl.getArgumentsToPass(args));
+  }
+
+  info(...args: unknown[]): void {
+    this.log.info(LoggerImpl.getArgumentsToPass(args));
+  }
+}

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

@@ -0,0 +1,86 @@
+import express, { Express } from 'express';
+import { CommandLineImpl } from './command-line-impl';
+import { Command, CommandLine } from '../command-line';
+import { RegisteredEndpoint } from '../models/registered-endpoint';
+import { HttpVerb } from '../types/http-verbs';
+import { Dirent } from 'fs';
+import { opendir } from 'fs/promises';
+import { LoggerImpl } from './logger-impl';
+import { Logger } from '../logger';
+import { TypescriptMockServer } from '../typescript-mock-server';
+
+export class TypescriptMockServerImpl implements TypescriptMockServer{
+
+  private readonly log: Logger = new LoggerImpl();
+  private readonly commandLine: CommandLine = new CommandLineImpl();
+  private readonly app: Express;
+  private readonly basePath;
+  private registeredEndpoints: RegisteredEndpoint[] = [];
+
+  constructor() {
+    this.app = express();
+    this.basePath = this.getPath();
+  }
+
+  private static async loadModule(moduleName: string) {
+    return await import(moduleName);
+  }
+
+  public start() {
+    this.log.info(`basePath: ${this.basePath}`);
+    this.readRoutes(this.basePath).catch(error => this.log.error(error));
+    const port = this.commandLine.getCommand(Command.PORT) || 3000;
+    this.app.listen(port, () => {
+      this.log.info(`App is listening on port ${port}!`);
+    });
+  }
+
+  private async readRoutes(path: string) {
+    const dir = await opendir(path);
+    for await (const dirent of dir) {
+      if (dirent.isDirectory()) {
+        await this.readRoutes(`${path}/${dirent.name}`);
+      } else {
+        this.handleFile(path, dirent);
+      }
+    }
+    this.registeredEndpoints.forEach(endpoint => this.log.info(`${endpoint.httpVerb.toUpperCase()}   http://localhost:${this.commandLine.getCommand(Command.PORT)}${endpoint.endpoint}`));
+  }
+
+  private handleFile(path: string, dirent: Dirent) {
+    const httpVerb = (dirent.name.indexOf('-') > -1 ? dirent.name.split('-')[0] : dirent.name.split('.')[0]) as HttpVerb;
+    this.handleRequest(path, dirent, httpVerb);
+  }
+
+  private addEndpoint(endpoint: string, httpVerb: HttpVerb, model: any) {
+    this.app[httpVerb](endpoint, (req, res) => res.send(model.data));
+  }
+
+  private handleRequest(path: string, dirent: Dirent, httpVerb: HttpVerb) {
+    const endpoint = this.convertFileNameToEndpoint(path, dirent, httpVerb);
+    const modulePath = `${path}/${dirent.name}`;
+    this.registeredEndpoints.push({ httpVerb, endpoint });
+    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}`
+      .replace('.ts', '')
+      .replace(httpVerb, '')
+      .replace('-', '');
+    if (endpoint.endsWith('/')) {
+      return endpoint.substring(0, endpoint.length - 1);
+    }
+    return endpoint;
+  }
+
+  private getPath(): string {
+    if (!this.commandLine.getCommands().has(Command.PATH)) {
+      this.log.warn(`Path parameter not set, fallback to default tms-models`);
+      return 'tms-models';
+    }
+    return `${process.cwd()}/${this.commandLine.getCommand(Command.PATH)}`;
+  }
+}

package/src/index.ts

@@ -1,88 +1,8 @@
 #!./node_modules/.bin/ts-node-dev
 
-import express, { Express } from 'express';
-import * as fs from 'fs';
+import { TypescriptMockServer } from './typescript-mock-server';
+import { TypescriptMockServerImpl } from './impl/typescript-mock-server-impl';
 
-type HttpVerb = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+const server: TypescriptMockServer = new TypescriptMockServerImpl();
 
-const argv: { [key: string]: string } = (() => {
-  const args = {};
-  process.argv.slice(2).map((element) => {
-    const matches = element.match('--([a-zA-Z0-9]+)=(.*)');
-    if (matches) {
-      // @ts-ignore
-      args[matches[1]] = matches[2]
-        .replace(/^['"]/, '').replace(/['"]$/, '');
-    }
-  });
-  return args;
-})();
-
-console.log(`Passed arguments %o`, argv);
-
-// Create a new express app instance
-const app: Express = express();
-
-const { path, port } = argv;
-
-const basePath = `${process.cwd()}/${path}`;
-
-interface RegisteredEndpoint {
-  httpVerb: string;
-  endpoint: string;
-}
-
-const registeredEndpoints: RegisteredEndpoint[] = [];
-
-console.log('basePath:' + basePath);
-
-async function readRoutes(path: string) {
-  const dir = await fs.promises.opendir(path);
-  for await (const dirent of dir) {
-    if (dirent.isDirectory()) {
-      await readRoutes(`${path}/${dirent.name}`);
-    } else {
-      handleFile(path, dirent);
-    }
-  }
-  registeredEndpoints.forEach(endpoint => console.log(`${endpoint.httpVerb.toUpperCase()}   http://localhost:${port}${endpoint.endpoint}`))
-}
-
-readRoutes(basePath).catch(console.error);
-
-app.listen(port || 3000, function() {
-  console.log(`App is listening on port ${port || 3000}!`);
-});
-
-async function loadModule(moduleName: string) {
-  return await import(moduleName);
-}
-
-function handleFile(path: string, dirent: fs.Dirent) {
-  const httpVerb = (dirent.name.indexOf('-') > -1 ? dirent.name.split('-')[0] : dirent.name.split('.')[0]) as HttpVerb;
-  handleRequest(path, dirent, httpVerb);
-}
-
-function addEndpoint(endpoint: string, httpVerb: HttpVerb, model: any) {
-  app[httpVerb](endpoint, (req, res) => res.send(model.data));
-}
-
-function handleRequest(path: string, dirent: fs.Dirent, httpVerb: HttpVerb) {
-  const endpoint = convertFileNameToEndpoint(path, dirent, httpVerb);
-  const modulePath = `${path}/${dirent.name}`;
-  registeredEndpoints.push({httpVerb, endpoint});
-  loadModule(modulePath)
-    .then(model => addEndpoint(endpoint, httpVerb, model))
-    .catch(err => console.error(err));
-}
-
-function convertFileNameToEndpoint(path: string, dirent: fs.Dirent, httpVerb: HttpVerb): string {
-  const endpoint = `${path.replace(basePath, '')}/${dirent.name}`
-    .replace('.ts', '')
-    .replace(httpVerb, '')
-    .replace('-', '');
-  if (endpoint.endsWith('/')) {
-    return endpoint.substring(0, endpoint.length - 1);
-  }
-  return endpoint;
-}
+server.start();

package/src/logger.ts

@@ -0,0 +1,7 @@
+export interface Logger {
+  debug(...args: unknown[]): void;
+  trace(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  info(...args: unknown[]): void
+}

package/src/models/registered-endpoint.ts

@@ -0,0 +1,4 @@
+export interface RegisteredEndpoint {
+  httpVerb: string;
+  endpoint: string;
+}

package/src/types/http-verbs.ts

@@ -0,0 +1 @@
+export type HttpVerb = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';

package/src/typescript-mock-server.ts

@@ -0,0 +1,3 @@
+export interface TypescriptMockServer {
+  start(): void;
+}

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es6",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "target": "ES2021",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
 
     "module": "commonjs",                                /* Specify what module code is generated. */