@platformos/platformos-check-common 0.0.12 → 0.0.16

package/src/checks/unknown-property/index.ts

@@ -12,6 +12,8 @@ import {
   GraphQLMarkup,
   GraphQLInlineMarkup,
   HashAssignMarkup,
+  JsonHashLiteral,
+  JsonArrayLiteral,
 } from '@platformos/liquid-html-parser';
 import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
 import { isError } from '../../utils';
@@ -85,8 +87,10 @@ export const UnknownProperty: LiquidCheckDefinition = {
         if (isLiquidTagAssign(node)) {
           const markup = node.markup;
 
-          // Close any previous shape for this variable (reassignment)
-          closeShapeRange(markup.name, node.position.start);
+          // Close any previous shape for this variable (reassignment).
+          // Use the value expression's end so the RHS can still see the old shape
+          // (e.g. {% assign c = c.d %} — c.d must resolve against the previous shape of c).
+          closeShapeRange(markup.name, markup.value.position.end);
 
           const hasParseJsonFilter =
             markup.value.filters &&
@@ -127,6 +131,19 @@ export const UnknownProperty: LiquidCheckDefinition = {
             }
           }
 
+          // {% assign x = {a: 5, b: {c: 1}} %} or {% assign x = [1, 2, 3] %}
+          const exprType = markup.value.expression.type;
+          if (exprType === NodeTypes.JsonHashLiteral || exprType === NodeTypes.JsonArrayLiteral) {
+            const shape = inferShapeFromLiteralNode(markup.value.expression);
+            if (shape) {
+              variableShapes.push({
+                name: markup.name,
+                shape,
+                range: [node.position.end],
+              });
+            }
+          }
+
           // {% assign x = y | dig: "key1" | dig: "key2" %}
           // Follow the dig path through the source variable's known shape.
           const digFilters =
@@ -540,3 +557,57 @@ function isGraphQLInlineMarkup(
 function isLiquidString(expr: LiquidString | LiquidVariableLookup): expr is LiquidString {
   return expr.type === NodeTypes.String;
 }
+
+/**
+ * Infer a PropertyShape from a JsonHashLiteral or JsonArrayLiteral AST node.
+ */
+function inferShapeFromLiteralNode(
+  node: JsonHashLiteral | JsonArrayLiteral,
+): PropertyShape | undefined {
+  if (node.type === NodeTypes.JsonArrayLiteral) {
+    let itemShape: PropertyShape | undefined;
+    for (const element of node.elements) {
+      const elShape = inferShapeFromExpressionNode(element);
+      if (elShape) {
+        itemShape = itemShape ? itemShape : elShape;
+      }
+    }
+    return { kind: 'array', itemShape };
+  }
+
+  if (node.type === NodeTypes.JsonHashLiteral) {
+    const properties = new Map<string, PropertyShape>();
+    for (const entry of node.entries) {
+      // Keys are VariableLookup nodes where the name is the key string
+      if (entry.key.type === NodeTypes.VariableLookup && entry.key.name) {
+        const valueShape = inferShapeFromExpressionNode(entry.value);
+        properties.set(entry.key.name, valueShape ?? { kind: 'primitive' });
+      }
+    }
+    return { kind: 'object', properties };
+  }
+
+  return undefined;
+}
+
+/**
+ * Infer a PropertyShape from a Liquid expression or variable node.
+ */
+function inferShapeFromExpressionNode(node: LiquidExpression | LiquidVariable): PropertyShape {
+  if (node.type === NodeTypes.JsonHashLiteral) {
+    return inferShapeFromLiteralNode(node as JsonHashLiteral) ?? { kind: 'primitive' };
+  }
+  if (node.type === NodeTypes.JsonArrayLiteral) {
+    return inferShapeFromLiteralNode(node as JsonArrayLiteral) ?? { kind: 'primitive' };
+  }
+  if (node.type === NodeTypes.String) {
+    return { kind: 'primitive', primitiveType: 'string' };
+  }
+  if (node.type === NodeTypes.Number) {
+    return { kind: 'primitive', primitiveType: 'number' };
+  }
+  if (node.type === NodeTypes.LiquidLiteral) {
+    return { kind: 'primitive' };
+  }
+  return { kind: 'primitive' };
+}

package/src/checks/unused-assign/index.spec.ts

@@ -56,7 +56,7 @@ describe('Module: UnusedAssign', () => {
       {{ usedVar }}
     `;
 
-    expect(suggestions).to.include(expectedFixedCode);
+    expect(suggestions).to.deep.equal([expectedFixedCode]);
   });
 
   it('should not report unused assigns for things used in a capture tag', async () => {

package/src/checks/unused-doc-param/index.spec.ts

@@ -51,14 +51,16 @@ describe('Module: UnusedDocParam', () => {
     const offenses = await runLiquidCheck(UnusedDocParam, sourceCode);
     const suggestions = applySuggestions(sourceCode, offenses[0]);
 
-    expect(suggestions).to.include(`
+    expect(suggestions).to.deep.equal([
+      `
       {% doc %}
         @param param1 - Example param
         
       {% enddoc %}
 
       {{ param1 }}
-    `);
+    `,
+    ]);
   });
 
   LoopNamedTags.forEach((tag) => {

package/src/checks/valid-doc-param-types/index.spec.ts

@@ -69,7 +69,7 @@ describe('Module: ValidDocParamTypes', () => {
       expect(offenses).to.have.length(1);
       const suggestions = applySuggestions(source, offenses[0]);
 
-      expect(suggestions).to.include(`{% doc %} @param param1 - Example param {% enddoc %}`);
+      expect(suggestions).to.deep.equal([`{% doc %} @param param1 - Example param {% enddoc %}`]);
     }
   });
 });

package/src/checks/valid-render-partial-argument-types/index.spec.ts

@@ -34,7 +34,7 @@ describe('Module: ValidRenderPartialParamTypes', () => {
           { value: "'hello'", actualType: BasicParamTypes.String },
           { value: '123', actualType: BasicParamTypes.Number },
           { value: 'true', actualType: BasicParamTypes.Boolean },
-          { value: 'empty', actualType: BasicParamTypes.Boolean },
+          { value: 'empty', actualType: BasicParamTypes.String },
         ],
       },
     ];
@@ -142,6 +142,29 @@ describe('Module: ValidRenderPartialParamTypes', () => {
       expect(offenses).toHaveLength(0);
     });
 
+    it('should not report null/nil as type mismatch for any type', async () => {
+      for (const type of ['string', 'number', 'object', 'boolean']) {
+        for (const literal of ['nil', 'null']) {
+          const sourceCode = `{% render 'card', param: ${literal} %}`;
+          const offenses = await runLiquidCheck(
+            ValidRenderPartialArgumentTypes,
+            sourceCode,
+            undefined,
+            {},
+            {
+              'app/views/partials/card.liquid': `
+                {% doc %}
+                  @param {${type}} param - Description
+                {% enddoc %}
+                <div>{{ param }}</div>
+              `,
+            },
+          );
+          expect(offenses, `${literal} should be valid for ${type}`).toHaveLength(0);
+        }
+      }
+    });
+
     it('should not enforce unsupported types', async () => {
       const sourceCode = `{% render 'card', title: 123 %}`;
       const offenses = await runLiquidCheck(

package/src/checks/valid-render-partial-argument-types/index.ts

@@ -1,7 +1,7 @@
 import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
 import { NodeTypes, RenderMarkup } from '@platformos/liquid-html-parser';
 import { LiquidDocParameter } from '../../liquid-doc/liquidDoc';
-import { inferArgumentType, isTypeCompatible } from '../../liquid-doc/utils';
+import { inferArgumentType, isNullLiteral, isTypeCompatible } from '../../liquid-doc/utils';
 import {
   findTypeMismatchParams,
   generateTypeMismatchSuggestions,
@@ -41,7 +41,8 @@ export const ValidRenderPartialArgumentTypes: LiquidCheckDefinition = {
       if (
         node.alias &&
         node.variable?.name &&
-        node.variable.name.type !== NodeTypes.VariableLookup
+        node.variable.name.type !== NodeTypes.VariableLookup &&
+        !isNullLiteral(node.variable.name)
       ) {
         const paramIsDefinedWithType = liquidDocParameters
           .get(node.alias.value)

package/src/checks/variable-name/index.spec.ts

@@ -40,7 +40,7 @@ describe('Module: VariableName', () => {
 
     const expectedFixedCode = `{% assign variable_name = "value" %}`;
 
-    expect(suggestions).to.include(expectedFixedCode);
+    expect(suggestions).to.deep.equal([expectedFixedCode]);
   });
 
   it('should not report an error for variables starting with underscore', async () => {

package/src/context-utils.ts

@@ -3,6 +3,7 @@ import {
   AbstractFileSystem,
   FileTuple,
   FileType,
+  RouteTable,
   TranslationProvider,
   UriString,
 } from '@platformos/platformos-common';
@@ -131,6 +132,31 @@ function getDefaultTranslationsFromBuffer(app: App): Translations | undefined {
   }
 }
 
+export function makeGetRouteTable(
+  fs: AbstractFileSystem,
+  rootUri: string,
+  existingTable?: RouteTable,
+): () => Promise<RouteTable> {
+  const table = existingTable ?? new RouteTable(fs);
+  let buildPromise: Promise<RouteTable> | null = null;
+  return () => {
+    if (!buildPromise) {
+      if (table.isBuilt()) {
+        buildPromise = Promise.resolve(table);
+      } else {
+        buildPromise = table
+          .build(URI.parse(rootUri))
+          .then(() => table)
+          .catch((err) => {
+            buildPromise = null;
+            throw err;
+          });
+      }
+    }
+    return buildPromise;
+  };
+}
+
 function cached<T>(fn: () => Promise<T>): () => Promise<T>;
 function cached<T>(fn: (...args: any[]) => Promise<T>): (...args: any[]) => Promise<T> {
   let cachedPromise: Promise<T>;
@@ -145,7 +171,13 @@ export async function recursiveReadDirectory(
   uri: string,
   filter: (fileTuple: FileTuple) => boolean,
 ): Promise<UriString[]> {
-  const allFiles = await fs.readDirectory(uri);
+  let allFiles: FileTuple[];
+  try {
+    allFiles = await fs.readDirectory(uri);
+  } catch (err: any) {
+    if (err?.code === 'ENOENT') return [];
+    throw err;
+  }
   const files = allFiles.filter((ft) => !isIgnored(ft) && (isDirectory(ft) || filter(ft)));
 
   const results = await Promise.all(

package/src/disabled-checks/index.spec.ts

@@ -194,7 +194,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it("should disable the parent node's next node if platformos-check is disabled as the last child node", async () => {
-        const file = `{% liquid
+        const file = `{% doc %}{% enddoc %}{% liquid
   if condition
     # platformos-check-disable-next-line
   elsif other_condition
@@ -211,7 +211,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it('should not disable any checks if platformos-check is disabled at the end', async () => {
-        const file = `{% liquid
+        const file = `{% doc %}{% enddoc %}{% liquid
   echo hello
   echo everyone
   # platformos-check-disable-next-line
@@ -232,7 +232,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it('should disable the next line if the content is an HTML tag with liquid', async () => {
-        const file = `{% # platformos-check-disable-next-line %}
+        const file = `{% doc %}{% enddoc %}{% # platformos-check-disable-next-line %}
 <div class="{{ foo }}"></div>
 <div class="{{ bar }}"></div>`;
 
@@ -246,7 +246,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it('should not disable the next line if the specified rule does not exist', async () => {
-        const file = `{% # platformos-check-disable-next-line FAKE_RULE %}
+        const file = `{% doc %}{% enddoc %}{% # platformos-check-disable-next-line FAKE_RULE %}
 <div class="{{ foo }}"></div>`;
 
         const offenses = await check({ 'code.liquid': file }, [UndefinedObject]);

package/src/index.ts

@@ -5,6 +5,7 @@ import {
   makeFileSize,
   makeGetDefaultLocale,
   makeGetDefaultTranslations,
+  makeGetRouteTable,
   makeGetTranslationsForBase,
 } from './context-utils';
 import { createDisabledChecksModule } from './disabled-checks';
@@ -80,6 +81,7 @@ export * from './utils/object';
 export * from './visitor';
 export * from './liquid-doc/liquidDoc';
 export * from './liquid-doc/utils';
+export * from './url-helpers';
 
 const defaultErrorHandler = (_error: Error): void => {
   // Silently ignores errors by default.
@@ -101,6 +103,7 @@ export async function check(
     getDefaultLocale: makeGetDefaultLocale(fs, rootUri),
     getDefaultTranslations: makeGetDefaultTranslations(fs, app, rootUri),
     getTranslationsForBase: makeGetTranslationsForBase(fs, app),
+    getRouteTable: makeGetRouteTable(fs, rootUri, injectedDependencies.routeTable),
   };
 
   const { DisabledChecksVisitor, isDisabled } = createDisabledChecksModule();

package/src/liquid-doc/arguments.ts

@@ -13,6 +13,7 @@ import {
   BasicParamTypes,
   getDefaultValueForType,
   inferArgumentType,
+  isNullLiteral,
   isTypeCompatible,
 } from './utils';
 import { isLiquidString } from '../checks/utils';
@@ -133,6 +134,11 @@ export function findTypeMismatchParams(
       continue;
     }
 
+    // null/nil is compatible with any type — skip type checking
+    if (isNullLiteral(arg.value)) {
+      continue;
+    }
+
     const liquidDocParamDef = liquidDocParameters.get(arg.name);
     if (liquidDocParamDef && liquidDocParamDef.type) {
       const paramType = liquidDocParamDef.type.toLowerCase();

package/src/liquid-doc/utils.ts

@@ -18,6 +18,11 @@ export enum BasicParamTypes {
   Object = 'object',
 }
 
+/** Inferred type for null/nil literals — not a valid @param type, only used in type mismatch messages. */
+export const InferredNull = 'null' as const;
+
+export type InferredParamType = BasicParamTypes | typeof InferredNull;
+
 export enum SupportedDocTagTypes {
   Param = 'param',
   Example = 'example',
@@ -44,7 +49,7 @@ export function getDefaultValueForType(type: string | null) {
 /**
  * Casts the value of a LiquidNamedArgument to a string representing the type of the value.
  */
-export function inferArgumentType(arg: LiquidExpression | LiquidVariable): BasicParamTypes {
+export function inferArgumentType(arg: LiquidExpression | LiquidVariable): InferredParamType {
   if (arg.type === NodeTypes.LiquidVariable) {
     // A variable with filters — delegate to the base expression if there are no filters,
     // otherwise we can't statically determine the filtered output type.
@@ -59,6 +64,8 @@ export function inferArgumentType(arg: LiquidExpression | LiquidVariable): Basic
     case NodeTypes.Number:
       return BasicParamTypes.Number;
     case NodeTypes.LiquidLiteral:
+      if (arg.value === null) return InferredNull;
+      if (arg.value === '') return BasicParamTypes.String;
       return BasicParamTypes.Boolean;
     case NodeTypes.Range:
     case NodeTypes.VariableLookup:
@@ -71,12 +78,29 @@ export function inferArgumentType(arg: LiquidExpression | LiquidVariable): Basic
   }
 }
 
+/**
+ * Checks if a LiquidExpression is a null/nil literal.
+ * null/nil is compatible with any type — it represents "no value".
+ */
+export function isNullLiteral(arg: LiquidExpression | LiquidVariable): boolean {
+  if (arg.type === NodeTypes.LiquidVariable) {
+    if (arg.filters.length > 0) return false;
+    const expr = arg.expression;
+    if (expr.type === NodeTypes.BooleanExpression) return false;
+    return isNullLiteral(expr);
+  }
+  if (arg.type === NodeTypes.LiquidLiteral) {
+    return arg.value === null;
+  }
+  return false;
+}
+
 /**
  * Checks if the provided argument type is compatible with the expected type.
  * Makes certain types more permissive:
  * - Boolean accepts any value, since everything is truthy / falsy in Liquid
  */
-export function isTypeCompatible(expectedType: string, actualType: BasicParamTypes): boolean {
+export function isTypeCompatible(expectedType: string, actualType: InferredParamType): boolean {
   const normalizedExpectedType = expectedType.toLowerCase();
 
   if (normalizedExpectedType === BasicParamTypes.Boolean) {

package/src/types.ts

@@ -2,7 +2,7 @@ import { LiquidHtmlNode, NodeTypes as LiquidHtmlNodeTypes } from '@platformos/li
 
 import { Schema, Settings } from './types/schema-prop-factory';
 
-import { AbstractFileSystem, UriString } from '@platformos/platformos-common';
+import { AbstractFileSystem, RouteTable, UriString } from '@platformos/platformos-common';
 import { JSONCorrector, StringCorrector } from './fixes';
 
 import {
@@ -355,6 +355,12 @@ export interface Dependencies {
    * Returns an empty array if no files reference this file
    */
   getReferences?: (uri: string) => Promise<Reference[]>;
+
+  /**
+   * Optional pre-built RouteTable. When provided (e.g. by the LSP),
+   * the check pipeline reuses it instead of building a new one per run.
+   */
+  routeTable?: RouteTable;
 }
 
 export type ValidateJSON = (
@@ -377,6 +383,8 @@ export interface AugmentedDependencies extends Dependencies {
    * Covers both `{base}/{locale}.yml` and `{base}/{locale}/*.yml`.
    */
   getTranslationsForBase(translationBaseUri: string, locale: string): Promise<Translations>;
+  /** Lazily builds and returns a shared RouteTable for the current check run. */
+  getRouteTable(): Promise<RouteTable>;
 }
 
 type StaticContextProperties<T extends SourceCodeType> = T extends SourceCodeType