@platformos/platformos-check-common 0.0.7 → 0.0.9

package/src/checks/index.ts

@@ -3,140 +3,71 @@ import {
   GraphQLCheckDefinition,
   JSONCheckDefinition,
   LiquidCheckDefinition,
+  YAMLCheckDefinition,
 } from '../types';
 
-import { AppBlockValidTags } from './app-block-valid-tags';
-import { AssetPreload } from './asset-preload';
-import { AssetSizeAppBlockCSS } from './asset-size-app-block-css';
-import { AssetSizeAppBlockJavaScript } from './asset-size-app-block-javascript';
-import { AssetSizeCSS } from './asset-size-css';
-import { AssetSizeJavaScript } from './asset-size-javascript';
-import { BlockIdUsage } from './block-id-usage';
-import { CdnPreconnect } from './cdn-preconnect';
-import { ContentForHeaderModification } from './content-for-header-modification';
-import { DeprecateBgsizes } from './deprecate-bgsizes';
-import { DeprecateLazysizes } from './deprecate-lazysizes';
 import { DeprecatedFilter } from './deprecated-filter';
-import { DeprecatedFontsOnSectionsAndBlocks } from './deprecated-fonts-on-sections-and-blocks';
-import { DeprecatedFontsOnSettingsSchema } from './deprecated-fonts-on-settings-schema';
 import { DeprecatedTag } from './deprecated-tag';
 import { DuplicateRenderPartialArguments } from './duplicate-render-partial-arguments';
-import { DuplicateContentForArguments } from './duplicate-content-for-arguments';
-import { EmptyBlockContent } from './empty-block-content';
-import { HardcodedRoutes } from './hardcoded-routes';
 import { ImgWidthAndHeight } from './img-width-and-height';
-import { JSONMissingBlock } from './json-missing-block';
 import { JSONSyntaxError } from './json-syntax-error';
-import { LiquidFreeSettings } from './liquid-free-settings';
 import { LiquidHTMLSyntaxError } from './liquid-html-syntax-error';
 import { MatchingTranslations } from './matching-translations';
 import { MissingAsset } from './missing-asset';
-import { MissingContentForArguments } from './missing-content-for-arguments';
-import { MissingTemplate } from './missing-template';
+import { MissingPartial } from './missing-partial';
 import { OrphanedPartial } from './orphaned-partial';
-import { PaginationSize } from './pagination-size';
 import { ParserBlockingScript } from './parser-blocking-script';
-import { SchemaPresetsBlockOrder } from './schema-presets-block-order';
-import { SchemaPresetsStaticBlocks } from './schema-presets-static-blocks';
-import { RemoteAsset } from './remote-asset';
-import { ReservedDocParamNames } from './reserved-doc-param-names';
-import { StaticStylesheetAndJavascriptTags } from './static-stylesheet-and-javascript-tags';
 import { TranslationKeyExists } from './translation-key-exists';
 import { UnclosedHTMLElement } from './unclosed-html-element';
 import { UndefinedObject } from './undefined-object';
 import { UniqueDocParamNames } from './unique-doc-param-names';
-import { UniqueStaticBlockId } from './unique-static-block-id';
 import { UnknownFilter } from './unknown-filter';
-import { UnrecognizedContentForArguments } from './unrecognized-content-for-arguments';
 import { UnrecognizedRenderPartialArguments } from './unrecognized-render-partial-arguments';
 import { UnusedAssign } from './unused-assign';
 import { UnusedDocParam } from './unused-doc-param';
-import { ValidContentForArguments } from './valid-content-for-arguments';
-import { ValidContentForArgumentTypes } from './valid-content-for-argument-types';
-import { ValidBlockTarget } from './valid-block-target';
 import { ValidHTMLTranslation } from './valid-html-translation';
 import { ValidJSON } from './valid-json';
 import { ValidDocParamTypes } from './valid-doc-param-types';
-import { ValidLocalBlocks } from './valid-local-blocks';
 import { ValidRenderPartialArgumentTypes } from './valid-render-partial-argument-types';
-import { ValidSchema } from './valid-schema';
-import { ValidSchemaName } from './valid-schema-name';
-import { ValidSettingsKey } from './valid-settings-key';
-import { ValidStaticBlockType } from './valid-static-block-type';
-import { ValidVisibleIf, ValidVisibleIfSettingsSchema } from './valid-visible-if';
 import { VariableName } from './variable-name';
-import { AppBlockMissingSchema } from './app-block-missing-schema';
-import { UniqueSettingIds } from './unique-settings-id';
 import { MetadataParamsCheck } from './metadata-params';
 import { GraphQLVariablesCheck } from './graphql-variables';
 import { GraphQLCheck } from './graphql';
 import { UnknownProperty } from './unknown-property';
 import { InvalidHashAssignTarget } from './invalid-hash-assign-target';
+import { DuplicateFunctionArguments } from './duplicate-function-arguments';
 
-export const allChecks: (LiquidCheckDefinition | JSONCheckDefinition | GraphQLCheckDefinition)[] = [
-  AppBlockValidTags,
-  AssetPreload,
-  AssetSizeAppBlockCSS,
-  AssetSizeAppBlockJavaScript,
-  AssetSizeCSS,
-  AssetSizeJavaScript,
-  BlockIdUsage,
-  CdnPreconnect,
-  ContentForHeaderModification,
-  DeprecateBgsizes,
-  DeprecateLazysizes,
+export const allChecks: (
+  | LiquidCheckDefinition
+  | JSONCheckDefinition
+  | GraphQLCheckDefinition
+  | YAMLCheckDefinition
+)[] = [
   DeprecatedFilter,
-  DeprecatedFontsOnSectionsAndBlocks,
-  DeprecatedFontsOnSettingsSchema,
   DeprecatedTag,
-  DuplicateContentForArguments,
+  DuplicateFunctionArguments,
   DuplicateRenderPartialArguments,
-  EmptyBlockContent,
-  HardcodedRoutes,
   ImgWidthAndHeight,
-  JSONMissingBlock,
   JSONSyntaxError,
-  LiquidFreeSettings,
   LiquidHTMLSyntaxError,
   MatchingTranslations,
   MissingAsset,
-  MissingContentForArguments,
-  MissingTemplate,
-  AppBlockMissingSchema,
+  MissingPartial,
   OrphanedPartial,
-  PaginationSize,
   ParserBlockingScript,
-  SchemaPresetsBlockOrder,
-  SchemaPresetsStaticBlocks,
-  RemoteAsset,
-  ReservedDocParamNames,
-  StaticStylesheetAndJavascriptTags,
   TranslationKeyExists,
   UnclosedHTMLElement,
   UndefinedObject,
   UniqueDocParamNames,
-  UniqueSettingIds,
-  UniqueStaticBlockId,
   UnknownFilter,
-  UnrecognizedContentForArguments,
   UnrecognizedRenderPartialArguments,
   UnusedAssign,
   UnusedDocParam,
-  ValidBlockTarget,
   ValidHTMLTranslation,
-  ValidContentForArguments,
-  ValidContentForArgumentTypes,
   ValidJSON,
   ValidDocParamTypes,
-  ValidLocalBlocks,
   ValidRenderPartialArgumentTypes,
-  ValidSchema,
-  ValidSettingsKey,
-  ValidStaticBlockType,
-  ValidVisibleIf,
-  ValidVisibleIfSettingsSchema,
   VariableName,
-  ValidSchemaName,
   MetadataParamsCheck,
   GraphQLVariablesCheck,
   GraphQLCheck,

package/src/checks/invalid-hash-assign-target/index.spec.ts

@@ -1,75 +1,75 @@
 import { describe, it, expect } from 'vitest';
 import { InvalidHashAssignTarget } from './index';
-import { check, MockTheme } from '../../test';
+import { check, MockApp } from '../../test';
 
 describe('Module: InvalidHashAssignTarget', () => {
   it('should report an error when hash_assign is used on a number', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% assign x = 10 %}
         {% hash_assign x['key'] = 'value' %}
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(1);
     expect(offenses[0].message).toContain('number');
     expect(offenses[0].message).toContain('hash_assign');
   });
 
   it('should report an error when hash_assign is used on a string', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% assign x = 'hello' %}
         {% hash_assign x['key'] = 'value' %}
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(1);
     expect(offenses[0].message).toContain('string');
   });
 
   it('should report an error when hash_assign is used on a boolean', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% assign x = true %}
         {% hash_assign x['key'] = 'value' %}
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(1);
     expect(offenses[0].message).toContain('boolean');
   });
 
   it('should report an error when hash_assign is used on an array (range)', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% assign x = (1..5) %}
         {% hash_assign x['key'] = 'value' %}
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(1);
     expect(offenses[0].message).toContain('array');
   });
 
   it('should not report an error when hash_assign is used on an object from parse_json', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% assign x = '{}' | parse_json %}
         {% hash_assign x['key'] = 'value' %}
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(0);
   });
 
   it('should not report an error when hash_assign is used on an object from parse_json tag', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% parse_json x %}
           {}
@@ -78,12 +78,12 @@ describe('Module: InvalidHashAssignTarget', () => {
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(0);
   });
 
   it('should not report an error when hash_assign is used on an object from graphql', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% graphql result %}
           query { user { id } }
@@ -92,35 +92,35 @@ describe('Module: InvalidHashAssignTarget', () => {
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(0);
   });
 
   it('should not report an error when hash_assign is used on an untyped variable', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% hash_assign unknown_var['key'] = 'value' %}
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(0);
   });
 
   it('should not report an error when hash_assign is used on a function return', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% function data = 'lib/get_data' %}
         {% hash_assign data['extra'] = 'value' %}
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(0);
   });
 
   it('should track reassignment and report error on new type', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% assign x = '{}' | parse_json %}
         {% hash_assign x['key1'] = 'value1' %}
@@ -129,39 +129,39 @@ describe('Module: InvalidHashAssignTarget', () => {
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(1);
     expect(offenses[0].message).toContain('number');
   });
 
   it('should handle increment/decrement as numbers', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% increment counter %}
         {% hash_assign counter['key'] = 'value' %}
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(1);
     expect(offenses[0].message).toContain('number');
   });
 
   it('should handle capture as string', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% capture x %}hello{% endcapture %}
         {% hash_assign x['key'] = 'value' %}
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(1);
     expect(offenses[0].message).toContain('string');
   });
 
   it('should allow multiple hash_assign on same object', async () => {
-    const theme: MockTheme = {
+    const app: MockApp = {
       'file.liquid': `
         {% assign x = '{}' | parse_json %}
         {% hash_assign x['key1'] = 'value1' %}
@@ -170,7 +170,7 @@ describe('Module: InvalidHashAssignTarget', () => {
       `,
     };
 
-    const offenses = await check(theme, [InvalidHashAssignTarget]);
+    const offenses = await check(app, [InvalidHashAssignTarget]);
     expect(offenses).toHaveLength(0);
   });
 });

package/src/checks/json-syntax-error/index.ts

@@ -13,9 +13,9 @@ export const JSONSyntaxError: JSONCheckDefinition = {
     code: 'JSONSyntaxError',
     name: 'Enforce valid JSON',
     docs: {
-      description: 'This check exists to prevent invalid JSON files in themes.',
+      description: 'This check exists to prevent invalid JSON files in apps.',
       recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/json-syntax-error',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/json-syntax-error',
     },
     type: SourceCodeType.JSON,
     severity: Severity.ERROR,

package/src/checks/liquid-html-syntax-error/checks/InvalidBooleanExpression.spec.ts

@@ -12,17 +12,6 @@ describe('detectTrailingAssignValue', async () => {
     }
   });
 
-  it('should not report when the boolean expression is in a schema tag', async () => {
-    const sourceCode = `{% schema %}
-      {
-        "visible_if": "{{ this > that }}"
-      }
-    {% endschema %}`;
-
-    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
-    expect(offenses).to.have.length(0);
-  });
-
   it('should report all use of boolean expressions', async () => {
     const testCases = [
       [`{% assign foo = something == else %}`, '{% assign foo = something %}'],

package/src/checks/liquid-html-syntax-error/checks/InvalidLoopArguments.spec.ts

@@ -109,7 +109,7 @@ describe('detectInvalidLoopArguments', async () => {
 
 function testCheck(sourceCode: string) {
   return runLiquidCheck(LiquidHTMLSyntaxError, sourceCode, undefined, {
-    themeDocset: {
+    platformosDocset: {
       graphQL: async () => null,
       tags: () =>
         Promise.resolve([
@@ -139,7 +139,6 @@ function testCheck(sourceCode: string) {
       filters: () => Promise.resolve([]),
       objects: () => Promise.resolve([]),
       liquidDrops: () => Promise.resolve([]),
-      systemTranslations: () => Promise.resolve({}),
     },
   });
 }

package/src/checks/liquid-html-syntax-error/checks/InvalidLoopArguments.ts

@@ -101,13 +101,13 @@ export function detectInvalidLoopArguments(
 }
 
 function isSupportedTagArgument(
-  tags: TagEntry[],
+  tags: TagEntry[] | undefined,
   tagName: string,
   key: string,
   positional: boolean,
 ) {
   return (
-    tags
+    (tags ?? [])
       .find((tag) => tag.name === tagName)
       ?.parameters?.some(
         (parameter) => parameter.name === key && parameter.positional === positional,