[Next.js][Multi-site] Updated site resolver to prefer more specific hostname matches

packages/sitecore-jss/src/site/site-resolver.test.ts

@@ -38,7 +38,6 @@ describe('SiteResolver', () => {
         { hostName: 'var.com', language: '', name: 'var' },
         { hostName: 'bar.net', language: '', name: 'bar' },
         { hostName: '*.com', language: '', name: 'foo' },
-        { hostName: 'foo.com', language: '', name: 'foo-en' },
       ]);
       const site = resolver.getByHost('foo.com');
 
@@ -50,7 +49,6 @@ describe('SiteResolver', () => {
       const resolver = new SiteResolver([
         { hostName: 'bar.net', language: '', name: 'bar' },
         { hostName: '*', language: '', name: 'wildcard' },
-        { hostName: 'foo.com', language: '', name: 'foo' },
       ]);
       const site = resolver.getByHost('foo.com');
 
@@ -66,6 +64,42 @@ describe('SiteResolver', () => {
       expect(site?.name).to.equal('foo');
     });
 
+    it('should prefer most specific match', () => {
+      const resolver = new SiteResolver([
+        { hostName: '*', language: '', name: 'foo' },
+        { hostName: '*.app.net', language: '', name: 'bar' },
+        { hostName: 'i.app.net', language: '', name: 'i-bar' },
+        { hostName: 'baz.app.net', language: '', name: 'baz' },
+      ]);
+      let site = resolver.getByHost('foo.net');
+      expect(site).to.not.be.undefined;
+      expect(site?.name).to.equal('foo');
+      site = resolver.getByHost('bar.app.net');
+      expect(site).to.not.be.undefined;
+      expect(site?.name).to.equal('bar');
+      site = resolver.getByHost('i.app.net');
+      expect(site).to.not.be.undefined;
+      expect(site?.name).to.equal('i-bar');
+      site = resolver.getByHost('Baz.app.net');
+      expect(site).to.not.be.undefined;
+      expect(site?.name).to.equal('baz');
+    });
+
+    it('should prefer first site match for same hostName', () => {
+      const resolver = new SiteResolver([
+        { hostName: '*', language: '', name: 'foo' },
+        { hostName: 'Bar.net', language: '', name: 'bar' },
+        { hostName: '*', language: '', name: 'foo-never' },
+        { hostName: 'bar.net', language: '', name: 'bar-never' },
+      ]);
+      let site = resolver.getByHost('foo.net');
+      expect(site).to.not.be.undefined;
+      expect(site?.name).to.equal('foo');
+      site = resolver.getByHost('bar.net');
+      expect(site).to.not.be.undefined;
+      expect(site?.name).to.equal('bar');
+    });
+
     describe('multi-value hostname', () => {
       it('hostnames include wildcard characters', () => {
         let resolver = new SiteResolver([

packages/sitecore-jss/src/site/site-resolver.ts

@@ -19,19 +19,12 @@ export class SiteResolver {
    * @throws {Error} if a matching site is not found
    */
   public getByHost = (hostName: string): SiteInfo => {
-    const siteInfo = this.sites.find((info) => {
-      const hostnames = info.hostName.replace(/\s/g, '').split(DELIMITERS);
-
-      return hostnames.some(
-        (hostname) => hostName === hostname || this.matchesPattern(hostName, hostname)
-      );
-    });
-
-    if (!siteInfo) {
-      throw new Error(`Could not resolve site for host ${hostName}`);
+    for (const [hostname, site] of this.getHostMap()) {
+      if (this.matchesPattern(hostName, hostname)) {
+        return site;
+      }
     }
-
-    return siteInfo;
+    throw new Error(`Could not resolve site for host ${hostName}`);
   };
 
   /**
@@ -52,6 +45,38 @@ export class SiteResolver {
     return siteInfo;
   };
 
+  protected getHostMap = (): Map<string, SiteInfo> => {
+    const map = new Map<string, SiteInfo>();
+
+    // First collect unique hostnames.
+    // For sites with same hostname defined, priority is given to the first encountered.
+    this.sites.forEach((site) => {
+      const hostnames = site.hostName
+        .replace(/\s/g, '')
+        .toLocaleLowerCase()
+        .split(DELIMITERS);
+      hostnames.forEach((hostname) => {
+        if (!map.has(hostname)) {
+          map.set(hostname, site);
+        }
+      });
+    });
+
+    // Now order by specificity.
+    // This equivalates to sorting from longest to shortest with the assumption
+    // that your match is less specific as wildcards are introduced.
+    // E.g. order.eu.site.com → *.eu.site.com → *.site.com → *
+    // In case of a tie (e.g. *.site.com vs i.site.com), prefer one with less wildcards.
+    return new Map(
+      Array.from(map).sort((a, b) => {
+        if (a[0].length === b[0].length) {
+          return (a[0].match(/\*/g) || []).length - (b[0].match(/\*/g) || []).length;
+        }
+        return b[0].length - a[0].length;
+      })
+    );
+  };
+  // b[0].match(/\*/g) || []).length
   protected matchesPattern(hostname: string, pattern: string): boolean {
     // dots should be treated as chars
     // stars should be treated as wildcards