host: Remove build-time realm URLs (#1527)

The only build-time realm configuration now is resolvedBaseRealmURL.

Author: backspace

packages/host/app/components/card-catalog/modal.gts

@@ -395,8 +395,8 @@ export default class CardCatalogModal extends Component<Signature> {
         dismissModal: false,
         query,
         originalQuery: query,
-        availableRealmUrls: this.cardService.realmURLs,
-        selectedRealmUrls: this.cardService.realmURLs,
+        availableRealmUrls: this.cardService.unresolvedRealmURLs,
+        selectedRealmUrls: this.cardService.unresolvedRealmURLs,
       });
       this.stateStack.push(cardCatalogState);
 

packages/host/app/components/matrix/login.gts

@@ -196,8 +196,8 @@ export default class Login extends Component<Signature> {
       throw e;
     }
     if (auth) {
-      await this.router.refresh();
       await this.matrixService.start(auth);
+      await this.router.refresh();
     } else {
       throw new Error(
         `bug: should be impossible to get here - successful matrix login with no auth response`,

packages/host/app/components/operator-mode/code-submode.gts

@@ -606,10 +606,32 @@ export default class CodeSubmode extends Component<Signature> {
       if (!this.createFileModal) {
         throw new Error(`bug: CreateFileModal not instantiated`);
       }
+
+      let destinationRealm: string | undefined;
+
+      if (sourceInstance && this.realm.canWrite(sourceInstance.id)) {
+        destinationRealm = this.realm.url(sourceInstance.id);
+      }
+
+      if (
+        definitionClass?.ref &&
+        this.realm.canWrite(definitionClass.ref.module)
+      ) {
+        destinationRealm = this.realm.url(definitionClass.ref.module);
+      }
+
+      if (!destinationRealm && this.realm.defaultWritableRealm) {
+        destinationRealm = this.realm.defaultWritableRealm.path;
+      }
+
+      if (!destinationRealm) {
+        throw new Error('No writable realm found');
+      }
+
       this.isCreateModalOpen = true;
       let url = await this.createFileModal.createNewFile(
         fileType,
-        new URL(this.realm.userDefaultRealm.path),
+        new URL(destinationRealm),
         definitionClass,
         sourceInstance,
       );

packages/host/app/components/operator-mode/workspace-chooser.gts

@@ -14,7 +14,7 @@ export default class WorkspaceChooser extends Component<Signature> {
     <div class='workspace-chooser' data-test-workspace-chooser>
       <span class='workspace-chooser__title'>Your Workspaces</span>
       <ul>
-        {{#each this.cardService.realmURLs as |realmURL|}}
+        {{#each this.cardService.userRealms as |realmURL|}}
           <li class='workspace' data-test-workspace>{{realmURL}}</li>
         {{/each}}
       </ul>

packages/host/app/components/pill-menu/usage.gts

@@ -10,9 +10,7 @@ import { TrackedObject } from 'tracked-built-ins';
 
 import { IconX } from '@cardstack/boxel-ui/icons';
 
-import { getPlural } from '@cardstack/runtime-common';
-
-import ENV from '@cardstack/host/config/environment';
+import { baseRealm, getPlural } from '@cardstack/runtime-common';
 
 import { getCard } from '@cardstack/host/resources/card-resource';
 
@@ -24,8 +22,10 @@ import PillMenu from './index';
 
 import type { PillMenuItem } from './index';
 
-const { ownRealmURL } = ENV;
-const sampleCardURLs = [`${ownRealmURL}Author/1`, `${ownRealmURL}BlogPost/1`];
+const sampleCardURLs = [
+  `${baseRealm.url}SkillCard/card-editing`,
+  `${baseRealm.url}SkillCard/generate-product-requirements`,
+];
 
 export default class PillMenuUsage extends Component {
   headerIconURL = headerIcon;

packages/host/app/components/realm-dropdown.gts

@@ -150,8 +150,14 @@ export default class RealmDropdown extends Component<Signature> {
       return selectedRealm;
     }
 
+    let defaultWritableRealm = this.realm.defaultWritableRealm;
+
+    if (!defaultWritableRealm) {
+      return undefined;
+    }
+
     return this.realms.find(
-      (realm) => realm.path === this.realm.userDefaultRealm.path,
+      (realm) => realm.path === defaultWritableRealm!.path,
     );
   }
 }

packages/host/app/components/search-sheet/card-query-results.gts

@@ -30,7 +30,7 @@ export default class CardQueryResults extends Component<Signature> {
   @service declare cardService: CardService;
 
   get realms() {
-    return this.cardService.realmURLs;
+    return this.cardService.unresolvedRealmURLs;
   }
   get query() {
     let { searchKey } = this.args;

packages/host/app/components/search-sheet/index.gts

@@ -174,7 +174,7 @@ export default class SearchSheet extends Component<Signature> {
     }
     let cardURL = this.searchKey;
 
-    let maybeIndexCardURL = this.cardService.realmURLs.find(
+    let maybeIndexCardURL = this.cardService.unresolvedRealmURLs.find(
       (u) => u === cardURL + '/',
     );
     let cardResource = getCard(this, () => maybeIndexCardURL ?? cardURL, {

packages/host/app/components/with-known-realms-loaded.gts

@@ -23,7 +23,7 @@ export default class WithKnownRealmsLoaded extends Component<Signature> {
   }
 
   private loadRealmsTask = task(async () => {
-    let realmURLs = this.cardService.realmURLs;
+    let realmURLs = this.cardService.unresolvedRealmURLs;
     await Promise.all(
       realmURLs.map(
         async (realmURL) => await this.realm.ensureRealmMeta(realmURL),

packages/host/app/config/environment.d.ts

@@ -11,17 +11,13 @@ declare const config: {
   locationType: 'history' | 'hash' | 'none' | 'auto';
   rootURL: string;
   APP: Record<string, unknown>;
-  ownRealmURL: string;
-  otherRealmURLs: string[];
-  testRealmURLs: string[];
   matrixURL: string;
   matrixServerName: string;
   experimentalAIEnabled: boolean;
   resolvedBaseRealmURL: string;
   hostsOwnAssets: boolean;
   realmsServed?: string[];
   logLevels: string;
-  resolvedOwnRealmURL: string;
   autoSaveDelayMs: number;
   monacoDebounceMs: number;
   monacoCursorDebounceMs: number;

packages/host/app/controllers/card.ts

@@ -3,6 +3,7 @@ import { tracked } from '@glimmer/tracking';
 
 export default class CardController extends Controller {
   queryParams = [
+    'card',
     'operatorModeState',
     'operatorModeEnabled',
     // `sid` and `clientSecret` come from email verification process to reset password

packages/host/app/resources/search.ts

@@ -37,7 +37,7 @@ export class Search extends Resource<Args> {
 
   modify(_positional: never[], named: Args['named']) {
     let { query, realms, isLive, doWhileRefreshing } = named;
-    this.realmsToSearch = realms ?? this.cardService.realmURLs;
+    this.realmsToSearch = realms ?? this.cardService.unresolvedRealmURLs;
 
     this.loaded = this.search.perform(query);
     waitForPromise(this.loaded);

packages/host/app/router.ts

@@ -1,21 +1,12 @@
 import EmberRouter from '@ember/routing/router';
 import config from '@cardstack/host/config/environment';
-const { ownRealmURL, resolvedOwnRealmURL, hostsOwnAssets } = config;
+const { hostsOwnAssets } = config;
 
 export default class Router extends EmberRouter {
   location = config.locationType;
   rootURL = config.rootURL;
 }
 
-// When resolvedOwnRealmURL is available, that is actually the path in the browser.
-// It will not be available when running in fastboot.
-// When paths of resolvedOwnRealmURL and ownRealmURL are not symmetrical,
-// that means that means the resolvedOwnRealmURL should be used instead of ownRealmURL.
-let path = new URL(resolvedOwnRealmURL ?? ownRealmURL).pathname.replace(
-  /\/$/,
-  '',
-);
-
 Router.map(function () {
   this.route('host-freestyle', { path: '/_freestyle' });
   this.route('indexer', { path: '/indexer/:id' });
@@ -25,7 +16,7 @@ Router.map(function () {
   // component exists to support the indexer
   this.route('acceptance-test-setup');
 
-  if (!path || hostsOwnAssets) {
+  if (hostsOwnAssets) {
     this.route('index-card', { path: '/' });
   }
 });

packages/host/app/routes/card.gts

@@ -14,13 +14,14 @@ import MatrixService from '@cardstack/host/services/matrix-service';
 import OperatorModeStateService, {
   SerializedState as OperatorModeSerializedState,
 } from '@cardstack/host/services/operator-mode-state-service';
+import Realm from '@cardstack/host/services/realm';
 import RealmInfoService from '@cardstack/host/services/realm-info-service';
 
 import { CardDef } from 'https://cardstack.com/base/card-api';
 
 import type CardService from '../services/card-service';
 
-const { ownRealmURL, loginMessageTimeoutMs } = ENV;
+const { hostsOwnAssets, loginMessageTimeoutMs, rootURL } = ENV;
 
 export type Model = CardDef | null;
 
@@ -47,35 +48,48 @@ export default class RenderCard extends Route<Model | null> {
   @service declare router: RouterService;
   @service declare operatorModeStateService: OperatorModeStateService;
   @service declare matrixService: MatrixService;
+  @service declare realm: Realm;
   @service declare realmInfoService: RealmInfoService;
 
   hasLoadMatrixBeenExecuted = false;
 
   async model(params: {
+    card?: string;
     path: string;
     operatorModeState: string;
     operatorModeEnabled: boolean;
   }): Promise<Model> {
     let { path, operatorModeState, operatorModeEnabled } = params;
     path = path || '';
-    let url = path
-      ? new URL(`/${path}`, ownRealmURL)
-      : new URL('./', ownRealmURL);
 
     try {
       await this.loadMatrix.perform();
-      let isPublicReadableRealm = await this.realmInfoService.isPublicReadable(
-        new URL(ownRealmURL),
-      );
+
       let model = null;
-      if (!isPublicReadableRealm && !this.matrixService.isLoggedIn) {
-        return model;
-      }
-      let cardResource = getCard(this, () => url.href);
-      await cardResource.loaded;
-      model = cardResource.card;
-      if (!model) {
-        throw new Error(`Could not find ${url}`);
+
+      if (params.card) {
+        let directlyRequestedCardResource = getCard(this, () => params.card);
+        await directlyRequestedCardResource.loaded;
+
+        if (directlyRequestedCardResource?.card) {
+          model = directlyRequestedCardResource.card;
+        }
+      } else if (!hostsOwnAssets) {
+        let externalURL = new URL(document.location.href);
+        let pathOnRoot = `${rootURL}${path}`;
+        let prospectiveCardURL = new URL(pathOnRoot, externalURL);
+
+        let resource = getCard(this, () => prospectiveCardURL.href);
+        await resource.loaded;
+
+        if (resource.card) {
+          model = resource.card;
+        }
+      } else {
+        let indexCardURL = new URL(this.realm.defaultReadableRealm.path);
+        let indexCardResource = getCard(this, () => indexCardURL.href);
+        await indexCardResource.loaded;
+        model = indexCardResource.card;
       }
 
       if (operatorModeEnabled) {
@@ -97,11 +111,8 @@ export default class RenderCard extends Route<Model | null> {
       return model ?? null;
     } catch (e) {
       console.error(e);
-      (e as any).loadType = params.operatorModeEnabled
-        ? 'stack'
-        : url.href === ownRealmURL
-        ? 'index'
-        : 'card';
+
+      (e as any).loadType = params.operatorModeEnabled ? 'stack' : 'card';
       (e as any).operatorModeState = params.operatorModeState;
       throw e;
     }
@@ -112,16 +123,16 @@ export default class RenderCard extends Route<Model | null> {
     // so users will be redirected to operator mode.
     // We can update the codes below after we have a clear idea on how to implement authentication in guest mode.
     let isPublicReadableRealm = await this.realmInfoService.isPublicReadable(
-      new URL(ownRealmURL),
+      new URL(this.realm.defaultReadableRealm.path),
     );
     if (
       !isPublicReadableRealm &&
       !transition.to?.queryParams['operatorModeEnabled']
     ) {
       let path = transition.to?.params?.path ?? '';
       let url = path
-        ? new URL(`/${path}`, ownRealmURL)
-        : new URL('./', ownRealmURL);
+        ? new URL(`/${path}`, this.realm.defaultReadableRealm.path)
+        : new URL('./', this.realm.defaultReadableRealm.path);
       await this.router.replaceWith(`card`, {
         queryParams: {
           operatorModeEnabled: 'true',