feat: added realities holder

jest.config.js

@@ -1,12 +1,14 @@
 module.exports = {
-    preset: 'ts-jest',
-    setupTestFrameworkScriptFile: './jest.setup.js',
-    testEnvironment: 'node',
-    clearMocks : true,
+    clearMocks: true,
     moduleFileExtensions: [
         "ts",
         "js",
     ],
+    preset: 'ts-jest',
+    setupFilesAfterEnv: [
+        './jest.setup.js'
+    ],
+    testEnvironment: 'node',
     testMatch: [
         "**/*.test.ts"
     ],

jest.setup.js

@@ -1,3 +1,2 @@
-
 // jest.setup.js
-jest.setTimeout(30000);
+jest.setTimeout(30000);

src/inversion-of-control/container-manager.ts

@@ -13,3 +13,4 @@ polarisContainer.bind(POLARIS_TYPES.GraphQLServer).to(PolarisGraphQLServer);
 polarisContainer.bind(POLARIS_TYPES.GraphQLLogger).to(PolarisGraphQLLogger);
 polarisContainer.bind(POLARIS_TYPES.Middleware).to(PolarisMiddleware);
 polarisContainer.bind(POLARIS_TYPES.Middleware).to(IrrelevantEntitiesMiddleware);
+polarisContainer.bind(POLARIS_TYPES.RealitiesHolder).toConstantValue({});

src/inversion-of-control/polaris-types.ts

@@ -18,4 +18,5 @@ export const POLARIS_TYPES = {
     InjectableType: Symbol('InjectableType'),
     InjectableResolver: Symbol('InjectableResolver'),
     CommonEntityInterface: Symbol('CommonEntityInterface`'),
+    RealitiesHolder: Symbol('RealitiesHolder'),
 };

src/middlewares/middleware-activation-condition/filter-condition.ts

@@ -1,4 +1,5 @@
 import { ResponseMiddlewareParams } from '../middleware';
+
 export interface MiddlewareCondition {
     shouldBeReturned(params: ResponseMiddlewareParams, isSubEntity?: boolean): boolean;
 }

src/middlewares/middleware-activation-condition/filter-realities.ts

@@ -1,6 +1,5 @@
 import { PolarisRequestHeaders } from '@enigmatis/utills';
 import { PolarisContext } from '../../server/polaris-context';
-import { ResponseMiddlewareParams } from '../middleware';
 import { MiddlewareCondition } from './filter-condition';
 
 class FilterRealities implements MiddlewareCondition {

src/middlewares/middleware-activation-condition/filter-soft-delete.ts

@@ -1,4 +1,3 @@
-import { ResponseMiddlewareParams } from '../middleware';
 import { MiddlewareCondition } from './filter-condition';
 
 class FilterSoftDelete implements MiddlewareCondition {

src/realities-holder/realities-holder.ts

@@ -0,0 +1,10 @@
+import { injectable } from 'inversify';
+
+@injectable()
+export abstract class RealitiesHolder {
+    abstract getRealities(): Set<number>;
+
+    isRealitySupported(reality: number): boolean {
+        return this.getRealities().has(reality);
+    }
+}

src/server/graphql-server.ts

@@ -13,8 +13,10 @@ import { PolarisGraphQLLogger } from '../logging/polaris-graphql-logger';
 import { Middleware } from '../middlewares/middleware';
 import { createMiddleware } from '../middlewares/polaris-middleware-creator';
 import { PolarisProperties } from '../properties/polaris-properties';
+import { RealitiesHolder } from '../realities-holder/realities-holder';
 import { IrrelevantEntitiesExtension } from './irrelevant-entities-extension';
 import { PolarisContext } from './polaris-context';
+import { RealitiesHolderChecker } from './realities-holder-checker';
 
 export interface GraphQLServer {
     server: ApolloServer;
@@ -39,6 +41,7 @@ export class PolarisGraphQLServer implements GraphQLServer {
         @inject(POLARIS_TYPES.PolarisServerConfig) propertiesConfig: PolarisServerConfig,
         @multiInject(POLARIS_TYPES.Middleware) middlewares: Middleware[],
         @inject(POLARIS_TYPES.GraphQLLogger) private polarisLogger: PolarisGraphQLLogger,
+        @inject(POLARIS_TYPES.RealitiesHolder) private realitiesHolder: RealitiesHolder,
     ) {
         const executableSchemaWithMiddleware = applyMiddleware(
             schema,
@@ -51,7 +54,10 @@ export class PolarisGraphQLServer implements GraphQLServer {
             context: (args: { ctx: Koa.Context; connection: any }) => this.getContext(args),
             formatError: (error: any) => this.formatError(error),
             formatResponse: (response: any) => this.formatResponse(response),
-            extensions: [() => new IrrelevantEntitiesExtension()],
+            extensions: [
+                () => new IrrelevantEntitiesExtension(),
+                () => new RealitiesHolderChecker(realitiesHolder),
+            ],
         };
         this.server = new ApolloServer(config);
         this.app = new Koa();

src/server/realities-holder-checker.ts

@@ -0,0 +1,25 @@
+import { GraphQLExtension} from 'graphql-extensions';
+import { RealitiesHolder } from '../realities-holder/realities-holder';
+import { PolarisContext } from './polaris-context';
+
+export class RealitiesHolderChecker extends GraphQLExtension {
+    constructor(private realitiesHolder: any) {
+        super();
+    }
+
+    requestDidStart(responseContext: { context: PolarisContext }) {
+        const requestedReality = responseContext.context.headers.realityId;
+
+        const realityIsNotSupported: boolean =
+            requestedReality &&
+            this.realitiesHolder &&
+            this.realitiesHolder instanceof RealitiesHolder &&
+            !this.realitiesHolder.isRealitySupported(requestedReality);
+
+        if (realityIsNotSupported) {
+            throw new Error(
+                `The requested reality-id is not supported!\nConsider support that reality-id with the class that extends RealitiesHolder`,
+            );
+        }
+    }
+}

test/integration-tests/test-server/server.ts

@@ -6,11 +6,13 @@ import { TestLogConfig } from './config/log-config';
 import { TestMiddlewaresConfig } from './config/middleware-config';
 import { TestServerConfig } from './config/server-config';
 import { schema } from './schema/schema';
+import { TestRealitiesHolder } from './test-realities-holder';
 
 polarisContainer.bind(POLARIS_TYPES.LoggerConfig).to(TestLogConfig);
 polarisContainer.bind(POLARIS_TYPES.PolarisServerConfig).to(TestServerConfig);
 polarisContainer.bind(POLARIS_TYPES.MiddlewaresConfig).to(TestMiddlewaresConfig);
 polarisContainer.bind(POLARIS_TYPES.GraphQLSchema).toConstantValue(schema);
+polarisContainer.rebind(POLARIS_TYPES.RealitiesHolder).to(TestRealitiesHolder);
 export const logger = polarisContainer.get<GraphqlLogger<any>>(POLARIS_TYPES.GraphQLLogger);
 
 export const server: GraphQLServer = polarisContainer.get<GraphQLServer>(

test/integration-tests/test-server/test-realities-holder.ts

@@ -0,0 +1,9 @@
+import { injectable } from 'inversify';
+import { RealitiesHolder } from '../../../src/realities-holder/realities-holder';
+
+@injectable()
+export class TestRealitiesHolder extends RealitiesHolder {
+    getRealities(): Set<number> {
+        return new Set<number>([0, 2]);
+    }
+}

test/server/graphql-server.test.ts

@@ -5,6 +5,7 @@ import 'reflect-metadata';
 import { PolarisServerConfig } from '../../src/common/injectable-interfaces';
 import { PolarisMiddleware } from '../../src/middlewares/polaris-middleware';
 import { createMiddleware } from '../../src/middlewares/polaris-middleware-creator';
+import { RealitiesHolder } from '../../src/realities-holder/realities-holder';
 import { PolarisGraphQLServer } from '../../src/server/graphql-server';
 
 const apolloServerMock: { [T in keyof ApolloServer]: any } = {
@@ -34,13 +35,15 @@ describe('graphql-server tests', () => {
         polarisProperties: jest.fn(),
     } as any;
     const polarisMiddlewareMock: { [T in keyof PolarisMiddleware]: any } = {} as any;
+    const realitiesHolderMock: { [T in keyof RealitiesHolder]: any } = {} as any;
 
     test('creating new polaris server - with arguments - graphql apply middleware have been called', () => {
         const server = new PolarisGraphQLServer(
             graphQLSchemaMock,
             polarisServerConfigMock,
             [polarisMiddlewareMock],
             polarisLog,
+            realitiesHolderMock,
         );
 
         expect(applyMiddleware).toHaveBeenCalled();
@@ -53,6 +56,7 @@ describe('graphql-server tests', () => {
             polarisServerConfigMock,
             middlewares,
             polarisLog,
+            realitiesHolderMock,
         );
 
         expect(createMiddleware).toHaveBeenCalledTimes(middlewares.length);
@@ -64,6 +68,7 @@ describe('graphql-server tests', () => {
             polarisServerConfigMock,
             [polarisMiddlewareMock],
             polarisLog,
+            realitiesHolderMock,
         );
 
         expect(ApolloServer).toHaveBeenCalled();
@@ -79,6 +84,7 @@ describe('graphql-server tests', () => {
             polarisServerConfigMockWithEndpoint,
             [polarisMiddlewareMock],
             polarisLog,
+            realitiesHolderMock,
         );
         server.start();
         expect(apolloServerMock.applyMiddleware).toHaveBeenCalledWith(
@@ -103,6 +109,7 @@ describe('graphql-server tests', () => {
             polarisServerConfigMockWithEndpoint,
             [polarisMiddlewareMock],
             polarisLog,
+            realitiesHolderMock,
         );
         server.start(app);
         expect(apolloServerMock.applyMiddleware).toHaveBeenCalledWith(
@@ -126,6 +133,7 @@ describe('graphql-server tests', () => {
             polarisServerConfigMockWithEndpoint,
             [polarisMiddlewareMock],
             polarisLog,
+            realitiesHolderMock,
         );
         server.start(app);
         expect(apolloServerMock.applyMiddleware).toHaveBeenCalledWith(