@platformos/platformos-graph 0.0.7 → 0.0.8

package/fixtures/skeleton/app/views/partials/header.liquid

@@ -0,0 +1,3 @@
+<header>
+  {% render "child", children: "nav" %}
+</header>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformos/platformos-graph",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Shopify Theme Graph as a data structure",
   "author": "platformOS",
   "homepage": "https://github.com/Platform-OS/platformos-tools/tree/master/packages/platformos-graph#readme",
@@ -29,13 +29,13 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@platformos/liquid-html-parser": "^0.0.7",
-    "@platformos/platformos-check-common": "0.0.7",
+    "@platformos/liquid-html-parser": "^0.0.8",
+    "@platformos/platformos-check-common": "0.0.8",
     "acorn": "^8.16.0",
     "acorn-walk": "^8.3.5",
     "vscode-uri": "^3.1.0"
   },
   "devDependencies": {
-    "@platformos/platformos-check-node": "0.0.7"
+    "@platformos/platformos-check-node": "0.0.8"
   }
 }

package/src/getWebComponentMap.ts

@@ -46,7 +46,7 @@ export async function findWebComponentReferences(
   result: WebComponentMap,
 ): Promise<Void> {
   const sourceCode = await getSourceCode(uri);
-  if (sourceCode.type !== 'javascript') {
+  if (!uri.endsWith('.js')) {
     return;
   }
 

package/src/graph/augment.ts

@@ -1,9 +1,4 @@
-import {
-  memoize,
-  memo,
-  recursiveReadDirectory as findAllFiles,
-  path,
-} from '@platformos/platformos-check-common';
+import { memoize, path } from '@platformos/platformos-check-common';
 import { toSourceCode } from '../toSourceCode';
 import { AugmentedDependencies, IDependencies } from '../types';
 import { identity } from '../utils';
@@ -11,8 +6,6 @@ import { identity } from '../utils';
 export function augmentDependencies(rootUri: string, ideps: IDependencies): AugmentedDependencies {
   return {
     fs: ideps.fs,
-    getBlockSchema: memoize(ideps.getBlockSchema, identity),
-    getSectionSchema: memoize(ideps.getSectionSchema, identity),
 
     // parse at most once
     getSourceCode: memoize(
@@ -25,10 +18,5 @@ export function augmentDependencies(rootUri: string, ideps: IDependencies): Augm
     ),
 
     getWebComponentDefinitionReference: ideps.getWebComponentDefinitionReference,
-    getThemeBlockNames: memo(() =>
-      findAllFiles(ideps.fs, path.join(rootUri, 'blocks'), ([uri]) => uri.endsWith('.liquid')).then(
-        (uris) => uris.map((uri) => path.basename(uri, '.liquid')),
-      ),
-    ),
   };
 }

package/src/graph/build.spec.ts

@@ -1,7 +1,7 @@
 import { path as pathUtils, SourceCodeType } from '@platformos/platformos-check-common';
 import { assert, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { buildThemeGraph } from '../index';
-import { Dependencies, JsonModuleKind, LiquidModuleKind, ModuleType, ThemeGraph } from '../types';
+import { buildAppGraph } from '../index';
+import { Dependencies, LiquidModuleKind, ModuleType, AppGraph } from '../types';
 import { getDependencies, skeleton } from './test-helpers';
 
 describe('Module: index', () => {
@@ -14,162 +14,51 @@ describe('Module: index', () => {
     dependencies = await getDependencies(rootUri);
   }, 15000);
 
-  describe('Unit: buildThemeGraph', { timeout: 10000 }, () => {
-    it('build a graph of the theme', { timeout: 10000 }, async () => {
-      const graph = await buildThemeGraph(rootUri, dependencies);
+  describe('Unit: buildAppGraph', { timeout: 10000 }, () => {
+    it('builds a graph of the app', { timeout: 10000 }, async () => {
+      const graph = await buildAppGraph(rootUri, dependencies);
       expect(graph).toBeDefined();
     });
 
-    describe('with a valid theme graph', () => {
-      let graph: ThemeGraph;
+    describe('with a valid app graph', () => {
+      let graph: AppGraph;
 
       beforeEach(async () => {
-        graph = await buildThemeGraph(rootUri, dependencies);
+        graph = await buildAppGraph(rootUri, dependencies);
       });
 
-      it('have a root URI', () => {
+      it('has a root URI', () => {
         expect(graph.rootUri).toBeDefined();
         expect(graph.rootUri).toBe(rootUri);
       });
 
-      // We're using sections as entry points because the section rendering API can render
-      // any section without it needing a preset or default value in its schema.
-      it('infers entry points from the templates folder and section files', () => {
-        expect(graph.entryPoints).toHaveLength(3);
+      it('infers entry points from layouts and pages', () => {
+        expect(graph.entryPoints).toHaveLength(2);
         expect(graph.entryPoints.map((x) => x.uri)).toEqual(
           expect.arrayContaining([
-            p('templates/index.json'),
-            p('sections/custom-section.liquid'),
-            p('sections/header.liquid'),
+            p('app/views/layouts/application.liquid'),
+            p('app/views/pages/index.liquid'),
           ]),
         );
       });
 
-      it("finds layout/theme.liquid's dependencies and references", () => {
-        const themeLayout = graph.modules[p('layout/theme.liquid')];
-        assert(themeLayout);
+      it("finds app/views/layouts/application.liquid's dependencies", () => {
+        const layout = graph.modules[p('app/views/layouts/application.liquid')];
+        assert(layout);
+        assert(layout.type === ModuleType.Liquid);
+        assert(layout.kind === LiquidModuleKind.Layout);
 
-        // outgoing links
-        const deps = themeLayout.dependencies;
-        assert(deps.map((x) => x.source.uri).every((x) => x === p('layout/theme.liquid')));
+        const deps = layout.dependencies;
         expect(deps.map((x) => x.target.uri)).toEqual(
           expect.arrayContaining([
-            p('sections/header-group.json'),
             p('assets/theme.js'),
             p('assets/theme.css'),
+            p('app/views/partials/header.liquid'),
           ]),
         );
-
-        // ingoing links
-        const refs = themeLayout.references;
-        expect(refs).toHaveLength(1);
-        assert(refs.map((x) => x.target.uri).every((x) => x === p('layout/theme.liquid')));
-        expect(refs.map((x) => x.source.uri)).toEqual(
-          expect.arrayContaining([p('templates/index.json')]),
-        );
-      });
-
-      it("finds templates/index.json's dependencies and references", () => {
-        const indexTemplate = graph.modules[p('templates/index.json')];
-        assert(indexTemplate);
-        assert(indexTemplate.type === ModuleType.Json);
-        assert(indexTemplate.kind === JsonModuleKind.Template);
-
-        // outgoing links
-        const deps = indexTemplate.dependencies;
-        assert(deps.map((x) => x.source.uri).every((x) => x === p('templates/index.json')));
-        expect(deps.map((x) => x.target.uri)).toEqual(
-          expect.arrayContaining([
-            p('layout/theme.liquid'),
-            p('sections/custom-section.liquid'),
-            p('blocks/group.liquid'),
-            p('blocks/text.liquid'),
-          ]),
-        );
-
-        // ingoing links
-        const refs = indexTemplate.references;
-        expect(refs).toHaveLength(0);
-      });
-
-      it("finds sections/custom-section's dependencies and references", () => {
-        const customSection = graph.modules[p('sections/custom-section.liquid')];
-        assert(customSection);
-        assert(customSection.type === ModuleType.Liquid);
-        assert(customSection.kind === LiquidModuleKind.Section);
-
-        // outgoing links
-        const deps = customSection.dependencies;
-        assert(deps.map((x) => x.source.uri).every((x) => x === customSection.uri));
-        expect(deps.map((x) => x.target.uri)).toEqual(
-          expect.arrayContaining([
-            p('blocks/group.liquid'),
-            p('blocks/text.liquid'),
-            p('blocks/_private.liquid'),
-          ]),
-        );
-
-        // ingoing links
-        const refs = customSection.references;
-        assert(refs.map((x) => x.target.uri).every((x) => x === customSection.uri));
-        expect(refs.map((x) => x.source.uri)).toEqual(
-          expect.arrayContaining([p('templates/index.json'), p('sections/header-group.json')]),
-        );
-        expect(refs).toHaveLength(2);
-      });
-
-      it("finds blocks/group's dependencies and references", () => {
-        const groupBlock = graph.modules[p('blocks/group.liquid')];
-        assert(groupBlock);
-        assert(groupBlock.type === ModuleType.Liquid);
-        assert(groupBlock.kind === LiquidModuleKind.Block);
-
-        const deps = groupBlock.dependencies;
-        assert(deps.map((x) => x.source.uri).every((x) => x === groupBlock.uri));
-        expect(deps).toEqual(
-          expect.arrayContaining([
-            {
-              source: loc('blocks/group.liquid'),
-              target: loc('app/views/partials/parent.liquid'),
-              type: 'direct',
-            }, // direct dep in partial
-            {
-              source: loc('blocks/group.liquid'),
-              target: loc('blocks/text.liquid'),
-              type: 'indirect',
-            }, // indirect because of @theme
-            {
-              source: loc('blocks/group.liquid'),
-              target: loc('blocks/text.liquid'),
-              type: 'preset',
-            }, // direct dep in preset
-          ]),
-        );
-
-        const refs = groupBlock.references;
-        assert(refs.map((x) => x.target.uri).every((x) => x === groupBlock.uri));
-        expect(refs.map((x) => x.source.uri)).toEqual(
-          expect.arrayContaining([
-            p('templates/index.json'),
-            p('sections/custom-section.liquid'), // @theme ref
-            p('sections/header-group.json'), // custom-section > group
-            p('blocks/group.liquid'), // @theme ref
-          ]),
-        );
-
-        expect(refs).toContainEqual(
-          // Expecting the `@theme` reference in the custom-section schema to be indirect
-          expect.objectContaining({
-            type: 'indirect',
-            source: {
-              uri: p('sections/custom-section.liquid'),
-              range: [expect.any(Number), expect.any(Number)],
-            },
-          }),
-        );
       });
 
-      it("finds the app/views/partials/parent's dependencies and references", async () => {
+      it("finds app/views/partials/parent's dependencies and references", async () => {
         const parentPartial = graph.modules[p('app/views/partials/parent.liquid')];
         assert(parentPartial);
         assert(parentPartial.type === ModuleType.Liquid);
@@ -179,22 +68,10 @@ describe('Module: index', () => {
         const deps = parentPartial.dependencies;
         assert(deps.map((x) => x.source.uri).every((x) => x === parentPartial.uri));
         expect(deps.map((x) => x.target.uri)).toEqual(
-          expect.arrayContaining([
-            p('app/views/partials/child.liquid'), // {% render 'child' %}
-            p('assets/theme.js'), // <parent-element>
-          ]),
-        );
-
-        // ingoing links
-        const refs = parentPartial.references;
-        assert(refs.map((x) => x.target.uri).every((x) => x === parentPartial.uri));
-        expect(refs.map((x) => x.source.uri)).toEqual(
-          expect.arrayContaining([
-            p('blocks/group.liquid'), // {% render 'parent' %}
-          ]),
+          expect.arrayContaining([p('app/views/partials/child.liquid'), p('assets/theme.js')]),
         );
 
-        // {% render 'child', children: children %} dependency
+        // {% render 'child' %} dependency
         const parentSource = await dependencies.getSourceCode(
           p('app/views/partials/parent.liquid'),
         );
@@ -210,36 +87,19 @@ describe('Module: index', () => {
             ],
           }),
         );
-
-        // <parent-element> dependency
-        expect(parentPartial.dependencies.map((x) => x.source)).toContainEqual(
-          expect.objectContaining({
-            uri: p('app/views/partials/parent.liquid'),
-            range: [
-              parentSource.source.indexOf('<parent-element'),
-              parentSource.source.indexOf('<parent-element') + '<parent-element'.length,
-            ],
-          }),
-        );
       });
 
-      it("finds the blocks/_static's dependencies and references", () => {
-        const staticBlock = graph.modules[p('blocks/_static.liquid')];
-        assert(staticBlock);
-        assert(staticBlock.type === ModuleType.Liquid);
-        assert(staticBlock.kind === LiquidModuleKind.Block);
-
-        // outgoing links
-        const deps = staticBlock.dependencies;
-        expect(deps).toEqual([]);
+      it("finds app/views/partials/child's references", () => {
+        const childPartial = graph.modules[p('app/views/partials/child.liquid')];
+        assert(childPartial);
+        assert(childPartial.type === ModuleType.Liquid);
+        assert(childPartial.kind === LiquidModuleKind.Partial);
 
-        // ingoing links
-        const refs = staticBlock.references;
-        assert(refs.map((x) => x.target.uri).every((x) => x === staticBlock.uri));
+        const refs = childPartial.references;
         expect(refs.map((x) => x.source.uri)).toEqual(
           expect.arrayContaining([
-            p('sections/header-group.json'),
-            p('blocks/render-static.liquid'),
+            p('app/views/partials/parent.liquid'),
+            p('app/views/partials/header.liquid'),
           ]),
         );
       });

package/src/graph/build.ts

@@ -3,33 +3,37 @@ import {
   path,
   UriString,
 } from '@platformos/platformos-check-common';
-import { IDependencies, ThemeGraph, ThemeModule } from '../types';
+import { IDependencies, AppGraph, AppModule } from '../types';
 import { augmentDependencies } from './augment';
 import { getModule } from './module';
 import { traverseModule } from './traverse';
 
-export async function buildThemeGraph(
+export async function buildAppGraph(
   rootUri: UriString,
   ideps: IDependencies,
   entryPoints?: UriString[],
-): Promise<ThemeGraph> {
+): Promise<AppGraph> {
   const deps = augmentDependencies(rootUri, ideps);
 
   entryPoints =
     entryPoints ??
     (await findAllFiles(deps.fs, rootUri, ([uri]) => {
-      // Templates are entry points in the theme graph.
-      const isTemplateFile = uri.startsWith(path.join(rootUri, 'templates'));
-
-      // Since any section file can be rendered directly by the Section Rendering API,
-      // we consider all section files as entry points.
-      const isSectionFile =
-        uri.startsWith(path.join(rootUri, 'sections')) && uri.endsWith('.liquid');
-
-      return isTemplateFile || isSectionFile;
+      // Layouts are entry points — they wrap all page content.
+      const isLayoutFile =
+        (uri.startsWith(path.join(rootUri, 'app/views/layouts')) ||
+          uri.startsWith(path.join(rootUri, 'views/layouts'))) &&
+        uri.endsWith('.liquid');
+
+      // Pages are also entry points — they are directly requested.
+      const isPageFile =
+        (uri.startsWith(path.join(rootUri, 'app/views/pages')) ||
+          uri.startsWith(path.join(rootUri, 'views/pages'))) &&
+        uri.endsWith('.liquid');
+
+      return isLayoutFile || isPageFile;
     }));
 
-  const graph: ThemeGraph = {
+  const graph: AppGraph = {
     entryPoints: [],
     modules: {},
     rootUri,
@@ -37,7 +41,7 @@ export async function buildThemeGraph(
 
   graph.entryPoints = entryPoints
     .map((uri) => getModule(graph, uri))
-    .filter((x): x is ThemeModule => x !== undefined);
+    .filter((x): x is AppModule => x !== undefined);
 
   await Promise.all(graph.entryPoints.map((entry) => traverseModule(entry, graph, deps)));
 

package/src/graph/module.ts

@@ -1,17 +1,12 @@
 import { path, UriString } from '@platformos/platformos-check-common';
 import {
-  CssModule,
-  ImageModule,
-  JavaScriptModule,
-  JsonModule,
-  JsonModuleKind,
+  AssetModule,
+  AppGraph,
+  AppModule,
   LiquidModule,
   LiquidModuleKind,
   ModuleType,
   SUPPORTED_ASSET_IMAGE_EXTENSIONS,
-  SvgModule,
-  ThemeGraph,
-  ThemeModule,
 } from '../types';
 import { extname } from '../utils';
 
@@ -23,155 +18,76 @@ import { extname } from '../utils';
  * graphs' modules record), we want to avoid creating two different module objects
  * that represent the same file.
  *
- * We're using a WeakMap<ThemeGraph> to cache modules so that if the theme graph
+ * We're using a WeakMap<AppGraph> to cache modules so that if the app graph
  * gets garbage collected, the module cache will also be garbage collected.
  *
  * This allows us to have a module cache without changing the API of the
- * ThemeGraph (no need for a `visited` property on modules, etc.)
+ * AppGraph (no need for a `visited` property on modules, etc.)
  */
-const ModuleCache: WeakMap<ThemeGraph, Map<string, ThemeModule>> = new WeakMap();
+const ModuleCache: WeakMap<AppGraph, Map<string, AppModule>> = new WeakMap();
 
-export function getModule(themeGraph: ThemeGraph, uri: UriString): ThemeModule | undefined {
-  const cache = getCache(themeGraph);
+export function getModule(appGraph: AppGraph, uri: UriString): AppModule | undefined {
+  const cache = getCache(appGraph);
   if (cache.has(uri)) {
     return cache.get(uri)!;
   }
 
-  const relativePath = path.relative(uri, themeGraph.rootUri);
+  const relativePath = path.relative(uri, appGraph.rootUri);
 
   switch (true) {
-    case relativePath.startsWith('assets'): {
-      return getAssetModule(themeGraph, path.basename(uri));
+    case relativePath.startsWith('assets') || relativePath.startsWith('modules'): {
+      return getAssetModule(appGraph, path.basename(uri));
     }
 
-    case relativePath.startsWith('blocks'): {
-      return getThemeBlockModule(themeGraph, path.basename(uri, '.liquid'));
+    case relativePath.includes('views/layouts'): {
+      return getLayoutModule(appGraph, uri);
     }
 
-    case relativePath.startsWith('layout'): {
-      return getLayoutModule(themeGraph, path.basename(uri, '.liquid'));
+    case relativePath.includes('views/pages'): {
+      return getPageModule(appGraph, uri);
     }
 
-    case relativePath.startsWith('sections'): {
-      if (relativePath.endsWith('.json')) {
-        return getSectionGroupModule(themeGraph, path.basename(uri, '.json'));
-      }
-      return getSectionModule(themeGraph, path.basename(uri, '.liquid'));
-    }
-
-    case relativePath.includes('/views/partials') || relativePath.includes('/lib/'): {
-      return getPartialModule(themeGraph, path.basename(uri, '.liquid'));
+    case relativePath.includes('views/partials') || relativePath.includes('/lib/'): {
+      return getPartialModule(appGraph, path.basename(uri, '.liquid'));
     }
 
     case relativePath.startsWith('snippets'): {
-      return getPartialModule(themeGraph, path.basename(uri, '.liquid'));
-    }
-
-    case relativePath.startsWith('templates'): {
-      return getTemplateModule(themeGraph, uri);
-    }
-  }
-}
-
-export function getTemplateModule(themeGraph: ThemeGraph, uri: UriString): ThemeModule {
-  const extension = extname(uri);
-  switch (extension) {
-    case 'json': {
-      return module(themeGraph, {
-        type: ModuleType.Json,
-        kind: JsonModuleKind.Template,
-        dependencies: [],
-        references: [],
-        uri: uri,
-      });
-    }
-
-    case 'liquid': {
-      return module(themeGraph, {
-        type: ModuleType.Liquid,
-        kind: LiquidModuleKind.Template,
-        dependencies: [],
-        references: [],
-        uri: uri,
-      });
-    }
-
-    default: {
-      throw new Error(`Unknown template type for ${uri}`);
+      return getPartialModule(appGraph, path.basename(uri, '.liquid'));
     }
   }
 }
 
-export function getThemeBlockModule(themeGraph: ThemeGraph, blockType: string): LiquidModule {
-  const uri = path.join(themeGraph.rootUri, 'blocks', `${blockType}.liquid`);
-  return module(themeGraph, {
-    type: ModuleType.Liquid,
-    kind: LiquidModuleKind.Block,
-    dependencies: [],
-    references: [],
-    uri,
-  });
-}
-
-export function getSectionModule(themeGraph: ThemeGraph, sectionType: string): LiquidModule {
-  const uri = path.join(themeGraph.rootUri, 'sections', `${sectionType}.liquid`);
-  return module(themeGraph, {
-    type: ModuleType.Liquid,
-    kind: LiquidModuleKind.Section,
-    dependencies: [],
-    references: [],
-    uri,
-  });
-}
-
-export function getSectionGroupModule(
-  themeGraph: ThemeGraph,
-  sectionGroupType: string,
-): JsonModule {
-  const uri = path.join(themeGraph.rootUri, 'sections', `${sectionGroupType}.json`);
-  return module(themeGraph, {
-    type: ModuleType.Json,
-    kind: JsonModuleKind.SectionGroup,
-    dependencies: [],
-    references: [],
-    uri,
-  });
-}
-
-export function getAssetModule(
-  themeGraph: ThemeGraph,
-  asset: string,
-): JavaScriptModule | CssModule | SvgModule | ImageModule | undefined {
+export function getAssetModule(appGraph: AppGraph, asset: string): AssetModule | undefined {
   const extension = extname(asset);
 
-  let type: ModuleType | undefined = undefined;
-
-  if (SUPPORTED_ASSET_IMAGE_EXTENSIONS.includes(extension)) {
-    type = ModuleType.Image;
-  } else if (extension === 'js') {
-    type = ModuleType.JavaScript;
-  } else if (extension === 'css') {
-    type = ModuleType.Css;
-  } else if (extension === 'svg') {
-    type = ModuleType.Svg;
-  }
-
-  if (!type) {
+  const SUPPORTED_ASSET_EXTENSIONS = [
+    ...SUPPORTED_ASSET_IMAGE_EXTENSIONS,
+    'js',
+    'css',
+    'svg',
+    'pdf',
+    'woff',
+    'woff2',
+    'ttf',
+    'eot',
+  ];
+
+  if (!SUPPORTED_ASSET_EXTENSIONS.includes(extension)) {
     return undefined;
   }
 
-  return module(themeGraph, {
-    type,
+  return module(appGraph, {
+    type: ModuleType.Asset,
     kind: 'unused',
     dependencies: [],
     references: [],
-    uri: path.join(themeGraph.rootUri, 'assets', asset),
+    uri: path.join(appGraph.rootUri, 'assets', asset),
   });
 }
 
-export function getPartialModule(themeGraph: ThemeGraph, partial: string): LiquidModule {
-  const uri = path.join(themeGraph.rootUri, 'app/views/partials', `${partial}.liquid`);
-  return module(themeGraph, {
+export function getPartialModule(appGraph: AppGraph, partial: string): LiquidModule {
+  const uri = path.join(appGraph.rootUri, 'app/views/partials', `${partial}.liquid`);
+  return module(appGraph, {
     type: ModuleType.Liquid,
     kind: LiquidModuleKind.Partial,
     uri: uri,
@@ -181,30 +97,38 @@ export function getPartialModule(themeGraph: ThemeGraph, partial: string): Liqui
 }
 
 export function getLayoutModule(
-  themeGraph: ThemeGraph,
-  layoutName: string | false | undefined = 'theme',
+  appGraph: AppGraph,
+  layoutUri: string | false | undefined,
 ): LiquidModule | undefined {
-  if (layoutName === false) return undefined;
-  if (layoutName === undefined) layoutName = 'theme';
-  const uri = path.join(themeGraph.rootUri, 'layout', `${layoutName}.liquid`);
-  return module(themeGraph, {
+  if (!layoutUri) return undefined;
+  return module(appGraph, {
     type: ModuleType.Liquid,
     kind: LiquidModuleKind.Layout,
-    uri: uri,
+    uri: layoutUri,
+    dependencies: [],
+    references: [],
+  });
+}
+
+export function getPageModule(appGraph: AppGraph, pageUri: string): LiquidModule {
+  return module(appGraph, {
+    type: ModuleType.Liquid,
+    kind: LiquidModuleKind.Page,
+    uri: pageUri,
     dependencies: [],
     references: [],
   });
 }
 
-function getCache(themeGraph: ThemeGraph): Map<string, ThemeModule> {
-  if (!ModuleCache.has(themeGraph)) {
-    ModuleCache.set(themeGraph, new Map());
+function getCache(appGraph: AppGraph): Map<string, AppModule> {
+  if (!ModuleCache.has(appGraph)) {
+    ModuleCache.set(appGraph, new Map());
   }
-  return ModuleCache.get(themeGraph)!;
+  return ModuleCache.get(appGraph)!;
 }
 
-function module<T extends ThemeModule>(themeGraph: ThemeGraph, mod: T): T {
-  const cache = getCache(themeGraph);
+function module<T extends AppModule>(appGraph: AppGraph, mod: T): T {
+  const cache = getCache(appGraph);
   if (!cache.has(mod.uri)) {
     cache.set(mod.uri, mod);
   }