Merge pull request #56 from Enigmatis/fix-without-connection-tests

fix: connection tests

src/config/create-apollo-config-util.ts

@@ -14,7 +14,7 @@ import {
 import { PolarisGraphQLLogger } from '@enigmatis/polaris-graphql-logger';
 import { AbstractPolarisLogger, LoggerConfiguration } from '@enigmatis/polaris-logs';
 import { PolarisLoggerPlugin, TransactionalMutationsPlugin } from '@enigmatis/polaris-middlewares';
-import { getPolarisConnectionManager } from '@enigmatis/polaris-typeorm';
+import { PolarisConnectionManager } from '@enigmatis/polaris-typeorm';
 import { ApolloServer, PlaygroundConfig } from 'apollo-server-express';
 import { ApolloServerPlugin } from 'apollo-server-plugin-base';
 import { GraphQLSchema } from 'graphql';
@@ -44,22 +44,31 @@ export function createPolarisLoggerFromPolarisServerConfig(
 export function createPolarisPlugins(
     polarisLogger: PolarisGraphQLLogger,
     config: PolarisServerConfig,
+    connectionManager?: PolarisConnectionManager,
 ): Array<ApolloServerPlugin | (() => ApolloServerPlugin)> {
     const plugins: Array<ApolloServerPlugin | (() => ApolloServerPlugin)> = [
         new ExtensionsPlugin(polarisLogger, config.shouldAddWarningsToExtensions),
         new ResponseHeadersPlugin(polarisLogger),
         new PolarisLoggerPlugin(polarisLogger),
-        new SnapshotPlugin(polarisLogger, config.supportedRealities, config.snapshotConfig),
     ];
-    if (config.middlewareConfiguration.allowTransactionalMutations) {
-        const connectionManager = getPolarisConnectionManager();
+    if (connectionManager) {
         plugins.push(
-            new TransactionalMutationsPlugin(
+            new SnapshotPlugin(
                 polarisLogger,
                 config.supportedRealities,
+                config.snapshotConfig,
                 connectionManager,
             ),
         );
+        if (config.middlewareConfiguration.allowTransactionalMutations) {
+            plugins.push(
+                new TransactionalMutationsPlugin(
+                    polarisLogger,
+                    config.supportedRealities,
+                    connectionManager,
+                ),
+            );
+        }
     }
     if (config.plugins) {
         plugins.push(...config.plugins);
@@ -72,8 +81,9 @@ export function initSnapshotGraphQLOptions(
     config: PolarisServerConfig,
     server: ApolloServer,
     schema: GraphQLSchema,
+    connectionManager: PolarisConnectionManager,
 ): void {
-    const plugins: any[] = createPolarisPlugins(polarisLogger, config);
+    const plugins: any[] = createPolarisPlugins(polarisLogger, config, connectionManager);
     remove(plugins, (plugin: ApolloServerPlugin) => plugin instanceof SnapshotPlugin);
     SnapshotListener.graphQLOptions = {
         ...server.requestOptions,
@@ -85,11 +95,16 @@ export function initSnapshotGraphQLOptions(
 export function createPolarisMiddlewares(
     config: PolarisServerConfig,
     logger: PolarisGraphQLLogger,
+    connectionManager?: PolarisConnectionManager,
 ): any[] {
     const allowedMiddlewares: any = [];
     const middlewareConfiguration = config.middlewareConfiguration;
     if (config.supportedRealities) {
-        const middlewaresMap = getMiddlewaresMap(logger, config.supportedRealities);
+        const middlewaresMap = getMiddlewaresMap(
+            logger,
+            config.supportedRealities,
+            connectionManager,
+        );
         for (const [key, value] of Object.entries({ ...middlewareConfiguration })) {
             if (value) {
                 const middlewares = middlewaresMap.get(key);
@@ -109,9 +124,10 @@ export function createPolarisSchemaWithMiddlewares(
     schema: GraphQLSchema,
     logger: PolarisGraphQLLogger,
     config: PolarisServerConfig,
+    connectionManager?: PolarisConnectionManager,
 ) {
     applyMiddleware(schema, new SnapshotMiddleware(logger, config.snapshotConfig).getMiddleware());
-    return applyMiddleware(schema, ...createPolarisMiddlewares(config, logger));
+    return applyMiddleware(schema, ...createPolarisMiddlewares(config, logger, connectionManager));
 }
 
 export function createPolarisSubscriptionsConfig(config: PolarisServerConfig): any {

src/config/polaris-server-config.ts

@@ -4,6 +4,7 @@ import {
     ApplicationProperties,
     LoggerConfiguration,
 } from '@enigmatis/polaris-logs';
+import { PolarisConnectionManager } from '@enigmatis/polaris-typeorm';
 import { ApolloServerExpressConfig } from 'apollo-server-express';
 import { DocumentNode } from 'graphql';
 import { IResolvers } from 'graphql-tools';
@@ -25,4 +26,5 @@ export interface PolarisServerConfig extends ApolloServerExpressConfig {
     shouldAddWarningsToExtensions: boolean;
     allowMandatoryHeaders: boolean;
     snapshotConfig: SnapshotConfiguration;
+    connectionManager?: PolarisConnectionManager;
 }

src/config/polaris-server-options.ts

@@ -1,6 +1,7 @@
 import { RealitiesHolder } from '@enigmatis/polaris-common';
 import { PolarisGraphQLLogger } from '@enigmatis/polaris-graphql-logger';
 import { ApplicationProperties, LoggerConfiguration } from '@enigmatis/polaris-logs';
+import { PolarisConnectionManager } from '@enigmatis/polaris-typeorm';
 import { ApolloServerExpressConfig } from 'apollo-server-express';
 import { DocumentNode } from 'graphql';
 import { IResolvers } from 'graphql-tools';
@@ -21,4 +22,5 @@ export interface PolarisServerOptions extends ApolloServerExpressConfig {
     shouldAddWarningsToExtensions?: boolean;
     allowMandatoryHeaders?: boolean;
     snapshotConfig?: SnapshotConfiguration;
+    connectionManager?: PolarisConnectionManager;
 }

src/index.ts

@@ -2,6 +2,7 @@ export { ExpressContext } from './server/express-context';
 export { PolarisServer, app } from './server/polaris-server';
 export * from './config/create-apollo-config-util';
 export { PolarisServerOptions } from './config/polaris-server-options';
+export { PolarisServerConfig } from './config/polaris-server-config';
 export { MiddlewareConfiguration } from './config/middleware-configuration';
 export { polarisFormatError } from './errors/error-formatter';
 export { SnapshotConfiguration } from './config/snapshot-configuration';

src/middlewares/middlewares-map.ts

@@ -6,13 +6,13 @@ import {
     RealitiesMiddleware,
     SoftDeleteMiddleware,
 } from '@enigmatis/polaris-middlewares';
-import { getPolarisConnectionManager } from '@enigmatis/polaris-typeorm';
+import { PolarisConnectionManager } from '@enigmatis/polaris-typeorm';
 
 export const getMiddlewaresMap = (
     logger: PolarisGraphQLLogger,
     realitiesHolder: RealitiesHolder,
+    connectionManager?: PolarisConnectionManager,
 ): Map<string, any[]> => {
-    const connectionManager = getPolarisConnectionManager();
     const softDeleteMiddleware = new SoftDeleteMiddleware(logger).getMiddleware();
     const realitiesMiddleware = new RealitiesMiddleware(logger, realitiesHolder).getMiddleware();
     const dataVersionMiddleware = new DataVersionMiddleware(

src/plugins/snapshot/snapshot-listener.ts

@@ -2,7 +2,7 @@ import { PolarisGraphQLContext, RealitiesHolder } from '@enigmatis/polaris-commo
 import { PolarisGraphQLLogger } from '@enigmatis/polaris-graphql-logger';
 import {
     getConnectionForReality,
-    getPolarisConnectionManager,
+    PolarisConnectionManager,
     SnapshotPage,
 } from '@enigmatis/polaris-typeorm';
 import { runHttpQuery } from 'apollo-server-core';
@@ -16,19 +16,13 @@ import { SnapshotConfiguration } from '../..';
 
 export class SnapshotListener implements GraphQLRequestListener<PolarisGraphQLContext> {
     public static graphQLOptions: GraphQLOptions;
-    private readonly logger: PolarisGraphQLLogger;
-    private readonly realitiesHolder: RealitiesHolder;
-    private readonly snapshotConfiguration: SnapshotConfiguration;
 
     public constructor(
-        logger: PolarisGraphQLLogger,
-        realitiesHolder: RealitiesHolder,
-        snapshotConfiguration: SnapshotConfiguration,
-    ) {
-        this.logger = logger;
-        this.realitiesHolder = realitiesHolder;
-        this.snapshotConfiguration = snapshotConfiguration;
-    }
+        private readonly logger: PolarisGraphQLLogger,
+        private readonly realitiesHolder: RealitiesHolder,
+        private readonly snapshotConfiguration: SnapshotConfiguration,
+        private readonly connectionManager: PolarisConnectionManager,
+    ) {}
 
     public didResolveOperation(
         requestContext: GraphQLRequestContext<PolarisGraphQLContext> &
@@ -49,8 +43,8 @@ export class SnapshotListener implements GraphQLRequestListener<PolarisGraphQLCo
             const { requestHeaders } = context;
             const snapshotRepository = getConnectionForReality(
                 requestHeaders.realityId!,
-                this.realitiesHolder,
-                getPolarisConnectionManager() as any,
+                this.realitiesHolder as any,
+                this.connectionManager,
             ).getRepository(SnapshotPage);
             const pagesIds: string[] = [];
 

src/plugins/snapshot/snapshot-plugin.ts

@@ -1,5 +1,6 @@
 import { PolarisGraphQLContext, RealitiesHolder } from '@enigmatis/polaris-common';
 import { PolarisGraphQLLogger } from '@enigmatis/polaris-graphql-logger';
+import { PolarisConnectionManager } from '@enigmatis/polaris-typeorm';
 import {
     ApolloServerPlugin,
     GraphQLRequestContext,
@@ -9,23 +10,21 @@ import { SnapshotConfiguration } from '../..';
 import { SnapshotListener } from './snapshot-listener';
 
 export class SnapshotPlugin implements ApolloServerPlugin<PolarisGraphQLContext> {
-    private readonly logger: PolarisGraphQLLogger;
-    private readonly realitiesHolder: RealitiesHolder;
-    private readonly snapshotConfiguration: SnapshotConfiguration;
-
     constructor(
-        logger: PolarisGraphQLLogger,
-        realitiesHolder: RealitiesHolder,
-        snapshotConfiguration: SnapshotConfiguration,
-    ) {
-        this.logger = logger;
-        this.realitiesHolder = realitiesHolder;
-        this.snapshotConfiguration = snapshotConfiguration;
-    }
+        private readonly logger: PolarisGraphQLLogger,
+        private readonly realitiesHolder: RealitiesHolder,
+        private readonly snapshotConfiguration: SnapshotConfiguration,
+        private readonly connectionManager: PolarisConnectionManager,
+    ) {}
 
     public requestDidStart(
         requestContext: GraphQLRequestContext<PolarisGraphQLContext>,
     ): GraphQLRequestListener<PolarisGraphQLContext> | void {
-        return new SnapshotListener(this.logger, this.realitiesHolder, this.snapshotConfiguration);
+        return new SnapshotListener(
+            this.logger,
+            this.realitiesHolder,
+            this.snapshotConfiguration,
+            this.connectionManager,
+        );
     }
 }

src/server/polaris-server.ts

@@ -4,7 +4,7 @@ import { AbstractPolarisLogger } from '@enigmatis/polaris-logs';
 import { makeExecutablePolarisSchema } from '@enigmatis/polaris-schema';
 import {
     getConnectionForReality,
-    getPolarisConnectionManager,
+    PolarisConnectionManager,
     SnapshotPage,
 } from '@enigmatis/polaris-typeorm';
 import { ApolloServer, ApolloServerExpressConfig } from 'apollo-server-express';
@@ -45,12 +45,27 @@ export class PolarisServer {
         this.polarisLogger = createPolarisLoggerFromPolarisServerConfig(this.polarisServerConfig);
         this.apolloServerConfiguration = this.getApolloServerConfigurations();
         this.apolloServer = new ApolloServer(this.apolloServerConfiguration);
-        initSnapshotGraphQLOptions(
-            this.polarisLogger as PolarisGraphQLLogger,
-            this.polarisServerConfig,
-            this.apolloServer,
-            this.createSchemaWithMiddlewares(),
-        );
+        if (config.connectionManager) {
+            initSnapshotGraphQLOptions(
+                this.polarisLogger as PolarisGraphQLLogger,
+                this.polarisServerConfig,
+                this.apolloServer,
+                this.createSchemaWithMiddlewares(),
+                config.connectionManager,
+            );
+            app.get('/snapshot', async (req: express.Request, res: express.Response) => {
+                const id = req.query.id;
+                const realityHeader: string | string[] | undefined = req.headers[REALITY_ID];
+                const realityId: number = realityHeader ? +realityHeader : 0;
+                const snapshotRepository = getConnectionForReality(
+                    realityId,
+                    this.polarisServerConfig.supportedRealities as any,
+                    config.connectionManager as PolarisConnectionManager,
+                ).getRepository(SnapshotPage);
+                const result = await snapshotRepository.findOne({} as any, id);
+                res.send(result?.getData());
+            });
+        }
         const endpoint = `${this.polarisServerConfig.applicationProperties.version}/graphql`;
         app.use(this.apolloServer.getMiddleware({ path: `/${endpoint}` }));
         app.use(
@@ -60,18 +75,6 @@ export class PolarisServer {
         app.use('/$', (req: express.Request, res: express.Response) => {
             res.redirect(endpoint);
         });
-        app.get('/snapshot', async (req: express.Request, res: express.Response) => {
-            const id = req.query.id;
-            const realityHeader: string | string[] | undefined = req.headers[REALITY_ID];
-            const realityId: number = realityHeader ? +realityHeader : 0;
-            const snapshotRepository = getConnectionForReality(
-                realityId,
-                this.polarisServerConfig.supportedRealities,
-                getPolarisConnectionManager(),
-            ).getRepository(SnapshotPage);
-            const result = await snapshotRepository.findOne({} as any, id);
-            res.send(result?.getData());
-        });
         app.get('/whoami', (req: express.Request, res: express.Response) => {
             const appProps = this.polarisServerConfig.applicationProperties;
             const whoami = { service: appProps.name, version: appProps.version };
@@ -85,12 +88,15 @@ export class PolarisServer {
             this.apolloServer.installSubscriptionHandlers(server);
         }
         await server.listen({ port: this.polarisServerConfig.port });
-        setSnapshotCleanerInterval(
-            this.polarisServerConfig.supportedRealities,
-            this.polarisServerConfig.snapshotConfig.secondsToBeOutdated,
-            this.polarisServerConfig.snapshotConfig.snapshotCleaningInterval,
-            this.polarisLogger,
-        );
+        if (this.polarisServerConfig.connectionManager) {
+            setSnapshotCleanerInterval(
+                this.polarisServerConfig.supportedRealities,
+                this.polarisServerConfig.snapshotConfig.secondsToBeOutdated,
+                this.polarisServerConfig.snapshotConfig.snapshotCleaningInterval,
+                this.polarisLogger,
+                this.polarisServerConfig.connectionManager,
+            );
+        }
         this.polarisLogger.info(`Server started at port ${this.polarisServerConfig.port}`);
     }
 
@@ -114,6 +120,7 @@ export class PolarisServer {
             plugins: createPolarisPlugins(
                 this.polarisLogger as PolarisGraphQLLogger,
                 this.polarisServerConfig,
+                this.polarisServerConfig.connectionManager,
             ),
             playground: createPlaygroundConfig(this.polarisServerConfig),
             introspection: createIntrospectionConfig(this.polarisServerConfig),
@@ -132,6 +139,7 @@ export class PolarisServer {
             schema,
             this.polarisLogger as PolarisGraphQLLogger,
             this.polarisServerConfig,
+            this.polarisServerConfig.connectionManager,
         );
     }
 }

src/snapshot/snapshot-cleaner.ts

@@ -2,7 +2,7 @@ import { RealitiesHolder, Reality } from '@enigmatis/polaris-common';
 import { AbstractPolarisLogger } from '@enigmatis/polaris-logs';
 import {
     getConnectionForReality,
-    getPolarisConnectionManager,
+    PolarisConnectionManager,
     SnapshotPage,
 } from '@enigmatis/polaris-typeorm';
 
@@ -13,9 +13,16 @@ export const setSnapshotCleanerInterval = (
     secondsToBeOutdated: number,
     snapshotCleaningInterval: number,
     logger: AbstractPolarisLogger,
+    connectionManager: PolarisConnectionManager,
 ): void => {
     snapshotCleanerInterval = setInterval(
-        () => deleteOutdatedSnapshotPages(realitiesHolder, secondsToBeOutdated, logger),
+        () =>
+            deleteOutdatedSnapshotPages(
+                realitiesHolder,
+                secondsToBeOutdated,
+                logger,
+                connectionManager,
+            ),
         snapshotCleaningInterval * 1000,
     );
 };
@@ -30,12 +37,13 @@ const deleteOutdatedSnapshotPages = (
     realitiesHolder: RealitiesHolder,
     secondsToBeOutdated: number,
     logger: AbstractPolarisLogger,
+    connectionManager: PolarisConnectionManager,
 ): void => {
     realitiesHolder.getRealitiesMap().forEach(async (reality: Reality) => {
         const snapshotRepository = getConnectionForReality(
             reality.id,
-            realitiesHolder,
-            getPolarisConnectionManager() as any,
+            realitiesHolder as any,
+            connectionManager,
         ).getRepository(SnapshotPage);
         await snapshotRepository.query(`DELETE FROM ${snapshotRepository.metadata.tablePath} 
                                         WHERE EXTRACT(EPOCH FROM (NOW() - "creationTime")) > ${secondsToBeOutdated};`);

test/integration/server-without-connection/test-server.ts

@@ -1,3 +1,4 @@
+import { getPolarisConnectionManager } from '@enigmatis/polaris-typeorm';
 import { PolarisServer } from '../../../src';
 import * as polarisProperties from './resources/polaris-properties.json';
 import { resolvers } from './schema/resolvers';
@@ -19,6 +20,7 @@ export async function startTestServer(): Promise<PolarisServer> {
         schemaDirectives: {
             upper: UpperCaseDirective,
         },
+        connectionManager: getPolarisConnectionManager(),
     });
 
     await server.start();

test/integration/server/schema/resolvers.ts

@@ -146,8 +146,13 @@ export const resolvers = {
         ): Promise<boolean> => {
             const connection = getPolarisConnectionManager().get();
             const authorRepos = connection.getRepository(Author);
-            await authorRepos.delete(context, args.id);
-            return true;
+            const result: DeleteResult = await authorRepos.delete(context, args.id);
+            return (
+                result &&
+                result.affected !== null &&
+                result.affected !== undefined &&
+                result.affected > 0
+            );
         },
     },
     Subscription: {