@cardstack/boxel-cli 0.2.0 → 0.3.0-unstable.58

package/bundled-types/host-app/services/card-type-service.ts

@@ -0,0 +1,226 @@
+import type Owner from '@ember/owner';
+import { service } from '@ember/service';
+import Service from '@ember/service';
+
+import type { RealmInfo } from '@cardstack/runtime-common';
+import {
+  identifyCard,
+  internalKeyFor,
+  baseRealm,
+  moduleFrom,
+  getAncestor,
+  SupportedMimeType,
+  isResolvedCodeRef,
+  cardIdToURL,
+  type ResolvedCodeRef,
+} from '@cardstack/runtime-common';
+import { isCodeRef, type CodeRef } from '@cardstack/runtime-common/code-ref';
+import type { Loader } from '@cardstack/runtime-common/loader';
+
+import type CardService from '@cardstack/host/services/card-service';
+
+import type {
+  BaseDef,
+  Field,
+  FieldType,
+} from 'https://cardstack.com/base/card-api';
+import type * as CardAPI from 'https://cardstack.com/base/card-api';
+
+import type LoaderService from '../services/loader-service';
+import type NetworkService from '../services/network';
+import type ResetService from '../services/reset';
+
+export type CodeRefType = CodeRef & {
+  displayName: string;
+  localName: string;
+};
+
+export interface FieldOfType {
+  name: string;
+  card: Type | CodeRefType;
+  isComputed: boolean;
+  isQueryField: boolean;
+  type: FieldType;
+}
+
+export interface Type {
+  id: string;
+  module: string;
+  displayName: string;
+  super: Type | undefined;
+  fields: FieldOfType[];
+  codeRef: CodeRef;
+  moduleInfo: ModuleInfo;
+  localName: string;
+}
+
+interface ModuleInfo {
+  extension: string;
+  realmInfo: RealmInfo;
+}
+
+export default class CardTypeService extends Service {
+  @service declare private cardService: CardService;
+  @service declare private network: NetworkService;
+  @service declare private loaderService: LoaderService;
+  @service declare private reset: ResetService;
+
+  private typeCache: Map<string, Type> = new Map();
+  private moduleInfoCache: Map<string, ModuleInfo> = new Map();
+  private loader: object | undefined; //keeps track of the current used loader so cache is reset after a loader reset
+
+  constructor(owner: Owner) {
+    super(owner);
+    this.reset.register(this);
+  }
+
+  resetState() {
+    this.invalidateAllCaches();
+    this.loader = undefined;
+  }
+
+  invalidateAllCaches(): void {
+    this.typeCache.clear();
+    this.moduleInfoCache.clear();
+  }
+
+  async assembleType(definition: typeof BaseDef): Promise<Type> {
+    // This should go away when we move to an architecture where NO loader reset is required
+    if (this.loader !== this.loaderService.loader) {
+      this.invalidateAllCaches();
+      this.loader = this.loaderService.loader;
+    }
+    let maybeType = await this.toType(definition, this.loaderService.loader);
+    if (isCodeRefType(maybeType)) {
+      throw new Error(`bug: should never get here`);
+    }
+    return maybeType;
+  }
+
+  private async toType(
+    card: typeof BaseDef,
+    loader: Loader,
+    stack: (typeof BaseDef)[] = [],
+  ): Promise<Type | CodeRefType> {
+    let maybeRef = identifyCard(card);
+    if (!maybeRef) {
+      throw new Error(`cannot identify card ${card.name}`);
+    }
+    let ref = maybeRef;
+    if (stack.includes(card)) {
+      return {
+        ...ref,
+        displayName: card.prototype.constructor.displayName,
+        localName: card.name,
+      };
+    }
+    let id = internalKeyFor(ref, undefined);
+    let cached = this.typeCache.get(id);
+    if (cached) {
+      return cached;
+    }
+    let moduleIdentifier = moduleFrom(ref);
+    let moduleURL = cardIdToURL(moduleIdentifier);
+    let moduleInfo =
+      this.moduleInfoCache.get(moduleURL.href) ??
+      (await this.fetchModuleInfo(moduleURL));
+
+    let api = await loader.import<typeof CardAPI>(`${baseRealm.url}card-api`);
+    let { id: _remove, ...fields } = api.getFields(card, {
+      includeComputeds: true,
+    });
+    let superCard = getAncestor(card);
+    let superType: Type | CodeRefType | undefined;
+    if (superCard && card !== superCard) {
+      superType = await this.toType(superCard, loader, [card, ...stack]);
+    }
+
+    let fieldTypes: FieldOfType[] = await Promise.all(
+      Object.entries(fields).map(
+        async ([name, field]: [string, Field<typeof BaseDef, any>]) => ({
+          name,
+          type: field.fieldType,
+          isComputed: field.computeVia != undefined,
+          isQueryField: field.queryDefinition != undefined,
+          card: await this.toType(field.card, loader, [card, ...stack]),
+        }),
+      ),
+    );
+
+    let type: Type = {
+      id,
+      module: moduleIdentifier,
+      super: isCodeRefType(superType) ? undefined : superType,
+      displayName: card.prototype.constructor.displayName || 'Card',
+      fields: fieldTypes,
+      moduleInfo,
+      codeRef: ref,
+      localName: card.name,
+    };
+    this.typeCache.set(id, type);
+    return type;
+  }
+
+  private async fetchModuleInfo(url: URL): Promise<ModuleInfo> {
+    let response = await this.network.authedFetch(url, {
+      headers: { Accept: SupportedMimeType.CardSource },
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Could not get file ${url.href}, status ${response.status}: ${
+          response.statusText
+        } - ${await response.text()}`,
+      );
+    }
+    let realmURL = response.headers.get('x-boxel-realm-url');
+    if (realmURL === null) {
+      throw new Error(`Could not get realm url for ${url.href}`);
+    }
+    let realmInfo = await this.cardService.getRealmInfoByRealmURL(
+      new URL(realmURL),
+    );
+    let moduleInfo = {
+      realmInfo,
+      extension: '.' + new URL(response.url).pathname.split('.').pop() || '',
+    };
+    this.moduleInfoCache.set(url.href, moduleInfo);
+    return moduleInfo;
+  }
+}
+
+function isCodeRefType(type: any): type is CodeRefType {
+  return (
+    type && isCodeRef(type) && 'displayName' in type && 'localName' in type
+  );
+}
+
+export function isFieldOfType(obj: any): obj is FieldOfType {
+  return obj && 'card' in obj;
+}
+
+export function getCodeRefFromType(t: Type | FieldOfType): CodeRef {
+  let codeRef: CodeRef;
+  if (isFieldOfType(t)) {
+    codeRef = isCodeRefType(t.card) ? t.card : (t.card as Type).codeRef;
+  } else {
+    codeRef = t.codeRef;
+  }
+  return codeRef;
+}
+
+export function getResolvedCodeRefFromType(
+  t: Type | FieldOfType,
+): ResolvedCodeRef | undefined {
+  let codeRef = getCodeRefFromType(t);
+  if (!isResolvedCodeRef(codeRef)) {
+    return;
+  }
+  return codeRef;
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    'card-type-service': CardTypeService;
+  }
+}

package/bundled-types/host-app/services/code-semantics-service.ts

@@ -0,0 +1,297 @@
+import type Owner from '@ember/owner';
+import Service from '@ember/service';
+import { service } from '@ember/service';
+
+import type { ResolvedCodeRef, CodeRef } from '@cardstack/runtime-common';
+import {
+  hasExecutableExtension,
+  identifyCard,
+  isCardDocumentString,
+  isResolvedCodeRef,
+  loadCardDef,
+  getAncestor,
+  isCardDef as isCardDefHelper,
+  isFieldDef as isFieldDefHelper,
+  getField,
+} from '@cardstack/runtime-common';
+
+import { isReady } from '@cardstack/host/resources/file';
+
+import type { BaseDef } from 'https://cardstack.com/base/card-api';
+
+import {
+  moduleContentsResource,
+  type State,
+  type ModuleDeclaration,
+  isCardOrFieldDeclaration,
+  isReexportCardOrField,
+} from '../resources/module-contents';
+import { findDeclarationByName } from '../services/module-contents-service';
+
+import type LoaderService from './loader-service';
+import type OperatorModeStateService from './operator-mode-state-service';
+import type ResetService from './reset';
+import type { Ready } from '../resources/file';
+
+export default class CodeSemanticsService extends Service {
+  @service declare operatorModeStateService: OperatorModeStateService;
+  @service declare loaderService: LoaderService;
+  @service declare reset: ResetService;
+
+  private onModuleEditCallback: ((state: State) => void) | undefined =
+    undefined;
+
+  // Cache the resource for each unique file
+  private resourceCache = new WeakMap<
+    Ready,
+    ReturnType<typeof moduleContentsResource>
+  >();
+
+  constructor(owner: Owner) {
+    super(owner);
+    this.reset.register(this);
+  }
+
+  resetState() {
+    this.onModuleEditCallback = undefined;
+    this.resourceCache = new WeakMap();
+  }
+
+  private getResourceForFile(file: Ready | undefined) {
+    if (!file) {
+      // Return a dummy resource for undefined file
+      return {
+        declarations: [],
+        moduleError: undefined,
+        isLoading: false,
+      };
+    }
+
+    if (this.resourceCache.has(file)) {
+      return this.resourceCache.get(file)!;
+    }
+
+    let resource = moduleContentsResource(
+      this,
+      () => file,
+      (newState: State) => this.handleModuleEdit(newState),
+    );
+
+    this.resourceCache.set(file, resource);
+    return resource;
+  }
+
+  getDeclarations(
+    file: Ready | undefined,
+    isModule: boolean,
+  ): ModuleDeclaration[] {
+    if (!isModule) return [];
+    let resource = this.getResourceForFile(file);
+    return resource.declarations;
+  }
+
+  getModuleError(file: Ready | undefined, isModule: boolean) {
+    if (!isModule) return undefined;
+    let resource = this.getResourceForFile(file);
+    return resource.moduleError;
+  }
+
+  getIsLoading(file: Ready | undefined, isModule: boolean): boolean {
+    if (!isModule) return false;
+    let resource = this.getResourceForFile(file);
+    return resource.isLoading;
+  }
+
+  getSelectedDeclaration(
+    file: Ready | undefined,
+    codeSelection: string | undefined,
+    isModule: boolean,
+  ): ModuleDeclaration | undefined {
+    if (!isModule) return undefined;
+    let resource = this.getResourceForFile(file);
+    if (resource.moduleError) return undefined;
+
+    let declarations = resource.declarations;
+    let found = codeSelection
+      ? findDeclarationByName(codeSelection, declarations)
+      : undefined;
+    // note: module inspector tools are not available for module with 0 exported declarations
+    // if not found, default to the last declaration in the module
+    return found ?? declarations[declarations.length - 1];
+  }
+
+  setOnModuleEditCallback(callback: (state: State) => void) {
+    this.onModuleEditCallback = callback;
+  }
+
+  clearOnModuleEditCallback(callback?: (state: State) => void) {
+    if (!callback || this.onModuleEditCallback === callback) {
+      this.onModuleEditCallback = undefined;
+    }
+  }
+
+  private handleModuleEdit(newState: State) {
+    this.onModuleEditCallback?.(newState);
+  }
+
+  get currentOpenFile() {
+    return this.operatorModeStateService.openFile.current;
+  }
+
+  get readyFile() {
+    if (isReady(this.currentOpenFile)) {
+      return this.currentOpenFile;
+    }
+    throw new Error(
+      `cannot access file contents ${this.codePath} before file is open`,
+    );
+  }
+
+  get codePath() {
+    return this.operatorModeStateService.state.codePath;
+  }
+
+  get isModule() {
+    return this.isReady && hasExecutableExtension(this.readyFile.url);
+  }
+
+  get isReady() {
+    return isReady(this.currentOpenFile);
+  }
+
+  get isIncompatibleFile() {
+    return this.readyFile.isBinary || (!this.isModule && this.isNonCardJson);
+  }
+
+  private get isNonCardJson() {
+    return !(
+      this.readyFile.name.endsWith('.json') &&
+      isCardDocumentString(this.readyFile.content)
+    );
+  }
+
+  get declarations() {
+    return this.getDeclarations(
+      this.isModule ? this.readyFile : undefined,
+      this.isModule,
+    );
+  }
+
+  get selectedDeclaration() {
+    return this.getSelectedDeclaration(
+      this.isModule ? this.readyFile : undefined,
+      this.operatorModeStateService.state.codeSelection,
+      this.isModule,
+    );
+  }
+
+  get selectedCardOrField() {
+    if (
+      this.selectedDeclaration !== undefined &&
+      (isCardOrFieldDeclaration(this.selectedDeclaration) ||
+        isReexportCardOrField(this.selectedDeclaration))
+    ) {
+      return this.selectedDeclaration;
+    }
+    return undefined;
+  }
+
+  get selectedCodeRef(): ResolvedCodeRef | undefined {
+    let codeRef = identifyCard(this.selectedCardOrField?.cardOrField);
+    return isResolvedCodeRef(codeRef) ? codeRef : undefined;
+  }
+
+  async getInheritanceChain(): Promise<
+    { codeRef: CodeRef; fields: string[] }[] | undefined
+  > {
+    if (!this.selectedCodeRef) {
+      return undefined;
+    }
+    try {
+      // Load the card definition to check if it's a CardDef or FieldDef descendant
+      let cardOrField = await loadCardDef(this.selectedCodeRef, {
+        loader: this.loaderService.loader,
+        relativeTo: this.codePath || undefined,
+      });
+
+      // Check if it's a CardDef or FieldDef (or descendant)
+      let isCardDef = isCardDefHelper(cardOrField);
+      let isFieldDef = isFieldDefHelper(cardOrField);
+
+      if (!isCardDef && !isFieldDef) {
+        return undefined;
+      }
+
+      let inheritanceChain: { codeRef: CodeRef; fields: string[] }[] = [];
+      let currentCard = cardOrField;
+
+      // Build the inheritance chain by walking up the prototype chain
+      // Stop when we reach CardDef or FieldDef (don't include BaseDef)
+      while (currentCard) {
+        let codeRef = identifyCard(currentCard);
+        if (codeRef) {
+          // Get fields defined at this level of the inheritance chain
+          let fields = this.getOwnFields(currentCard);
+
+          inheritanceChain.push({
+            codeRef,
+            fields,
+          });
+        }
+
+        // Stop if we've reached CardDef or FieldDef
+        if (
+          (isCardDefHelper(currentCard) && currentCard.name === 'CardDef') ||
+          (isFieldDefHelper(currentCard) && currentCard.name === 'FieldDef')
+        ) {
+          break;
+        }
+
+        // Get the parent (ancestor) card
+        let ancestor = getAncestor(currentCard);
+        if (ancestor && ancestor !== currentCard) {
+          currentCard = ancestor;
+        } else {
+          break;
+        }
+      }
+
+      return inheritanceChain.length > 0 ? inheritanceChain : undefined;
+    } catch (error) {
+      console.warn('Failed to build inheritance chain:', error);
+      return undefined;
+    }
+  }
+
+  private getOwnFields(card: typeof BaseDef): string[] {
+    // Get own property descriptors to only get fields defined at this level
+    let fields: string[] = [];
+    let obj = card.prototype;
+
+    if (obj) {
+      let descs = Object.getOwnPropertyDescriptors(obj);
+      for (let fieldName of Object.keys(descs)) {
+        if (fieldName === 'constructor') {
+          continue;
+        }
+
+        // Check if this is actually a field by trying to get it
+        try {
+          let maybeField = getField(card, fieldName);
+          if (
+            maybeField &&
+            !maybeField.computeVia &&
+            !maybeField.queryDefinition
+          ) {
+            fields.push(fieldName);
+          }
+        } catch {
+          // If getField throws, it's not a valid field
+          continue;
+        }
+      }
+    }
+
+    return fields;
+  }
+}