@common-stack/generate-plugin 5.0.4-alpha.0 → 5.0.4-alpha.11

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

@@ -0,0 +1,277 @@
+/* eslint-disable import/namespace */
+/* eslint-disable import/no-unresolved */
+/* eslint-disable import/no-extraneous-dependencies */
+// version 08/25/2021
+import * as http from 'http';
+import * as express from 'express';
+import { logger as serverLogger } from '@cdm-logger/server';
+import { Feature } from '@common-stack/server-core';
+import { ContainerModule, interfaces, Container } from 'inversify';
+import { ServiceBroker, ServiceSettingSchema } from 'moleculer';
+import { CommonType } from '@common-stack/core';
+import { isEmpty } from 'lodash-es';
+import { CdmLogger } from '@cdm-logger/core';
+import { applyMiddleware } from 'graphql-middleware';
+import { shield } from 'graphql-shield';
+import { expressApp } from './express-app';
+import { GraphqlServer } from './server-setup/graphql-server';
+import { config } from './config';
+import { ConnectionBroker } from './connectors/connection-broker';
+import { brokerConfig } from './config/moleculer.config';
+import modules, { settings } from './modules';
+import { GatewaySchemaBuilder } from './api/schema-builder';
+import { WebsocketMultiPathServer } from './server-setup/websocket-multipath-update';
+import { IModuleService } from './interfaces';
+import { migrate } from './utils/migrations';
+import { InterNamespaceMiddleware } from './middleware/moleculer-inter-namespace';
+// This is temp and will be replaced one we add support for rules in Feature
+
+type ILogger = CdmLogger.ILogger;
+
+function startListening(port) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const server = this;
+    return new Promise((resolve) => {
+        server.listen(port, resolve);
+    });
+}
+
+const infraModule = ({ broker, pubsub, mongoClient, logger }) =>
+    new ContainerModule((bind: interfaces.Bind) => {
+        bind('Logger').toConstantValue(logger);
+        bind(CommonType.LOGGER).toConstantValue(logger);
+        bind('Environment').toConstantValue(config.NODE_ENV || 'development');
+        bind(CommonType.ENVIRONMENT).toConstantValue(config.NODE_ENV || 'development');
+        bind('PubSub').toConstantValue(pubsub);
+        bind(CommonType.PUBSUB).toConstantValue(pubsub);
+        bind(CommonType.MOLECULER_BROKER).toConstantValue(broker);
+        bind('MoleculerBroker').toConstantValue(broker);
+        bind('MongoDBConnection').toConstantValue(mongoClient);
+    });
+
+/**
+ *  Controls the lifecycle of the Application Server
+ *
+ * @export
+ * @class StackServer
+ */
+export class StackServer {
+    public httpServer: http.Server & { startListening?: (port) => void };
+
+    private app: express.Express;
+
+    private logger: ILogger;
+
+    private connectionBroker: ConnectionBroker;
+
+    private mainserviceBroker: ServiceBroker;
+
+    private microserviceBroker: ServiceBroker;
+
+    private multiPathWebsocket: WebsocketMultiPathServer;
+
+    private serviceContainer: Container;
+
+    private microserviceContainer: Container;
+
+    constructor() {
+        this.logger = serverLogger.child({ className: 'StackServer' });
+    }
+
+    public async initialize() {
+        this.logger.info('StackServer initializing');
+
+        // eslint-disable-next-line import/namespace
+        this.connectionBroker = new ConnectionBroker(brokerConfig.transporter, this.logger);
+        const redisClient = this.connectionBroker.redisDataloaderClient;
+
+        const mongoClient = await this.connectionBroker.mongoConnection;
+
+        // Moleculer Broker Setup
+        this.mainserviceBroker = new ServiceBroker({
+            ...brokerConfig,
+            middlewares: [
+                InterNamespaceMiddleware([
+                    {
+                        namespace: 'api-admin',
+                        transporter: brokerConfig.transporter,
+                    },
+                ]),
+            ],
+            started: async () => {
+                await modules.preStart(this.serviceContainer);
+                if (config.NODE_ENV === 'development') {
+                    // await modules.microservicePreStart(this.micorserviceContainer);
+                }
+
+                try {
+                    this.logger.info('Starting Migration');
+                    await migrate(mongoClient, this.serviceContainer, this.logger);
+                    this.logger.info('End Migration');
+                } catch (e) {
+                    this.logger.error('Error while running migrations', e);
+                    this.logger.error(e.stack);
+                }
+
+                try {
+                    await modules.postStart(this.serviceContainer);
+                } catch (e) {
+                    this.logger.error('Error while running Post Start', e);
+                    this.logger.error(e.stack);
+                }
+                // start DB migration
+
+                if (config.NODE_ENV === 'development') {
+                    // await modules.microservicePostStart(this.micorserviceContainer);
+                }
+            },
+
+            // created,
+            async created() {
+                return Promise.resolve();
+            },
+        });
+
+        if (config.NODE_ENV === 'development') {
+            this.microserviceBroker = new ServiceBroker({
+                ...brokerConfig,
+                nodeID: 'node-broker-2',
+                started: async () => {
+                    await modules.microservicePreStart(this.microserviceContainer);
+                    await modules.microservicePostStart(this.microserviceContainer);
+                },
+                // created,
+                created: async () => Promise.resolve(),
+            });
+        }
+        const pubsub = await this.connectionBroker.graphqlPubsub;
+        const InfraStructureFeature = new Feature({
+            createContainerFunc: [
+                () =>
+                    infraModule({
+                        broker: this.mainserviceBroker,
+                        pubsub,
+                        mongoClient,
+                        logger: serverLogger,
+                    }),
+            ],
+            createServiceFunc: (container) => ({ moleculerBroker: container.get(CommonType.MOLECULER_BROKER) }),
+            createHemeraContainerFunc: [
+                () =>
+                    infraModule({
+                        broker: this.mainserviceBroker,
+                        pubsub,
+                        mongoClient,
+                        logger: serverLogger,
+                    }),
+            ],
+        });
+
+        const allModules = new Feature(InfraStructureFeature, modules as Feature);
+        let executableSchema = await new GatewaySchemaBuilder({
+            schema: allModules.schemas,
+            resolvers: allModules.createResolvers({
+                pubsub,
+                logger: serverLogger,
+                subscriptionID: `${settings.subTopic}`,
+            }),
+            directives: [],
+            directiveResolvers: allModules.createDirectives({ logger: this.logger }),
+            middlewares: allModules.graphqlMiddlewares,
+            rules: allModules.rules,
+            logger: serverLogger,
+        }).build();
+
+        // set the service container
+        this.serviceContainer = await allModules.createContainers({ ...settings, mongoConnection: mongoClient });
+        const createServiceContext = allModules.createServiceContext({ ...settings, mongoConnection: mongoClient });
+        const serviceBroker: IModuleService = {
+            serviceContainer: this.serviceContainer,
+            serviceContext: createServiceContext,
+            dataSource: allModules.createDataSource(),
+            defaultPreferences: allModules.createDefaultPreferences(),
+            createContext: async (req, res) => allModules.createContext(req, res),
+            logger: serverLogger,
+            schema: executableSchema,
+        };
+        allModules.loadMainMoleculerService({
+            broker: this.mainserviceBroker,
+            container: this.serviceContainer,
+            settings,
+        });
+        if (config.NODE_ENV === 'development') {
+            this.microserviceContainer = await allModules.createHemeraContainers({
+                ...settings,
+                mongoConnection: mongoClient,
+            });
+            allModules.loadClientMoleculerService({
+                broker: this.microserviceBroker,
+                container: this.microserviceContainer,
+                settings,
+            });
+        }
+
+        // initialize Servers
+        this.httpServer = http.createServer();
+        this.app = await expressApp(serviceBroker, null, this.httpServer);
+
+        this.httpServer.startListening = startListening.bind(this.httpServer);
+        this.httpServer.on('request', this.app);
+        this.httpServer.on('close', () => {
+            this.httpServer = undefined;
+        });
+
+        const customWebsocket = allModules.getWebsocketConfig();
+        const customWebsocketEnable = !isEmpty(customWebsocket);
+
+        if (customWebsocketEnable) {
+            this.multiPathWebsocket = new WebsocketMultiPathServer(serviceBroker, redisClient, customWebsocket);
+            this.httpServer = this.multiPathWebsocket.httpServerUpgrade(this.httpServer);
+        }
+        const graphqlServer = new GraphqlServer(
+            this.app,
+            this.httpServer,
+            redisClient,
+            serviceBroker,
+            !customWebsocketEnable,
+        );
+
+        await graphqlServer.initialize();
+        this.app.use('/graphql', (req, res, next) => {
+            res.append('Access-Control-Allow-Credentials', JSON.stringify(true));
+            res.append('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE');
+            res.append('Access-Control-Allow-Origin', '*');
+            res.append(
+                'Access-Control-Allow-Headers',
+                'X-Requested-With, X-HTTP-Method-Override, X-CSP-Nonce, Content-Type, Accept',
+            );
+            next();
+        });
+    }
+
+    public async start() {
+        if (config.NODE_ENV === 'development') {
+            await Promise.all([this.mainserviceBroker.start(), this.microserviceBroker.start()]);
+        } else {
+            await this.mainserviceBroker.start();
+        }
+    }
+
+    public async cleanup() {
+        if (this.multiPathWebsocket) {
+            this.multiPathWebsocket.close();
+        }
+        if (this.httpServer) {
+            await this.httpServer.close();
+        }
+        if (this.connectionBroker) {
+            await this.connectionBroker.stop();
+        }
+        if (this.mainserviceBroker) {
+            await this.mainserviceBroker.stop();
+        }
+        if (this.microserviceBroker) {
+            await this.microserviceBroker.stop();
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+import { Schema, Connection } from 'mongoose';
+import { Container } from 'inversify';
+import { IDatabaseMigration } from '@adminide-stack/core';
+import { CdmLogger } from '@cdm-logger/core';
+
+export const MigrationSchema = new Schema({
+    migrated_at: Date,
+    name: { required: true, type: String },
+});
+
+export async function migrate(db: Connection, container: Container, logger: CdmLogger.ILogger) {
+    try {
+        const migrations = container.getAll<IDatabaseMigration>('MongodbMigration');
+        const model = db.model<any, any>('Migration', MigrationSchema);
+        migrations.map(async (migration) => {
+            const exists = await model.findOne({ name: migration.id });
+            if (!exists) {
+                try {
+                    await migration.up();
+                    await model.create({ name: migration.id, migrated_at: new Date() });
+                } catch (e) {
+                    console.log(`Can not process migration ${migration.id}: `, e);
+                }
+            }
+
+            return migration.id;
+        });
+    } catch (err) {
+        console.warn('ignoring migrate database due to ', err.message);
+    }
+
+}

package/lib/generators/add-backend/files/tsconfig.base.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "module": "ESNext",
+    "esModuleInterop": true, // Important for ESM interoperability
+    "moduleResolution": "node",
+    "jsx": "react",
+    "declaration": true,
+    "experimentalDecorators": true,
+    "preserveConstEnums": true,
+    "sourceMap": true,
+    "noImplicitAny": false,
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": false,
+    "pretty": true,
+    "removeComments": false,
+    "lib": [
+      "es2017",
+      "dom",
+      "esnext.asynciterable"
+    ],
+    "types": [
+      "@types/node",
+      "@types/jest"
+    ]
+  },
+  "include": [
+    "../../typings/*.d.ts"
+  ]
+}

package/lib/generators/add-backend/files/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "sourceMap": true,
+    "declaration": false,
+    "allowSyntheticDefaultImports": true,
+    "rootDirs": ["./src","../knexfile.ts"],
+    "outDir": "./dist"
+  },
+  "include": [
+    "../../typings/*.d.ts",
+  ],
+  "exclude": [
+    "node_modules",
+    "lib",
+    "dist",
+    "webpack.config.js"
+  ]
+}

package/lib/generators/add-backend/files/webpack.config.js

@@ -0,0 +1,186 @@
+process.env.ENV_FILE !== null && require('dotenv').config({ path: process.env.ENV_FILE });
+const webpack = require('webpack');
+const path = require('path');
+const { CleanWebpackPlugin } = require('clean-webpack-plugin');
+const nodeExternals = require('webpack-node-externals');
+const NodemonPlugin = require('nodemon-webpack-plugin'); // Ding
+const EnvListPlugin = require('@common-stack/env-list-loader');
+const buildConfig = require('./build.config');
+
+const modulenameExtra = process.env.BUILD_MODULE_TO_INCLUDE ? `${process.env.BUILD_MODULE_TO_INCLUDE}|` : '';
+let modulenameRegex;
+
+try {
+    modulenameRegex = new RegExp(
+        `(${modulenameExtra}ts-invariant|webpack/hot/poll)|(\\.(css|less|scss|png|ico|jpg|gif|xml|woff|woff2|otf|ttf|eot|svg)(\\?[0-9a-z]+)?$)`,
+    );
+    console.log('Module Name Regex: ', modulenameRegex);
+} catch (error) {
+    console.error('Error creating regex for module name: ', error);
+}
+
+if (process.env.BUILD_MODULE_TO_INCLUDE) {
+    console.log('Build Module to include (BUILD_MODULE_TO_INCLUDE): ', process.env.BUILD_MODULE_TO_INCLUDE);
+} else {
+    console.log('BUILD_MODULE_TO_INCLUDE is not set.');
+}
+
+const config = {
+    entry: {
+        index: (process.env.NODE_ENV !== 'production' ? ['webpack/hot/poll?200'] : []).concat([
+            // 'raf/polyfill',
+            './src/index.ts',
+        ]),
+    },
+    name: 'server',
+    module: {
+        rules: [
+            {
+                test: /\.(png|ico|jpg|gif|xml)$/,
+                use: { loader: 'url-loader', options: { name: '[hash].[ext]', limit: 100000 } },
+            },
+            {
+                test: /\.woff(2)?(\?[0-9a-z]+)?$/,
+                use: { loader: 'url-loader', options: { name: '[hash].[ext]', limit: 100000 } },
+            },
+            {
+                test: /\.(otf|ttf|eot|svg)(\?[0-9a-z]+)?$/,
+                use: { loader: 'file-loader', options: { name: '[hash].[ext]' } },
+            },
+            {
+                test: /\.css$/,
+                use: [
+                    { loader: 'isomorphic-style-loader' },
+                    { loader: 'css-loader', options: { sourceMap: true } },
+                    { loader: 'postcss-loader', options: { sourceMap: true } },
+                ],
+            },
+            {
+                test: /\.scss$/,
+                use: [
+                    { loader: 'isomorphic-style-loader' },
+                    { loader: 'css-loader', options: { sourceMap: true } },
+                    { loader: 'postcss-loader', options: { sourceMap: true } },
+                    { loader: 'sass-loader', options: { sourceMap: true } },
+                ],
+            },
+            {
+                test: /\.less$/,
+                use: [
+                    { loader: 'isomorphic-style-loader' },
+                    { loader: 'css-loader', options: { sourceMap: true } },
+                    { loader: 'postcss-loader', options: { sourceMap: true } },
+                    { loader: 'less-loader', options: { javascriptEnabled: true, sourceMap: true } },
+                ],
+            },
+            { test: /\.graphqls/, use: { loader: 'raw-loader' } },
+            { test: /\.(graphql|gql)$/, use: [{ loader: 'graphql-tag/loader' }] },
+            // {
+            //     test: /\.[tj]sx?$/,
+            //     use: {
+            //         loader: 'babel-loader',
+            //         options: { babelrc: true, rootMode: 'upward-optional' },
+            //     },
+            // },
+            {
+                test: /\.tsx?$/, // for TypeScript
+                loader: 'esbuild-loader',
+                options: {
+                    loader: 'tsx', // Or 'ts' for TypeScript without JSX
+                    target: 'es2015', // Specify ECMAScript target version
+                },
+                exclude: /node_modules/,
+            },
+            {
+                test: /\.jsx?$/, // for JavaScript
+                loader: 'esbuild-loader',
+                options: {
+                    loader: 'jsx', // Or 'js' for plain JavaScript
+                    target: 'es2015',
+                },
+                exclude: /node_modules/,
+            },
+            {
+                // searches for files ends with <dir>/config/env-config.js or <dir>/config/public-config.js
+                test: /config\/(env-config|public-config)\.(j|t)s/,
+                use: {
+                    loader: '@common-stack/env-list-loader',
+                },
+            },
+            { test: /locales/, use: { loader: '@alienfast/i18next-loader' } },
+        ],
+        unsafeCache: false,
+    },
+    resolve: {
+        symlinks: true,
+        cacheWithContext: false,
+        unsafeCache: false,
+        extensions: [
+            '.web.mjs',
+            '.web.js',
+            '.web.jsx',
+            '.web.ts',
+            '.web.tsx',
+            '.mjs',
+            '.js',
+            '.jsx',
+            '.ts',
+            '.tsx',
+            '.json',
+        ],
+    },
+    watchOptions: { ignored: /dist/ },
+    output: {
+        pathinfo: false,
+        filename: 'index.js',
+        path: path.join(__dirname, 'dist'),
+        publicPath: '/',
+        sourceMapFilename: '[name].[chunkhash].js.map',
+    },
+    devtool: process.env.NODE_ENV === 'production' ? 'nosources-source-map' : 'cheap-module-source-map',
+    mode: process.env.NODE_ENV || 'development',
+    performance: { hints: false },
+    plugins: (process.env.NODE_ENV !== 'production'
+        ? [
+              //   new Dotenv(),
+              new webpack.HotModuleReplacementPlugin(),
+              new NodemonPlugin({ script: './dist/index.js' }),
+          ]
+        : []
+    ).concat([
+        // The plugin lists the environment that required as well recommendation about the keys used.
+        new EnvListPlugin.Plugin(),
+        new CleanWebpackPlugin({ cleanOnceBeforeBuildPatterns: ['dist'] }),
+        new webpack.BannerPlugin({ banner: 'require("source-map-support").install();', raw: true, entryOnly: true }),
+        new webpack.DefinePlugin(
+            Object.assign(
+                ...Object.entries(buildConfig).map(([k, v]) => ({
+                    [k]: typeof v !== 'string' ? v : `"${v.replace(/\\/g, '\\\\')}"`,
+                })),
+            ),
+        ),
+        // new CopyWebpackPlugin({
+        //     patterns: [
+        //         {
+        //             from: '../../tools/esm-wrapper.js',
+        //             to: 'index.js',
+        //         },
+        //     ],
+        // }),
+    ]),
+    target: 'node',
+    externals: [
+        nodeExternals(),
+        nodeExternals({
+            modulesDir: path.resolve(__dirname, '../../node_modules'),
+            allowlist: [modulenameRegex],
+        }),
+    ],
+    optimization: {
+        concatenateModules: false,
+        minimize: false,
+    },
+    node: { __dirname: true, __filename: true },
+};
+
+module.exports = config;