Function getUriWithOrg

apps/web/services/config/config.ts:272–335

(orgslug: string, path: string)

 * the menu to forge a non-existent subdomain like `default.localhost:3000`.
 */
export const getUriWithOrg = (orgslug: string, path: string) => {
  const tenancy = getTenancy()

  // Client-side
  if (typeof window !== 'undefined') {
    // Single tenancy → always relative. The browser keeps us on the same host.
    // Custom domain → relative (we're already on the org's host).
    // Missing slug → relative (caller wants a generic intra-app URL).
    if (tenancy === 'single' || getCustomDomainFromContext() || !orgslug) {
      return path
    }

    // Multi tenancy: relative if we're already on the correct subdomain.
    const baseDomain = stripPort(getLEARNHOUSE_DOMAIN())
    const currentHostname = window.location.hostname
    const expectedHostname = `${orgslug}.${baseDomain}`
    if (currentHostname === expectedHostname) {
      return path
    }

    // Safety net: only synthesize an absolute subdomain URL when the user is
    // on the apex base domain itself (e.g. the org-selection screen) or on
    // some subdomain of it. On any other host — localhost, a host that
    // doesn't end in `.{baseDomain}` — building `${slug}.${baseDomain}` would
    // land them on a hostname that may not resolve (e.g. `default.localhost`),
    // so we return a relative path and keep navigation on the current origin.
    //
    // The apex case is essential: the org-selection screen lives on the apex
    // (`{baseDomain}`), and from there every org link must cross to its
    // `${slug}.${baseDomain}` subdomain. `isSubdomainOf` is false for the apex
    // (a host is not a subdomain of itself), so without the `isSameHost` check
    // org links would collapse to the apex path and loop back to the selector.
    if (!isSubdomainOf(currentHostname, baseDomain) && !isSameHost(currentHostname, baseDomain)) {
      return path
    }

    // Crossing subdomains — build an absolute URL with current scheme/port.
    const protocol = window.location.protocol + '//'
    const port = window.location.port
    const portSuffix = port && port !== '80' && port !== '443' ? `:${port}` : ''
    return `${protocol}${orgslug}.${baseDomain}${portSuffix}${path}`
  }

  // Server-side
  // Single tenancy → relative. The page will render on whatever host the
  // request came in on; relative URLs resolve correctly at the client.
  if (tenancy === 'single') {
    return path
  }

  // Multi tenancy server-side: build the subdomain URL because we can't
  // assume server components know the user's current host.
  if (orgslug) {
    const protocol = getLEARNHOUSE_HTTP_PROTOCOL()
    const domain = getLEARNHOUSE_DOMAIN()
    return `${protocol}${orgslug}.${domain}${path}`
  }
  const explicitDomain = getConfig('NEXT_PUBLIC_LEARNHOUSE_DOMAIN')