@furystack/rest-service 4.0.19

package/dist/validate.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validate = void 0;
+const schema_validator_1 = require("./schema-validator");
+const Validate = (validationOptions) => (action) => {
+    const schema = { ...validationOptions.schema };
+    Object.values(schema.definitions).forEach((definition) => {
+        var _a;
+        if (definition.required && definition.required.includes('result')) {
+            definition.required = definition.required.filter((value) => value !== 'result');
+        }
+        definition.additionalProperties = true;
+        if ((_a = definition.properties) === null || _a === void 0 ? void 0 : _a.headers) {
+            definition.properties.headers.additionalProperties = true;
+        }
+    });
+    const validator = new schema_validator_1.SchemaValidator(schema, { coerceTypes: true });
+    return async (args) => {
+        var _a, _b, _c;
+        const anyArgs = args;
+        let body;
+        const { headers } = anyArgs;
+        const query = (_a = anyArgs.getQuery) === null || _a === void 0 ? void 0 : _a.call(anyArgs);
+        const url = (_b = anyArgs.getUrlParams) === null || _b === void 0 ? void 0 : _b.call(anyArgs);
+        try {
+            body = await ((_c = anyArgs.getBody) === null || _c === void 0 ? void 0 : _c.call(anyArgs));
+        }
+        catch (error) {
+            // ignore
+        }
+        validator.isValid({
+            ...(query ? { query } : {}),
+            ...(body ? { body } : {}),
+            ...(url ? { url } : {}),
+            ...(headers ? { headers } : {}),
+        }, { schemaName: validationOptions.schemaName });
+        return await action({
+            request: args.request,
+            response: args.response,
+            injector: args.injector,
+            headers,
+            getQuery: () => query,
+            getUrlParams: () => url,
+            getBody: () => Promise.resolve(body),
+        });
+    };
+};
+exports.Validate = Validate;
+//# sourceMappingURL=validate.js.map

package/dist/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":";;;AACA,yDAAoD;AAE7C,MAAM,QAAQ,GACnB,CAAkF,iBASjF,EAAE,EAAE,CACL,CAA4B,MAAwB,EAAoB,EAAE;IACxE,MAAM,MAAM,GAAG,EAAE,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAA;IAE9C,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE;;QACvD,IAAI,UAAU,CAAC,QAAQ,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YACjE,UAAU,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAA;SACrF;QACD,UAAU,CAAC,oBAAoB,GAAG,IAAI,CAAA;QACtC,IAAI,MAAA,UAAU,CAAC,UAAU,0CAAE,OAAO,EAAE;YAClC,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAA;SAC1D;IACH,CAAC,CAAC,CAAA;IAEF,MAAM,SAAS,GAAG,IAAI,kCAAe,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAA;IAEpE,OAAO,KAAK,EAAE,IAA6B,EAA4B,EAAE;;QACvE,MAAM,OAAO,GAAG,IAAW,CAAA;QAC3B,IAAI,IAAU,CAAA;QACd,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAA;QAC3B,MAAM,KAAK,GAAG,MAAA,OAAO,CAAC,QAAQ,+CAAhB,OAAO,CAAa,CAAA;QAClC,MAAM,GAAG,GAAG,MAAA,OAAO,CAAC,YAAY,+CAApB,OAAO,CAAiB,CAAA;QACpC,IAAI;YACF,IAAI,GAAG,MAAM,CAAA,MAAA,OAAO,CAAC,OAAO,+CAAf,OAAO,CAAY,CAAA,CAAA;SACjC;QAAC,OAAO,KAAK,EAAE;YACd,SAAS;SACV;QACD,SAAS,CAAC,OAAO,CACf;YACE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3B,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACzB,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACvB,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAChC,EACD,EAAE,UAAU,EAAE,iBAAiB,CAAC,UAAU,EAAE,CAC7C,CAAA;QACD,OAAO,MAAM,MAAM,CAAC;YAClB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,OAAO;YACP,QAAQ,EAAE,GAAG,EAAE,CAAC,KAAK;YACrB,YAAY,EAAE,GAAG,EAAE,CAAC,GAAG;YACvB,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;SAC9B,CAAC,CAAA;IACX,CAAC,CAAA;AACH,CAAC,CAAA;AAxDU,QAAA,QAAQ,YAwDlB"}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@furystack/rest-service",
+  "version": "4.0.19",
+  "description": "Repository implementation for FuryStack",
+  "main": "dist/index.js",
+  "scripts": {
+    "start:mock": "yarn node ./dist/mock.js"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/furystack/furystack.git"
+  },
+  "keywords": [
+    "FuryStack",
+    "HTTP",
+    "REST",
+    "API",
+    "Actions"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "gallay.lajos@gmail.com",
+  "license": "GPL-2.0",
+  "bugs": {
+    "url": "https://github.com/furystack/furystack/issues"
+  },
+  "homepage": "https://github.com/furystack/furystack",
+  "dependencies": {
+    "@furystack/core": "^10.3.3",
+    "@furystack/inject": "^4.0.74",
+    "@furystack/logging": "^2.0.81",
+    "@furystack/repository": "^5.0.18",
+    "@furystack/rest": "^3.0.18",
+    "@furystack/utils": "^1.2.44",
+    "ajv": "^8.6.3",
+    "ajv-formats": "^2.1.1",
+    "hash.js": "^1.1.7",
+    "path-to-regexp": "^6.2.0",
+    "semaphore-async-await": "^1.5.1",
+    "tslib": "^2.3.1",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^27.0.1",
+    "@types/node": "^16.9.1",
+    "@types/uuid": "^8.3.1",
+    "got": "^11.8.2"
+  },
+  "typings": "./dist/index.d.ts",
+  "gitHead": "0e6c724905b574603b1587fea9b6a6ed7446f93b"
+}

package/src/actions/error-action.spec.ts

@@ -0,0 +1,54 @@
+import { Injector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import { ErrorAction } from './error-action'
+import { IncomingMessage } from 'http'
+import { RequestError } from '@furystack/rest'
+import { AuthorizationError } from '@furystack/core'
+import { ServerResponse } from 'http'
+
+describe('ErrorAction tests', () => {
+  const request = { url: 'https://google.com' } as IncomingMessage
+  const response = {} as ServerResponse
+
+  it('returns the error in the standard format', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      const result = await ErrorAction({
+        injector: i,
+        getBody: async () => new Error('Something went wrong'),
+        request,
+        response,
+      })
+      expect(result.statusCode).toBe(500)
+      expect(result.chunk.message).toBe('Something went wrong')
+      expect(result.chunk.url).toBe('https://google.com')
+    })
+  })
+
+  it('returns the error code from request errors', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      const result = await ErrorAction({
+        request,
+        response,
+        injector: i,
+        getBody: async () => new RequestError('Something went wrong', 401),
+      })
+      expect(result.statusCode).toBe(401)
+      expect(result.chunk.message).toBe('Something went wrong')
+      expect(result.chunk.url).toBe('https://google.com')
+    })
+  })
+
+  it('returns the 403 for authorization errors', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      const result = await ErrorAction({
+        request,
+        response,
+        injector: i,
+        getBody: async () => new AuthorizationError('Something went wrong'),
+      })
+      expect(result.statusCode).toBe(403)
+      expect(result.chunk.message).toBe('Something went wrong')
+      expect(result.chunk.url).toBe('https://google.com')
+    })
+  })
+})

package/src/actions/error-action.ts

@@ -0,0 +1,34 @@
+import { RequestError } from '@furystack/rest'
+import { AuthorizationError } from '@furystack/core'
+import { JsonResult, RequestAction } from '../request-action-implementation'
+import { SchemaValidationError } from '../schema-validator'
+
+/**
+ * Action for unhandled (500) errors
+ * Returns a serialized error instance in JSON format.
+ */
+
+export const ErrorAction: RequestAction<{
+  body: unknown
+  result: { message: string; url?: string; stack?: string }
+}> = async ({ getBody, request }) => {
+  const body = await getBody()
+
+  if (body instanceof SchemaValidationError) {
+    return JsonResult({ message: body.message, stack: body.stack, errors: body.errors }, 400)
+  }
+
+  if (body instanceof RequestError) {
+    return JsonResult({ message: body.message, url: request.url, stack: body.stack }, body.responseCode)
+  }
+
+  if (body instanceof AuthorizationError) {
+    return JsonResult({ message: body.message, url: request.url, stack: body.stack }, 403)
+  }
+
+  if (body instanceof Error) {
+    return JsonResult({ message: body.message, url: request.url, stack: body.stack }, 500)
+  }
+
+  return JsonResult({ message: 'An unexpected error happened' }, 500)
+}

package/src/actions/get-current-user.spec.ts

@@ -0,0 +1,23 @@
+import { Injector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import { GetCurrentUser } from './get-current-user'
+import { IncomingMessage, ServerResponse } from 'http'
+import { IdentityContext } from '@furystack/core'
+
+describe('getCurrentUser', () => {
+  const request = { url: 'https://google.com' } as IncomingMessage
+  const response = {} as ServerResponse
+
+  it('exec', async () => {
+    const testUser = { Name: 'Userke' }
+    await usingAsync(new Injector(), async (i) => {
+      i.setExplicitInstance(
+        { getCurrentUser: async () => testUser, isAuthenticated: async () => true },
+        IdentityContext,
+      )
+      const result = await GetCurrentUser({ injector: i, request, response })
+      expect(result.statusCode).toBe(200)
+      expect(result.chunk).toEqual(testUser)
+    })
+  })
+})

package/src/actions/get-current-user.ts

@@ -0,0 +1,15 @@
+import { User } from '@furystack/core'
+import { Authenticate } from '../authenticate'
+import { JsonResult, RequestAction } from '../request-action-implementation'
+
+/**
+ * Action that returns the current authenticated user
+ *
+ * @param injector The injector from the current stack
+ */
+export const GetCurrentUser: RequestAction<{
+  result: User
+}> = Authenticate()(async ({ injector }) => {
+  const user = await injector.getCurrentUser()
+  return JsonResult(user)
+})

package/src/actions/index.ts

@@ -0,0 +1,6 @@
+export * from './error-action'
+export * from './get-current-user'
+export * from './is-authenticated'
+export * from './login'
+export * from './logout'
+export * from './not-found-action'

package/src/actions/is-authenticated.spec.ts

@@ -0,0 +1,18 @@
+import { Injector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import { IsAuthenticated } from './is-authenticated'
+import { IncomingMessage, ServerResponse } from 'http'
+import { IdentityContext } from '@furystack/core'
+
+describe('isAuthenticated', () => {
+  const request = { url: 'https://google.com' } as IncomingMessage
+  const response = {} as ServerResponse
+  it('exec', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      i.setExplicitInstance({ isAuthenticated: async () => true }, IdentityContext)
+      const result = await IsAuthenticated({ injector: i, request, response } as any)
+      expect(result.statusCode).toBe(200)
+      expect(result.chunk).toEqual({ isAuthenticated: true })
+    })
+  })
+})

package/src/actions/is-authenticated.ts

@@ -0,0 +1,13 @@
+import { JsonResult, RequestAction } from '../request-action-implementation'
+
+/**
+ * Action that returns if the current user is authenticated
+ *
+ * @param options The options for the Custom Action
+ * @param options.injector The Injector from the current context
+ * @returns A standard authentication result
+ */
+export const IsAuthenticated: RequestAction<{ result: { isAuthenticated: boolean } }> = async ({ injector }) => {
+  const isAuthenticated = await injector.isAuthenticated()
+  return JsonResult({ isAuthenticated })
+}

package/src/actions/login-action.spec.ts

@@ -0,0 +1,41 @@
+import { IncomingMessage, ServerResponse } from 'http'
+import { Injector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import { LoginAction } from './login'
+import { HttpUserContext } from '../http-user-context'
+
+describe('LoginAction', () => {
+  const request = { url: 'https://google.com' } as IncomingMessage
+  const response = {} as ServerResponse
+
+  it('Returns the provided user with 200 on success', async () => {
+    const testUser = { Name: 'Userke' }
+    await usingAsync(new Injector(), async (i) => {
+      i.setExplicitInstance(
+        {
+          authenticateUser: jest.fn(async () => testUser),
+          cookieLogin: jest.fn(async () => testUser),
+          authentication: {},
+        },
+        HttpUserContext,
+      )
+      const result = await LoginAction({
+        request,
+        response,
+        injector: i,
+        getBody: async () => ({ username: 'testuser', password: 'alma' }),
+      } as any)
+      expect(result.chunk).toEqual(testUser)
+      expect(result.statusCode).toBe(200)
+    })
+  })
+
+  it('Returns throw error with 400 on fail', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      i.setExplicitInstance({ cookieLogin: async () => Promise.reject(':(') }, HttpUserContext)
+      await expect(
+        LoginAction({ request, response, injector: i, getBody: async () => ({ username: '', password: '' }) }),
+      ).rejects.toThrowError('Login Failed')
+    })
+  })
+})

package/src/actions/login.ts

@@ -0,0 +1,26 @@
+import { HttpUserContext } from '../http-user-context'
+import '../injector-extensions'
+import { User } from '@furystack/core'
+import { RequestError } from '@furystack/rest'
+import { JsonResult, RequestAction } from '../request-action-implementation'
+
+/**
+ * Action that logs in the current user
+ * Should be called with a JSON Post body with ``username`` and ``password`` fields.
+ * Returns the current user instance
+ */
+
+export const LoginAction: RequestAction<{
+  result: User
+  body: { username: string; password: string }
+}> = async ({ injector, getBody, response }) => {
+  const userContext = injector.getInstance(HttpUserContext)
+  const body = await getBody()
+  try {
+    const user = await userContext.authenticateUser(body.username, body.password)
+    await userContext.cookieLogin(user, response)
+    return JsonResult(user, 200)
+  } catch (error) {
+    throw new RequestError('Login Failed', 400)
+  }
+}

package/src/actions/logout-action.spec.ts

@@ -0,0 +1,27 @@
+import { Injector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import { HttpUserContext } from '../http-user-context'
+import { LogoutAction } from './logout'
+import { IncomingMessage, ServerResponse } from 'http'
+
+describe('LogoutAction', () => {
+  const request = { url: 'https://google.com' } as IncomingMessage
+  const response = {} as ServerResponse
+
+  it('exec', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      const cookieLogout = jest.fn(async () => true)
+      i.setExplicitInstance(
+        {
+          cookieLogout,
+        },
+        HttpUserContext,
+      )
+
+      const result = await LogoutAction({ request, response, injector: i } as any)
+      expect(result.statusCode).toBe(200)
+      expect(result.chunk).toBe(undefined)
+      expect(cookieLogout).toBeCalled()
+    })
+  })
+})

package/src/actions/logout.ts

@@ -0,0 +1,16 @@
+import { HttpUserContext } from '../http-user-context'
+import { EmptyResult, RequestAction } from '../request-action-implementation'
+
+/**
+ * Action that logs out the current user
+ *
+ * @param root0 The Options object
+ * @param root0.injector The injector from the context
+ * @param root0.request The current Request object
+ * @param root0.response The Response object
+ * @returns An empty result that indicates the success
+ */
+export const LogoutAction: RequestAction<{ result: unknown }> = async ({ injector, request, response }) => {
+  await injector.getInstance(HttpUserContext).cookieLogout(request, response)
+  return EmptyResult()
+}

package/src/actions/not-found-action.spec.ts

@@ -0,0 +1,17 @@
+import { Injector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import { NotFoundAction } from './not-found-action'
+import { IncomingMessage, ServerResponse } from 'http'
+
+describe('NotFoundAction tests', () => {
+  const request = { url: 'https://google.com' } as IncomingMessage
+  const response = {} as ServerResponse
+
+  it('exec', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      const result = await NotFoundAction({ injector: i, request, response })
+      expect(result.statusCode).toBe(404)
+      expect(result.chunk).toEqual({ error: 'Content not found' })
+    })
+  })
+})

package/src/actions/not-found-action.ts

@@ -0,0 +1,13 @@
+import { JsonResult, RequestAction } from '../request-action-implementation'
+
+/**
+ * @returns The standard Not Found action result
+ */
+export const NotFoundAction: RequestAction<{ result: { error: string } }> = async () => {
+  return JsonResult(
+    {
+      error: 'Content not found',
+    },
+    404,
+  )
+}

package/src/add-cors-header.spec.ts

@@ -0,0 +1,133 @@
+import { IncomingMessage, ServerResponse } from 'http'
+import { Utils } from './utils'
+
+describe('AddCorsHeaders', () => {
+  const utils = new Utils()
+  it('Should NOT add headers for non-cross-site requests', () => {
+    const req: IncomingMessage = {
+      headers: { origin: 'http://localhost/', host: 'http://localhost' },
+    } as any as IncomingMessage
+    const resp: ServerResponse = {
+      setHeader: jest.fn(),
+    } as unknown as ServerResponse
+
+    utils.addCorsHeaders(
+      {
+        origins: ['https://google.com'],
+        credentials: true,
+        headers: ['my-custom-header', 'header-2'],
+      },
+      req,
+      resp,
+    )
+    expect(resp.setHeader).not.toBeCalled()
+  })
+
+  it('Should NOT add headers for not-enabled hosts', () => {
+    const req: IncomingMessage = {
+      headers: { origin: 'http://localhost/', host: 'http://google.com' },
+    } as any as IncomingMessage
+    const resp: ServerResponse = {
+      setHeader: jest.fn(),
+    } as unknown as ServerResponse
+
+    utils.addCorsHeaders(
+      {
+        origins: ['https://github.com'],
+        credentials: true,
+        headers: ['my-custom-header', 'header-2'],
+      },
+      req,
+      resp,
+    )
+    expect(resp.setHeader).not.toBeCalled()
+  })
+
+  it('Should add allow-origin header for enabled hosts', () => {
+    const req: IncomingMessage = {
+      headers: { origin: 'http://localhost/', host: 'http://github.com' },
+    } as any as IncomingMessage
+    const resp: ServerResponse = {
+      setHeader: jest.fn(),
+    } as unknown as ServerResponse
+
+    utils.addCorsHeaders(
+      {
+        origins: ['http://localhost/'],
+      },
+      req,
+      resp,
+    )
+    expect(resp.setHeader).toBeCalledTimes(1)
+    expect(resp.setHeader).toBeCalledWith('Access-Control-Allow-Origin', 'http://localhost/')
+  })
+
+  it('Should add allow-credentials header if enabled', () => {
+    const req: IncomingMessage = {
+      headers: { origin: 'http://localhost/', host: 'http://github.com' },
+    } as any as IncomingMessage
+    const resp: ServerResponse = {
+      setHeader: jest.fn(),
+    } as unknown as ServerResponse
+
+    utils.addCorsHeaders(
+      {
+        origins: ['http://localhost/'],
+        credentials: true,
+        // headers: ['my-custom-header', 'header-2'],
+        // methods: ['DELETE', 'GET', 'POST', 'PUT', 'PATCH'],
+      },
+      req,
+      resp,
+    )
+    expect(resp.setHeader).toBeCalledTimes(2)
+    expect(resp.setHeader).toBeCalledWith('Access-Control-Allow-Origin', 'http://localhost/')
+    expect(resp.setHeader).toBeCalledWith('Access-Control-Allow-Credentials', 'true')
+    // expect(resp.setHeader).toBeCalledWith('Access-Control-Allow-Headers', 'my-custom-header, header-2')
+    // expect(resp.setHeader).toBeCalledWith('Access-Control-Allow-Methods', 'DELETE, GET, POST, PUT, PATCH')
+  })
+
+  it('Should add allow-headers header if enabled', () => {
+    const req: IncomingMessage = {
+      headers: { origin: 'http://localhost/', host: 'http://github.com' },
+    } as any as IncomingMessage
+    const resp: ServerResponse = {
+      setHeader: jest.fn(),
+    } as unknown as ServerResponse
+
+    utils.addCorsHeaders(
+      {
+        origins: ['http://localhost/'],
+        headers: ['my-custom-header', 'header-2'],
+        // methods: ['DELETE', 'GET', 'POST', 'PUT', 'PATCH'],
+      },
+      req,
+      resp,
+    )
+    expect(resp.setHeader).toBeCalledTimes(2)
+    expect(resp.setHeader).toBeCalledWith('Access-Control-Allow-Origin', 'http://localhost/')
+    expect(resp.setHeader).toBeCalledWith('Access-Control-Allow-Headers', 'my-custom-header, header-2')
+    // expect(resp.setHeader).toBeCalledWith('Access-Control-Allow-Methods', 'DELETE, GET, POST, PUT, PATCH')
+  })
+
+  it('Should add allow-methods header if enabled', () => {
+    const req: IncomingMessage = {
+      headers: { origin: 'http://localhost/', host: 'http://github.com' },
+    } as any as IncomingMessage
+    const resp: ServerResponse = {
+      setHeader: jest.fn(),
+    } as unknown as ServerResponse
+
+    utils.addCorsHeaders(
+      {
+        origins: ['http://localhost/'],
+        methods: ['DELETE', 'GET', 'POST', 'PUT', 'PATCH'],
+      },
+      req,
+      resp,
+    )
+    expect(resp.setHeader).toBeCalledTimes(2)
+    expect(resp.setHeader).toBeCalledWith('Access-Control-Allow-Origin', 'http://localhost/')
+    expect(resp.setHeader).toBeCalledWith('Access-Control-Allow-Methods', 'DELETE, GET, POST, PUT, PATCH')
+  })
+})