@eventcatalog/core 3.46.0 → 3.47.0

package/eventcatalog/src/components/SchemaExplorer/SchemaViewerModal.tsx

@@ -2,6 +2,7 @@ import * as Dialog from '@radix-ui/react-dialog';
 import { XMarkIcon, ArrowsPointingOutIcon } from '@heroicons/react/24/outline';
 import JSONSchemaViewer from './JSONSchemaViewer';
 import AvroSchemaViewer from './AvroSchemaViewer';
+import ProtobufSchemaViewer from './ProtobufSchemaViewer';
 import type { SchemaItem } from './types';
 
 interface SchemaViewerModalProps {
@@ -10,6 +11,7 @@ interface SchemaViewerModalProps {
   message: SchemaItem;
   parsedSchema: any;
   parsedAvroSchema?: any;
+  parsedProtoSchema?: any;
 }
 
 export default function SchemaViewerModal({
@@ -18,10 +20,12 @@ export default function SchemaViewerModal({
   message,
   parsedSchema,
   parsedAvroSchema,
+  parsedProtoSchema,
 }: SchemaViewerModalProps) {
-  if (!parsedSchema && !parsedAvroSchema) return null;
+  if (!parsedSchema && !parsedAvroSchema && !parsedProtoSchema) return null;
 
   const isAvro = !!parsedAvroSchema;
+  const isProto = !!parsedProtoSchema;
 
   return (
     <Dialog.Root open={isOpen} onOpenChange={onOpenChange}>
@@ -35,7 +39,7 @@ export default function SchemaViewerModal({
               <div>
                 <Dialog.Title className="text-xl font-semibold text-[rgb(var(--ec-page-text))]">{message.data.name}</Dialog.Title>
                 <Dialog.Description className="text-sm text-[rgb(var(--ec-page-text-muted))] mt-1">
-                  v{message.data.version} · {isAvro ? 'Avro' : 'JSON'} Schema
+                  v{message.data.version} · {isAvro ? 'Avro' : isProto ? 'Protobuf' : 'JSON'} Schema
                 </Dialog.Description>
               </div>
             </div>
@@ -54,6 +58,8 @@ export default function SchemaViewerModal({
           <div className="flex-1 overflow-hidden p-6">
             {isAvro ? (
               <AvroSchemaViewer schema={parsedAvroSchema} expand={true} search={true} />
+            ) : isProto ? (
+              <ProtobufSchemaViewer schema={parsedProtoSchema} expand={true} search={true} />
             ) : (
               <JSONSchemaViewer schema={parsedSchema} expand={true} search={true} />
             )}

package/eventcatalog/src/components/SchemaExplorer/utils.ts

@@ -7,6 +7,7 @@ export const ICON_SPECS: Record<string, string> = {
   avro: 'avro',
   avsc: 'avro',
   proto: 'proto',
+  protobuf: 'proto',
   json: 'json-schema',
 };
 
@@ -20,6 +21,7 @@ export function getFormatBadge(ext?: string): { label: string; color: string } {
     case 'avsc':
       return { label: 'avro', color: 'text-blue-400' };
     case 'proto':
+    case 'protobuf':
       return { label: 'proto', color: 'text-orange-400' };
     case 'yaml':
     case 'yml':
@@ -48,6 +50,7 @@ export const getLanguageForHighlight = (extension?: string): string => {
     case 'json':
       return 'json';
     case 'proto':
+    case 'protobuf':
       return 'protobuf';
     case 'xsd':
     case 'xml':
@@ -79,6 +82,7 @@ export const getSchemaTypeLabel = (extension?: string): string => {
     case 'avsc':
       return 'Avro';
     case 'proto':
+    case 'protobuf':
       return 'Protobuf';
     case 'xsd':
       return 'XML Schema';

package/eventcatalog/src/pages/docs/[type]/[id]/language/_index.data.ts

@@ -10,10 +10,19 @@ export class Page extends HybridPage {
       return [];
     }
 
-    const { getDomains } = await import('@utils/collections/domains');
+    const { getDomains, hasUbiquitousLanguageTermsWithSubdomains } = await import('@utils/collections/domains');
     const domains = await getDomains({ getAllVersions: false });
+    const domainsWithUbiquitousLanguage = await domains.reduce<Promise<typeof domains>>(async (acc, domain) => {
+      const accumulator = await acc;
 
-    return domains.map((item) => ({
+      if (await hasUbiquitousLanguageTermsWithSubdomains(domain)) {
+        return [...accumulator, domain];
+      }
+
+      return accumulator;
+    }, Promise.resolve([]));
+
+    return domainsWithUbiquitousLanguage.map((item) => ({
       params: {
         type: item.collection,
         id: item.data.id,
@@ -23,9 +32,15 @@ export class Page extends HybridPage {
   }
 
   protected static async fetchData(params: any) {
-    const { getDomains } = await import('@utils/collections/domains');
+    const { getDomains, hasUbiquitousLanguageTermsWithSubdomains } = await import('@utils/collections/domains');
     const domains = await getDomains({ getAllVersions: false });
-    return domains.find((d) => d.data.id === params.id && d.collection === params.type) || null;
+    const domain = domains.find((d) => d.data.id === params.id && d.collection === params.type);
+
+    if (!domain || !(await hasUbiquitousLanguageTermsWithSubdomains(domain))) {
+      return null;
+    }
+
+    return domain;
   }
 
   protected static createNotFoundResponse(): Response {

package/eventcatalog/src/pages/docs/[type]/[id]/language.mdx.ts

@@ -1,4 +1,4 @@
-import { getDomains, getUbiquitousLanguage } from '@utils/collections/domains';
+import { getDomains, getUbiquitousLanguage, hasUbiquitousLanguageTerms } from '@utils/collections/domains';
 import type { CollectionEntry } from 'astro:content';
 import type { APIRoute } from 'astro';
 import config from '@config';
@@ -9,8 +9,19 @@ import { filterMarkdownForAgents } from '@utils/llms';
 export async function getStaticPaths() {
   const domains = await getDomains({ getAllVersions: false });
 
-  const buildPages = (collection: CollectionEntry<'domains'>[]) => {
-    return collection.map((item) => ({
+  const buildPages = async (collection: CollectionEntry<'domains'>[]) => {
+    const collectionWithUbiquitousLanguage = await collection.reduce<Promise<CollectionEntry<'domains'>[]>>(async (acc, item) => {
+      const accumulator = await acc;
+      const ubiquitousLanguages = await getUbiquitousLanguage(item);
+
+      if (ubiquitousLanguages.some(hasUbiquitousLanguageTerms)) {
+        return [...accumulator, item];
+      }
+
+      return accumulator;
+    }, Promise.resolve([]));
+
+    return collectionWithUbiquitousLanguage.map((item) => ({
       params: {
         type: item.collection,
         id: item.data.id,
@@ -22,7 +33,7 @@ export async function getStaticPaths() {
     }));
   };
 
-  return [...buildPages(domains)];
+  return [...(await buildPages(domains))];
 }
 
 export const GET: APIRoute = async ({ params, props }) => {
@@ -40,7 +51,7 @@ export const GET: APIRoute = async ({ params, props }) => {
   const ubiquitousLanguages = await getUbiquitousLanguage(domain as CollectionEntry<'domains'>);
   const ubiquitousLanguage = ubiquitousLanguages[0];
 
-  if (ubiquitousLanguage?.filePath) {
+  if (ubiquitousLanguage?.filePath && hasUbiquitousLanguageTerms(ubiquitousLanguage)) {
     let file = filterMarkdownForAgents(fs.readFileSync(ubiquitousLanguage.filePath, 'utf8'));
 
     return new Response(file, { status: 200 });

package/eventcatalog/src/stores/sidebar-store/builders/domain.ts

@@ -13,7 +13,7 @@ import {
 } from './shared';
 import { isVisualiserEnabled, isChangelogEnabled } from '@utils/feature';
 import { pluralizeMessageType } from '@utils/collections/messages';
-import { getSpecificationsForDomain } from '@utils/collections/domains';
+import { getSpecificationsForDomain, hasUbiquitousLanguageTermsWithSubdomainsInCollection } from '@utils/collections/domains';
 import { iconFieldsForResource } from '@utils/icon';
 
 export const buildDomainNode = (domain: CollectionEntry<'domains'>, owners: any[], context: ResourceGroupContext): NavNode => {
@@ -41,7 +41,9 @@ export const buildDomainNode = (domain: CollectionEntry<'domains'>, owners: any[
   const resourceGroups = domain.data.resourceGroups || [];
   const hasResourceGroups = resourceGroups.length > 0;
 
-  const renderUbiquitousLanguage = shouldRenderSideBarSection(domain, 'ubiquitousLanguage');
+  const renderUbiquitousLanguage =
+    hasUbiquitousLanguageTermsWithSubdomainsInCollection(domain, context.ubiquitousLanguages || []) &&
+    shouldRenderSideBarSection(domain, 'ubiquitousLanguage');
   const renderOwners = owners.length > 0 && shouldRenderSideBarSection(domain, 'owners');
 
   const renderVisualiser = isVisualiserEnabled();

package/eventcatalog/src/stores/sidebar-store/builders/entity.ts

@@ -0,0 +1,87 @@
+import type { CollectionEntry } from 'astro:content';
+import { buildUrl } from '@utils/url-builder';
+import type { NavNode, ChildRef, ResourceGroupContext } from './shared';
+import {
+  buildAttachmentsSection,
+  buildOwnersSection,
+  buildQuickReferenceSection,
+  buildResourceDocsSection,
+  shouldRenderSideBarSection,
+} from './shared';
+import { isChangelogEnabled, isVisualiserEnabled } from '@utils/feature';
+import { iconFieldsForResource } from '@utils/icon';
+
+export const buildEntityNode = (entity: CollectionEntry<'entities'>, owners: any[], context: ResourceGroupContext): NavNode => {
+  const domains = entity.data.domains || [];
+  const services = entity.data.services || [];
+
+  const entityMapTargets = [
+    domains.length === 1 && {
+      label: 'Domain',
+      href: buildUrl(`/visualiser/domains/${(domains[0] as any).data.id}/${(domains[0] as any).data.version}/entity-map`),
+    },
+    services.length === 1 && {
+      label: 'Service',
+      href: buildUrl(`/visualiser/services/${(services[0] as any).data.id}/${(services[0] as any).data.version}/entity-map`),
+    },
+  ].filter(Boolean) as { label: string; href: string }[];
+
+  const renderArchitecture = isVisualiserEnabled() && entityMapTargets.length > 0;
+  const renderDomains = domains.length > 0 && shouldRenderSideBarSection(entity, 'domains');
+  const renderServices = services.length > 0 && shouldRenderSideBarSection(entity, 'services');
+  const renderOwners = owners.length > 0 && shouldRenderSideBarSection(entity, 'owners');
+  const hasAttachments = entity.data.attachments && entity.data.attachments.length > 0;
+
+  const docsSection = buildResourceDocsSection(
+    'entities',
+    entity.data.id,
+    entity.data.version,
+    context.resourceDocs,
+    context.resourceDocCategories
+  );
+
+  return {
+    type: 'item',
+    title: entity.data.name,
+    badge: 'Entity',
+    summary: entity.data.summary,
+    ...iconFieldsForResource(entity.data, 'Box'),
+    pages: [
+      buildQuickReferenceSection(
+        [
+          { title: 'Overview', href: buildUrl(`/docs/entities/${entity.data.id}/${entity.data.version}`) },
+          isChangelogEnabled() &&
+            shouldRenderSideBarSection(entity, 'changelog') && {
+              title: 'Changelog',
+              href: buildUrl(`/docs/entities/${entity.data.id}/${entity.data.version}/changelog`),
+            },
+        ].filter(Boolean) as { title: string; href: string }[]
+      ),
+      docsSection,
+      renderArchitecture && {
+        type: 'group',
+        title: 'Architecture',
+        icon: 'Workflow',
+        pages: entityMapTargets.map((target) => ({
+          type: 'item',
+          title: entityMapTargets.length === 1 ? 'Entity Map' : `${target.label} Entity Map`,
+          href: target.href,
+        })),
+      },
+      renderDomains && {
+        type: 'group',
+        title: 'Domains',
+        icon: 'Boxes',
+        pages: domains.map((domain: any) => `domain:${domain.data.id}:${domain.data.version}`),
+      },
+      renderServices && {
+        type: 'group',
+        title: 'Services',
+        icon: 'Server',
+        pages: services.map((service: any) => `service:${service.data.id}:${service.data.version}`),
+      },
+      renderOwners && buildOwnersSection(owners),
+      hasAttachments && buildAttachmentsSection(entity.data.attachments as any[]),
+    ].filter(Boolean) as ChildRef[],
+  };
+};

package/eventcatalog/src/stores/sidebar-store/builders/shared.ts

@@ -66,6 +66,7 @@ export type ResourceGroupContext = {
   containers: CollectionEntry<'containers'>[];
   entities?: CollectionEntry<'entities'>[];
   dataProducts: CollectionEntry<'data-products'>[];
+  ubiquitousLanguages?: CollectionEntry<'ubiquitousLanguages'>[];
   diagrams: CollectionEntry<'diagrams'>[];
   schemas?: CollectionEntry<'schemas'>[];
   adrs: Adr[];

package/eventcatalog/src/stores/sidebar-store/state.ts

@@ -25,6 +25,7 @@ import { buildContainerNode } from './builders/container';
 import { buildFlowNode } from './builders/flow';
 import { buildDataProductNode } from './builders/data-product';
 import { buildAdrNode } from './builders/adr';
+import { buildEntityNode } from './builders/entity';
 import config from '@config';
 import { getDesigns } from '@utils/collections/designs';
 import { getChannels } from '@utils/collections/channels';
@@ -293,6 +294,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     entities,
     adrs,
     schemas,
+    ubiquitousLanguages,
     resourceDocs,
     resourceDocCategories,
   ] = await Promise.all([
@@ -311,6 +313,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     getEntities({ getAllVersions: false }),
     getAdrs({ getAllVersions: false }),
     getCollection('schemas'),
+    getCollection('ubiquitousLanguages'),
     getResourceDocs(),
     getResourceDocCategories(),
   ]);
@@ -333,6 +336,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     channels,
     diagrams,
     schemas,
+    ubiquitousLanguages,
     dataProducts,
     entities,
     adrs,
@@ -406,6 +410,14 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     })
   );
 
+  const entitiesWithOwners = await Promise.all(
+    entities.map(async (entity) => {
+      const owners = await Promise.all((entity.data.owners || []).map((owner) => getOwner(owner)));
+      const filteredOwners = owners.filter((o) => o !== undefined) as Array<NonNullable<(typeof owners)[0]>>;
+      return { entity, owners: filteredOwners };
+    })
+  );
+
   const flowNodes = flows.reduce(
     (acc, flow) => {
       acc[`flow:${flow.data.id}:${flow.data.version}`] = withArchitectureDecisionsSection(
@@ -650,21 +662,10 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     {} as Record<string, NavNode | string>
   );
 
-  const entityNodes = entities.reduce(
-    (acc, entity) => {
+  const entityNodes = entitiesWithOwners.reduce(
+    (acc, { entity, owners }) => {
       const versionedKey = `entity:${entity.data.id}:${entity.data.version}`;
-      acc[versionedKey] = withArchitectureDecisionsSection(
-        {
-          type: 'item',
-          title: entity.data.name,
-          badge: 'Entity',
-          summary: entity.data.summary,
-          icon: 'Box',
-          href: buildUrl(`/docs/entities/${entity.data.id}/${entity.data.version}`),
-        },
-        entity,
-        adrs
-      );
+      acc[versionedKey] = withArchitectureDecisionsSection(buildEntityNode(entity, owners, context), entity, adrs);
       if (entity.data.latestVersion === entity.data.version) {
         acc[`entity:${entity.data.id}`] = versionedKey;
       }

package/eventcatalog/src/styles/tailwind.css

@@ -2,6 +2,24 @@
 
 @plugin "@tailwindcss/typography";
 
+/*
+ * EventCatalog renders MDX inside Tailwind Typography's `.prose` wrapper.
+ * Typography adds decorative backticks around inline code via pseudo-elements;
+ * docs should show only the code content itself.
+ */
+.prose code::before,
+.prose code::after {
+  content: '';
+}
+
+.prose :not(pre) > code {
+  background-color: oklab(0.97 0 0.0013 / 0.5);
+  border-radius: 0.25rem;
+  font-family: var(--font-mono);
+  padding: 0.125rem 0.375rem;
+  font-weight: 400;
+}
+
 /* Dark mode uses data-theme attribute, not prefers-color-scheme */
 @custom-variant dark (&:where([data-theme=dark], [data-theme=dark] *));
 

package/eventcatalog/src/utils/collections/domains.ts

@@ -367,6 +367,36 @@ export const getUbiquitousLanguage = async (domain: Domain): Promise<UbiquitousL
   return ubiquitousLanguages;
 };
 
+export const hasUbiquitousLanguageTerms = (ubiquitousLanguage: UbiquitousLanguage | null | undefined): boolean =>
+  (ubiquitousLanguage?.data?.dictionary?.length || 0) > 0;
+
+export const getUbiquitousLanguageFromCollection = (
+  domain: Domain,
+  ubiquitousLanguages: UbiquitousLanguage[]
+): UbiquitousLanguage[] => {
+  const domainFolder = path.dirname(domain.filePath || '');
+
+  return ubiquitousLanguages.filter((ubiquitousLanguage) => {
+    const ubiquitousLanguageFolder = path.dirname(ubiquitousLanguage.filePath || '');
+    return domainFolder === ubiquitousLanguageFolder;
+  });
+};
+
+export const hasUbiquitousLanguageTermsInCollection = (domain: Domain, ubiquitousLanguages: UbiquitousLanguage[]): boolean =>
+  getUbiquitousLanguageFromCollection(domain, ubiquitousLanguages).some(hasUbiquitousLanguageTerms);
+
+export const hasUbiquitousLanguageTermsWithSubdomainsInCollection = (
+  domain: Domain,
+  ubiquitousLanguages: UbiquitousLanguage[]
+): boolean => {
+  const subdomains = (domain.data.domains as unknown as Domain[]) || [];
+
+  return (
+    hasUbiquitousLanguageTermsInCollection(domain, ubiquitousLanguages) ||
+    subdomains.some((subdomain) => hasUbiquitousLanguageTermsInCollection(subdomain, ubiquitousLanguages))
+  );
+};
+
 export const getUbiquitousLanguageWithSubdomains = async (
   domain: Domain
 ): Promise<{
@@ -428,6 +458,15 @@ export const getUbiquitousLanguageWithSubdomains = async (
   };
 };
 
+export const hasUbiquitousLanguageTermsWithSubdomains = async (domain: Domain): Promise<boolean> => {
+  const { domain: domainUbiquitousLanguage, subdomains } = await getUbiquitousLanguageWithSubdomains(domain);
+
+  return (
+    hasUbiquitousLanguageTerms(domainUbiquitousLanguage) ||
+    subdomains.some(({ ubiquitousLanguage }) => hasUbiquitousLanguageTerms(ubiquitousLanguage))
+  );
+};
+
 export const getParentDomains = async (domain: Domain): Promise<Domain[]> => {
   const domains = await getDomains({ getAllVersions: false });
   return domains.filter((d) => {

package/eventcatalog/src/utils/collections/entities.ts

@@ -2,6 +2,8 @@ import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import { createVersionedMap, satisfies } from './util';
 
+const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
+
 export type Entity = CollectionEntry<'entities'>;
 
 interface Props {
@@ -15,7 +17,7 @@ export const getEntities = async ({ getAllVersions = true }: Props = {}): Promis
   // console.time('✅ New getEntities');
   const cacheKey = getAllVersions ? 'allVersions' : 'currentVersions';
 
-  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0) {
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
     // console.timeEnd('✅ New getEntities');
     return memoryCache[cacheKey];
   }

package/eventcatalog/src/utils/files.ts

@@ -59,3 +59,12 @@ export const getAbsoluteFilePathForAstroFile = (filePath: string, fileName?: str
 export const isAvroSchema = (filePath: string): boolean => {
   return filePath.endsWith('.avro') || filePath.endsWith('.avsc');
 };
+
+/**
+ * Checks if a file path is a Protocol Buffers schema based on its extension
+ * @param filePath - The file path to check
+ * @returns True if the file is a Protocol Buffers schema (.proto)
+ */
+export const isProtobufSchema = (filePath: string): boolean => {
+  return filePath.endsWith('.proto');
+};

package/eventcatalog/src/utils/node-graphs/domain-entity-map.ts

@@ -10,6 +10,18 @@ import { getServices, type Service } from '@utils/collections/services';
 
 const elk = new ELK();
 
+const getReferencedEntityId = (property: any, entityMap: Map<string, Entity[]>) => {
+  if (property.references) return property.references;
+  if (property.type === 'array' && property.items?.type && entityMap.has(property.items.type)) return property.items.type;
+  return undefined;
+};
+
+const getRelationType = (property: any) => {
+  if (property.relationType) return property.relationType;
+  if (property.type === 'array' && property.items?.type) return 'hasMany';
+  return 'references';
+};
+
 interface Props {
   id: string;
   version: string;
@@ -23,6 +35,7 @@ export const getNodesAndEdges = async ({ id, version, entities, type = 'domains'
 
   // 1. Fetch all collections in parallel
   const [allDomains, allEntities, allServices] = await Promise.all([getDomains(), getEntities(), getServices()]);
+  const entityMap = createVersionedMap(allEntities);
 
   let resource = null;
 
@@ -42,7 +55,7 @@ export const getNodesAndEdges = async ({ id, version, entities, type = 'domains'
   }
 
   const entitiesWithReferences = resourceEntities.filter((entity: Entity) =>
-    entity.data.properties?.some((property: any) => property.references)
+    entity.data.properties?.some((property: any) => getReferencedEntityId(property, entityMap))
   );
   // Creates all the entity nodes for the domain
   for (const entity of resourceEntities) {
@@ -57,7 +70,7 @@ export const getNodesAndEdges = async ({ id, version, entities, type = 'domains'
 
   // Create entities that are referenced but not owned by this domain
   const listOfReferencedEntities = entitiesWithReferences
-    .map((entity: Entity) => entity.data.properties?.map((property: any) => property.references))
+    .map((entity: Entity) => entity.data.properties?.map((property: any) => getReferencedEntityId(property, entityMap)))
     .flat()
     .filter((ref: any) => ref !== undefined);
 
@@ -67,8 +80,6 @@ export const getNodesAndEdges = async ({ id, version, entities, type = 'domains'
   // 2. Build optimized maps
   // Only build domain map if we have domains to search
   // Only build entity map if we have entities to search
-  const entityMap = createVersionedMap(allEntities);
-
   // Helper function to find which domain an entity belongs to
   // Optimized to use direct iteration over domains (domains usually contain entity arrays)
   // We can't easily map entity->domain without scanning domains first unless we build a reverse index.
@@ -123,12 +134,15 @@ export const getNodesAndEdges = async ({ id, version, entities, type = 'domains'
   // Go through any entities that are related to other entities
   for (const entity of entitiesWithReferences) {
     // Get a list of properties that reference other entities
-    const allReferencesForEntity = entity.data.properties?.filter((property: any) => property.references) ?? [];
+    const allReferencesForEntity =
+      entity.data.properties?.filter((property: any) => getReferencedEntityId(property, entityMap)) ?? [];
 
     for (const referenceProperty of allReferencesForEntity) {
+      const referencedEntityId = getReferencedEntityId(referenceProperty, entityMap);
+
       // Find the referenced entity by matching the references field with entity IDs
       // Look in both domain entities and external entities
-      const referencedEntity = allEntitiesInGraph.find((targetEntity) => targetEntity.data.id === referenceProperty.references);
+      const referencedEntity = allEntitiesInGraph.find((targetEntity) => targetEntity.data.id === referencedEntityId);
 
       if (referencedEntity) {
         const sourceNodeId = generateIdForNode(entity);
@@ -164,7 +178,7 @@ export const getNodesAndEdges = async ({ id, version, entities, type = 'domains'
           targetHandle: targetHandle,
           type: 'animated',
           animated: true,
-          label: referenceProperty.relationType || 'references',
+          label: getRelationType(referenceProperty),
           style: {
             strokeWidth: 2,
             strokeDasharray: '5,5', // dashed line
@@ -176,9 +190,7 @@ export const getNodesAndEdges = async ({ id, version, entities, type = 'domains'
           },
         });
       } else {
-        console.warn(
-          `Referenced entity "${referenceProperty.references}" not found for ${entity.data.name}.${referenceProperty.name}`
-        );
+        console.warn(`Referenced entity "${referencedEntityId}" not found for ${entity.data.name}.${referenceProperty.name}`);
       }
     }
   }
@@ -188,10 +200,10 @@ export const getNodesAndEdges = async ({ id, version, entities, type = 'domains'
   // Separate entities with and without relationships (including external entities)
   const entitiesWithRelationships = allEntitiesInGraph.filter((entity) => {
     // Has outgoing references
-    const hasOutgoingRefs = entity.data.properties?.some((property: any) => property.references);
+    const hasOutgoingRefs = entity.data.properties?.some((property: any) => getReferencedEntityId(property, entityMap));
     // Has incoming references (is referenced by others)
     const hasIncomingRefs = entitiesWithReferences.some((e: any) =>
-      e.data.properties?.some((prop: any) => prop.references === entity.data.id)
+      e.data.properties?.some((prop: any) => getReferencedEntityId(prop, entityMap) === entity.data.id)
     );
     return hasOutgoingRefs || hasIncomingRefs;
   });