AppsEngineValidator.ts

import * as vm from 'vm';
import path from 'path';

import { ICompilerResult } from '../definition';
import { IPermission } from '../definition/IPermission';
import { getAvailablePermissions } from '../misc/getAvailablePermissions';
import { Utilities } from '../misc/Utilities';

export class AppsEngineValidator {
    constructor(private readonly appSourceRequire: NodeRequire) { }

    public validateAppPermissionsSchema(permissions: Array<IPermission>): void {
        if (!permissions) {
            return;
        }

        if (!Array.isArray(permissions)) {
            throw new Error('Invalid permission definition. Check your manifest file.');
        }

        const permissionsRequire = this.appSourceRequire('@rocket.chat/apps-engine/server/permissions/AppPermissions');

        if (!permissionsRequire || !permissionsRequire.AppPermissions) {
            return;
        }

        const availablePermissions = getAvailablePermissions(permissionsRequire.AppPermissions);

        permissions.forEach((permission) => {
            if (permission && !availablePermissions.includes(permission.name)) {
                throw new Error(`Invalid permission "${ String(permission.name) }" defined. Check your manifest file`);
            }
        });
    }

    public isValidAppInterface(interfaceName: string): boolean {
        let { AppInterface } = this.appSourceRequire('@rocket.chat/apps-engine/definition/metadata');

        if (!AppInterface) {
            AppInterface = this.appSourceRequire('@rocket.chat/apps-engine/server/compiler/AppImplements');
        }

        return interfaceName in AppInterface;
    }

    public resolveAppDependencyPath(module: string): string | undefined {
        try {
            return this.appSourceRequire.resolve(module);
        } catch (e) {
            console.warn(e);
        }
    }

    public checkInheritance(mainClassFile: string, compilationResult: ICompilerResult): void {
        const { App: EngineBaseApp } = this.appSourceRequire('@rocket.chat/apps-engine/definition/App');
        const mainClassModule = this.compiledRequire(mainClassFile, compilationResult);

        // if the main class is default export use that,
        // else take it from the object { [mainClassFile]: Class }
        const RealApp = typeof mainClassModule === 'function'
            ? mainClassModule
            : mainClassModule.default
                ? mainClassModule.default
                : mainClassModule[mainClassFile];

        if (!RealApp) {
            throw new Error(`There must be an exported class "${ mainClassFile }" or a default export in the main class file.`);
        }

        const mockInfo = { name: '', requiredApiVersion: '', author: { name: '' } };
        const mockLogger = { debug: () => { } };
        const realApp = new RealApp(mockInfo, mockLogger);

        if (!(realApp instanceof EngineBaseApp)) {
            throw new Error('App must extend apps-engine\'s "App" abstract class.'
                + ' Maybe you forgot to install dependencies? Try running `npm install`'
                + ' in your app folder to fix it.',
            );
        }
    }

    /**
     * Require a module from the app compiled  source files
     */
    private compiledRequire(filename: string, compilationResult: ICompilerResult): any {
        const exports = {};
        const context = vm.createContext({
            require: (filepath: string) => {
                // Handles Apps-Engine import
                if (filepath.startsWith('@rocket.chat/apps-engine/definition/')) {
                    return this.appSourceRequire(filepath);
                }

                // Handles native node modules import
                if (Utilities.allowedInternalModuleRequire(filepath)) {
                    return require(filepath);
                }

                // At this point, if the app is trying to require anything that
                // is not a relative path, we don't want to let it through
                if (!filepath.startsWith('.')) {
                    return undefined;
                }

                filepath = path.normalize(path.join(path.dirname(filename), filepath));

                // Handles import of other files in app's source
                if (compilationResult.files[filepath.endsWith('.js') ? filepath : `${ filepath }.js`]) {
                    return this.compiledRequire(filepath, compilationResult);
                }
            },
            exports,
        });

        vm.runInContext(compilationResult.files[`${ filename }.js` as keyof ICompilerResult['files']].compiled, context);

        /**
          * exports will always contain everything
          * for result = vm.runInContext(...), result == Object.values(exports)[0] or exports[filename]
          * since compiledRequired is not classFile only method (called recursively), better to return all exports
          * and extract the main class constructor in the checkInheritance method.
          */
        return exports;
    }
}