@axinom/mosaic-graphql-common 0.1.0-rc.0

package/src/postgraphile/postgraphile-options-builder.spec.ts

@@ -0,0 +1,744 @@
+/* eslint-disable no-console */
+import PgPubsub from '@graphile/pg-pubsub';
+import { Request, Response } from 'express';
+import { MutationPayloadQueryPlugin, NodePlugin } from 'graphile-build';
+import { stub } from 'jest-auto-stub';
+import 'jest-extended';
+import { Pool } from 'pg';
+import { Plugin, PostGraphilePlugin } from 'postgraphile';
+import { Dict } from '../common';
+import {
+  AnnotateTypesWithPermissionsPlugin,
+  ValidationDirectivesPlugin,
+} from '../plugins';
+import { PostgraphileOptionsBuilder } from './postgraphile-options-builder';
+
+const testHookFactory = (): PostGraphilePlugin => {
+  return {};
+};
+
+describe('RascalConfigBuilder', () => {
+  let req: Request & { token: string };
+  let res: Response;
+  let headers: Dict<string> = {};
+  beforeEach(async () => {
+    req = stub<Request & { token: string }>({ token: 'test-jwt-token-string' });
+    res = stub<Response>({
+      setHeader: (key: string, val: string) => (headers[key] = val),
+    });
+  });
+  afterEach(async () => {
+    headers = {};
+  });
+  describe('build', () => {
+    it('Builder without any calls -> returns empty object', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder.build();
+
+      // Assert
+      expect(options).toEqual({});
+    });
+
+    it('Builder with setPgSettings call with sync function -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+      const mockFunc = () => {
+        return {};
+      };
+
+      // Act
+      const options = builder.setPgSettings(mockFunc).build();
+
+      // Assert
+      expect(options).toEqual({
+        pgSettings: mockFunc,
+      });
+    });
+
+    it('Builder with setPgSettings call with async function -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+      const mockFunc = async () => {
+        return {};
+      };
+
+      // Act
+      const options = builder.setPgSettings(mockFunc).build();
+
+      // Assert
+      expect(options).toEqual({
+        pgSettings: mockFunc,
+      });
+    });
+
+    it('Builder with setErrorsHandler call -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+      const mockFunc = () => {
+        return [];
+      };
+
+      // Act
+      const options = builder.setErrorsHandler(mockFunc).build();
+
+      // Assert
+      expect(options).toEqual({
+        handleErrors: mockFunc,
+      });
+    });
+
+    it.each([
+      {},
+      { enableCors: true },
+      { enableCors: true, legacyRelations: 'omit' },
+    ])('Builder with setProperties "%p" -> options adjusted', (props) => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder.setProperties(props as any).build();
+
+      // Assert
+      expect(options).toEqual(props);
+    });
+
+    it.each([
+      {},
+      { enableCors: true },
+      { enableCors: true, exportGqlSchemaPath: 'schema.graphql' },
+    ])(
+      'Builder with setConditionalProperties %p and true condition -> options adjusted',
+      (props) => {
+        // Arrange
+        const builder = new PostgraphileOptionsBuilder();
+
+        // Act
+        const options = builder.setConditionalProperties(true, props).build();
+
+        // Assert
+        expect(options).toEqual(props);
+      },
+    );
+
+    it.each([
+      {},
+      { enableCors: true },
+      { enableCors: true, exportGqlSchemaPath: 'schema.graphql' },
+    ])(
+      'Builder with setConditionalProperties %p and false condition -> options not adjusted',
+      (props) => {
+        // Arrange
+        const builder = new PostgraphileOptionsBuilder();
+
+        // Act
+        const options = builder.setConditionalProperties(false, props).build();
+
+        // Assert
+        expect(options).toEqual({});
+      },
+    );
+
+    it('Builder with multiple setProperties calls in dev setup -> options adjusted using latest values', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder
+        .setProperties({
+          enableCors: true,
+          legacyRelations: 'omit',
+          ownerConnectionString: 'value 1',
+        })
+        .setProperties({
+          enableCors: true,
+          legacyRelations: 'only',
+          ownerConnectionString: 'value 2',
+        })
+        .setConditionalProperties(true, {
+          dynamicJson: true,
+          exportGqlSchemaPath: 'value 1',
+          ownerConnectionString: 'value 3',
+        })
+        .setConditionalProperties(true, {
+          dynamicJson: true,
+          exportGqlSchemaPath: 'value 2',
+          ownerConnectionString: 'value 4',
+        })
+        .build();
+
+      // Assert
+      expect(options).toEqual({
+        enableCors: true,
+        dynamicJson: true,
+        legacyRelations: 'only',
+        exportGqlSchemaPath: 'value 2',
+        ownerConnectionString: 'value 4',
+      });
+    });
+
+    it('Builder with multiple setProperties calls in non-dev setup -> options adjusted using latest values', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder
+        .setProperties({
+          enableCors: true,
+          legacyRelations: 'omit',
+          ownerConnectionString: 'value 1',
+        })
+        .setProperties({
+          enableCors: true,
+          legacyRelations: 'only',
+          ownerConnectionString: 'value 2',
+        })
+        // Ignored, because condition is false
+        .setConditionalProperties(false, {
+          enableCors: false,
+          legacyRelations: 'deprecated',
+          ownerConnectionString: 'value X',
+        })
+        .build();
+
+      // Assert
+      expect(options).toEqual({
+        enableCors: true,
+        legacyRelations: 'only',
+        ownerConnectionString: 'value 2',
+      });
+    });
+
+    it('Builder with enableSubscriptions call without middleware -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+      const subPlugin: Plugin = () => {
+        return;
+      };
+
+      // Act
+      const options = builder
+        .enableSubscriptions({ plugin: subPlugin })
+        .build();
+
+      // Assert
+      expect([...builder['pluginHooks']]).toEqual([PgPubsub]);
+      expect(options.pluginHook).toBeTruthy();
+      expect(options).toMatchObject({
+        appendPlugins: [subPlugin],
+        subscriptions: true,
+        websocketMiddlewares: [],
+      });
+    });
+
+    it('Builder with enableSubscriptions call with middleware -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+      const subPlugin: Plugin = () => {
+        return;
+      };
+      const mockMiddleware = () => {
+        return;
+      };
+
+      // Act
+      const options = builder
+        .enableSubscriptions({
+          plugin: subPlugin,
+          websocketMiddlewares: [mockMiddleware],
+        })
+        .build();
+
+      // Assert
+      expect([...builder['pluginHooks']]).toEqual([PgPubsub]);
+      expect(options.pluginHook).toBeTruthy();
+      expect(options).toMatchObject({
+        appendPlugins: [subPlugin],
+        subscriptions: true,
+        websocketMiddlewares: [mockMiddleware],
+      });
+    });
+
+    it('Builder with addPlugins calls -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+      const plugin1: Plugin = () => {
+        return;
+      };
+      const plugin2: Plugin = () => {
+        return;
+      };
+      const plugin3: Plugin = () => {
+        return;
+      };
+
+      // Act
+      const options = builder
+        .addPlugins(plugin1, plugin2)
+        .addPlugins(plugin2, plugin3)
+        .build();
+
+      // Assert
+      expect(options).toEqual({
+        appendPlugins: [plugin1, plugin2, plugin3],
+      });
+    });
+
+    it('Builder with addPlugins and enableSubscriptions calls -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+      const plugin1: Plugin = () => {
+        return;
+      };
+      const plugin2: Plugin = () => {
+        return;
+      };
+      const plugin3: Plugin = () => {
+        return;
+      };
+
+      // Act
+      const options = builder
+        .addPlugins(plugin1, plugin2)
+        .enableSubscriptions({ plugin: plugin2 })
+        .enableSubscriptions({ plugin: plugin3 })
+        .build();
+
+      // Assert
+      expect([...builder['pluginHooks']]).toEqual([PgPubsub]);
+      expect(options.pluginHook).toBeTruthy();
+      expect(options).toMatchObject({
+        appendPlugins: [plugin1, plugin2, plugin3],
+        subscriptions: true,
+        websocketMiddlewares: [],
+      });
+    });
+
+    it('Builder with enableSubscriptions and addHookPluginFactory calls -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+      const plugin: Plugin = () => {
+        return;
+      };
+
+      // Act
+      const options = builder
+        .enableSubscriptions({ plugin, hookFactory: testHookFactory })
+        .addHookPluginFactory(testHookFactory)
+        .build();
+
+      // Assert
+      expect([...builder['pluginHooks']]).toEqual([
+        PgPubsub,
+        testHookFactory(),
+      ]);
+      expect(options.pluginHook).toBeTruthy();
+      expect(options).toMatchObject({
+        appendPlugins: [plugin],
+        subscriptions: true,
+        websocketMiddlewares: [],
+      });
+    });
+
+    it('Builder with one setHeader call -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder.setHeader('Access-Control-Max-Age', 60).build();
+
+      // Assert
+      expect(Object.keys(options)).toHaveLength(1);
+      const pluginHooks = [...builder['pluginHooks']];
+      expect(pluginHooks).toHaveLength(1);
+      expect(pluginHooks[0]['postgraphile:http:handler']).toBeFunction();
+      pluginHooks[0]['postgraphile:http:handler']?.(req, {
+        res,
+      });
+      expect(headers).toEqual({ 'Access-Control-Max-Age': 60 });
+      expect(options.pluginHook).toBeFunction();
+    });
+
+    it('Builder with two setHeader call -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder
+        .setHeader('Access-Control-Max-Age', 60)
+        .setHeader('random-header', 'test')
+        .build();
+
+      // Assert
+      expect(Object.keys(options)).toHaveLength(1);
+      const pluginHooks = [...builder['pluginHooks']];
+      expect(pluginHooks).toHaveLength(1);
+      expect(pluginHooks[0]['postgraphile:http:handler']).toBeFunction();
+      pluginHooks[0]['postgraphile:http:handler']?.(req, {
+        res,
+      });
+      expect(headers).toEqual({
+        'Access-Control-Max-Age': 60,
+        'random-header': 'test',
+      });
+      expect(options.pluginHook).toBeFunction();
+    });
+
+    it('Builder with skipPlugins calls -> options adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder
+        .skipPlugins(NodePlugin)
+        .skipPlugins(NodePlugin, MutationPayloadQueryPlugin)
+        .build();
+
+      // Assert
+      expect(options).toEqual({
+        skipPlugins: [NodePlugin, MutationPayloadQueryPlugin],
+      });
+    });
+
+    it('Builder with addConditionalPlugins call in production env and true condition -> options are adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+      const plugin1: Plugin = () => {
+        return;
+      };
+
+      // Act
+      const options = builder.addConditionalPlugins(true, plugin1).build();
+
+      // Assert
+      expect(options).toEqual({
+        appendPlugins: [plugin1],
+      });
+    });
+
+    it('Builder with addConditionalPlugins call in production env and false condition -> options are not adjusted', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+      const plugin1: Plugin = () => {
+        return;
+      };
+
+      // Act
+      const options = builder.addConditionalPlugins(false, plugin1).build();
+
+      // Assert
+      expect(options).toEqual({});
+    });
+
+    it('Builder with addGraphileBuildOptions calls -> results are merged on first hierarchy level, overridden on others', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder
+        .addGraphileBuildOptions({
+          test1: 'test1',
+          test3: 'test3-1',
+          test4: { t1: 't1', t2: 't2' },
+        })
+        .addGraphileBuildOptions({
+          test2: 'test2',
+          test3: 'test3-2',
+          test4: { t1: 't1', t3: 't3' },
+        })
+        .build();
+
+      // Assert
+      expect(options).toEqual({
+        graphileBuildOptions: {
+          test1: 'test1',
+          test2: 'test2',
+          test3: 'test3-2',
+          test4: { t1: 't1', t3: 't3' },
+        },
+      });
+    });
+
+    it('Builder with setAdditionalGraphQLContextFromRequest calls -> latest result is set', async () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder
+        .setAdditionalGraphQLContextFromRequest(async () => {
+          return { test: 'test1' };
+        })
+        .setAdditionalGraphQLContextFromRequest(async () => {
+          return { test: 'test2' };
+        })
+        .build();
+
+      // Assert
+      expect(options.additionalGraphQLContextFromRequest).not.toBeFalsy();
+      const contextProps = await options.additionalGraphQLContextFromRequest?.(
+        req,
+        res,
+      );
+      expect(contextProps).toEqual({ test: 'test2' });
+    });
+
+    it('Builder with setDefaultSettings calls in dev environment -> default settings are set', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder.setDefaultSettings(true, true).build();
+
+      // Assert
+      expect(options.handleErrors).toBeFunction();
+      expect(options).toEqual({
+        allowExplain: true,
+        disableQueryLog: false,
+        dynamicJson: true,
+        enableCors: true,
+        enhanceGraphiql: true,
+        exportGqlSchemaPath: './src/generated/graphql/schema.graphql',
+        graphiql: true,
+        handleErrors: options.handleErrors,
+        ignoreRBAC: false,
+        legacyRelations: 'omit',
+        setofFunctionsContainNulls: false,
+        watchPg: true,
+        retryOnInitFail: false,
+        skipPlugins: [NodePlugin],
+      });
+    });
+
+    it('Builder with setDefaultSettings calls in non-dev environment -> default settings are set', () => {
+      // Arrange
+      const builder = new PostgraphileOptionsBuilder();
+
+      // Act
+      const options = builder.setDefaultSettings(false, false).build();
+
+      // Assert
+      expect(options.handleErrors).toBeFunction();
+      expect(options).toEqual({
+        disableQueryLog: true,
+        dynamicJson: true,
+        enableCors: true,
+        handleErrors: options.handleErrors,
+        ignoreRBAC: false,
+        legacyRelations: 'omit',
+        setofFunctionsContainNulls: false,
+        enhanceGraphiql: false,
+        graphiql: false,
+        allowExplain: false,
+        retryOnInitFail: true,
+        watchPg: false,
+        skipPlugins: [NodePlugin],
+      });
+    });
+
+    it('Builder with setDefaultSettings calls in dev environment with overrides -> default settings are overridden', () => {
+      // Arrange
+      const isDev = true;
+      const builder = new PostgraphileOptionsBuilder();
+      const syncFunc = () => {
+        return [];
+      };
+      const plugin1: Plugin = () => {
+        return;
+      };
+
+      // Act
+      const options = builder
+        .setDefaultSettings(isDev, true)
+        .setErrorsHandler(syncFunc)
+        .setProperties({ dynamicJson: false, ownerConnectionString: 'test' })
+        .setConditionalProperties(isDev, {
+          enhanceGraphiql: false,
+          graphiqlCredentials: 'omit',
+          exportGqlSchemaPath: 'test-path',
+        })
+        .skipPlugins(plugin1)
+        .build();
+
+      // Assert
+      expect(options).toEqual({
+        allowExplain: true,
+        disableQueryLog: false,
+        dynamicJson: false,
+        enableCors: true,
+        enhanceGraphiql: false,
+        exportGqlSchemaPath: 'test-path',
+        graphiql: true,
+        handleErrors: syncFunc,
+        ignoreRBAC: false,
+        legacyRelations: 'omit',
+        setofFunctionsContainNulls: false,
+        watchPg: true,
+        ownerConnectionString: 'test',
+        graphiqlCredentials: 'omit',
+        retryOnInitFail: false,
+        skipPlugins: [NodePlugin, plugin1],
+      });
+    });
+
+    it.each([true, false])(
+      'Builder with setGraphiql call -> settings are set to %p',
+      (graphqlGuiEnabled) => {
+        // Arrange
+        const builder = new PostgraphileOptionsBuilder();
+        // Act
+        const options = builder.setGraphiql(graphqlGuiEnabled).build();
+
+        // Assert
+        expect(options).toEqual({
+          graphiql: graphqlGuiEnabled,
+          enhanceGraphiql: graphqlGuiEnabled,
+          allowExplain: graphqlGuiEnabled,
+        });
+      },
+    );
+
+    it('Builder with most methods called -> options are adjusted', async () => {
+      // Arrange
+      const isDev = true;
+      const builder = new PostgraphileOptionsBuilder();
+      const plugin1: Plugin = () => {
+        return;
+      };
+      const plugin2: Plugin = () => {
+        return;
+      };
+      const plugin3: Plugin = () => {
+        return;
+      };
+      const plugin4: Plugin = () => {
+        return;
+      };
+      const plugin5: Plugin = () => {
+        return;
+      };
+      const asyncFunc = async () => {
+        return {};
+      };
+      const syncFunc = () => {
+        return [];
+      };
+      const authFunc = (_req: unknown) => {
+        return { subject: {}, authErrorInfo: {} };
+      };
+      const ownerPool = new Pool();
+
+      // Act
+      const options = builder
+        .setPgSettings(asyncFunc)
+        .setErrorsHandler(syncFunc)
+        .setProperties({
+          enableCors: true,
+          dynamicJson: true,
+          ignoreRBAC: false,
+          legacyRelations: 'omit',
+          setofFunctionsContainNulls: false,
+          disableQueryLog: true,
+        })
+        .setConditionalProperties(isDev, {
+          ownerConnectionString: 'db-connection-string',
+          exportGqlSchemaPath: './src/generated/graphql/schema.graphql',
+          watchPg: true,
+          graphiql: true,
+          enhanceGraphiql: true,
+          allowExplain: true,
+          disableQueryLog: false,
+        })
+        .enableSubscriptions({
+          plugin: plugin1,
+          websocketMiddlewares: [],
+          hookFactory: testHookFactory,
+        })
+        .skipPlugins(NodePlugin)
+        .addPlugins(ValidationDirectivesPlugin)
+        .addConditionalPlugins(isDev, plugin2)
+        .addPlugins(plugin3)
+        .addPlugins(plugin4, plugin5)
+        .addPlugins(AnnotateTypesWithPermissionsPlugin)
+        .addGraphileBuildOptions({
+          serviceId: 'serviceIdValue',
+          permissionDefinition: 'permissionDefinitionValue',
+        })
+        .addGraphileBuildOptions({
+          ownerPool,
+        })
+        .setAdditionalGraphQLContextFromRequest(async (req) => {
+          const extendedRequest = req as Request & { token: string };
+          const { subject, authErrorInfo } = authFunc(req);
+          return {
+            ownerPool,
+            jwtToken: extendedRequest.token,
+            authErrorInfo,
+            subject,
+          };
+        })
+        .build();
+
+      // Assert
+      const {
+        additionalGraphQLContextFromRequest,
+        appendPlugins,
+        skipPlugins,
+        ...optionsWithoutContextAndPlugins
+      } = options;
+
+      expect(appendPlugins).toEqual([
+        plugin1,
+        ValidationDirectivesPlugin,
+        plugin2,
+        plugin3,
+        plugin4,
+        plugin5,
+        AnnotateTypesWithPermissionsPlugin,
+      ]);
+
+      expect(skipPlugins).toEqual([NodePlugin]);
+      expect([...builder['pluginHooks']]).toEqual([
+        PgPubsub,
+        testHookFactory(),
+      ]);
+      expect(options.pluginHook).toBeTruthy();
+      expect(optionsWithoutContextAndPlugins).toMatchObject({
+        pgSettings: asyncFunc,
+        handleErrors: syncFunc,
+        enableCors: true,
+        dynamicJson: true,
+        ignoreRBAC: false,
+        legacyRelations: 'omit',
+        setofFunctionsContainNulls: false,
+        disableQueryLog: false,
+        ownerConnectionString: 'db-connection-string',
+        exportGqlSchemaPath: './src/generated/graphql/schema.graphql',
+        watchPg: true,
+        graphiql: true,
+        enhanceGraphiql: true,
+        allowExplain: true,
+        subscriptions: true,
+        websocketMiddlewares: [],
+        graphileBuildOptions: {
+          serviceId: 'serviceIdValue',
+          permissionDefinition: 'permissionDefinitionValue',
+          ownerPool,
+        },
+      });
+
+      expect(additionalGraphQLContextFromRequest).not.toBeFalsy();
+      const contextProps = await additionalGraphQLContextFromRequest?.(
+        req,
+        res,
+      );
+      expect(contextProps).toEqual({
+        ownerPool,
+        jwtToken: 'test-jwt-token-string',
+        authErrorInfo: {},
+        subject: {},
+      });
+    });
+  });
+});