@platformos/platformos-check-common 0.0.12 → 0.0.13

package/src/checks/missing-page/index.ts

@@ -0,0 +1,89 @@
+import { HtmlElement, LiquidTag } from '@platformos/liquid-html-parser';
+import { RouteTable } from '@platformos/platformos-common';
+import {
+  shouldSkipUrl,
+  isValuedAttrNode,
+  getAttrName,
+  extractUrlPattern,
+  getEffectiveMethod,
+  tryExtractAssignUrl,
+} from '../../url-helpers';
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { isHtmlTag } from '../utils';
+
+export const MissingPage: LiquidCheckDefinition = {
+  meta: {
+    code: 'MissingPage',
+    name: 'Missing page for route',
+    docs: {
+      description:
+        'Reports links and form actions that point to routes with no corresponding platformOS page.',
+      recommended: true,
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/missing-page',
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.WARNING,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    let routeTable: RouteTable;
+    // Tracks {% assign %} variable mappings incrementally in document order.
+    // This means each <a> / <form> sees only the assigns that precede it,
+    // and reassignments correctly shadow earlier values at their position.
+    const variableMap = new Map<string, string>();
+
+    function checkUrlAttribute(attr: Parameters<typeof extractUrlPattern>[0], method: string) {
+      const urlPattern = extractUrlPattern(attr, variableMap);
+      if (urlPattern === null) return;
+      if (shouldSkipUrl(urlPattern)) return;
+
+      if (!routeTable.hasMatch(urlPattern, method)) {
+        const methodLabel = method.toUpperCase();
+        context.report({
+          message: `No page found for route '${urlPattern}' (${methodLabel})`,
+          startIndex: attr.value[0].position.start,
+          endIndex: attr.value[attr.value.length - 1].position.end,
+        });
+      }
+    }
+
+    return {
+      async onCodePathStart() {
+        // Front-load the route table build so individual HtmlElement visits don't wait.
+        routeTable = await context.getRouteTable();
+      },
+
+      async LiquidTag(node: LiquidTag) {
+        const extracted = tryExtractAssignUrl(node);
+        if (extracted) {
+          variableMap.set(extracted.name, extracted.urlPattern);
+        }
+      },
+
+      async HtmlElement(node) {
+        if (isHtmlTag(node, 'a')) {
+          const hrefAttr = node.attributes.find(
+            (a) => isValuedAttrNode(a) && getAttrName(a) === 'href',
+          );
+
+          if (hrefAttr && isValuedAttrNode(hrefAttr)) {
+            checkUrlAttribute(hrefAttr, 'get');
+          }
+        } else if (isHtmlTag(node, 'form')) {
+          const actionAttr = node.attributes.find(
+            (a) => isValuedAttrNode(a) && getAttrName(a) === 'action',
+          );
+
+          if (actionAttr && isValuedAttrNode(actionAttr)) {
+            const method = getEffectiveMethod(node as HtmlElement);
+            if (method !== null) {
+              checkUrlAttribute(actionAttr, method);
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/src/checks/missing-partial/index.spec.ts

@@ -47,6 +47,19 @@ describe('Module: MissingPartial', () => {
           'app/views/partials/partial.liquid': file,
         }),
       },
+      {
+        testCase: 'should report the missing partial to be rendered with "theme_render_rc"',
+        file: "{% theme_render_rc 'missing' %}",
+        expected: {
+          message: "'missing' does not exist",
+          uri: 'file:///app/views/partials/partial.liquid',
+          start: { index: 19, line: 0, character: 19 },
+          end: { index: 28, line: 0, character: 28 },
+        },
+        filesWith: (file: string) => ({
+          'app/views/partials/partial.liquid': file,
+        }),
+      },
     ];
     for (const { testCase, file, expected, filesWith } of testCases) {
       const offenses = await check(filesWith(file), [MissingPartial]);
@@ -58,4 +71,352 @@ describe('Module: MissingPartial', () => {
       });
     }
   });
+
+  it('should not report when the partial exists for theme_render_rc', async () => {
+    const offenses = await check(
+      {
+        'app/views/partials/partial.liquid':
+          "{% theme_render_rc 'my_product', class: 'featured' %}",
+        'app/views/partials/my_product.liquid': '<div>Product</div>',
+      },
+      [MissingPartial],
+    );
+
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should not report theme_render_rc with variable lookup', async () => {
+    const offenses = await check(
+      {
+        'app/views/partials/partial.liquid':
+          "{% theme_render_rc 'existing' for products as product %}",
+        'app/views/partials/existing.liquid': '{{ product }}',
+      },
+      [MissingPartial],
+    );
+
+    expect(offenses).to.have.length(0);
+  });
+
+  describe('theme_render_rc with theme_search_paths', () => {
+    it('should find partial via first search path (highest priority)', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress\n  - theme/simple',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'another/super/partial' %}",
+          'app/views/partials/theme/dress/another/super/partial.liquid': 'dress partial',
+          'app/views/partials/theme/simple/another/super/partial.liquid': 'simple partial',
+          'app/views/partials/another/super/partial.liquid': 'default partial',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should find partial via second search path when first does not have it', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress\n  - theme/simple',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'my/partial' %}",
+          'app/views/partials/theme/simple/my/partial.liquid': 'simple partial',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should fallback to default path when no search path matches', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress\n  - theme/simple',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'default' %}",
+          'app/views/partials/default.liquid': 'default partial',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should report missing when partial is not found in any search path or fallback', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress\n  - theme/simple',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'my/missing' %}",
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(1);
+      expect(offenses).to.containOffense({
+        check: 'MissingPartial',
+        message: "'my/missing' does not exist",
+      });
+    });
+
+    it('should respect empty string in search paths as default path position', async () => {
+      // With ['theme/dress', '', 'theme/simple'], the empty string means "default path"
+      // appears between dress and simple in priority order.
+      // So if dress doesn't have it but default path does, use default (skip simple).
+      const offenses = await check(
+        {
+          'app/config.yml': "theme_search_paths:\n  - theme/dress\n  - ''\n  - theme/simple",
+          'app/views/partials/page.liquid': "{% theme_render_rc 'my/partial' %}",
+          'app/views/partials/my/partial.liquid': 'default partial',
+          'app/views/partials/theme/simple/my/partial.liquid': 'simple partial',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should expand Liquid expressions as wildcards and find matching partial', async () => {
+      // {{ context.constants.MY_THEME }} acts as a wildcard matching any subdirectory.
+      // With theme/custom_theme/my/partial.liquid existing, the wildcard should match it.
+      const offenses = await check(
+        {
+          'app/config.yml':
+            'theme_search_paths:\n  - theme/{{ context.constants.MY_THEME }}\n  - theme/simple',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'my/partial' %}",
+          'app/views/partials/theme/custom_theme/my/partial.liquid': 'custom theme partial',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should find partial via static path when dynamic path has no match', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml':
+            'theme_search_paths:\n  - theme/{{ context.constants.MY_THEME }}\n  - theme/simple',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'product' %}",
+          'app/views/partials/theme/simple/product.liquid': 'simple partial',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should report missing when wildcard expansion finds no matching partial', async () => {
+      // Dynamic path expands but the partial doesn't exist in any expanded directory
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/{{ context.constants.MY_THEME }}',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'missing' %}",
+          'app/views/partials/theme/custom/other.liquid': 'wrong partial',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(1);
+      expect(offenses).to.containOffense({
+        check: 'MissingPartial',
+        message: "'missing' does not exist",
+      });
+    });
+
+    it('should handle multiple Liquid expressions in a path', async () => {
+      // E.g. "{{ context.constants.BRAND }}/{{ context.constants.TIER }}" - both segments are wildcards
+      const offenses = await check(
+        {
+          'app/config.yml':
+            'theme_search_paths:\n  - "{{ context.constants.BRAND }}/{{ context.constants.TIER }}"',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'card' %}",
+          'app/views/partials/acme/premium/card.liquid': 'acme premium card',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should render partial which includes path in its name', async () => {
+      // When the partial name itself includes the search path prefix
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/simple',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'theme/simple/my/partial' %}",
+          'app/views/partials/theme/simple/my/partial.liquid': 'simple partial',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should work with nested partial directories', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress\n  - theme/simple',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'components/card' %}",
+          'app/views/partials/theme/dress/components/card.liquid': 'dress card',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should not affect regular render tags even when config exists', async () => {
+      // 'card' exists under the search path prefix, so theme_render_rc would find it,
+      // but render ignores search paths entirely and looks only in the default locations.
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress\n  - theme/simple',
+          'app/views/partials/page.liquid': "{% render 'card' %}",
+          'app/views/partials/theme/simple/card.liquid': 'simple card',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(1);
+      expect(offenses).to.containOffense({
+        check: 'MissingPartial',
+        message: "'card' does not exist",
+      });
+    });
+
+    it('should also search in app/lib with search paths', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'my_helper' %}",
+          'app/lib/theme/dress/my_helper.liquid': 'helper from lib',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should fallback to standard render resolution when no config.yml exists', async () => {
+      const offenses = await check(
+        {
+          'app/views/partials/page.liquid': "{% theme_render_rc 'existing' %}",
+          'app/views/partials/existing.liquid': 'found it',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should handle theme_render_rc with named arguments and search paths', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress',
+          'app/views/partials/page.liquid':
+            "{% theme_render_rc 'product', class: 'featured', size: 'large' %}",
+          'app/views/partials/theme/dress/product.liquid': '{{ class }} {{ size }}',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should handle theme_render_rc with for/with and search paths', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'item' for products as product %}",
+          'app/views/partials/theme/dress/item.liquid': '{{ product }}',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should treat empty theme_search_paths array same as absent', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths: []',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'existing' %}",
+          'app/views/partials/existing.liquid': 'found it',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should handle malformed theme_search_paths (not an array)', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths: some_string',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'existing' %}",
+          'app/views/partials/existing.liquid': 'found it',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should handle multiple theme_render_rc tags in one file', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress\n  - theme/simple',
+          'app/views/partials/page.liquid':
+            "{% theme_render_rc 'header' %} {% theme_render_rc 'footer' %} {% theme_render_rc 'missing' %}",
+          'app/views/partials/theme/dress/header.liquid': 'header',
+          'app/views/partials/theme/simple/footer.liquid': 'footer',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(1);
+      expect(offenses).to.containOffense({
+        check: 'MissingPartial',
+        message: "'missing' does not exist",
+      });
+    });
+
+    it('should handle theme_render_rc inside {% liquid %} block', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress',
+          'app/views/partials/page.liquid': "{% liquid\n  theme_render_rc 'card'\n%}",
+          'app/views/partials/theme/dress/card.liquid': 'card',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should resolve module-prefixed partials via fallback', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - theme/dress',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'modules/shop/card' %}",
+          'modules/shop/public/views/partials/card.liquid': 'module card',
+        },
+        [MissingPartial],
+      );
+
+      expect(offenses).to.have.length(0);
+    });
+
+    it('should handle non-string entries in theme_search_paths gracefully', async () => {
+      const offenses = await check(
+        {
+          'app/config.yml': 'theme_search_paths:\n  - 123\n  - true',
+          'app/views/partials/page.liquid': "{% theme_render_rc 'card' %}",
+          'app/views/partials/card.liquid': 'default card',
+        },
+        [MissingPartial],
+      );
+
+      // 123/card and true/card won't exist, but fallback to unprefixed finds it
+      expect(offenses).to.have.length(0);
+    });
+  });
 });

package/src/checks/missing-partial/index.ts

@@ -1,8 +1,16 @@
-import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode, NamedTags, NodeTypes } from '@platformos/liquid-html-parser';
 import { LiquidCheckDefinition, SchemaProp, Severity, SourceCodeType } from '../../types';
-import { DocumentsLocator } from '@platformos/platformos-common';
+import { DocumentsLocator, DocumentType, loadSearchPaths } from '@platformos/platformos-common';
 import { URI } from 'vscode-uri';
 
+function getTagName(ancestors: LiquidHtmlNode[]): DocumentType {
+  const parent = ancestors.at(-1);
+  if (parent?.type === NodeTypes.LiquidTag && parent.name === NamedTags.theme_render_rc) {
+    return 'theme_render_rc';
+  }
+  return 'render';
+}
+
 const schema = {
   ignoreMissing: SchemaProp.array(SchemaProp.string(), []),
 };
@@ -24,62 +32,46 @@ export const MissingPartial: LiquidCheckDefinition<typeof schema> = {
 
   create(context) {
     const locator = new DocumentsLocator(context.fs);
+    const rootUri = URI.parse(context.config.rootUri);
+    let searchPathsPromise: Promise<string[] | null> | undefined;
 
-    return {
-      async RenderMarkup(node) {
-        if (node.partial.type === NodeTypes.VariableLookup) return;
+    function getSearchPaths(): Promise<string[] | null> {
+      searchPathsPromise ??= loadSearchPaths(context.fs, rootUri);
+      return searchPathsPromise;
+    }
 
-        const partial = node.partial;
-        const location = await locator.locate(
-          URI.parse(context.config.rootUri),
-          'render',
-          partial.value,
-        );
+    async function reportIfMissing(
+      docType: DocumentType,
+      name: string,
+      position: LiquidHtmlNode['position'],
+    ) {
+      const searchPaths = docType === 'theme_render_rc' ? await getSearchPaths() : null;
+      const location = await locator.locate(rootUri, docType, name, searchPaths);
+      if (!location) {
+        context.report({
+          message: `'${name}' does not exist`,
+          startIndex: position.start,
+          endIndex: position.end,
+        });
+      }
+    }
 
-        if (!location) {
-          context.report({
-            message: `'${partial.value}' does not exist`,
-            startIndex: node.partial.position.start,
-            endIndex: node.partial.position.end,
-          });
+    return {
+      async RenderMarkup(node, ancestors) {
+        if (node.partial.type !== NodeTypes.VariableLookup) {
+          await reportIfMissing(getTagName(ancestors), node.partial.value, node.partial.position);
         }
       },
 
       async FunctionMarkup(node) {
-        if (node.partial.type === NodeTypes.VariableLookup) return;
-
-        const partial = node.partial;
-        const location = await locator.locate(
-          URI.parse(context.config.rootUri),
-          'function',
-          partial.value,
-        );
-
-        if (!location) {
-          context.report({
-            message: `'${partial.value}' does not exist`,
-            startIndex: node.partial.position.start,
-            endIndex: node.partial.position.end,
-          });
+        if (node.partial.type !== NodeTypes.VariableLookup) {
+          await reportIfMissing('function', node.partial.value, node.partial.position);
         }
       },
 
       async GraphQLMarkup(node) {
-        if (node.graphql.type === NodeTypes.VariableLookup) return;
-
-        const graphql = node.graphql;
-        const location = await locator.locate(
-          URI.parse(context.config.rootUri),
-          'graphql',
-          graphql.value,
-        );
-
-        if (!location) {
-          context.report({
-            message: `'${graphql.value}' does not exist`,
-            startIndex: node.graphql.position.start,
-            endIndex: node.graphql.position.end,
-          });
+        if (node.graphql.type !== NodeTypes.VariableLookup) {
+          await reportIfMissing('graphql', node.graphql.value, node.graphql.position);
         }
       },
     };

package/src/checks/missing-render-partial-arguments/index.spec.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { applySuggestions, runLiquidCheck } from '../../test';
+import { MissingRenderPartialArguments } from '.';
+
+function check(partial: string, source: string) {
+  return runLiquidCheck(
+    MissingRenderPartialArguments,
+    source,
+    undefined,
+    {},
+    { 'app/views/partials/card.liquid': partial },
+  );
+}
+
+const partialWithRequiredParams = `
+{% doc %}
+  @param {string} title - The card title
+  @param {string} [subtitle] - Optional subtitle
+{% enddoc %}
+`;
+
+describe('Module: MissingRenderPartialArguments', () => {
+  it('should not report when partial has no LiquidDoc', async () => {
+    const offenses = await check('<h1>card</h1>', `{% render 'card' %}`);
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should not report when all required params are provided', async () => {
+    const offenses = await check(partialWithRequiredParams, `{% render 'card', title: 'Hello' %}`);
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should not report for missing optional params', async () => {
+    const offenses = await check(partialWithRequiredParams, `{% render 'card', title: 'Hello' %}`);
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should report ERROR when a required param is missing', async () => {
+    const offenses = await check(partialWithRequiredParams, `{% render 'card' %}`);
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      "Missing required argument 'title' in render tag for partial 'card'.",
+    );
+  });
+
+  it('should suggest adding the missing required param', async () => {
+    const source = `{% render 'card' %}`;
+    const offenses = await check(partialWithRequiredParams, source);
+    expect(offenses[0].suggest).to.have.length(1);
+    expect(offenses[0].suggest![0].message).to.equal("Add required argument 'title'");
+    const fixed = applySuggestions(source, offenses[0]);
+    expect(fixed).to.not.be.undefined;
+    expect(fixed![0]).to.equal("{% render 'card', title: '' %}");
+  });
+
+  it('should report one ERROR per missing required param', async () => {
+    const partial = `
+      {% doc %}
+        @param {string} title - title
+        @param {string} body - body
+      {% enddoc %}
+    `;
+    const offenses = await check(partial, `{% render 'card' %}`);
+    expect(offenses).to.have.length(2);
+  });
+
+  it('should not report for dynamic partials', async () => {
+    const offenses = await runLiquidCheck(
+      MissingRenderPartialArguments,
+      `{% render partial_name %}`,
+    );
+    expect(offenses).to.have.length(0);
+  });
+});