@platformos/platformos-check-common 0.0.2

package/src/fixes/correctors/string-corrector.ts

@@ -0,0 +1,78 @@
+import { Fix } from '../../types';
+import { BaseCorrector } from './base-corrector';
+
+/**
+ * The corrector is a helper that collects Fix objects. At the end we
+ * collect those fix objects and apply them on the source code to obtain a
+ * "fixed" file.
+ *
+ * We cannot fix on overlapping ranges.
+ *
+ * All fix are assumed to be on the file without modifications. The
+ * FixApplicator should take care of knowing where to apply fixes as the
+ * changes are applied.
+ */
+export class StringCorrector implements BaseCorrector {
+  public readonly fix: Fix[] = [] satisfies Fix;
+
+  constructor(public source: string) {}
+
+  /**
+   * insert text before the given index
+   *
+   * @example
+   * corrector.insert(
+   *   node.position.start,
+   *   node.position.start,
+   *   'prefix node with this content'
+   * )
+   *
+   * corrector.insert(
+   *   node.position.end,
+   *   node.position.end,
+   *   'suffix node with this content (since position.end is excluded)'
+   * )
+   */
+  insert(index: number, text: string) {
+    this.fix.push({
+      startIndex: index,
+      endIndex: index,
+      insert: text,
+    });
+  }
+
+  /**
+   * replace text between start (included) and end (excluded) with text.
+   *
+   * @example
+   * corrector.replace(
+   *   node.position.start,
+   *   node.position.end,
+   *   'ho ho ho',
+   * );
+   */
+  replace(start: number, end: number, text: string) {
+    this.fix.push({
+      startIndex: start,
+      endIndex: end,
+      insert: text,
+    });
+  }
+
+  /**
+   * remove text between start (included) and end (excluded)
+   *
+   * @example
+   * corrector.remove(
+   *   node.position.start,
+   *   node.position.end,
+   * )
+   */
+  remove(start: number, end: number) {
+    this.fix.push({
+      startIndex: start,
+      endIndex: end,
+      insert: '',
+    });
+  }
+}

package/src/fixes/index.ts

@@ -0,0 +1,4 @@
+export { flattenFixes } from './utils';
+export { StringCorrector, JSONCorrector, createCorrector } from './correctors';
+export { autofix } from './autofix';
+export { applyFixToString } from './apply-fix-to-string';

package/src/fixes/utils.ts

@@ -0,0 +1,6 @@
+import { Fix, FixDescription } from '../types';
+
+export function flattenFixes(fix: Fix): FixDescription[] {
+  if (!Array.isArray(fix)) return [fix];
+  return fix.flatMap(flattenFixes);
+}

package/src/ignore.spec.ts

@@ -0,0 +1,202 @@
+import { expect, describe, it } from 'vitest';
+import { isIgnored } from './ignore';
+import { UriString, CheckDefinition, Config, SourceCodeType } from './types';
+
+const checkDef: CheckDefinition = {
+  meta: {
+    name: 'Mock Check',
+    code: 'MockCheck',
+    severity: 0,
+    type: SourceCodeType.LiquidHtml,
+    docs: {
+      description: 'Mock check for testing',
+    },
+    schema: {},
+    targets: [],
+  },
+  create: () => ({}),
+};
+
+describe('Function: isIgnored', () => {
+  it('should return false when no ignore patterns are provided', () => {
+    const result = isIgnored(
+      toUri('app/views/partials/foo.liquid'),
+      config({
+        checkIgnore: [],
+        globalIgnore: [],
+      }),
+      checkDef,
+    );
+    expect(result).toBe(false);
+  });
+
+  it('should return true when the file matches a base ignore pattern', () => {
+    const result = isIgnored(
+      toUri('app/views/partials/foo.liquid'),
+      config({
+        checkIgnore: ['*.liquid'],
+        globalIgnore: [],
+      }),
+      checkDef,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it('should return false when the file does not matches a negative pattern', () => {
+    const result = isIgnored(
+      toUri('app/views/partials/foo.liquid'),
+      config({
+        checkIgnore: ['!snippets/*'],
+        globalIgnore: [],
+      }),
+      checkDef,
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it('should return true when the file matches an ignore pattern', () => {
+    const result = isIgnored(
+      toUri('app/views/partials/foo.liquid'),
+      config({
+        checkIgnore: ['app/views/partials/*.liquid'],
+        globalIgnore: [],
+      }),
+      checkDef,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it('should return false when the file does not match any ignore patterns', () => {
+    const result = isIgnored(
+      toUri('app/views/partials/foo.liquid'),
+      config({
+        checkIgnore: ['other-snippets/*.liquid'],
+        globalIgnore: [],
+      }),
+      checkDef,
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it('should return true when the file matches a global ignore pattern', () => {
+    const result = isIgnored(
+      toUri('app/views/partials/foo.liquid'),
+      config({
+        checkIgnore: [],
+        globalIgnore: ['app/views/partials/*.liquid'],
+      }),
+      checkDef,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it('should return true when the file matches both check-specific and global ignore patterns', () => {
+    const result = isIgnored(
+      toUri('app/views/partials/foo.liquid'),
+      config({
+        checkIgnore: ['app/views/partials/*.liquid'],
+        globalIgnore: ['app/views/partials/*.liquid'],
+      }),
+      checkDef,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it('should return true when the file partially matches an ignore pattern', () => {
+    const result = isIgnored(
+      toUri('node_modules/some-library/foo.liquid'),
+      config({
+        checkIgnore: ['node_modules/*'],
+        globalIgnore: [],
+      }),
+      checkDef,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it('should return true when the file partially matches a non-root ignore pattern', () => {
+    const result = isIgnored(
+      toUri('some-library/node_modules/foo.liquid'),
+      config({
+        // any kind of node_modules are ignored
+        checkIgnore: ['node_modules/*'],
+        globalIgnore: [],
+      }),
+      checkDef,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it('should return true when the file matches a non-root /** pattern', () => {
+    const result = isIgnored(
+      toUri('some-library/node_modules/foo.liquid'),
+      config({
+        // any kind of node_modules are ignored
+        checkIgnore: ['node_modules/**'],
+        globalIgnore: [],
+      }),
+      checkDef,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it('should return false when the file partially matches a root ignore pattern', () => {
+    const result = isIgnored(
+      toUri('some-library/node_modules/foo.liquid'),
+      config({
+        // only /root/node_modules/* is ignored, other ones aren't
+        checkIgnore: ['/node_modules/*'],
+        globalIgnore: [],
+      }),
+      checkDef,
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it('should work with only global ignore as well', () => {
+    const result = isIgnored(
+      toUri('layout/theme.liquid'),
+      config({
+        checkIgnore: [],
+        globalIgnore: ['layout/theme.liquid'],
+      }),
+    );
+
+    expect(result).toBe(true);
+  });
+});
+
+function toUri(relativePath: string): UriString {
+  return `file:/path/to/${relativePath}`;
+}
+
+function config({
+  checkIgnore,
+  globalIgnore,
+}: {
+  checkIgnore?: string[];
+  globalIgnore?: string[];
+}): Config {
+  return {
+    context: 'theme',
+    settings: {
+      MockCheck: {
+        enabled: true,
+        ignore: checkIgnore,
+      },
+    },
+    checks: [],
+    rootUri: 'file:/path/to',
+    ignore: globalIgnore,
+  };
+}

package/src/ignore.ts

@@ -0,0 +1,23 @@
+import { UriString, CheckDefinition, Config } from './types';
+import { minimatch } from 'minimatch';
+
+export function isIgnored(uri: UriString, config: Config, checkDef?: CheckDefinition): boolean {
+  const ignorePatterns = [...checkIgnorePatterns(checkDef, config), ...asArray(config.ignore)].map(
+    (pattern) =>
+      pattern
+        .replace(/^\//, config.rootUri + '/') // "absolute patterns" are config.rootUri matches
+        .replace(/^([^\/])/, '**/$1') // "relative patterns" are "**/${pattern}"
+        .replace(/\/\*$/, '/**'), // "/*" patterns are really "/**"
+  );
+
+  return ignorePatterns.some((pattern) => minimatch(uri, pattern));
+}
+
+function checkIgnorePatterns(checkDef: CheckDefinition | undefined, config: Config) {
+  if (!checkDef) return [];
+  return asArray(config.settings[checkDef.meta.code]?.ignore);
+}
+
+function asArray<T>(x: T[] | undefined): T[] {
+  return x ?? [];
+}

package/src/index.spec.ts

@@ -0,0 +1,8 @@
+import { expect, describe, it } from 'vitest';
+import { check } from './index';
+
+describe('Module: Hello World', () => {
+  it('should validate that we can test files', () => {
+    expect(check).to.exist;
+  });
+});

package/src/index.ts

@@ -0,0 +1,234 @@
+import { AugmentedThemeDocset } from './AugmentedThemeDocset';
+import { JSONValidator } from './JSONValidator';
+import {
+  makeFileExists,
+  makeFileSize,
+  makeGetDefaultLocale,
+  makeGetDefaultSchemaLocale,
+  makeGetDefaultSchemaTranslations,
+  makeGetDefaultTranslations,
+  makeGetMetafieldDefinitions,
+} from './context-utils';
+import { createDisabledChecksModule } from './disabled-checks';
+import { isIgnored } from './ignore';
+import * as path from './path';
+import {
+  AugmentedDependencies,
+  Check,
+  CheckDefinition,
+  CheckSettings,
+  Config,
+  Context,
+  Dependencies,
+  GraphQLCheck,
+  GraphQLDocumentNode,
+  GraphQLSourceCode,
+  JSONCheck,
+  JSONNode,
+  JSONSourceCode,
+  LiquidCheck,
+  LiquidHtmlNode,
+  LiquidSourceCode,
+  Offense,
+  Problem,
+  Schema,
+  Settings,
+  SourceCode,
+  SourceCodeType,
+  Theme,
+  ValidateJSON,
+} from './types';
+import { getPosition } from './utils';
+import { visitJSON, visitLiquid } from './visitors';
+
+export * from './AugmentedThemeDocset';
+export * from './checks';
+export * from './context-utils';
+export * from './find-root';
+export * from './fixes';
+export * from './ignore';
+export * from './json';
+export * from './JSONValidator';
+export * as path from './path';
+export * from './to-schema';
+export * from './to-source-code';
+export * from './types';
+export * from './utils/error';
+export * from './utils/indexBy';
+export * from './utils/memo';
+export * from './utils/types';
+export * from './utils/object';
+export * from './visitor';
+export * from './liquid-doc/liquidDoc';
+export { getBlockName } from './liquid-doc/arguments';
+export * from './liquid-doc/utils';
+
+const defaultErrorHandler = (_error: Error): void => {
+  // Silently ignores errors by default.
+};
+
+export async function check(
+  theme: Theme,
+  config: Config,
+  injectedDependencies: Dependencies,
+): Promise<Offense[]> {
+  const pipelines: Promise<void>[] = [];
+  const offenses: Offense[] = [];
+  const { fs } = injectedDependencies;
+  const { rootUri } = config;
+  const dependencies: AugmentedDependencies = {
+    ...injectedDependencies,
+    mode: config.context,
+    fileExists: makeFileExists(fs),
+    fileSize: makeFileSize(fs),
+    getDefaultLocale: makeGetDefaultLocale(fs, rootUri),
+    getDefaultTranslations: makeGetDefaultTranslations(fs, theme, rootUri),
+    getDefaultSchemaLocale: makeGetDefaultSchemaLocale(fs, rootUri),
+    getDefaultSchemaTranslations: makeGetDefaultSchemaTranslations(fs, theme, rootUri),
+    getMetafieldDefinitions:
+      injectedDependencies.getMetafieldDefinitions ?? makeGetMetafieldDefinitions(fs),
+  };
+
+  const { DisabledChecksVisitor, isDisabled } = createDisabledChecksModule();
+  const jsonValidator = await JSONValidator.create(dependencies.jsonValidationSet, config);
+  const validateJSON = jsonValidator?.validate;
+
+  // We're memozing those deps here because they shouldn't change within a run.
+  if (dependencies.themeDocset && !dependencies.themeDocset.isAugmented) {
+    dependencies.themeDocset = new AugmentedThemeDocset(dependencies.themeDocset);
+  }
+
+  for (const type of Object.values(SourceCodeType)) {
+    switch (type) {
+      case SourceCodeType.JSON: {
+        const files = filesOfType(type, theme);
+        const checkDefs = checksOfType(type, config.checks);
+        for (const file of files) {
+          for (const checkDef of checkDefs) {
+            if (isIgnored(file.uri, config, checkDef)) continue;
+            const check = createCheck(checkDef, file, config, offenses, dependencies, validateJSON);
+            pipelines.push(checkJSONFile(check, file));
+          }
+        }
+        break;
+      }
+      case SourceCodeType.GraphQL: {
+        const files = filesOfType(type, theme);
+        const checkDefs = checksOfType(type, config.checks);
+        for (const file of files) {
+          for (const checkDef of checkDefs) {
+            if (isIgnored(file.uri, config, checkDef)) continue;
+            const check = createCheck(checkDef, file, config, offenses, dependencies, validateJSON);
+            pipelines.push(checkGraphQLFile(check, file));
+          }
+        }
+        break;
+      }
+      case SourceCodeType.LiquidHtml: {
+        const files = filesOfType(type, theme);
+        const checkDefs = [DisabledChecksVisitor, ...checksOfType(type, config.checks)];
+        for (const file of files) {
+          for (const checkDef of checkDefs) {
+            if (isIgnored(file.uri, config, checkDef)) continue;
+            const check = createCheck(checkDef, file, config, offenses, dependencies, validateJSON);
+            pipelines.push(checkLiquidFile(check, file));
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  const onRejected = config.onError || defaultErrorHandler;
+  await Promise.all(pipelines.map((pipeline) => pipeline.catch(onRejected)));
+
+  return offenses.filter((offense) => !isDisabled(offense));
+}
+
+function createContext<T extends SourceCodeType, S extends Schema>(
+  check: CheckDefinition<T, S>,
+  file: SourceCode<T>,
+  offenses: Offense[],
+  config: Config,
+  dependencies: Dependencies,
+  validateJSON?: ValidateJSON,
+): Context<T, S> {
+  const checkSettings = config.settings[check.meta.code];
+  return {
+    ...dependencies,
+    validateJSON,
+    settings: createSettings(checkSettings, check.meta.schema),
+    toUri: (relativePath) => path.join(config.rootUri, ...relativePath.split('/')),
+    toRelativePath: (uri) => path.relative(uri, config.rootUri),
+    report(problem: Problem<T>): void {
+      offenses.push({
+        type: check.meta.type,
+        check: check.meta.code,
+        message: problem.message,
+        uri: file.uri,
+        severity: checkSettings?.severity ?? check.meta.severity,
+        start: getPosition(file.source, problem.startIndex),
+        end: getPosition(file.source, problem.endIndex),
+        fix: problem.fix,
+        suggest: problem.suggest,
+      } as Offense<T> as Offense);
+    },
+    file,
+    config,
+  } as Context<T, S>;
+}
+
+function createSettings<S extends Schema>(
+  checkSettings: CheckSettings | undefined,
+  schema: S,
+): Settings<S> {
+  const settings: Partial<Settings<S>> = {};
+
+  for (const [key, schemaProp] of Object.entries(schema)) {
+    settings[key as keyof S] = checkSettings?.[key] ?? schemaProp.defaultValue();
+  }
+
+  return settings as Settings<S>;
+}
+
+function checksOfType<S extends SourceCodeType>(
+  type: S,
+  checks: CheckDefinition<SourceCodeType>[],
+): CheckDefinition<S>[] {
+  return checks.filter((def): def is CheckDefinition<S> => def.meta.type === type);
+}
+
+function createCheck<S extends SourceCodeType>(
+  check: CheckDefinition<S>,
+  file: SourceCode<S>,
+  config: Config,
+  offenses: Offense[],
+  dependencies: Dependencies,
+  validateJSON?: ValidateJSON,
+): Check<S> {
+  const context = createContext(check, file, offenses, config, dependencies, validateJSON);
+  return check.create(context as any) as Check<S>;
+}
+
+function filesOfType<S extends SourceCodeType>(type: S, sourceCodes: Theme): SourceCode<S>[] {
+  return sourceCodes.filter((file): file is SourceCode<S> => file.type === type);
+}
+
+async function checkJSONFile(check: JSONCheck, file: JSONSourceCode): Promise<void> {
+  if (check.onCodePathStart) await check.onCodePathStart(file);
+  if (file.ast instanceof Error) return;
+  if (Object.keys(check).length > 0) await visitJSON(file.ast, check);
+  if (check.onCodePathEnd) await check.onCodePathEnd(file as typeof file & { ast: JSONNode });
+}
+
+async function checkGraphQLFile(check: GraphQLCheck, file: GraphQLSourceCode): Promise<void> {
+  if (check.onCodePathEnd)
+    await check.onCodePathEnd(file as typeof file & { ast: GraphQLDocumentNode });
+}
+
+async function checkLiquidFile(check: LiquidCheck, file: LiquidSourceCode): Promise<void> {
+  if (check.onCodePathStart) await check.onCodePathStart(file);
+  if (file.ast instanceof Error) return;
+  if (Object.keys(check).length > 0) await visitLiquid(file.ast, check);
+  if (check.onCodePathEnd) await check.onCodePathEnd(file as typeof file & { ast: LiquidHtmlNode });
+}

package/src/json.spec.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect, assert } from 'vitest';
+import { nodeAtPath, parseJSON } from './json';
+import { toJSONAST } from './to-source-code';
+
+describe('Function: parseJSON', () => {
+  it('should parse valid JSON string', () => {
+    const jsonString = '{"key": "value"}';
+    const result = parseJSON(jsonString);
+
+    expect(result).toEqual({ key: 'value' });
+  });
+
+  it('should return an Error for invalid JSON string', () => {
+    const jsonString = '{"key": "value"';
+
+    const result = parseJSON(jsonString, undefined, true);
+
+    expect(result).toBeInstanceOf(Error);
+    expect(result.message).toBe('Closing brace `}` expected.');
+  });
+
+  it('should not return an Error for invalid JSON string if not strict', () => {
+    const jsonString = '{"key": "value"';
+
+    const result = parseJSON(jsonString);
+
+    expect(result).toEqual({ key: 'value' });
+  });
+
+  it('should return default value for invalid JSON string when provided', () => {
+    const jsonString = '{"key": "value"';
+    const defaultValue = { defaultKey: 'defaultValue' };
+
+    const result = parseJSON(jsonString, defaultValue, true);
+
+    expect(result).toEqual(defaultValue);
+  });
+
+  it('should parse JSON string with comments if disallowComments is false', () => {
+    const jsonString = `{
+        // This is a comment
+        "key": "value"
+        /*
+         * This is a multiline comment
+         */
+      }`;
+
+    const result = parseJSON(jsonString);
+
+    expect(result).toEqual({ key: 'value' });
+  });
+
+  it('should handle trailing commas', () => {
+    const jsonString = '{"key":["value1","value2",],}';
+
+    const result = parseJSON(jsonString);
+
+    expect(result).toEqual({ key: ['value1', 'value2'] });
+  });
+
+  it('should return an Error object if parsing fails', () => {
+    const jsonString = '{"key": "value"';
+
+    const result = parseJSON(jsonString, undefined, true);
+
+    expect(result).toBeInstanceOf(Error);
+    expect(result.message).toBe('Closing brace `}` expected.');
+  });
+});
+
+describe('Function: nodeAtPath', () => {
+  it('should return the node at the given object path (basic)', () => {
+    const ast = toAST({ key: 'value' });
+    assert(!(ast instanceof Error));
+    const node = nodeAtPath(ast, ['key']);
+    assert(node);
+    expect(node.type).to.equal('Literal');
+  });
+
+  it('should return the node at a given array path (basic)', () => {
+    const ast = toAST(['value1', 'value2']);
+    assert(!(ast instanceof Error));
+    const node = nodeAtPath(ast, [1]);
+    assert(node);
+    expect(node.type).to.equal('Literal');
+  });
+
+  it('should return deep object nodes', () => {
+    const ast = toAST({ key: { nestedKey: 'value' } });
+    assert(!(ast instanceof Error));
+    const node = nodeAtPath(ast, ['key', 'nestedKey']);
+    assert(node);
+    assert(node.type === 'Literal');
+    expect(node.value).to.equal('value');
+  });
+
+  it('should return deep array nodes', () => {
+    const ast = toAST({ key: ['value1', 'value2'] });
+    assert(!(ast instanceof Error));
+    const node = nodeAtPath(ast, ['key', 1]);
+    assert(node);
+    assert(node.type === 'Literal');
+    expect(node.value).to.equal('value2');
+  });
+
+  it('should return object nodes inside array', () => {
+    const ast = toAST({ key: [{ nestedKey: 'value' }] });
+    assert(!(ast instanceof Error));
+    const node = nodeAtPath(ast, ['key', 0]);
+    assert(node);
+    assert(node.type === 'Object');
+  });
+
+  it('should return the ndoe for nested object inside array paths', () => {
+    const ast = toAST({ key: [{ nestedKey: 'value' }] });
+    assert(!(ast instanceof Error));
+    const node = nodeAtPath(ast, ['key', 0, 'nestedKey']);
+    assert(node);
+    assert(node.type === 'Literal');
+    expect(node.value).to.equal('value');
+  });
+
+  it('should return undefined for invalid paths', () => {
+    const ast = toAST({ key: 'value' });
+    assert(!(ast instanceof Error));
+    const node = nodeAtPath(ast, ['invalidKey']);
+    expect(node).to.equal(undefined);
+  });
+
+  it('should return undefined for invalid array paths', () => {
+    const ast = toAST(['value1', 'value2']);
+    assert(!(ast instanceof Error));
+    const node = nodeAtPath(ast, [2]);
+    expect(node).to.equal(undefined);
+  });
+
+  function toAST(jsonObject: any) {
+    return toJSONAST(JSON.stringify(jsonObject));
+  }
+});