namecheap / ilc Goto Github PK

const kaAgent = new Agent({ freeSocketTimeout: 750 });
const kaAgentHttps = new HttpsAgent({ freeSocketTimeout: 750 });

[...]
#compiler = (routes) => {
        return routes.map(v => {
-            const route = this.#escapeStringRegexp(v.route);
+            let route = this.#escapeStringRegexp(v.route);
+            if (v.meta && v.meta.isSpecialPattern) {
+                route = v.route
+            }
[...]
+              v.meta.isSpecialPattern = true;
            } else {
                let basePath = route;

                if (v.route[v.route.length - 1] === '/') {

describe('when a route contain `/(.*)`', () => {
    const routeWithSpecialPattern = Object.freeze({
        route: '/test/(.*)/test',
        next: false,
        template: 'specialPatternTemplate',
        slots: {
            specialPattern: {
                appName: 'specialPattern',
                props: {
                },
                kind: 'primary',
            },
        },
        meta: {
            isSpecialPattern: true,
        },
    });

    const registryConfigWithSpecialRoute = Object.freeze({
        ...registryConfig,
        routes: [
            routeWithSpecialPattern,
            ...registryConfig.routes
        ],
    });

    it('should match request url template', () => {
        const router = new Router(registryConfigWithSpecialRoute);
        const reqUrl = '/test/launchpad/test';

        chai.expect(router.match(reqUrl)).to.be.eql({
            route: '/test/(.*)/test',
            basePath: '/test/launchpad/test',
            reqUrl,
            template: 'specialPatternTemplate',
            specialRole: null,
            slots: routeWithSpecialPattern.slots,
            meta: {
                isSpecialPattern: true,
            },
        });
    });
});

function generateRouteProps(currentRoute) {
    if (!currentRoute || !currentRoute.route || !currentRoute.meta || !currentRoute.meta.isSpecialPattern) {
        return
    }

    // avoid changing MFEs behaviour default routing
    const tempCurrentRoute = { ...currentRoute };

    if (currentRoute.route.includes('/*') || currentRoute.route.includes('//*')) {
        currentRoute.route = currentRoute.route.replace('//', '/');
        currentRoute.route = currentRoute.route.replace('/*', '/(.*)')
        currentRoute.basePath = currentRoute.reqUrl && currentRoute.reqUrl.split(/[?#]/)[0]
    }

    if (!currentRoute.meta.dynamicProps) {
        currentRoute = tempCurrentRoute;
        return { isSpecialRoute: true }
    }

    const urlAllPaths = currentRoute.basePath.split('/').filter(Boolean);
    const urlStaticPaths = currentRoute.route.split('/(.*)').reduce((acc, path) => {
        const paths = path.split('/').filter(Boolean)
        return [...acc, ...paths]
    }, []);

    const urlDynamicPaths = urlAllPaths.filter(item => !urlStaticPaths.includes(item));
    const urlDynamicProps = currentRoute.meta.dynamicProps.reduce((acc, dynamicPart, index) => {
        return {
            ...acc,
            [dynamicPart]: urlDynamicPaths[index],
        };
    }, {});

    currentRoute = tempCurrentRoute;
    return { isSpecialRoute: true, urlDynamicProps }
}

describe('generateRouteProps', () => {
        const isSpecial = { isSpecialRoute: true }

        const specialRoute = {
            basePath: '/static-first-part/dynamic/static-second-part',
            reqUrl: '/static-first-part/dynamic/static-second-part',
            routeId: 10,
            route: '/static-first-part/(.*)/static-second-part',
            template: 'template',
            specialRole: null,
            meta: { isSpecialPattern: true, dynamicProps: ['dynamicProp'] },
            slots: {
                slot: { appName: 'appName', props: {}, kind: null }
            }
        }

        const expectedProps = {
            ...isSpecial,
            urlDynamicProps: { dynamicProp: "dynamic" },
        }

        const dynamicProps = specialRoute.meta.dynamicProps
        const routeDynamicMiddleAndEnd = "/static-first-part/(.*)/static-second-part/(.*)"

        test('given no route, should return nothing', () => {
            expect(generateRouteProps()).not.toBeDefined()
        });

        test('given a route that is not special, should return nothing', () => {
            expect(generateRouteProps({ meta: {} })).not.toBeDefined()
        });

        test('given a route that is dynamic in the end but dont have dynamicProps, should return isSpecial', () => {
            expect(generateRouteProps({ route: '/news//*', meta: { isSpecialPattern: true } })).toStrictEqual(isSpecial)
        });

        test('given a route that is dynamic in the middle but dont have dynamicProps, should return isSpecial', () => {
            delete specialRoute.meta.dynamicProps

            expect(generateRouteProps(specialRoute)).toStrictEqual(isSpecial)
            specialRoute.meta.dynamicProps = dynamicProps
        });

        test('given a route that is dynamic in the middle and also in the end but dont have dynamicProps, should return isSpecial', () => {
            specialRoute.route = routeDynamicMiddleAndEnd
            delete specialRoute.meta.dynamicProps

            expect(generateRouteProps(specialRoute)).toStrictEqual(isSpecial)
            specialRoute.meta.dynamicProps = dynamicProps
        });


        test('given a route that is dynamic in the end and have dynamicProps, should return routeProps correctly', () => {
            specialRoute.route = '/static//*'
            specialRoute.basePath = '/static/dynamic'
            specialRoute.reqUrl = '/static/dynamic?test=true'

            expect(generateRouteProps(specialRoute)).toStrictEqual(expectedProps)
        });

        test('given a route that is dynamic in the middle, should return routeProps correctly', () => {
            expect(generateRouteProps(specialRoute)).toStrictEqual(expectedProps)
        });

        test('given a route that is dynamic in the middle and start with 2 subpath, should return routeProps correctly', () => {
            specialRoute.route = '/partone/parttwo/(.*)/partthree'
            specialRoute.basePath = '/partone/parttwo/dynamic/partthree'
            specialRoute.reqUrl = '/partone/parttwo/dynamic/partthree?test=true'
            expect(generateRouteProps(specialRoute)).toStrictEqual(expectedProps)
        });

        test('given a route that is dynamic in the middle and end with 2 subpath, should return routeProps correctly', () => {
            specialRoute.route = '/partone/(.*)/parttwo/partthree'
            specialRoute.basePath = '/partone/dynamic/parttwo/partthree'
            specialRoute.reqUrl = '/partone/dynamic/parttwo/partthree?test=true'
            expect(generateRouteProps(specialRoute)).toStrictEqual(expectedProps)
        });

        test('given a route that is dynamic and have multiples before and after subpath, should return routeProps correctly', () => {
            specialRoute.route = '/partone/parttwo/partthree/(.*)/partfour/partfive/partsix'
            specialRoute.basePath = '/partone/parttwo/partthree/dynamic/partfour/partfive/partsix'
            specialRoute.reqUrl = '/partone/parttwo/partthree/dynamic/partfour/partfive/partsix?test=true'
            expect(generateRouteProps(specialRoute)).toStrictEqual(expectedProps)
        });

        test('given a route that is special and more complicated, should return routeProps correctly', () => {
            specialRoute.route = routeDynamicMiddleAndEnd
            specialRoute.basePath = '/static-first-part/dynamic-part-one/static-second-part/dynamic-part-two'
            specialRoute.reqUrl = '/static-first-part/dynamic-part-one/static-second-part/dynamic-part-two'
            specialRoute.meta.dynamicProps = ['dynamicProp', 'dynamicProp2']
            expectedProps.urlDynamicProps = { dynamicProp: "dynamic-part-one", dynamicProp2: "dynamic-part-two" }

            expect(generateRouteProps(specialRoute)).toStrictEqual(expectedProps)
        });
    });

[...]
 const currRoute = request.router.getRoute();

 const routeProps = generateRouteProps(currRoute);

[...]
props: { ...wrapperConf.props, ...routeProps },
[...]
props: { ...wrapperConf.props, ...routeProps },
[...]

function makeFragmentUrl({
  route,
  baseUrl,
  appId,
  props,
  ignoreBasePath = false,
}) {
  const url = new URL(baseUrl);

    if (route.basePath && route.basePath === route.reqUrl && props.isSpecialRoute && !props.urlDynamicProps) {
      // Legacy case we want default basePath i.e. without last path 
      route.basePath = route.basePath.split(route.basePath.split('/').pop())[0]
    
  }