@platformos/platformos-check-common 0.0.7 → 0.0.9

package/src/types.ts

@@ -15,15 +15,13 @@ import {
   PropertyNode,
   ValueNode,
 } from './jsonc/types';
-import { JsonValidationSet, ThemeDocset } from './types/theme-liquid-docs';
-import { AppBlockSchema, SectionSchema, ThemeBlockSchema } from './types/theme-schemas';
+import { JsonValidationSet, PlatformOSDocset } from './types/platformos-liquid-docs';
 import { DocDefinition } from './liquid-doc/liquidDoc';
 import { GraphQLCorrector } from './fixes/correctors/graphql-corrector';
 
 export * from './jsonc/types';
 export * from './types/schema-prop-factory';
-export * from './types/theme-liquid-docs';
-export * from './types/theme-schemas';
+export * from './types/platformos-liquid-docs';
 
 export const isObjectNode = (node?: ASTNode): node is ObjectNode => node?.type === 'Object';
 export const isArrayNode = (node?: ASTNode): node is ArrayNode => node?.type === 'Array';
@@ -31,9 +29,7 @@ export const isPropertyNode = (node?: ASTNode): node is PropertyNode => node?.ty
 export const isValueNode = (node?: ASTNode): node is ValueNode => node?.type === 'Value';
 export const isLiteralNode = (node?: ASTNode): node is LiteralNode => node?.type === 'Literal';
 
-export const Modes = ['theme', 'app'] as const;
-export type Mode = (typeof Modes)[number];
-export type Theme = SourceCode<SourceCodeType>[];
+export type App = SourceCode<SourceCodeType>[];
 
 export type SourceCode<T = SourceCodeType> = T extends SourceCodeType
   ? {
@@ -53,6 +49,7 @@ export enum SourceCodeType {
   JSON = 'JSON',
   LiquidHtml = 'LiquidHtml',
   GraphQL = 'GraphQL',
+  YAML = 'YAML',
 }
 
 export type LiquidSourceCode = SourceCode<SourceCodeType.LiquidHtml>;
@@ -82,6 +79,13 @@ export type JSONCheckDefinition<S extends Schema = Schema> = CheckDefinition<
 >;
 export type JSONCheck = Check<SourceCodeType.JSON>;
 
+export type YAMLSourceCode = SourceCode<SourceCodeType.YAML>;
+export type YAMLCheckDefinition<S extends Schema = Schema> = CheckDefinition<
+  SourceCodeType.YAML,
+  S
+>;
+export type YAMLCheck = Check<SourceCodeType.YAML>;
+
 export interface PlatformOSFile {
   name: string;
   module_name: string;
@@ -99,6 +103,7 @@ export type AST = {
     [SourceCodeType.JSON]: JSONNode;
     [SourceCodeType.LiquidHtml]: LiquidHtmlNode;
     [SourceCodeType.GraphQL]: GraphQLDocumentNode;
+    [SourceCodeType.YAML]: JSONNode; // YAML shares the JSONNode AST
   }[T];
 };
 
@@ -107,6 +112,7 @@ export type NodeTypes = {
     [SourceCodeType.JSON]: JSONNodeTypes;
     [SourceCodeType.LiquidHtml]: LiquidHtmlNodeTypes;
     [SourceCodeType.GraphQL]: 'Document';
+    [SourceCodeType.YAML]: JSONNodeTypes; // YAML shares JSON node types
   }[T];
 };
 
@@ -136,12 +142,6 @@ export type GraphQLCheckDefinition<S extends Schema = Schema> = CheckDefinition<
 >;
 
 export interface Config {
-  // I know, it's `context` in the config and `Mode` in the code...
-  // We already have something named "Context" internally when you're writing a check.
-  // I don't like "Mode" as a public API in the configs. Context sounds more Shopify-y.
-  // So we have `context: theme` and `context: app` as valid .theme-check.yml configs.
-  // I think it's rather obvious what they mean.
-  context: Mode;
   settings: ChecksSettings;
   checks: CheckDefinition<SourceCodeType, Schema>[];
   rootUri: string; // e.g. file:///path-to-root
@@ -214,8 +214,6 @@ export type CheckDefinition<
          *
          * When values are given, this check will be `enabled: false` in the `all.yml` configuration
          * and `enabled: true` within all yaml configurations with a matching filename.
-         *
-         * Note: theme-app-extension target is deprecated (Shopify-specific)
          */
         targets?: ConfigTarget[];
 
@@ -302,37 +300,6 @@ type CheckLifecycleMethods<T extends SourceCodeType> = {
   onCodePathEnd(file: SourceCode<T> & { ast: AST[T] }): Promise<void>;
 };
 
-export type MetafieldCategory =
-  | 'article'
-  | 'blog'
-  | 'collection'
-  | 'company'
-  | 'company_location'
-  | 'location'
-  | 'market'
-  | 'order'
-  | 'page'
-  | 'product'
-  | 'variant'
-  | 'shop';
-
-export type MetafieldDefinitionMap = {
-  [key in MetafieldCategory]: MetafieldDefinition[];
-};
-
-export type MetafieldDefinition = {
-  key: string;
-  name: string;
-  namespace: string;
-  description: string;
-  type: MetafieldDefinitionType;
-};
-
-type MetafieldDefinitionType = {
-  category: string;
-  name: string;
-};
-
 export type Translations = {
   [k in string]: string | Translations;
 };
@@ -344,17 +311,8 @@ export type Translations = {
  *
  * It could be a specific range that points to a whole file
  * {
- *   source: { uri: 'file:///templates/index.json', range: [167, 190] },
- *   target: 'file:///sections/custom-section.liquid'
- * }
- *
- * It could be a specific range that points to a specific range
- * {
- *   // e.g. `<parent-component></parent-component>`
  *   source: { uri: 'file:///app/views/partials/parent.liquid', range: [167, 190] },
- *
- *   // e.g. window.customElements.define('parent-component', ParentComponent);
- *   target: { uri: 'file:///assets/theme.js', range: [0, undefined] }
+ *   target: 'file:///app/views/partials/child.liquid'
  * }
  */
 export type Reference = {
@@ -362,9 +320,8 @@ export type Reference = {
   target: Location;
 
   type:
-    | 'direct' // explicit dependency, e.g. {% render 'child' %}
-    | 'indirect' // indirect dependency, e.g. "blocks": [{ "type": "@theme" }]
-    | 'preset'; // preset dependency
+    | 'direct' // explicit dependency, e.g. {% render 'partial' %}
+    | 'indirect'; // indirect dependency
 };
 
 export type Range = [start: number, end: number]; // represents a range in the source code
@@ -380,41 +337,16 @@ export interface Dependencies {
   fs: AbstractFileSystem;
 
   /** The typing information */
-  themeDocset?: ThemeDocset;
+  platformosDocset?: PlatformOSDocset;
 
-  /** The blocks/sections JSON schemas */
+  /** The JSON schemas */
   jsonValidationSet?: JsonValidationSet;
 
-  /** Returns the typing information for the theme's metafields */
-  getMetafieldDefinitions?: (rootUri: UriString) => Promise<MetafieldDefinitionMap>;
-
-  /**
-   * Asynchronously get the block schema for 'blocks/${name}.liquid'
-   * May return undefined when the theme isn't preloaded.
-   * See {@link ThemeBlockSchema} for more information
-   */
-  getBlockSchema?: (name: string) => Promise<ThemeBlockSchema | undefined>;
-
-  /**
-   * Asynchronously get the section schema for 'section/${name}.liquid'
-   * May return undefined when the theme isn't preloaded or if there are none.
-   * See {@link SectionSchema} for more information
-   */
-  getSectionSchema?: (name: string) => Promise<SectionSchema | undefined>;
-
-  /**
-   * (In theme app extension mode)
-   * Asynchronously get the block schema for 'blocks/${name}.liquid'
-   * May return undefined when the theme isn't preloaded.
-   * See {@link AppBlockSchema} for more information
-   */
-  getAppBlockSchema?: (name: string) => Promise<AppBlockSchema | undefined>;
-
   /**
    * Asynchronously get the Liquid HTML AST for a file.
-   * May return undefined when the theme isn't preloaded.
+   * May return undefined when the app isn't preloaded.
    *
-   * Used in theme-checks for cross-file checks rather that going through fs.
+   * Used in checks for cross-file checks rather than going through fs.
    */
   getDocDefinition?: (relativePath: string) => Promise<DocDefinition | undefined>;
 
@@ -436,10 +368,15 @@ export interface AugmentedDependencies extends Dependencies {
   fileExists: (uri: UriString) => Promise<boolean>;
   fileSize: (uri: UriString) => Promise<number>;
   getDefaultLocale: () => Promise<string>;
-  getDefaultSchemaLocale: () => Promise<string>;
   getDefaultTranslations(): Promise<Translations>;
-  getDefaultSchemaTranslations(): Promise<Translations>;
-  mode: Mode;
+  /**
+   * Aggregates ALL translation files for `locale` within the given translations
+   * base directory (e.g. `file:///app/translations` or
+   * `file:///modules/common-styling/public/translations`).
+   *
+   * Covers both `{base}/{locale}.yml` and `{base}/{locale}/*.yml`.
+   */
+  getTranslationsForBase(translationBaseUri: string, locale: string): Promise<Translations>;
 }
 
 type StaticContextProperties<T extends SourceCodeType> = T extends SourceCodeType
@@ -461,6 +398,7 @@ export type Corrector<T extends SourceCodeType> = T extends SourceCodeType
       [SourceCodeType.JSON]: JSONCorrector;
       [SourceCodeType.LiquidHtml]: StringCorrector;
       [SourceCodeType.GraphQL]: GraphQLCorrector;
+      [SourceCodeType.YAML]: StringCorrector; // no YAML autofix yet; StringCorrector as placeholder
     }[T]
   : never;
 
@@ -613,5 +551,4 @@ export enum Severity {
 export enum ConfigTarget {
   All = 'all',
   Recommended = 'recommended',
-  ThemeAppExtension = 'theme-app-extension',
 }

package/src/utils/index.ts

@@ -5,4 +5,3 @@ export * from './error';
 export * from './types';
 export * from './memo';
 export * from './indexBy';
-export * from './block';

package/src/visitor.spec.ts

@@ -14,12 +14,12 @@ describe('Module: visitor', () => {
 
         if (
           typeof node.markup === 'string' ||
-          node.markup.snippet.type === LiquidHtmlNodeTypes.VariableLookup
+          node.markup.partial.type === LiquidHtmlNodeTypes.VariableLookup
         ) {
           return;
         }
 
-        return node.markup.snippet.value;
+        return node.markup.partial.value;
       },
     };
 

package/src/yaml/parse.ts

@@ -0,0 +1,111 @@
+import { isMap, isScalar, isSeq, isPair, parseDocument } from 'yaml';
+import type { Pair, Scalar, YAMLMap, YAMLSeq } from 'yaml';
+import type {
+  ArrayNode,
+  IdentifierNode,
+  JSONNode,
+  LiteralNode,
+  Location,
+  ObjectNode,
+  PropertyNode,
+  ValueNode,
+} from '../jsonc/types';
+
+export class YAMLConvertError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'YAMLConvertError';
+  }
+}
+
+function loc(start: number, end: number): Location {
+  return { start: { offset: start }, end: { offset: end } };
+}
+
+function getRange(node: any): [number, number] {
+  if (node && node.range && Array.isArray(node.range)) {
+    const start = node.range[0] ?? 0;
+    const end = node.range[1] ?? 0;
+    return [start, end];
+  }
+  return [0, 0];
+}
+
+export function toYAMLNode(source: string): JSONNode {
+  const doc = parseDocument(source);
+
+  if (doc.errors.length > 0) {
+    throw new YAMLConvertError(doc.errors[0].message);
+  }
+
+  if (doc.contents === null || doc.contents === undefined) {
+    return { type: 'Object', children: [], loc: loc(0, 0) } as ObjectNode;
+  }
+
+  return convertNode(doc.contents as any, source) as JSONNode;
+}
+
+function convertNode(node: any, source: string): JSONNode {
+  if (isMap(node)) return convertMap(node, source);
+  if (isSeq(node)) return convertSeq(node, source);
+  if (isScalar(node)) return convertScalar(node);
+  return { type: 'Literal', value: null, raw: 'null', loc: loc(0, 0) } as LiteralNode;
+}
+
+function convertMap(node: YAMLMap, source: string): ObjectNode {
+  const [start, end] = getRange(node);
+  return {
+    type: 'Object',
+    children: node.items.map((pair) => convertPair(pair as Pair<any, any>, source)),
+    loc: loc(start, end),
+  };
+}
+
+function convertPair(pair: Pair<any, any>, source: string): PropertyNode {
+  const key = pair.key as Scalar;
+  const value = pair.value;
+
+  const [keyStart, keyEnd] = getRange(key);
+  const [, valueEnd] = value ? getRange(value) : [keyEnd, keyEnd];
+  const pairEnd = valueEnd > keyEnd ? valueEnd : keyEnd;
+
+  return {
+    type: 'Property',
+    key: convertIdentifier(key),
+    value: value
+      ? (convertNode(value, source) as ValueNode)
+      : ({ type: 'Literal', value: null, raw: 'null', loc: loc(keyEnd, keyEnd) } as LiteralNode),
+    loc: loc(keyStart, pairEnd),
+  };
+}
+
+function convertIdentifier(node: Scalar): IdentifierNode {
+  const [start, end] = getRange(node);
+  const value = String(node.value ?? '');
+  return {
+    type: 'Identifier',
+    value,
+    raw: JSON.stringify(value),
+    loc: loc(start, end),
+  };
+}
+
+function convertScalar(node: Scalar): LiteralNode {
+  const [start, end] = getRange(node);
+  const value = node.value as string | number | boolean | null;
+  return {
+    type: 'Literal',
+    value,
+    raw: JSON.stringify(value),
+    loc: loc(start, end),
+  };
+}
+
+function convertSeq(node: YAMLSeq, source: string): ArrayNode {
+  const [start, end] = getRange(node);
+  return {
+    type: 'Array',
+    children: node.items.map((item) => convertNode(item, source) as ValueNode),
+    loc: loc(start, end),
+  };
+}

package/src/AugmentedThemeDocset.ts

@@ -1,137 +0,0 @@
-import {
-  Access,
-  FilterEntry,
-  ObjectEntry,
-  TagEntry,
-  ThemeDocset,
-  Translations,
-  ReturnType,
-} from './types';
-import { memo } from './utils';
-
-const toFilterEntry = (name: string): FilterEntry => ({ name });
-
-const expandAliases = (entries: FilterEntry[]): FilterEntry[] => {
-  return entries.flatMap((entry) => {
-    const aliases: string[] = (entry as any).aliases ?? [];
-    return aliases.map((alias) => ({ ...entry, name: alias }));
-  });
-};
-
-const undocumentedFilters = [
-  '_online_store_editor_live_setting',
-  'addresses_url',
-  'app_block_path?',
-  'app_block_path_for',
-  'app_extension_path?',
-  'app_snippet_path?',
-  'cancel_customer_order_link',
-  'debug',
-  'delete_customer_address_link',
-  'dev_shop?',
-  'distance_from',
-  'edit_customer_address_link',
-  'encode_url_component',
-  'excerpt',
-  'format_code',
-  'global_block_type?',
-  'h',
-  'handle_from',
-  'installments_pricing',
-  'link_to_theme',
-  'login_button',
-  'login_url',
-  'logout_url',
-  'pad_spaces',
-  'paragraphize',
-  'recover_password_link',
-  'recover_url',
-  'register_url',
-  'registration_uuid_from',
-  'root_account_url',
-  'sentence',
-  'theme_url',
-  'unit',
-  'weight',
-];
-
-const undocumentedObjectEntryKeys = [
-  'locale',
-  'direction',
-  'skip_to_content_link',
-  'checkout_html_classes',
-  'checkout_stylesheets',
-  'checkout_scripts',
-  'content_for_logo',
-  'breadcrumb',
-  'order_summary_toggle',
-  'content_for_order_summary',
-  'alternative_payment_methods',
-  'content_for_footer',
-  'tracking_code',
-];
-
-const toObjectEntry = (name: string, access?: Access, returnType?: ReturnType[]): ObjectEntry => ({
-  name,
-  ...(access && { access }),
-  ...(returnType && { return_type: returnType }),
-});
-
-const undocumentedObjects = ['customer_address', 'product_variant'];
-const legacyCheckoutEntries: ObjectEntry[] = undocumentedObjectEntryKeys.map((objectKey) =>
-  toObjectEntry(objectKey, { global: false, parents: [], template: [] }, [
-    { type: 'string', name: '' },
-  ]),
-);
-
-const toTagEntry = (name: string): TagEntry => ({ name });
-const undocumentedTags = ['elsif', 'ifchanged', 'when', 'schema'];
-
-export class AugmentedThemeDocset implements ThemeDocset {
-  constructor(private themeDocset: ThemeDocset) {}
-  graphQL = memo(async (): Promise<string | null> => {
-    return await this.themeDocset.graphQL();
-  });
-
-  public isAugmented = true;
-
-  filters = memo(async (): Promise<FilterEntry[]> => {
-    const officialFilters = await this.themeDocset.filters();
-    return [
-      ...officialFilters,
-      ...expandAliases(officialFilters),
-      ...undocumentedFilters.map(toFilterEntry),
-    ];
-  });
-
-  objects = memo(async (): Promise<ObjectEntry[]> => {
-    return [
-      ...(await this.themeDocset.objects()),
-      ...undocumentedObjects.map((obj) => toObjectEntry(obj)),
-      ...legacyCheckoutEntries,
-    ];
-  });
-
-  liquidDrops = memo(async (): Promise<ObjectEntry[]> => {
-    return (await this.themeDocset.objects()).filter((obj) => {
-      if (!obj.access) {
-        return true;
-      }
-
-      if (obj.deprecated) {
-        return false;
-      }
-
-      // objects that are accessible outside Global context
-      return !obj.access.global || (obj.access.global && obj.access.parents.length > 0);
-    });
-  });
-
-  tags = memo(async (): Promise<TagEntry[]> => {
-    return [...(await this.themeDocset.tags()), ...undocumentedTags.map(toTagEntry)];
-  });
-
-  systemTranslations = memo(async (): Promise<Translations> => {
-    return this.themeDocset.systemTranslations();
-  });
-}

package/src/checks/app-block-missing-schema/index.spec.ts

@@ -1,121 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runLiquidCheck } from '../../test';
-import { AppBlockMissingSchema } from './index';
-
-describe('AppBlockMissingSchema', () => {
-  it('should report an error when schema tag is missing on a theme app extension (blocks only)', async () => {
-    const sourceCode = `
-      <footer class="footer">
-        {% for block in section.blocks %}
-          {% case block.type %}
-            {% when 'link' %}
-              <div class="link" {{ block.shopify_attributes }}>
-                {{ block.settings.linktext | link_to: block.settings.linkurl }}
-              </div>
-
-            {% when 'custom-text' %}
-              <div class="text" {{ block.shopify_attributes }}>
-                {{ block.settings.custom-text-field }}
-              </div>
-          {% endcase %}
-        {% endfor %}
-      </footer>
-    `;
-
-    const offenses = await runLiquidCheck(
-      AppBlockMissingSchema,
-      sourceCode,
-      'blocks/footer.liquid',
-    );
-    expect(offenses).to.have.lengthOf(1);
-  });
-
-  it('should not report an error when schema tag is missing on a snippet in a theme app extension )', async () => {
-    const sourceCode = `
-      <footer class="footer">
-        {% for block in section.blocks %}
-          {% case block.type %}
-            {% when 'link' %}
-              <div class="link" {{ block.shopify_attributes }}>
-                {{ block.settings.linktext | link_to: block.settings.linkurl }}
-              </div>
-
-            {% when 'custom-text' %}
-              <div class="text" {{ block.shopify_attributes }}>
-                {{ block.settings.custom-text-field }}
-              </div>
-          {% endcase %}
-        {% endfor %}
-      </footer>
-    `;
-
-    const offenses = await runLiquidCheck(
-      AppBlockMissingSchema,
-      sourceCode,
-      'app/views/partials/footer.liquid',
-    );
-    expect(offenses).to.have.lengthOf(0);
-  });
-
-  it('should not report when the schema is present on a theme app extension', async () => {
-    const sourceCode = `
-<footer class="footer">
-  {% for block in section.blocks %}
-    {% case block.type %}
-      {% when 'link' %}
-        <div class="link" {{ block.shopify_attributes }}>
-          {{ block.settings.linktext | link_to: block.settings.linkurl }}
-        </div>
-
-      {% when 'custom-text' %}
-        <div class="text" {{ block.shopify_attributes }}>
-          {{ block.settings.custom-text-field }}
-        </div>
-    {% endcase %}
-  {% endfor %}
-</footer>
-
-{% schema %}
-{
-  "name": "Footer",
-  "max_blocks": 8,
-  "blocks": [
-    {
-      "type": "link",
-      "name": "Link",
-      "settings": [
-        {
-          "id": "linkurl",
-          "type": "url",
-          "label": "URL link"
-        },
-        {
-          "id": "linktext",
-          "type": "text",
-          "label": "Link text"
-        }
-      ]
-    },
-    {
-      "type": "custom-text",
-      "name": "Custom Text",
-      "settings": [
-        {
-          "id": "custom-text-field",
-          "type": "textarea",
-          "label": "Text"
-        }
-      ]
-    }
-  ]
-}
-{% endschema %}`;
-
-    const offenses = await runLiquidCheck(
-      AppBlockMissingSchema,
-      sourceCode,
-      'blocks/footer.liquid',
-    );
-    expect(offenses).to.have.lengthOf(0);
-  });
-});

package/src/checks/app-block-missing-schema/index.ts

@@ -1,46 +0,0 @@
-import { ConfigTarget, LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-
-export const AppBlockMissingSchema: LiquidCheckDefinition = {
-  meta: {
-    code: 'AppBlockMissingSchema',
-    name: 'Missing schema definitions in theme app extensions app blocks should be avoided',
-    docs: {
-      description: 'Report missing schema definitions in theme app extensions app blocks',
-      recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/app-block-missing-schema',
-    },
-    severity: Severity.ERROR,
-    type: SourceCodeType.LiquidHtml,
-    schema: {},
-    targets: [ConfigTarget.ThemeAppExtension],
-  },
-
-  create(context) {
-    let foundSchema = false;
-    const relativePath = context.toRelativePath(context.file.uri);
-
-    /**
-     * Theme app extension blocks are the only types of files that can have a
-     * schema defined in them.
-     */
-    if (!relativePath.startsWith('blocks/')) {
-      return {};
-    }
-
-    return {
-      async LiquidRawTag(node) {
-        if (node.name == 'schema') foundSchema = true;
-      },
-
-      async onCodePathEnd() {
-        if (!foundSchema) {
-          context.report({
-            message: `The schema does not exist`,
-            startIndex: 0,
-            endIndex: 0,
-          });
-        }
-      },
-    };
-  },
-};