@furystack/rest-service 4.0.19

package/src/incoming-message-extensions.spec.ts

@@ -0,0 +1,41 @@
+import { IncomingMessage } from 'http'
+import './incoming-message-extensions'
+import { Socket } from 'net'
+
+describe('IncomingMessage extensions', () => {
+  describe('readPostBody', () => {
+    it('Should be extended', () => {
+      const socket = new Socket()
+      const msg = new IncomingMessage(socket)
+      expect(typeof msg.readPostBody).toBe('function')
+    })
+
+    it('Should read the raw post body', async () => {
+      const exampleValue = { value: Math.random().toString() }
+      const socket = new Socket()
+      const msg = new IncomingMessage(socket)
+      setTimeout(() => {
+        msg.read = () => JSON.stringify(exampleValue)
+        msg.emit('readable')
+        msg.emit('end')
+      }, 10)
+
+      const result = await msg.readPostBodyRaw()
+      expect(result).toEqual(JSON.stringify(exampleValue))
+    })
+
+    it('Should read the post body', async () => {
+      const exampleValue = { value: Math.random().toString() }
+      const socket = new Socket()
+      const msg = new IncomingMessage(socket)
+      setTimeout(() => {
+        msg.read = () => JSON.stringify(exampleValue)
+        msg.emit('readable')
+        msg.emit('end')
+      }, 10)
+
+      const result = await msg.readPostBody()
+      expect(result).toEqual(exampleValue)
+    })
+  })
+})

package/src/incoming-message-extensions.ts

@@ -0,0 +1,19 @@
+import http from 'http'
+import { Utils } from './utils'
+
+declare module 'http' {
+  export interface IncomingMessage {
+    readPostBodyRaw: () => Promise<string>
+    readPostBody: <T>() => Promise<T>
+  }
+}
+
+http.IncomingMessage.prototype.readPostBody = async function <T>() {
+  const utils = new Utils()
+  return await utils.readPostBody<T>(this)
+}
+
+http.IncomingMessage.prototype.readPostBodyRaw = async function () {
+  const utils = new Utils()
+  return await utils.readPostBodyRaw(this)
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+import './injector-extensions'
+export * from './api-manager'
+export * from './actions'
+export * from './authenticate'
+export * from './authorize'
+export * from './http-authentication-settings'
+export * from './http-user-context'
+export * from './incoming-message-extensions'
+export * from './server-manager'
+export * from './server-response-extensions'
+export * from './utils'
+export * from './models/default-session'
+export * from './endpoint-generators'
+export * from './schema-validator'
+export * from './request-action-implementation'
+export * from './validate'

package/src/injector-extensions.spec.ts

@@ -0,0 +1,19 @@
+import { Injector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import './injector-extensions'
+
+// tslint:disable: no-string-literal
+
+describe('Injector extensions', () => {
+  it('useRestService() Should be added to the injector prototype', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      i.useHttpAuthentication().useRestService({ api: {}, port: 19999, root: '/api' })
+    })
+  })
+
+  it('useHttpAuthentication() Should be added to the injector prototype', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      i.useHttpAuthentication().useHttpAuthentication()
+    })
+  })
+})

package/src/injector-extensions.ts

@@ -0,0 +1,35 @@
+import { User } from '@furystack/core'
+import { Injector } from '@furystack/inject/dist/injector'
+import { HttpAuthenticationSettings } from './http-authentication-settings'
+import { RestApi } from '@furystack/rest'
+import { ApiManager, ImplementApiOptions } from './api-manager'
+import { DefaultSession } from 'models/default-session'
+
+declare module '@furystack/inject/dist/injector' {
+  /**
+   * Extended Injector with Http API related methods
+   */
+  export interface Injector {
+    /**
+     * Sets up the @furystack/rest-service with the provided settings
+     */
+    useRestService: <T extends RestApi>(api: Omit<ImplementApiOptions<T>, 'injector'>) => Promise<this>
+
+    /**
+     * Sets up the HTTP Authentication
+     */
+    useHttpAuthentication: <TUser extends User, TSession extends DefaultSession>(
+      settings?: Partial<HttpAuthenticationSettings<TUser, TSession>>,
+    ) => this
+  }
+}
+
+Injector.prototype.useRestService = async function (api) {
+  await this.getInstance(ApiManager).addApi({ ...api, injector: this })
+  return this
+}
+
+Injector.prototype.useHttpAuthentication = function (s) {
+  this.setExplicitInstance({ ...new HttpAuthenticationSettings(), ...s }, HttpAuthenticationSettings)
+  return this
+}

package/src/models/cors-options.ts

@@ -0,0 +1,21 @@
+/**
+ * CORS settings
+ */
+export interface CorsOptions {
+  /**
+   * List of allowed origins
+   */
+  origins: string[]
+  /**
+   * List of the allowed actions
+   */
+  methods?: Array<'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH'>
+  /**
+   * List of the allowed headers
+   */
+  headers?: string[]
+  /**
+   * Enable cookies
+   */
+  credentials?: boolean
+}

package/src/models/default-session.ts

@@ -0,0 +1,14 @@
+/**
+ * Model class that defines the default session data
+ */
+export class DefaultSession {
+  /**
+   * The generated session identifier
+   */
+  public sessionId!: string
+
+  /**
+   * The user's login name for the session
+   */
+  public username!: string
+}

package/src/request-action-implementation.ts

@@ -0,0 +1,70 @@
+import { Injector } from '@furystack/inject'
+import { ServerResponse } from 'http'
+import { IncomingMessage } from 'http'
+
+export interface ActionResult<T> {
+  statusCode: number
+  headers: { [K: string]: string }
+  chunk: T
+}
+
+export const JsonResult = <T extends object>(chunk: T, statusCode = 200, headers?: { [K: string]: string }) =>
+  ({
+    statusCode,
+    chunk,
+    headers: {
+      ...headers,
+      'Content-Type': 'application/json',
+    },
+  } as ActionResult<T>)
+
+export const PlainTextResult = (text: string, statusCode = 200, headers?: { [K: string]: string }) =>
+  ({
+    statusCode,
+    chunk: text,
+    headers: {
+      ...headers,
+      'Content-Type': 'plain/text',
+    },
+  } as ActionResult<string>)
+
+export const XmlResult = (text: string, statusCode = 200, headers?: { [K: string]: string }) =>
+  ({
+    statusCode,
+    chunk: text,
+    headers: {
+      ...headers,
+      'Content-Type': 'application/xml;charset=utf-8',
+    },
+  } as ActionResult<string>)
+
+export const EmptyResult = (statusCode = 200, headers?: { [K: string]: string }) =>
+  ({
+    statusCode,
+    headers: {
+      ...headers,
+    },
+  } as ActionResult<undefined>)
+
+export const BypassResult = () =>
+  ({
+    chunk: 'BypassResult',
+  } as ActionResult<'BypassResult'>)
+
+export type RequestActionOptions<T extends { result: unknown }> = {
+  request: IncomingMessage
+  response: ServerResponse
+  injector: Injector
+} & (T extends {
+  result: unknown
+  body: infer U
+}
+  ? { getBody: () => Promise<U> }
+  : unknown) &
+  (T extends { result: unknown; url: infer U } ? { getUrlParams: () => U } : unknown) &
+  (T extends { result: unknown; query: infer U } ? { getQuery: () => U } : unknown) &
+  (T extends { result: unknown; headers: infer U } ? { headers: U } : unknown)
+
+export type RequestAction<T extends { result: unknown }> = (
+  options: RequestActionOptions<T>,
+) => Promise<ActionResult<T['result']>>

package/src/rest-service.integration.spec.ts

@@ -0,0 +1,166 @@
+import { Injector } from '@furystack/inject'
+import './injector-extensions'
+import { usingAsync, PathHelper } from '@furystack/utils'
+import { GetCurrentUser, IsAuthenticated, LoginAction, LogoutAction } from './actions'
+import { RestApi } from '@furystack/rest'
+import { User, InMemoryStore } from '@furystack/core'
+import { DefaultSession } from './models/default-session'
+import got from 'got'
+import { JsonResult } from './request-action-implementation'
+
+class UserWithPassword extends User {
+  password!: string
+}
+
+interface IntegrationTestApi extends RestApi {
+  GET: {
+    '/isAuthenticated': { result: { isAuthenticated: boolean } }
+    '/currentUser': { result: User }
+    '/testQuery': { query: { param1: string }; result: { param1Value: string } }
+    '/testUrlParams/:urlParam': { url: { urlParam: string }; result: { urlParamValue: string } }
+  }
+  POST: {
+    '/login': { result: User; body: { username: string; password: string } }
+    '/logout': { result: unknown }
+    '/testPostBody': { body: { value: string }; result: { bodyValue: string } }
+  }
+}
+
+const port = 19090
+const hostName = 'localhost'
+const root = 'test-api'
+
+const prepareInjector = (i: Injector) =>
+  i
+    .setupStores((sm) =>
+      sm
+        .addStore(new InMemoryStore({ model: User, primaryKey: 'username' }))
+        .addStore(new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' })),
+    )
+    .useHttpAuthentication({
+      getUserStore: (sm) => sm.getStoreFor(UserWithPassword, 'username'),
+      getSessionStore: (sm) => sm.getStoreFor(DefaultSession, 'sessionId'),
+    })
+    .useRestService<IntegrationTestApi>({
+      root,
+      port,
+      hostName,
+      cors: {
+        credentials: true,
+        origins: ['http://localhost:8080'],
+        headers: ['cache', 'content-type'],
+      },
+      api: {
+        GET: {
+          '/currentUser': GetCurrentUser,
+          '/isAuthenticated': IsAuthenticated,
+          '/testQuery': async (options) => JsonResult({ param1Value: options.getQuery().param1 }),
+          '/testUrlParams/:urlParam': async (options) => JsonResult({ urlParamValue: options.getUrlParams().urlParam }),
+        },
+        POST: {
+          '/login': LoginAction,
+          '/logout': LogoutAction,
+          '/testPostBody': async (options) => {
+            const body = await options.getBody()
+            return JsonResult({ bodyValue: body.value })
+          },
+        },
+      },
+    })
+
+const apiUrl = PathHelper.joinPaths(`http://${hostName}:${port}`, root)
+
+describe('@furystack/rest-service inregration tests', () => {
+  it('Should be started and disposed', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      await prepareInjector(i)
+    })
+  })
+
+  it('Should respond with 404 when a route is not found', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      await prepareInjector(i)
+      await expect(got(PathHelper.joinPaths(apiUrl, 'some-route-that-does-not-exists'))).rejects.toThrow(
+        'Response code 404 (Not Found)',
+      )
+    })
+  })
+
+  it('Should respond with 401 for unauthorized request errors', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      await prepareInjector(i)
+      await expect(got(PathHelper.joinPaths(apiUrl, 'currentUser'), { retry: 0 })).rejects.toThrow(
+        'Response code 401 (Unauthorized)',
+      )
+    })
+  })
+
+  it('Should respond with 401 for unauthorized request errors', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      await prepareInjector(i)
+      await expect(got(PathHelper.joinPaths(apiUrl, 'currentUser'), { retry: 0 })).rejects.toThrow(
+        'Response code 401 (Unauthorized)',
+      )
+    })
+  })
+
+  it('Should respond with the correct result body', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      await prepareInjector(i)
+      const response = await got(PathHelper.joinPaths(apiUrl, 'isAuthenticated'), { retry: 0 })
+      expect(response.statusCode).toBe(200)
+      expect(JSON.parse(response.body)).toStrictEqual({ isAuthenticated: false })
+    })
+  })
+
+  it('Should be able to read query parameters', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      await prepareInjector(i)
+      const response = await got(PathHelper.joinPaths(apiUrl, 'testQuery?param1=foo'), { retry: 0 })
+      expect(response.statusCode).toBe(200)
+      expect(JSON.parse(response.body)).toStrictEqual({ param1Value: 'foo' })
+    })
+  })
+
+  it('Should be able to read url parameters', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      await prepareInjector(i)
+      const response = await got(PathHelper.joinPaths(apiUrl, 'testUrlParams/bar'), { retry: 0 })
+      expect(response.statusCode).toBe(200)
+      expect(JSON.parse(response.body)).toStrictEqual({ urlParamValue: 'bar' })
+    })
+  })
+
+  it('Should be able to read post body', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      await prepareInjector(i)
+      const response = await got(PathHelper.joinPaths(apiUrl, 'testPostBody'), {
+        method: 'POST',
+        body: JSON.stringify({ value: 'baz' }),
+        retry: 0,
+      })
+      expect(response.statusCode).toBe(200)
+      expect(JSON.parse(response.body)).toStrictEqual({ bodyValue: 'baz' })
+    })
+  })
+
+  it('Should respond with OK to OPTIONS requests', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      await prepareInjector(i)
+      const response = await got(PathHelper.joinPaths(apiUrl, 'testPostBody'), {
+        method: 'OPTIONS',
+        retry: 0,
+      })
+      expect(response.statusCode).toBe(200)
+    })
+  })
+
+  it('Should reject requests outside of the API Root', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      await prepareInjector(i)
+      await expect(
+        got(PathHelper.joinPaths(`http://${hostName}:${port}`, 'not-my-api-root'), { retry: 0 }),
+      ).rejects.toThrowError('socket hang up')
+    })
+  })
+})

package/src/rest.integration.test.ts

@@ -0,0 +1,112 @@
+import { Injector } from '@furystack/inject'
+import { RestApi } from '@furystack/rest'
+import { createClient } from '@furystack/rest-client-got'
+import { usingAsync } from '@furystack/utils'
+import { JsonResult } from './request-action-implementation'
+import { v4 } from 'uuid'
+import './injector-extensions'
+
+export interface EchoApi extends RestApi {
+  GET: {
+    '/plain': { result: unknown }
+    '/headers': { headers: { value?: string }; result: { headers: { value?: string } } }
+    '/urlParams/:id': { url: { id: string }; result: { url: { id: string } } }
+    '/query': {
+      query: { someObject: { foo: string } }
+      result: { query: { someObject: { foo: string } } }
+    }
+  }
+  POST: {
+    '/body': { body: { foo: string; bar: number }; result: { body: { foo: string; bar: number } } }
+  }
+}
+
+const createEchoApiServer = async () => {
+  const port = Math.round(Math.random() * 1000) + 10000
+  const root = '/api'
+  const injector = new Injector()
+  await injector.useRestService<EchoApi>({
+    port,
+    root,
+    api: {
+      GET: {
+        '/plain': async () => JsonResult({}),
+        '/headers': async ({ headers }) => JsonResult({ headers }),
+        '/query': async ({ getQuery }) => JsonResult({ query: getQuery() }),
+        '/urlParams/:id': async ({ getUrlParams }) => JsonResult({ url: getUrlParams() }),
+      },
+      POST: {
+        '/body': async ({ getBody }) => JsonResult({ body: await getBody() }),
+      },
+    },
+  })
+  const client = createClient<EchoApi>({
+    endpointUrl: `http://localhost:${port}/api`,
+  })
+  return {
+    dispose: injector.dispose.bind(injector),
+    root,
+    port,
+    client,
+  }
+}
+
+describe('REST Integration tests with GOT client', () => {
+  it('Should execute a single parameterless GET query', async () => {
+    await usingAsync(await createEchoApiServer(), async ({ client }) => {
+      const result = await client({
+        method: 'GET',
+        action: '/plain',
+      })
+      expect(result.response.statusCode).toBe(200)
+      expect(result.getJson()).toStrictEqual({})
+    })
+  })
+
+  it('Should execute a request with headers', async () => {
+    await usingAsync(await createEchoApiServer(), async ({ client }) => {
+      const value = v4()
+      const result = await client({
+        method: 'GET',
+        action: '/headers',
+        headers: {
+          value,
+        },
+      })
+      expect(result.response.statusCode).toBe(200)
+      expect(result.getJson().headers.value).toStrictEqual(value)
+    })
+  })
+
+  it('Should execute a request with query', async () => {
+    await usingAsync(await createEchoApiServer(), async ({ client }) => {
+      const value = v4()
+      const result = await client({
+        method: 'GET',
+        action: '/query',
+        query: {
+          someObject: {
+            foo: value,
+          },
+        },
+      })
+      expect(result.response.statusCode).toBe(200)
+      expect(result.getJson().query.someObject.foo).toStrictEqual(value)
+    })
+  })
+
+  it('Should execute a request with URL parameters', async () => {
+    await usingAsync(await createEchoApiServer(), async ({ client }) => {
+      const value = v4()
+      const result = await client({
+        method: 'GET',
+        action: '/urlParams/:id',
+        url: {
+          id: value,
+        },
+      })
+      expect(result.response.statusCode).toBe(200)
+      expect(result.getJson().url.id).toEqual(value)
+    })
+  })
+})