@common-stack/generate-plugin 6.0.1-alpha.9 → 6.0.2-alpha.2

package/lib/generators/add-backend/files/src/server-setup/graphql-server.ts.template

@@ -1,185 +0,0 @@
-import { ApolloServer, ApolloServerExpressConfig } from 'apollo-server-express';
-import {
-    ApolloServerPluginCacheControl,
-    ApolloServerPluginDrainHttpServer,
-    GraphQLRequestContext
-} from 'apollo-server-core';
-import responseCachePlugin from 'apollo-server-plugin-response-cache';
-import 'isomorphic-fetch';
-import { Express } from 'express';
-import * as http from 'http';
-import Keyv from 'keyv';
-import KeyvRedis from '@keyv/redis';
-import { KeyvAdapter } from '@apollo/utils.keyvadapter';
-import { RedisCache, RedisClusterCache } from 'apollo-server-cache-redis';
-import { CdmLogger } from '@cdm-logger/core';
-import { WebSocketServer } from 'ws';
-import { IModuleService } from '../interfaces';
-import { GraphqlWs } from './graphql-ws';
-import { invalidateCachePlugin } from '@adminide-stack/platform-server';
-import { config } from '../config';
-
-type ILogger = CdmLogger.ILogger;
-
-let debug = false;
-if ((process.env.LOG_LEVEL && process.env.LOG_LEVEL === 'trace') || process.env.LOG_LEVEL === 'debug') {
-    debug = true;
-}
-
-// @workaround as the `dataSources` not available in Subscription (websocket) Context.
-// https://github.com/apollographql/apollo-server/issues/1526 need to revisit in Apollo-Server v3.
-const constructDataSourcesForSubscriptions = (context, cache, dataSources) => {
-    const intializeDataSource = (instance) => {
-        instance.initialize({ context, cache });
-    };
-    // tslint:disable-next-line:forin
-    // eslint-disable-next-line guard-for-in
-    for (const prop in dataSources) {
-        intializeDataSource(dataSources[prop]);
-    }
-    return dataSources;
-};
-
-let wsServerCleanup: any;
-
-
-
-export class GraphqlServer {
-    private logger: ILogger;
-
-    constructor(
-        private app: Express,
-        private httpServer: http.Server,
-        private cache: RedisCache | RedisClusterCache,
-        private moduleService: IModuleService,
-        private enableSubscription = true,
-    ) {
-        this.logger = this.moduleService.logger.child({ className: 'GraphqlServer' });
-        if (enableSubscription) {
-            const wsServer = new WebSocketServer({
-                server: this.httpServer,
-                path: __GRAPHQL_ENDPOINT__,
-            });
-            const graphqlWs = new GraphqlWs(wsServer, this.moduleService, this.cache);
-            wsServerCleanup = graphqlWs.create();
-        }
-    }
-
-    public async initialize() {
-        this.logger.info('GraphqlServer initializing...');
-        const apolloServer = this.configureApolloServer();
-        await apolloServer.start();
-        const corsOptions = {
-            origin: [config.CLIENT_URL],
-            credentials: true,
-        };
-        apolloServer.applyMiddleware({
-            app: this.app,
-            cors: corsOptions,
-            path: __GRAPHQL_ENDPOINT__,
-        });
-        this.logger.info('GraphqlServer initialized - ', config.CLIENT_URL);
-    }
-
-    getUserIpAddress(req) {
-        let ip = (req?.headers['x-forwarded-for'] || '').split(',')[0] || req?.connection?.remoteAddress;
-        if (ip.substr(0, 7) === '::ffff:') {
-            ip = ip.substr(7);
-        }
-        if (ip === '::1') {
-            ip = '127.0.0.1';
-        }
-        return ip;
-    }
-
-    private configureApolloServer(): ApolloServer {
-        this.logger.info('-- Configuring Apollo Server --');
-        const cache = new KeyvAdapter(new Keyv({ store: new KeyvRedis(this.cache.client) }), {
-            disableBatchReads: true,
-        });
-
-        const serverConfig: ApolloServerExpressConfig = {
-            debug,
-            cache,
-            schema: this.moduleService.schema,
-            dataSources: () => this.moduleService.dataSource,
-            context: async ({
-                req,
-                res,
-                connection,
-            }: {
-                req: Express.Request;
-                res: Express.Response;
-                connection: any;
-            }) => {
-                let context;
-                let addons = {};
-                try {
-                    if (connection) {
-                        context = connection.context;
-                        if (!context.dataSources) {
-                            addons = {
-                                // @workaround for apollo server issue #1526
-                                dataSources: constructDataSourcesForSubscriptions(
-                                    connection.context,
-                                    this.cache,
-                                    this.moduleService.dataSource,
-                                ),
-                            };
-                        } else {
-                            addons = {
-                                // @workaround for apollo server issue #1526
-                                dataSources: context.dataSources,
-                            };
-                        }
-                    } else {
-                        const pureContext = await this.moduleService.createContext(req, res);
-                        const contextServices = await this.moduleService.serviceContext(req, res);
-                        context = {
-                            ...pureContext,
-                            ...contextServices,
-                            preferences: this.moduleService.defaultPreferences,
-                            // update: updateContainers,
-                        };
-                    }
-                    context.userIp = this.getUserIpAddress(req);
-                } catch (err) {
-                    this.logger.error('Adding context to GraphQL failed', { error: err });
-                    throw err;
-                }
-                return {
-                    req,
-                    res,
-                    ...context,
-                    ...addons,
-                };
-            },
-            plugins: [
-                ApolloServerPluginDrainHttpServer({ httpServer: this.httpServer }),
-                ApolloServerPluginCacheControl(),
-                responseCachePlugin({
-                    sessionId: ({ context }) => context?.userContext?.accountId ?? null,
-                    generateCacheKey({
-                                         queryHash,
-                                         operationName
-                                     }: GraphQLRequestContext<Record<string, any>>, keyData): string {
-                        return `${operationName}:${queryHash}`;
-                    },
-                }),
-                invalidateCachePlugin({ cache: this.cache }),
-            ],
-        };
-        if (this.enableSubscription) {
-            serverConfig.plugins.push({
-                async serverWillStart() {
-                    return {
-                        drainServer: async () => {
-                            await wsServerCleanup.dispose();
-                        },
-                    };
-                },
-            });
-        }
-        return new ApolloServer(serverConfig);
-    }
-}

package/lib/generators/add-backend/files/src/server-setup/graphql-subscription-server.ts.template

@@ -1,113 +0,0 @@
-// import { SubscriptionServer, ConnectionContext, ExecutionParams } from 'subscriptions-transport-ws';
-// import { execute, subscribe, ExecutionResult } from 'graphql';
-// // import { GraphQLServerOptions } from 'apollo-server-core';
-// import { formatApolloErrors } from 'apollo-server-errors';
-// import { GraphQLServerOptions } from 'apollo-server-core/dist/graphqlOptions';
-// import { Context } from 'apollo-server-core';
-// import { RedisClusterCache, RedisCache } from 'apollo-server-cache-redis';
-// import { CdmLogger } from '@cdm-logger/core';
-// import { IModuleService } from '../interfaces';
-
-// type ILogger = CdmLogger.ILogger;
-
-// // @workaround as the `dataSources` not available in Subscription (websocket) Context.
-// // https://github.com/apollographql/apollo-server/issues/1526 need to revisit in Apollo-Server v3.
-// const constructDataSourcesForSubscriptions = (context, cache, dataSources) => {
-//     const intializeDataSource = (instance) => {
-//         instance.initialize({ context, cache });
-//     };
-//     // tslint:disable-next-line:forin
-//     for (const prop in dataSources) {
-//         // tslint:disable-next-line:no-console
-//         intializeDataSource(dataSources[prop]);
-//     }
-//     return dataSources;
-// };
-
-// export class GraphqlSubscriptionServer {
-//     private subscriptionServer: SubscriptionServer;
-
-//     private context: Context;
-
-//     private logger: ILogger;
-
-//     constructor(
-//         private moduleService: IModuleService,
-//         private cache: RedisCache | RedisClusterCache,
-//         private requestOptions: Partial<GraphQLServerOptions<any>> = Object.create(null),
-//     ) {
-//         this.logger = this.moduleService.logger.child({ className: 'GraphqlSubscriptionServer' });
-//     }
-
-//     public create() {
-//         this.subscriptionServer = SubscriptionServer.create(
-//             {
-//                 schema: this.moduleService.schema as any,
-//                 execute,
-//                 subscribe,
-//                 onConnect: async (connectionParams: any, webSocket: any, ctx: ConnectionContext) => {
-//                     try {
-//                         this.logger.debug(`Subscription client connected using built-in SubscriptionServer.`);
-//                         const pureContext = await this.moduleService.createContext(connectionParams, webSocket);
-//                         const contextServices = await this.moduleService.serviceContext(connectionParams, webSocket);
-//                         const context = {
-//                             ...contextServices,
-//                             ...pureContext,
-//                             preferences: this.moduleService.defaultPreferences,
-//                             // update: updateContainers,
-//                             wsCtx: ctx,
-//                         };
-//                         const addons = {
-//                             dataSources: constructDataSourcesForSubscriptions(
-//                                 context,
-//                                 this.cache,
-//                                 this.moduleService.dataSource,
-//                             ),
-//                         };
-//                         return {
-//                             ...context,
-//                             ...addons,
-//                         };
-//                     } catch (e) {
-//                         this.logger.error(e);
-//                     }
-//                 },
-//                 onOperation: async (message: { payload: any }, connection: ExecutionParams) => {
-//                     connection.formatResponse = (value: ExecutionResult) => ({
-//                         ...value,
-//                         errors:
-//                             value.errors &&
-//                             formatApolloErrors([...value.errors], {
-//                                 formatter: this.requestOptions.formatError,
-//                                 debug: this.requestOptions.debug,
-//                             }),
-//                     });
-//                     let context: Context = this.context ? this.context : { connection };
-//                     try {
-//                         context =
-//                             typeof this.context === 'function'
-//                                 ? await this.context({ connection, payload: message.payload })
-//                                 : context;
-//                     } catch (e) {
-//                         throw formatApolloErrors([e], {
-//                             formatter: this.requestOptions.formatError,
-//                             debug: this.requestOptions.debug,
-//                         })[0];
-//                     }
-
-//                     return { ...connection }; // TODO: we didn't add `context`
-//                 },
-//             },
-//             {
-//                 noServer: true,
-//             },
-//         );
-//         return this.subscriptionServer;
-//     }
-
-//     public disconnect() {
-//         if (this.subscriptionServer) {
-//             this.subscriptionServer.close();
-//         }
-//     }
-// }

package/lib/generators/add-backend/files/src/server-setup/graphql-ws.ts.template

@@ -1,158 +0,0 @@
-import { useServer } from 'graphql-ws/lib/use/ws';
-import { GraphQLSchema, parse, getOperationAST, GraphQLError, validate } from 'graphql';
-import { GraphQLServerOptions } from 'apollo-server-core/dist/graphqlOptions';
-import { Context } from 'apollo-server-core';
-import { RedisClusterCache, RedisCache } from 'apollo-server-cache-redis';
-import { CdmLogger } from '@cdm-logger/core';
-import { Disposable, SubscribeMessage } from 'graphql-ws';
-import { WebSocketServer } from 'ws';
-import { IModuleService } from '../interfaces';
-import { createContextFromConnectionParams } from './utils';
-
-type ILogger = CdmLogger.ILogger;
-
-// @workaround as the `dataSources` not available in Subscription (websocket) Context.
-// https://github.com/apollographql/apollo-server/issues/1526 need to revisit in Apollo-Server v3.
-const constructDataSourcesForSubscriptions = (context, cache, dataSources) => {
-    const intializeDataSource = (instance) => {
-        instance.initialize({ context, cache });
-    };
-    // tslint:disable-next-line:forin
-    for (const prop in dataSources) {
-        // tslint:disable-next-line:no-console
-        intializeDataSource(dataSources[prop]);
-    }
-    return dataSources;
-};
-
-/**
- * Accept only subscription operations
- * Code from graphql-ws recipes:
- * https://github.com/enisdenjo/graphql-ws/blob/master/README.md#recipes
- */
-function allowOnlySub(schema: GraphQLSchema, msg: SubscribeMessage) {
-    // construct the execution arguments
-    const args = {
-        schema,
-        operationName: msg.payload.operationName,
-        document: parse(msg.payload.query),
-        variableValues: msg.payload.variables,
-    };
-
-    const operationAST = getOperationAST(args.document, args.operationName);
-    if (!operationAST) {
-        // returning `GraphQLError[]` sends an `ErrorMessage` and stops the subscription
-        return [new GraphQLError('Unable to identify operation')];
-    }
-
-    // handle mutation and query requests
-    if (operationAST.operation !== 'subscription') {
-        // returning `GraphQLError[]` sends an `ErrorMessage` and stops the subscription
-        // return [new GraphQLError('Only subscription operations are supported')];
-
-        // or if you want to be strict and terminate the connection on illegal operations
-        throw new Error('Only subscription operations are supported');
-    }
-
-    // dont forget to validate
-    const errors = validate(args.schema, args.document);
-    if (errors.length > 0) {
-        // returning `GraphQLError[]` sends an `ErrorMessage` and stops the subscription
-        return errors;
-    }
-
-    // ready execution arguments
-    return args;
-}
-
-export class GraphqlWs {
-    private subscriptionServer: Disposable;
-
-    private logger: ILogger;
-
-    constructor(
-        private wsServer: WebSocketServer,
-        private moduleService: IModuleService,
-        protected cache: RedisCache | RedisClusterCache,
-    ) {}
-
-    public create() {
-        this.subscriptionServer = useServer(
-            {
-                schema: this.moduleService.schema,
-                // Adding a context property lets you add data to your GraphQL operation context
-                context: async (ctx) => {
-                    // Returning an object here will add that information to our
-                    // GraphQL context, which all of our resolvers have access to.
-                    // ctx is the `graphql-ws` Context where connectionParams live
-                    try {
-                        const pureContext = await this.moduleService.createContext(ctx.connectionParams, null);
-                        const contextServices = await this.moduleService.serviceContext(ctx.connectionParams, null);
-                        const context = {
-                            ...contextServices,
-                            ...pureContext,
-                            preferences: this.moduleService.defaultPreferences,
-                            // update: updateContainers,
-                            ...ctx,
-                        };
-                        const addons = {
-                            dataSources: constructDataSourcesForSubscriptions(
-                                context,
-                                this.cache,
-                                this.moduleService.dataSource,
-                            ),
-                        };
-                        return {
-                            ...context,
-                            ...addons,
-                            ...ctx,
-                            ...pureContext,
-                            preferences: this.moduleService.defaultPreferences,
-                        };
-                    } catch (err) {
-                        this.logger.error(err);
-                    }
-                },
-                // onConnect: async (ctx) => {
-                //     // do anything when connected
-                // },
-                // onOperation: (ctx, msg) => {
-
-                // }
-                // onOperation: async (message: { payload: any }, connection: ExecutionParams) => {
-                //     connection.formatResponse = (value: ExecutionResult) => ({
-                //         ...value,
-                //         errors:
-                //             value.errors &&
-                //             formatApolloErrors([...value.errors], {
-                //                 formatter: this.requestOptions.formatError,
-                //                 debug: this.requestOptions.debug,
-                //             }),
-                //     });
-                //     let context: Context = this.context ? this.context : { connection };
-                //     try {
-                //         context =
-                //             typeof this.context === 'function'
-                //                 ? await this.context({ connection, payload: message.payload })
-                //                 : context;
-                //     } catch (e) {
-                //         throw formatApolloErrors([e], {
-                //             formatter: this.requestOptions.formatError,
-                //             debug: this.requestOptions.debug,
-                //         })[0];
-                //     }
-
-                //     return { ...connection }; // TODO: we didn't add `context`
-                // },
-            },
-            this.wsServer,
-        );
-        return this.subscriptionServer;
-    }
-
-    public disconnect() {
-        if (this.subscriptionServer) {
-            this.subscriptionServer.dispose();
-        }
-    }
-}

package/lib/generators/add-backend/files/src/server-setup/mongodb-migration-update.ts.template

@@ -1,47 +0,0 @@
-import { IModuleService } from '../interfaces';
-import { Schema, Connection as DBConnection } from 'mongoose';
-
-
-
-export const MigrationSchema = new Schema({
-    migrated_at: Date,
-    name: { required: true, type: String },
-});
-
-
-
-export class MongoDBMigrationUpgrade {
-
-    constructor(
-        private moduleService: IModuleService,
-        private mongoDB: DBConnection,
-    ) {
-    }
-
-    public async migrate(): Promise<any> {
-        const container = await this.moduleService.createContext({});
-        try {
-            const migrations: any[]  = container.getAll('MongodbMigration');
-            const model = this.mongoDB.model('Migration', MigrationSchema);
-    
-            return Promise.all(
-                migrations.map(async (migration) => {
-                    const exists = await model.findOne({ name: migration.constructor.name });
-                    if (!exists) {
-                        try {
-                            await migration.up();
-                            await model.create({ name: migration.constructor.name, migrated_at: new Date() });
-                        } catch (e) {
-                            console.log(`Can not process migration ${migration.constructor.name}: `, e);
-                        }
-                    }
-    
-                    return migration.constructor.name;
-                }),
-            );
-        } catch (err) {
-            console.warn('ignoring database migratoin');
-        }
-    }
-}
-

package/lib/generators/add-backend/files/src/server-setup/utils.ts.template

@@ -1,43 +0,0 @@
-import { RedisCache } from 'apollo-server-cache-redis';
-import { CdmLogger } from '@cdm-logger/core';
-
-type ILogger = CdmLogger.ILogger;
-
-// @workaround as the `dataSources` not available in Subscription (websocket) Context.
-// https://github.com/apollographql/apollo-server/issues/1526 need to revisit in Apollo-Server v3.
-const constructDataSourcesForSubscriptions = (context, cache, dataSources) => {
-    const intializeDataSource = (instance) => {
-        instance.initialize({ context, cache });
-    };
-    // tslint:disable-next-line:forin
-    for (const prop in dataSources) {
-        // tslint:disable-next-line:no-console
-        intializeDataSource(dataSources[prop]);
-    }
-    return dataSources;
-};
-
-/**
- * It'll get messy below but there's an issue currently with the state of the protocols that can be used (subscriptions-transport-ws vs graphql-ws).
- * Read more from: https://www.apollographql.com/docs/apollo-server/data/subscriptions/#the-graphql-ws-transport-library
- *
- * Bottomline is, if we use the newer and actively maintained `graphql-ws` lib, then the GraphQL Playground will not work because it uses the old protocol.
- *
- * The approach below tries to support both based on the template provided here but adjusted for our setup here.
- * https://github.com/enisdenjo/graphql-ws#ws-backwards-compat
- */
-export async function createContextFromConnectionParams(
-    context: any,
-    datasources: any,
-    cache: RedisCache,
-    logger: ILogger,
-): Promise<any> {
-    // logger.debug(`Subscription client connected using built-in SubscriptionServer.`);
-    const addons = {
-        dataSources: constructDataSourcesForSubscriptions(context, cache, datasources),
-    };
-    return {
-        ...context,
-        ...addons,
-    };
-}

package/lib/generators/add-backend/files/src/server-setup/websocket-multipath-update.ts.template

@@ -1,88 +0,0 @@
-import * as url from 'url';
-// import { GraphqlSubscriptionServer } from './graphql-subscription-server';
-import { GraphqlWs } from './graphql-ws';
-import { WebSocketServer } from 'ws';
-import { Server } from 'http';
-import { RedisClusterCache, RedisCache } from 'apollo-server-cache-redis';
-import { IModuleService } from '../interfaces';
-import { useServer } from 'graphql-ws/lib/use/ws';
-
-interface WebSocketsCache {
-    [key: string]: WebSocketServer;
-}
-
-interface MultiWebsocketConfig {
-    [key: string]: any;
-}
-export class WebsocketMultiPathServer {
-    private webSockets: WebSocketsCache = {};
-    // private graphqlSubscriptionServer: GraphqlSubscriptionServer;
-    private _graphqlWs: WebSocketServer;
-    constructor(
-        public moduleService: IModuleService,
-        public cache: RedisCache | RedisClusterCache,
-        multiplePathConfig?: MultiWebsocketConfig,
-    ) {
-        this._graphqlWs = new WebSocketServer({ noServer: true, path: __GRAPHQL_ENDPOINT__ });
-        this.webSockets[__GRAPHQL_ENDPOINT__] = this._graphqlWs;
-        this.webSockets[__GRAPHQL_ENDPOINT__].on('connection', (ws, request) => {
-            console.log('--REQUESTED CONNECTION--', this._graphqlWs)
-            useServer({
-                schema: moduleService.schema,
-            }, this._graphqlWs);
-        });
-    
-        for (let key in multiplePathConfig) {
-            if (!multiplePathConfig.hasOwnProperty(key)) {
-                continue;
-            }
-
-            if (!this.webSockets[key]) {
-                this.webSockets[key] = new WebSocketServer({ noServer: true });
-                this.webSockets[key].on('connection', (ws, request) => {
-                    Promise.all([
-                        moduleService.createContext(request, null),
-                        moduleService.serviceContext(request, null),
-
-                    ]).then(multiplePathConfig[key](ws));
-                });
-            }
-        }
-    }
-
-    public httpServerUpgrade(httpServer: Server) {
-        httpServer.on('upgrade', (request, socket, head) => {
-            const pathname = url.parse(request.url).pathname;
-            console.log('--UPGRADE', request.url)
-
-            if (!this.webSockets[pathname]) {
-                // in development 
-                if (pathname !== '/sockjs-node') {
-                    // need to destroy
-                    socket.destroy();
-                }
-            }
-
-            // code to run when a new connection is made
-            this.webSockets[pathname].handleUpgrade(request, socket, head, (ws) => {
-                this.webSockets[pathname].emit('connection', ws, request);
-            });
-        });
-
-        // (new GraphqlWs(this.graphqlWs, this.moduleService, this.cache)).create();
-        // useServer({
-        //     schema: this.moduleService.schema,
-        // }, this.graphqlWs);
-
-        return httpServer;
-    }
-
-    public get graphqlWs() {
-        return this._graphqlWs;
-    }
-    public close() {
-        for (const key in this.webSockets) {
-            this.webSockets[key].close();
-        }
-    }
-}