@servicetitan/startup 16.0.2 → 17.1.0

package/src/webpack/loaders/expose-loader/__tests__/__snapshots__/index.test.ts.snap

@@ -0,0 +1,134 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`expose-loader should work for a nested property for a global object: errors 1`] = `Array []`;
+
+exports[`expose-loader should work for a nested property for a global object: module 1`] = `
+"var ___EXPOSE_LOADER_IMPORT___ = require(\\"-!./configuration.expose-loader.js\\");
+var ___EXPOSE_LOADER_GLOBAL_THIS___ = require(\\"../../runtime/get-global-this.ts\\");
+var ___EXPOSE_LOADER_STORAGE_KEY___ = Symbol.for('SERVICETITAN_EXPOSE_LOADER_STORAGE');
+if (___EXPOSE_LOADER_GLOBAL_THIS___[___EXPOSE_LOADER_STORAGE_KEY___] === undefined) {
+  ___EXPOSE_LOADER_GLOBAL_THIS___[___EXPOSE_LOADER_STORAGE_KEY___] = Object.assign(
+    Object.create(null),
+    {
+      clear(scope) {
+        delete this[scope];
+      },
+    }
+  );
+}
+var ___EXPOSE_LOADER_STORAGE___ = ___EXPOSE_LOADER_GLOBAL_THIS___[___EXPOSE_LOADER_STORAGE_KEY___];
+if (___EXPOSE_LOADER_GLOBAL_THIS___['SharedDependencies'] === undefined) {
+  ___EXPOSE_LOADER_GLOBAL_THIS___['SharedDependencies'] = Object.create(null);
+}
+___EXPOSE_LOADER_GLOBAL_THIS___.SharedDependencies.Configuration = new Proxy(
+  Object.assign(Object.create(null), {
+    getStorage() {
+      return ___EXPOSE_LOADER_STORAGE___;
+    },
+  }),
+  {
+    get: function (target, prop, receiver) {
+      function getModule(id) {
+        if (___EXPOSE_LOADER_STORAGE___[prop] === undefined) {
+          ___EXPOSE_LOADER_STORAGE___[prop] = Object.create(null);
+        }
+        if (___EXPOSE_LOADER_STORAGE___[prop][id] !== undefined) {
+          return ___EXPOSE_LOADER_STORAGE___[prop][id].exports;
+        }
+        var module = (___EXPOSE_LOADER_STORAGE___[prop][id] = {
+          id,
+          loaded: false,
+          exports: Object.create(null),
+        });
+        __webpack_modules__[id].call(module.exports, module, module.exports, getModule);
+        module.loaded = true;
+        return module.exports;
+      }
+      Object.setPrototypeOf(getModule, __webpack_require__);
+      if (prop === 'getStorage') {
+        return Reflect.get(target, prop, receiver);
+      }
+      return getModule(require.resolveWeak(\\"-!./configuration.expose-loader.js\\"))
+    },
+  }
+);
+module.exports = ___EXPOSE_LOADER_IMPORT___;
+"
+`;
+
+exports[`expose-loader should work for a nested property for a global object: result 1`] = `
+Object {
+  "configuration": Object {
+    "get": [Function],
+    "set": [Function],
+    "version": "1.0.0",
+  },
+}
+`;
+
+exports[`expose-loader should work for a nested property for a global object: warnings 1`] = `Array []`;
+
+exports[`expose-loader should work: errors 1`] = `Array []`;
+
+exports[`expose-loader should work: module 1`] = `
+"var ___EXPOSE_LOADER_IMPORT___ = require(\\"-!./configuration.expose-loader.js\\");
+var ___EXPOSE_LOADER_GLOBAL_THIS___ = require(\\"../../runtime/get-global-this.ts\\");
+var ___EXPOSE_LOADER_STORAGE_KEY___ = Symbol.for('SERVICETITAN_EXPOSE_LOADER_STORAGE');
+if (___EXPOSE_LOADER_GLOBAL_THIS___[___EXPOSE_LOADER_STORAGE_KEY___] === undefined) {
+  ___EXPOSE_LOADER_GLOBAL_THIS___[___EXPOSE_LOADER_STORAGE_KEY___] = Object.assign(
+    Object.create(null),
+    {
+      clear(scope) {
+        delete this[scope];
+      },
+    }
+  );
+}
+var ___EXPOSE_LOADER_STORAGE___ = ___EXPOSE_LOADER_GLOBAL_THIS___[___EXPOSE_LOADER_STORAGE_KEY___];
+___EXPOSE_LOADER_GLOBAL_THIS___.Configuration = new Proxy(
+  Object.assign(Object.create(null), {
+    getStorage() {
+      return ___EXPOSE_LOADER_STORAGE___;
+    },
+  }),
+  {
+    get: function (target, prop, receiver) {
+      function getModule(id) {
+        if (___EXPOSE_LOADER_STORAGE___[prop] === undefined) {
+          ___EXPOSE_LOADER_STORAGE___[prop] = Object.create(null);
+        }
+        if (___EXPOSE_LOADER_STORAGE___[prop][id] !== undefined) {
+          return ___EXPOSE_LOADER_STORAGE___[prop][id].exports;
+        }
+        var module = (___EXPOSE_LOADER_STORAGE___[prop][id] = {
+          id,
+          loaded: false,
+          exports: Object.create(null),
+        });
+        __webpack_modules__[id].call(module.exports, module, module.exports, getModule);
+        module.loaded = true;
+        return module.exports;
+      }
+      Object.setPrototypeOf(getModule, __webpack_require__);
+      if (prop === 'getStorage') {
+        return Reflect.get(target, prop, receiver);
+      }
+      return getModule(require.resolveWeak(\\"-!./configuration.expose-loader.js\\"))
+    },
+  }
+);
+module.exports = ___EXPOSE_LOADER_IMPORT___;
+"
+`;
+
+exports[`expose-loader should work: result 1`] = `
+Object {
+  "configuration": Object {
+    "get": [Function],
+    "set": [Function],
+    "version": "1.0.0",
+  },
+}
+`;
+
+exports[`expose-loader should work: warnings 1`] = `Array []`;

package/src/webpack/loaders/expose-loader/__tests__/index.test.ts

@@ -0,0 +1,99 @@
+/**
+ * @jest-environment node
+ */
+
+import path from 'path';
+
+import { Stats } from 'webpack';
+
+import { getUtils } from '../../../utils/testing';
+
+const { compile, execute, getCompiler, getErrors, getModuleSource, getWarnings, readAsset } =
+    getUtils(path.join(__dirname, '../'));
+
+function getModulesList(name: string, stats: Stats) {
+    const { modules } = stats.toJson({ source: true });
+
+    if (modules) {
+        return modules
+            .map(item => item.id)
+            .filter(item => (item !== undefined ? String(item).startsWith(name) : false));
+    }
+
+    return [];
+}
+
+jest.setTimeout(30000);
+
+describe('expose-loader', () => {
+    it('should work', async () => {
+        const compiler = getCompiler('index.js', {
+            exposes: 'Configuration',
+        });
+        const stats = await compile(compiler);
+
+        expect(getModuleSource('./configuration.expose-loader-exposed.js', stats)).toMatchSnapshot(
+            'module'
+        );
+        expect(
+            execute(readAsset('main.bundle.js', compiler, stats), {
+                before: '',
+                after: 'module.exports = { configuration: Configuration.instance };',
+            })
+        ).toMatchSnapshot('result');
+        expect(getErrors(stats)).toMatchSnapshot('errors');
+        expect(getWarnings(stats)).toMatchSnapshot('warnings');
+    });
+
+    it('should work for a nested property for a global object', async () => {
+        const compiler = getCompiler('index.js', {
+            exposes: 'SharedDependencies.Configuration',
+        });
+        const stats = await compile(compiler);
+
+        expect(getModuleSource('./configuration.expose-loader-exposed.js', stats)).toMatchSnapshot(
+            'module'
+        );
+        expect(
+            execute(readAsset('main.bundle.js', compiler, stats), {
+                before: '',
+                after: 'module.exports = { configuration: SharedDependencies.Configuration.instance };',
+            })
+        ).toMatchSnapshot('result');
+        expect(getErrors(stats)).toMatchSnapshot('errors');
+        expect(getWarnings(stats)).toMatchSnapshot('warnings');
+    });
+
+    it('should be different modules id', async () => {
+        const compiler = getCompiler('index.js', {
+            exposes: 'Configuration',
+        });
+        const stats = await compile(compiler);
+
+        const modules = getModulesList('./configuration.expose-loader', stats);
+        expect(modules[0] !== modules[1]).toBe(true);
+    });
+
+    it('should resolve different instances', async () => {
+        const compiler = getCompiler('index.js', {
+            exposes: 'Configuration',
+        });
+        const stats = await compile(compiler);
+
+        const { instance1, instance2 } = execute(readAsset('main.bundle.js', compiler, stats), {
+            before: '',
+            after: 'module.exports = { instance1: Configuration.instance1, instance2: Configuration.instance2 };',
+        });
+
+        expect(instance1.get()).toEqual(instance1.get());
+        expect(instance2.get()).toEqual(instance2.get());
+        expect(instance1.get()).toEqual(instance2.get());
+
+        instance1.set({ foo: 'instance1' });
+        instance2.set({ foo: 'instance2' });
+
+        expect(instance1.get()).toEqual(instance1.get());
+        expect(instance2.get()).toEqual(instance2.get());
+        expect(instance1.get()).not.toEqual(instance2.get());
+    });
+});

package/src/webpack/loaders/expose-loader/index.ts

@@ -0,0 +1,124 @@
+import { LoaderDefinitionFunction } from 'webpack';
+
+import { contextifyRequest, getNewUserRequest, stringifyRequest } from './utils';
+
+interface Options {
+    exposes: string;
+}
+
+// eslint-disable-next-line func-style
+const loader: LoaderDefinitionFunction<Options> = function () {
+    const { exposes } = this.getOptions({
+        type: 'object',
+        properties: {
+            exposes: {
+                type: 'string',
+                minLength: 1,
+            },
+        },
+        required: ['exposes'],
+        additionalProperties: false,
+    });
+    const callback = this.async();
+
+    const context = this.context;
+
+    // Adding `-exposed` suffix for the module with expose-loader preparations.
+    if (this._module) {
+        this._module.userRequest = getNewUserRequest(this._module.userRequest);
+    }
+
+    /**
+     * Change the request from an absolute to a relative path, this prevents [chunkhash] values
+     * from changing when running webpack builds in different directories.
+     */
+    const request = stringifyRequest(
+        context,
+        `-!${contextifyRequest(context, this.remainingRequest)}`
+    );
+
+    let code = '';
+
+    code += `var ___EXPOSE_LOADER_IMPORT___ = require(${request});\n`;
+
+    code += `var ___EXPOSE_LOADER_GLOBAL_THIS___ = require(${stringifyRequest(
+        context,
+        require.resolve('./runtime/get-global-this')
+    )});\n`;
+
+    /**
+     * Initialization of the storage for the webpack modules cache.
+     * It has the following structure: <storage>.<scope>.<module_id>
+     */
+    code += `var ___EXPOSE_LOADER_STORAGE_KEY___ = Symbol.for('SERVICETITAN_EXPOSE_LOADER_STORAGE');\n`;
+    code += `if (___EXPOSE_LOADER_GLOBAL_THIS___[___EXPOSE_LOADER_STORAGE_KEY___] === undefined) {\n`;
+    code += `  ___EXPOSE_LOADER_GLOBAL_THIS___[___EXPOSE_LOADER_STORAGE_KEY___] = Object.assign(\n`;
+    code += `    Object.create(null),\n`;
+    code += `    {\n`;
+    code += `      clear(scope) {\n`;
+    code += `        delete this[scope];\n`;
+    code += `      },\n`;
+    code += `    }\n`;
+    code += `  );\n`;
+    code += `}\n`;
+    code += `var ___EXPOSE_LOADER_STORAGE___ = ___EXPOSE_LOADER_GLOBAL_THIS___[___EXPOSE_LOADER_STORAGE_KEY___];\n`;
+
+    // Initialization of the path to exposed dependency.
+    let path = `___EXPOSE_LOADER_GLOBAL_THIS___`;
+    for (const segment of exposes.split('.').slice(0, -1)) {
+        path += `['${segment}']`;
+        code += `if (${path} === undefined) {\n`;
+        code += `  ${path} = Object.create(null);\n`;
+        code += `}\n`;
+    }
+
+    /**
+     * Initialization of the exposed dependency variable.
+     * It has the following structure: <path>.<dependency_variable>.<scope>
+     */
+    code += `___EXPOSE_LOADER_GLOBAL_THIS___.${exposes} = new Proxy(\n`;
+    code += `  Object.assign(Object.create(null), {\n`;
+    code += `    getStorage() {\n`;
+    code += `      return ___EXPOSE_LOADER_STORAGE___;\n`;
+    code += `    },\n`;
+    code += `  }),\n`;
+    code += `  {\n`;
+    code += `    get: function (target, prop, receiver) {\n`;
+    code += `      function getModule(id) {\n`;
+    //               The scope initialization in the storage if not been defined yet.
+    code += `        if (___EXPOSE_LOADER_STORAGE___[prop] === undefined) {\n`;
+    code += `          ___EXPOSE_LOADER_STORAGE___[prop] = Object.create(null);\n`;
+    code += `        }\n`;
+    //               Use module from the cache if already initialized.
+    code += `        if (___EXPOSE_LOADER_STORAGE___[prop][id] !== undefined) {\n`;
+    code += `          return ___EXPOSE_LOADER_STORAGE___[prop][id].exports;\n`;
+    code += `        }\n`;
+    //               Define the blank for the module.
+    code += `        var module = (___EXPOSE_LOADER_STORAGE___[prop][id] = {\n`;
+    code += `          id,\n`;
+    code += `          loaded: false,\n`;
+    code += `          exports: Object.create(null),\n`;
+    code += `        });\n`;
+    //               Load the module and its dependencies.
+    code += `        __webpack_modules__[id].call(module.exports, module, module.exports, getModule);\n`;
+    code += `        module.loaded = true;\n`;
+    code += `        return module.exports;\n`;
+    code += `      }\n`;
+    //             Define additional webpack utilities required for the module loading.
+    code += `      Object.setPrototypeOf(getModule, __webpack_require__);\n`;
+    //             Getting the storage is required for the scope cleaning on customer unmounting.
+    code += `      if (prop === 'getStorage') {\n`;
+    code += `        return Reflect.get(target, prop, receiver);\n`;
+    code += `      }\n`;
+    code += `      return getModule(require.resolveWeak(${request}))\n`;
+    code += `    },\n`;
+    code += `  }\n`;
+    code += `);\n`;
+
+    // Return the regular dependency for the in bundle usage.
+    code += `module.exports = ___EXPOSE_LOADER_IMPORT___;\n`;
+
+    callback(null, code);
+};
+
+export = loader;

package/src/webpack/loaders/expose-loader/runtime/get-global-this.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+// @ts-nocheck
+module.exports = (function () {
+    if (typeof globalThis === 'object') {
+        return globalThis;
+    }
+
+    let result;
+
+    try {
+        // This works if eval is allowed (see CSP)
+        result = this || new Function('return this')();
+    } catch (e) {
+        // This works if the window reference is available
+        if (typeof window === 'object') {
+            return window;
+        }
+
+        // This works if the self reference is available
+        if (typeof self === 'object') {
+            return self;
+        }
+
+        // This works if the global reference is available
+        if (typeof global !== 'undefined') {
+            return global;
+        }
+    }
+
+    return result;
+})();

package/src/webpack/loaders/expose-loader/utils/contextify-request.ts

@@ -0,0 +1,28 @@
+import path from 'path';
+
+export function contextifyRequest(context: string, request: string) {
+    return request
+        .split('!')
+        .map(r => {
+            const splitPath = r.split('?');
+
+            if (/^[a-zA-Z]:\\/.test(splitPath[0])) {
+                splitPath[0] = path.win32.relative(context, splitPath[0]);
+
+                if (!/^[a-zA-Z]:\\/.test(splitPath[0])) {
+                    splitPath[0] = splitPath[0].replace(/\\/g, '/');
+                }
+            }
+
+            if (/^\//.test(splitPath[0])) {
+                splitPath[0] = path.posix.relative(context, splitPath[0]);
+            }
+
+            if (!/^(\.\.\/|\/|[a-zA-Z]:\\)/.test(splitPath[0])) {
+                splitPath[0] = `./${splitPath[0]}`;
+            }
+
+            return splitPath.join('?');
+        })
+        .join('!');
+}

package/src/webpack/loaders/expose-loader/utils/get-new-user-request.ts

@@ -0,0 +1,15 @@
+import path from 'path';
+
+export function getNewUserRequest(request: string) {
+    const splittedRequest = request.split('!');
+    const lastPartRequest = splittedRequest.pop()?.split('?', 2) ?? [];
+    const pathObject = path.parse(lastPartRequest[0]);
+
+    pathObject.base = `${path.basename(pathObject.base, pathObject.ext)}-exposed${pathObject.ext}`;
+
+    lastPartRequest[0] = path.format(pathObject);
+
+    splittedRequest.push(lastPartRequest.join('?'));
+
+    return splittedRequest.join('!');
+}

package/src/webpack/loaders/expose-loader/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './contextify-request';
+export * from './get-new-user-request';
+export * from './stringify-request';

package/src/webpack/loaders/expose-loader/utils/stringify-request.ts

@@ -0,0 +1,26 @@
+import path from 'path';
+
+export function stringifyRequest(context: string, request: string) {
+    const splitted = request.split('!');
+
+    return JSON.stringify(
+        splitted
+            .map(part => {
+                // First, separate singlePath from query, because the query might contain paths again
+                const splittedPart = /^(.*?)(\?.*)/.exec(part);
+                const query = splittedPart ? splittedPart[2] : '';
+                let singlePath = splittedPart ? splittedPart[1] : part;
+
+                if (isAbsolutePath(singlePath) && context) {
+                    singlePath = path.relative(context, singlePath);
+                }
+
+                return singlePath.replace(/\\/g, '/') + query;
+            })
+            .join('!')
+    );
+}
+
+function isAbsolutePath(str: string) {
+    return path.posix.isAbsolute(str) || path.win32.isAbsolute(str);
+}

package/src/webpack/shared.config.ts

@@ -105,7 +105,7 @@ export function createConfig(
                     ...(isExposeSharedDependencies()
                         ? Object.entries(sharedDependencies).map(([dependency, variable]) => ({
                               test: require.resolve(dependency),
-                              loader: 'expose-loader',
+                              loader: require.resolve('./loaders/expose-loader'),
                               options: {
                                   exposes: variable,
                               },
@@ -208,7 +208,7 @@ export function createConfig(
                       externals: Object.entries(sharedDependencies).reduce(
                           (result, [dependency, variable]) =>
                               Object.assign(result, {
-                                  [dependency]: variable,
+                                  [dependency]: `${variable}['${metadata.name}']`,
                               }),
                           {}
                       ),

package/src/webpack/utils/testing/compile.ts

@@ -0,0 +1,13 @@
+import { Compiler, Stats } from 'webpack';
+
+export function compile(compiler: Compiler) {
+    return new Promise<Stats>((resolve, reject) => {
+        compiler.run((error, stats) => {
+            if (!stats || error) {
+                return reject(error);
+            }
+
+            return resolve(stats);
+        });
+    });
+}

package/src/webpack/utils/testing/execute.ts

@@ -0,0 +1,21 @@
+import Module from 'module';
+import path from 'path';
+
+const parentModule = module;
+
+export function executeFactory(cwd: string) {
+    return function execute(
+        code: string,
+        { before, after } = { before: 'const __export__;', after: 'module.exports = __export__;' }
+    ) {
+        const resource = 'test.js';
+        const module = new Module(resource, parentModule);
+
+        module.paths = (Module as any)._nodeModulePaths(path.resolve(cwd, './__tests__/__mocks__'));
+        module.filename = resource;
+
+        (module as any)._compile(`${before}\n${code}\n${after}`, resource);
+
+        return module.exports;
+    };
+}

package/src/webpack/utils/testing/get-compiler.ts

@@ -0,0 +1,45 @@
+import path from 'path';
+
+import webpack, { Configuration } from 'webpack';
+import { merge } from 'webpack-merge';
+
+import { createFsFromVolume, Volume } from 'memfs';
+
+export function getCompilerFactory(cwd: string) {
+    return function getCompiler(entry: string, loaderOptions = {}, config: Configuration = {}) {
+        const compiler = webpack(
+            merge(
+                {
+                    mode: 'development',
+                    devtool: config.devtool ?? false,
+                    context: path.resolve(cwd, './__tests__/__mocks__'),
+                    entry: path.resolve(cwd, './__tests__/__mocks__', entry),
+                    output: {
+                        path: path.resolve(cwd, './__tests__/dist'),
+                        filename: '[name].bundle.js',
+                        chunkFilename: '[name].chunk.js',
+                    },
+                    module: {
+                        rules: [
+                            {
+                                test: new RegExp(`\\.${path.basename(cwd)}\\.\\w+$`, 'i'),
+                                rules: [
+                                    {
+                                        loader: require.resolve(cwd),
+                                        options: loaderOptions,
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    plugins: [],
+                },
+                config
+            )
+        );
+
+        compiler.outputFileSystem = createFsFromVolume(new Volume());
+
+        return compiler;
+    };
+}

package/src/webpack/utils/testing/get-errors.ts

@@ -0,0 +1,7 @@
+import { Stats } from 'webpack';
+
+import { normalizeErrors } from './normalize-errors';
+
+export function getErrors(stats: Stats) {
+    return normalizeErrors(stats.compilation.errors);
+}

package/src/webpack/utils/testing/get-module-source.ts

@@ -0,0 +1,11 @@
+import { Stats } from 'webpack';
+
+export function getModuleSource(name: string, stats: Stats) {
+    const { modules } = stats.toJson({ source: true });
+
+    if (modules) {
+        return modules.find(m => m.name?.endsWith(name))?.source;
+    }
+
+    return undefined;
+}

package/src/webpack/utils/testing/get-warnings.ts

@@ -0,0 +1,7 @@
+import { Stats } from 'webpack';
+
+import { normalizeErrors } from './normalize-errors';
+
+export function getWarnings(stats: Stats) {
+    return normalizeErrors(stats.compilation.warnings);
+}

package/src/webpack/utils/testing/index.ts

@@ -0,0 +1,23 @@
+import { compile } from './compile';
+import { executeFactory } from './execute';
+import { getCompilerFactory } from './get-compiler';
+import { getErrors } from './get-errors';
+import { getModuleSource } from './get-module-source';
+import { getWarnings } from './get-warnings';
+import { normalizeErrors } from './normalize-errors';
+import { readAsset } from './read-asset';
+import { readAssets } from './read-assets';
+
+export function getUtils(cwd: string) {
+    return {
+        compile,
+        execute: executeFactory(cwd),
+        getCompiler: getCompilerFactory(cwd),
+        getErrors,
+        getModuleSource,
+        getWarnings,
+        normalizeErrors,
+        readAsset,
+        readAssets,
+    };
+}

package/src/webpack/utils/testing/normalize-errors.ts

@@ -0,0 +1,18 @@
+import { WebpackError } from 'webpack';
+
+function removeCWD(str: string) {
+    const isWin = process.platform === 'win32';
+    let cwd = process.cwd();
+
+    if (isWin) {
+        // eslint-disable-next-line no-param-reassign
+        str = str.replace(/\\/g, '/');
+        cwd = cwd.replace(/\\/g, '/');
+    }
+
+    return str.replace(new RegExp(cwd, 'g'), '');
+}
+
+export function normalizeErrors(errors: WebpackError[]) {
+    return errors.map(error => removeCWD(error.toString().split('\n').slice(0, 2).join('\n')));
+}

package/src/webpack/utils/testing/read-asset.ts

@@ -0,0 +1,26 @@
+import path from 'path';
+
+import { Compiler, Stats } from 'webpack';
+import { IFs } from 'memfs';
+
+export function readAsset(asset: string, compiler: Compiler, stats: Stats) {
+    const usedFs = compiler.outputFileSystem as IFs;
+    const outputPath = stats.compilation.outputOptions.path ?? '';
+
+    let data = '';
+    let targetFile = asset;
+
+    const queryStringIdx = targetFile.indexOf('?');
+
+    if (queryStringIdx >= 0) {
+        targetFile = targetFile.substr(0, queryStringIdx);
+    }
+
+    try {
+        data = usedFs.readFileSync(path.join(outputPath, targetFile)).toString();
+    } catch (error) {
+        data = String(error);
+    }
+
+    return data;
+}