@furystack/rest-service 4.0.19

package/src/schema-validator/index.ts

@@ -0,0 +1,2 @@
+export * from './schema-validator'
+export * from './schema-validation-error'

package/src/schema-validator/schema-validation-error.ts

@@ -0,0 +1,11 @@
+import { RequestError } from '@furystack/rest'
+import { ErrorObject } from 'ajv'
+
+/**
+ * Custom Error class for Schema Validation Errors
+ */
+export class SchemaValidationError extends RequestError {
+  constructor(public readonly errors: ErrorObject[]) {
+    super('Schema Validation failed', 400)
+  }
+}

package/src/schema-validator/schema-validator.test.ts

@@ -0,0 +1,72 @@
+import { SchemaValidator } from './schema-validator'
+import { exampleSchema, BodyParameters, Language } from './validate-examples'
+import { SchemaValidationError } from './schema-validation-error'
+
+describe('ValidateSchema', () => {
+  describe('String Literal checks', () => {
+    it('Should pass on valid string literal parameters', () => {
+      expect(new SchemaValidator(exampleSchema).isValid<Language>('en', { schemaName: 'Language' })).toBeTruthy()
+    })
+
+    it('Should throw a ValidationError on Age parameters', () => {
+      try {
+        const result = new SchemaValidator(exampleSchema).isValid<Language>('foo', { schemaName: 'Language' })
+        expect(result).toBeFalsy() // should not hit
+      } catch (error) {
+        expect(error).toBeInstanceOf(SchemaValidationError)
+        const { errors } = error as SchemaValidationError
+        expect(errors).toHaveLength(1)
+        expect(errors[0].message).toEqual('must be equal to one of the allowed values')
+      }
+    })
+  })
+
+  describe('Object checks', () => {
+    it('Should fail when string is passed instead of object', () => {
+      try {
+        new SchemaValidator(exampleSchema).isValid<BodyParameters>('foo', { schemaName: 'BodyParameters' })
+      } catch (error) {
+        expect(error).toBeInstanceOf(SchemaValidationError)
+        const { errors } = error as SchemaValidationError
+        expect(errors).toHaveLength(1)
+        expect(errors[0].message).toEqual('must be object')
+      }
+    })
+
+    it('Should fail when an additional property is present', () => {
+      try {
+        new SchemaValidator(exampleSchema).isValid<BodyParameters>(
+          { age: '3', foo: 2 },
+          { schemaName: 'BodyParameters' },
+        )
+      } catch (error) {
+        expect(error).toBeInstanceOf(SchemaValidationError)
+        const { errors } = error as SchemaValidationError
+        expect(errors).toHaveLength(1)
+        expect(errors[0].message).toEqual('must NOT have additional properties')
+      }
+    })
+
+    it('Should pass with empty objects', () => {
+      expect(
+        new SchemaValidator(exampleSchema).isValid<BodyParameters>({}, { schemaName: 'BodyParameters' }),
+      ).toBeTruthy()
+    })
+
+    it('Should pass with valid partial objects', () => {
+      expect(
+        new SchemaValidator(exampleSchema).isValid<BodyParameters>({ age: '3' }, { schemaName: 'BodyParameters' }),
+      ).toBeTruthy()
+    })
+  })
+
+  describe('Multiple checks per validator instance', () => {
+    it('Should pass with multiple types from schema per validator instance', () => {
+      const validator = new SchemaValidator(exampleSchema)
+      expect(validator.isValid<Language>('en', { schemaName: 'Language' })).toBeTruthy()
+      expect(
+        new SchemaValidator(exampleSchema).isValid<BodyParameters>({}, { schemaName: 'BodyParameters' }),
+      ).toBeTruthy()
+    })
+  })
+})

package/src/schema-validator/schema-validator.ts

@@ -0,0 +1,31 @@
+import Ajv, { ErrorObject, Options } from 'ajv'
+import useFormats from 'ajv-formats'
+import { SchemaValidationError } from './schema-validation-error'
+
+export class SchemaValidator<TSchema extends { definitions: {} }> {
+  private readonly ajv = new Ajv({
+    allErrors: true,
+    ...this.ajvOptions,
+  })
+  constructor(private readonly schema: TSchema, private readonly ajvOptions?: Options) {
+    useFormats(this.ajv)
+  }
+
+  /**
+   * @param data The object to validate
+   * @param options Options for the schema validation
+   * @param options.schemaName The name of the type in the Schema Definitions
+   * @throws SchemaValidationError when the validation has been failed
+   * @returns true in case of validation success
+   */
+  public isValid<T>(data: any, options: { schemaName: keyof TSchema['definitions'] }): data is T {
+    const schema = { ...this.schema, $ref: `#/definitions/${options.schemaName}` }
+    const validatorFn = this.ajv.compile(schema)
+    const isValid = validatorFn(data)
+    if (!isValid) {
+      throw new SchemaValidationError(validatorFn.errors as ErrorObject[])
+    }
+
+    return true
+  }
+}

package/src/schema-validator/validate-examples.ts

@@ -0,0 +1,38 @@
+/**
+ * example string literal type - needed for Typescipt Generics
+ */
+export type Language = 'en' | 'hu' | 'de' | 'all'
+
+/**
+ * example object type - needed for TypeScipt Generics
+ */
+export interface BodyParameters {
+  gender?: 'MALE' | 'FEMALE'
+  age?: string
+}
+
+/**
+ * Example Schema Definition - can be generated from the example types above with ts-json-schema-generator
+ */
+export const exampleSchema = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  definitions: {
+    BodyParameters: {
+      additionalProperties: false,
+      properties: {
+        age: {
+          type: 'string',
+        },
+        gender: {
+          enum: ['MALE', 'FEMALE'],
+          type: 'string',
+        },
+      },
+      type: 'object',
+    },
+    Language: {
+      enum: ['en', 'hu', 'de', 'all'],
+      type: 'string',
+    },
+  },
+}

package/src/server-manager.ts

@@ -0,0 +1,88 @@
+import { Injectable } from '@furystack/inject'
+import { Disposable } from '@furystack/utils'
+import { Server, createServer } from 'http'
+import Semaphore from 'semaphore-async-await'
+import { IncomingMessage, ServerResponse } from 'http'
+import { Socket } from 'net'
+
+export interface ServerOptions {
+  hostName?: string
+  port: number
+}
+
+export interface OnRequest {
+  req: IncomingMessage
+  res: ServerResponse
+}
+
+export interface ServerRecord {
+  server: Server
+  apis: Array<{ shouldExec: (options: OnRequest) => boolean; onRequest: (options: OnRequest) => void }>
+}
+
+@Injectable({ lifetime: 'singleton' })
+export class ServerManager implements Disposable {
+  public static DEFAULT_HOST = 'localhost'
+
+  public servers = new Map<string, ServerRecord>()
+  private openedSockets = new Set<Socket>()
+
+  private readonly listenLock = new Semaphore(1)
+
+  private getHostUrl = (options: ServerOptions) =>
+    `http://${options.hostName || ServerManager.DEFAULT_HOST}:${options.port}`
+
+  private onConnection = (socket: Socket) => {
+    this.openedSockets.add(socket)
+    socket.once('close', () => this.openedSockets.delete(socket))
+  }
+
+  public async dispose() {
+    try {
+      await this.listenLock.waitFor(5000)
+    } finally {
+      this.openedSockets.forEach((s) => s.destroy())
+      await Promise.allSettled(
+        [...this.servers.values()].map(
+          (s) =>
+            new Promise<void>((resolve, reject) => {
+              s.server.close((err) => (err ? reject(err) : resolve()))
+              s.server.off('connection', this.onConnection)
+            }),
+        ),
+      )
+      this.servers.clear()
+      this.listenLock.release()
+    }
+  }
+
+  public async getOrCreate(options: ServerOptions): Promise<ServerRecord> {
+    const url = this.getHostUrl(options)
+    if (!this.servers.has(url)) {
+      await this.listenLock.acquire()
+      try {
+        if (!this.servers.has(url)) {
+          await new Promise<void>((resolve, reject) => {
+            const apis: ServerRecord['apis'] = []
+            const server = createServer((req, res) => {
+              const apiMatch = apis.find((api) => api.shouldExec({ req, res }))
+              if (apiMatch) {
+                apiMatch.onRequest({ req, res })
+              } else {
+                res.destroy()
+              }
+            })
+            server.on('connection', this.onConnection)
+            server.on('listening', () => resolve())
+            server.on('error', (err) => reject(err))
+            server.listen(options.port, options.hostName)
+            this.servers.set(url, { server, apis })
+          })
+        }
+      } finally {
+        this.listenLock.release()
+      }
+    }
+    return this.servers.get(url) as ServerRecord
+  }
+}

package/src/server-response-extensions.spec.ts

@@ -0,0 +1,53 @@
+import { Socket } from 'net'
+import { IncomingMessage, ServerResponse } from 'http'
+import './server-response-extensions'
+import { BypassResult, JsonResult, PlainTextResult } from './request-action-implementation'
+
+describe('ServerResponse extensions', () => {
+  describe('sendActionResult', () => {
+    it('Should be extended', () => {
+      const socket = new Socket()
+      const msg = new ServerResponse(new IncomingMessage(socket))
+      expect(typeof msg.sendActionResult).toBe('function')
+    })
+
+    it('Should send the JSON response with the correct Content Type header and default status', (done) => {
+      const jsonValue = { value: Math.random() }
+      const socket = new Socket()
+      const msg = new ServerResponse(new IncomingMessage(socket))
+      msg.writeHead = jest.fn()
+      msg.end = (chunk?: any) => {
+        expect(chunk).toBe(JSON.stringify(jsonValue))
+        expect(msg.writeHead).toBeCalledWith(200, { 'Content-Type': 'application/json' })
+        done()
+      }
+
+      msg.sendActionResult(JsonResult(jsonValue))
+    })
+
+    it('Should send the plain TEXT response with the correct Content Type header and default status', (done) => {
+      const textValue = `${Math.random()}`
+      const socket = new Socket()
+      const msg = new ServerResponse(new IncomingMessage(socket))
+      msg.writeHead = jest.fn()
+      msg.end = (chunk?: any) => {
+        expect(chunk).toBe(textValue)
+        expect(msg.writeHead).toBeCalledWith(200, { 'Content-Type': 'plain/text' })
+        done()
+      }
+
+      msg.sendActionResult(PlainTextResult(textValue))
+    })
+
+    it('Should skip sending on BypassResult', () => {
+      const socket = new Socket()
+      const msg = new ServerResponse(new IncomingMessage(socket))
+      msg.writeHead = jest.fn()
+      msg.end = jest.fn()
+
+      msg.sendActionResult(BypassResult())
+      expect(msg.writeHead).not.toBeCalled()
+      expect(msg.end).not.toBeCalled()
+    })
+  })
+})

package/src/server-response-extensions.ts

@@ -0,0 +1,30 @@
+import http from 'http'
+import { ActionResult } from './request-action-implementation'
+
+export interface SendJsonOptions<T> {
+  statusCode?: number
+  json: T
+  headers?: { [K: string]: string }
+}
+export interface SendPlainTextOptions {
+  statusCode?: number
+  text: string
+  headers?: { [K: string]: string }
+}
+
+declare module 'http' {
+  export interface ServerResponse {
+    sendActionResult: <T>(result: ActionResult<T>) => void
+  }
+}
+
+http.ServerResponse.prototype.sendActionResult = function <T>(options: ActionResult<T>) {
+  if (typeof options.chunk === 'object') {
+    options.chunk = JSON.stringify(options.chunk) as any
+  }
+  if (typeof options.chunk === 'string' && options.chunk === 'BypassResult') {
+    return
+  }
+  this.writeHead(options.statusCode, options.headers)
+  this.end(options.chunk)
+}

package/src/utils.ts

@@ -0,0 +1,65 @@
+import { IncomingMessage, ServerResponse } from 'http'
+import { Injectable } from '@furystack/inject'
+import { CorsOptions } from './models/cors-options'
+
+/**
+ * A collection of various HTTP API related utilities
+ */
+@Injectable({ lifetime: 'transient' })
+export class Utils {
+  public async readPostBodyRaw(incomingMessage: IncomingMessage) {
+    let body = ''
+    await new Promise<void>((resolve, reject) => {
+      incomingMessage.on('readable', () => {
+        const data = incomingMessage.read()
+        if (data) {
+          body += data
+        }
+      })
+      incomingMessage.on('end', () => {
+        resolve()
+      })
+      incomingMessage.on('error', (err) => {
+        reject(err)
+      })
+    })
+    return body
+  }
+
+  /**
+   * Reads the post's body and returns a promise with a parsed value
+   *
+   * @param incomingMessage The incoming message instance
+   * @returns the parsed object from the post body
+   */
+  public async readPostBody<T>(incomingMessage: IncomingMessage): Promise<T> {
+    const body = await this.readPostBodyRaw(incomingMessage)
+    return JSON.parse(body) as T
+  }
+
+  /**
+   * Adds the specified CORS headers to the response
+   *
+   * @param options The CORS Options object
+   * @param incomingMessage The incoming message instance
+   * @param serverResponse The outgoing response instance
+   */
+  public addCorsHeaders(options: CorsOptions, incomingMessage: IncomingMessage, serverResponse: ServerResponse) {
+    if (
+      incomingMessage.headers &&
+      incomingMessage.headers.origin !== incomingMessage.headers.host &&
+      options.origins.some((origin) => origin === incomingMessage.headers.origin)
+    ) {
+      serverResponse.setHeader('Access-Control-Allow-Origin', incomingMessage.headers.origin as string)
+      if (options.credentials) {
+        serverResponse.setHeader('Access-Control-Allow-Credentials', 'true')
+      }
+      if (options.headers && options.headers.length) {
+        serverResponse.setHeader('Access-Control-Allow-Headers', options.headers.join(', '))
+      }
+      if (options.methods && options.methods.length) {
+        serverResponse.setHeader('Access-Control-Allow-Methods', options.methods.join(', '))
+      }
+    }
+  }
+}

package/src/validate.integration.schema.ts

@@ -0,0 +1,50 @@
+import {
+  DeleteEndpoint,
+  GetCollectionEndpoint,
+  GetEntityEndpoint,
+  PatchEndpoint,
+  PostEndpoint,
+  RestApi,
+} from '@furystack/rest'
+
+export interface Mock {
+  id: string
+  value: string
+}
+
+export interface ValidateQuery {
+  query: { foo: string; bar: number; baz: boolean }
+  result: { foo: string; bar: number; baz: boolean }
+}
+export interface ValidateUrl {
+  url: { id: number }
+  result: { id: number }
+}
+export interface ValidateHeaders {
+  headers: { foo: string; bar: number; baz: boolean }
+  result: { foo: string; bar: number; baz: boolean }
+}
+export interface ValidateBody {
+  body: { foo: string; bar: number; baz: boolean }
+  result: { foo: string; bar: number; baz: boolean }
+}
+
+export interface ValidationApi extends RestApi {
+  GET: {
+    '/validate-query': ValidateQuery
+    '/validate-url/:id': ValidateUrl
+    '/validate-headers': ValidateHeaders
+    '/mock': GetCollectionEndpoint<Mock>
+    '/mock/:id': GetEntityEndpoint<Mock, 'id'>
+  }
+  POST: {
+    '/validate-body': ValidateBody
+    '/mock': PostEndpoint<Mock, 'id'>
+  }
+  PATCH: {
+    '/mock/:id': PatchEndpoint<Mock, 'id'>
+  }
+  DELETE: {
+    '/mock/:id': DeleteEndpoint<Mock, 'id'>
+  }
+}