@platformos/platformos-check-common 0.0.2

package/src/disabled-checks/test-checks.ts

@@ -0,0 +1,60 @@
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '..';
+import { NodeTypes } from '@platformos/liquid-html-parser';
+
+export const LiquidFilter: LiquidCheckDefinition = {
+  meta: {
+    code: 'LiquidFilter',
+    name: 'Complains about every LiquidFilter',
+    docs: {
+      description: 'Complains about every LiquidFilter',
+      recommended: true,
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      LiquidFilter: async (node) => {
+        context.report({
+          message: 'Liquid filter can not be used',
+          startIndex: node.position.start,
+          endIndex: node.position.end,
+        });
+      },
+    };
+  },
+};
+
+export const RenderMarkup: LiquidCheckDefinition = {
+  meta: {
+    code: 'RenderMarkup',
+    name: 'Complains about every RenderMarkup',
+    docs: {
+      description: 'Complains about every RenderMarkup',
+      recommended: true,
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async RenderMarkup(node) {
+        if (node.snippet.type === NodeTypes.VariableLookup) {
+          return;
+        }
+
+        context.report({
+          message: `'${node.snippet.value}.liquid' can not be rendered`,
+          startIndex: node.snippet.position.start,
+          endIndex: node.snippet.position.end,
+        });
+      },
+    };
+  },
+};

package/src/find-root.ts

@@ -0,0 +1,60 @@
+import { UriString } from '@platformos/platformos-common';
+import * as path from './path';
+
+type FileExists = (uri: string) => Promise<boolean>;
+
+async function isRoot(dir: UriString, fileExists: FileExists) {
+  return or(
+    // .pos config file and app directory exists
+    and(
+      fileExists(path.join(dir, '.pos')),
+      fileExists(path.join(dir, 'app')),
+      fileExists(path.join(dir, 'modules')),
+      fileExists(path.join(dir, '.git')),
+    ),
+  );
+}
+
+async function and(...promises: Promise<boolean>[]) {
+  const bools = await Promise.all(promises);
+  return bools.reduce((a, b) => a && b, true);
+}
+
+async function or(...promises: Promise<boolean>[]) {
+  const bools = await Promise.all(promises);
+  return bools.reduce((a, b) => a || b, false);
+}
+
+async function not(ap: Promise<boolean>) {
+  const a = await ap;
+  return !a;
+}
+
+/**
+ * Returns the "root" of a theme or theme app extension. The root is the
+ * directory that contains a `.theme-check.yml` file, a `.git` directory, or a
+ * `shopify.extension.toml` file.
+ *
+ * There are cases where .theme-check.yml is not defined and we have to infer the root.
+ * We'll assume that the root is the directory that contains a `snippets` directory.
+ *
+ * So you can think of this function as the function that infers where a .theme-check.yml
+ * should be.
+ *
+ * Note: that this is not the theme root. The config file might have a `root` entry in it
+ * that points to somewhere else.
+ */
+export async function findRoot(curr: UriString, fileExists: FileExists): Promise<UriString | null> {
+  const currIsRoot = await isRoot(curr, fileExists);
+  if (currIsRoot) {
+    return curr;
+  }
+
+  const dir = path.dirname(curr);
+  const currIsAbsoluteRoot = dir === curr;
+  if (currIsAbsoluteRoot) {
+    return null; // Root not found.
+  }
+
+  return findRoot(dir, fileExists);
+}

package/src/fixes/apply-fix-to-string.spec.ts

@@ -0,0 +1,52 @@
+import { expect, describe, it } from 'vitest';
+import { applyFixToString } from './apply-fix-to-string';
+
+// You'll be happy to note that ChatGPT kind of generated this as well.
+describe('Module: applyFixToString', () => {
+  it('should apply 1 fix description correctly', () => {
+    const source = 'Hello, world!';
+    const fixDescriptions = [{ startIndex: 0, endIndex: 5, insert: 'Hi' }];
+    const result = applyFixToString(source, fixDescriptions);
+    expect(result).to.equal('Hi, world!');
+  });
+
+  it('should apply a couple of fix descriptions correctly', () => {
+    const source = 'Hello, world!';
+    const fixDescriptions = [
+      { startIndex: 7, endIndex: 7, insert: 'beautiful ' },
+      { startIndex: 12, endIndex: 13, insert: '' },
+      { startIndex: 0, endIndex: 5, insert: 'Hi' },
+    ];
+    const result = applyFixToString(source, fixDescriptions);
+    expect(result).to.equal('Hi, beautiful world');
+  });
+
+  it('should throw an error for overlapping fix descriptions', () => {
+    const source = 'Hello, world!';
+    const fixDescriptions = [
+      { startIndex: 5, endIndex: 7, insert: 'wonderful ' },
+      { startIndex: 6, endIndex: 8, insert: 'beautiful ' },
+    ];
+    expect(() => applyFixToString(source, fixDescriptions)).to.throw(
+      'Overlapping ranges are not allowed',
+    );
+  });
+
+  it('should not throw an error for fixes ending and starting on the same index', () => {
+    const source = 'Hello, world!';
+    const fixDescriptions = [
+      { startIndex: 6, endIndex: 6, insert: ' wonderful' },
+      { startIndex: 6, endIndex: 7, insert: ' and beautiful ' },
+    ];
+    const result = applyFixToString(source, fixDescriptions);
+    expect(result).to.equal('Hello, wonderful and beautiful world!');
+  });
+
+  it('should throw an error for fix descriptions going over bounds', () => {
+    const source = 'Hello, world!';
+    const fixDescriptions = [{ startIndex: 0, endIndex: 20, insert: 'Hi' }];
+    expect(() => applyFixToString(source, fixDescriptions)).to.throw(
+      'Fix description is going overboard',
+    );
+  });
+});

package/src/fixes/apply-fix-to-string.ts

@@ -0,0 +1,59 @@
+import { Fix } from '../types';
+import { flattenFixes } from './utils';
+
+// First iteration imported @codemirror/state to do this but it's kind of
+// a gross dependency. I asked chatGPT to make me something similar and,
+// after a couple of prompts, was surprised to like the result.
+//
+// So here goes:
+// A neat and mean (Source, Fix) => Source function :)
+export function applyFixToString(source: string, fix: Fix): string {
+  // Create a copy of the original string to store the modified result
+  let newStr = source;
+
+  // Initialize an offset variable to keep track of the changes in index
+  // due to previous fixes. This is necessary because each modification
+  // is assumed to be to the original document, and we need to account for
+  // the index drift caused by previous fixes.
+  let offset = 0;
+
+  // Sort modifications by startIndex in ascending order to ensure that
+  // modifications with lower indices are applied first. This helps to
+  // maintain the correct index positions for subsequent modifications.
+  const sortedFixes = flattenFixes(fix).sort((a, b) => a.startIndex - b.startIndex);
+
+  // Verify that the fixes are valid and do not overlap
+  for (let i = 0; i < sortedFixes.length - 1; i++) {
+    const currentFix = sortedFixes[i];
+    const nextFix = sortedFixes[i + 1];
+
+    // Check if the current fix overlaps with the next fix
+    if (currentFix.endIndex > nextFix.startIndex) {
+      throw new Error('Overlapping ranges are not allowed');
+    }
+  }
+
+  for (const fix of sortedFixes) {
+    // Drift-adjust the fix location
+    const startIndex = fix.startIndex + offset;
+    const endIndex = fix.endIndex + offset;
+
+    // Throw an error if either startIndex or endIndex are out of bounds.
+    if (
+      startIndex < 0 ||
+      startIndex > newStr.length ||
+      endIndex < startIndex ||
+      endIndex > newStr.length
+    ) {
+      throw new Error('Fix description is going overboard');
+    }
+
+    // Perform the modification at the drift-adjusted location
+    newStr = newStr.slice(0, startIndex) + fix.insert + newStr.slice(endIndex);
+
+    // Account for "index drift" as the modifications are applied.
+    offset += fix.insert.length - (endIndex - startIndex);
+  }
+
+  return newStr;
+}

package/src/fixes/autofix.spec.ts

@@ -0,0 +1,85 @@
+import { expect, describe, it } from 'vitest';
+import { autofix, prettyJSON } from '../test';
+import { Offense, SourceCodeType } from '../types';
+
+describe('Module: autofix', () => {
+  it('should apply a list of all safe changes', async () => {
+    const mockTheme = {
+      'a.liquid': 'Banana world',
+      'b.json': prettyJSON({ a: 'b' }),
+    };
+
+    const offenses: Offense[] = [
+      {
+        type: SourceCodeType.LiquidHtml,
+        fix: (corrector) => corrector.insert(2, 'nanana'),
+        uri: 'file:///a.liquid',
+        check: 'Mock Check',
+        message: 'Mock check message',
+        severity: 0,
+        start: { line: 0, character: 0, index: 0 },
+        end: { line: 0, character: 0, index: 0 },
+      },
+      {
+        type: SourceCodeType.LiquidHtml,
+        suggest: [
+          {
+            message: 'unsafe change',
+            fix: (corrector) => {
+              corrector.replace(0, 5, 'nooooo');
+            },
+          },
+        ],
+        uri: 'file:///a.liquid',
+        check: 'Mock Check',
+        message: 'Mock check message',
+        severity: 0,
+        start: { line: 0, character: 0, index: 0 },
+        end: { line: 0, character: 0, index: 0 },
+      },
+      {
+        type: SourceCodeType.JSON,
+        fix: (corrector) => {
+          corrector.add('a.b.c', 'c');
+          corrector.add('a.b.d', 'd');
+        },
+        uri: 'file:///b.json',
+        check: 'Mock Check',
+        message: 'Mock check message',
+        severity: 0,
+        start: { line: 0, character: 0, index: 0 },
+        end: { line: 0, character: 0, index: 0 },
+      },
+      {
+        type: SourceCodeType.JSON,
+        suggest: [
+          {
+            message: 'unsafe change',
+            fix: (corrector) => {
+              corrector.remove('a.b');
+            },
+          },
+        ],
+        uri: 'file:///b.json',
+        check: 'Mock Check',
+        message: 'Mock check message',
+        severity: 0,
+        start: { line: 0, character: 0, index: 0 },
+        end: { line: 0, character: 0, index: 0 },
+      },
+    ];
+
+    const fixed = await autofix(mockTheme, offenses);
+    expect(fixed['a.liquid']).to.eql('Bananananana world');
+    expect(fixed['b.json']).to.eql(
+      prettyJSON({
+        a: {
+          b: {
+            c: 'c',
+            d: 'd',
+          },
+        },
+      }),
+    );
+  });
+});

package/src/fixes/autofix.ts

@@ -0,0 +1,41 @@
+import { FixApplicator, Offense, SourceCodeType, Theme } from '../types';
+import { WithRequired } from '../utils/types';
+import { createCorrector } from './correctors';
+import { flattenFixes } from './utils';
+
+type FixableOffense<S extends SourceCodeType> = S extends SourceCodeType
+  ? WithRequired<Offense<S>, 'fix'>
+  : never;
+
+/**
+ * Takes a theme, list of offenses and a fixApplicator and runs all the
+ * safe ones on the theme.
+ *
+ * Note that offense.fix is assumed to be safe, unlike offense.suggest
+ * options.
+ */
+export async function autofix(sourceCodes: Theme, offenses: Offense[], applyFixes: FixApplicator) {
+  const fixableOffenses = offenses.filter(
+    (offense): offense is FixableOffense<SourceCodeType> => 'fix' in offense && !!offense.fix,
+  );
+
+  const promises = [];
+
+  for (const sourceCode of sourceCodes) {
+    const sourceCodeOffenses = fixableOffenses.filter((offense) => offense.uri === sourceCode.uri);
+
+    if (sourceCodeOffenses.length === 0) {
+      continue;
+    }
+
+    const corrector = createCorrector(sourceCode.type, sourceCode.source);
+    for (const offense of sourceCodeOffenses) {
+      // I'm being slightly too clever for TypeScript here...
+      offense.fix(corrector as any);
+    }
+
+    promises.push(applyFixes(sourceCode, flattenFixes(corrector.fix)));
+  }
+
+  await Promise.all(promises);
+}

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

@@ -0,0 +1,5 @@
+import { Fix } from '../../types';
+
+export interface BaseCorrector {
+  get fix(): Fix;
+}

package/src/fixes/correctors/graphql-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 GraphQLCorrector 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/correctors/index.ts

@@ -0,0 +1,29 @@
+import { Corrector, SourceCodeType } from '../../types';
+import { JSONCorrector } from './json-corrector';
+import { StringCorrector } from './string-corrector';
+import { GraphQLCorrector } from './graphql-corrector';
+
+export { JSONCorrector, StringCorrector, GraphQLCorrector };
+
+export function createCorrector<S extends SourceCodeType>(
+  sourceCodeType: S,
+  source: string,
+): Corrector<S> {
+  switch (sourceCodeType) {
+    case SourceCodeType.JSON: {
+      return new JSONCorrector(source) as Corrector<typeof sourceCodeType>;
+    }
+    case SourceCodeType.LiquidHtml: {
+      return new StringCorrector(source) as Corrector<typeof sourceCodeType>;
+    }
+    case SourceCodeType.GraphQL:
+      return new GraphQLCorrector(source) as Corrector<typeof sourceCodeType>;
+    default: {
+      return assertNever(sourceCodeType);
+    }
+  }
+}
+
+function assertNever(x: never): never {
+  throw new Error(`Case statement not exhausted: ${x}`);
+}

package/src/fixes/correctors/json-corrector.spec.ts

@@ -0,0 +1,111 @@
+import { expect, describe, it } from 'vitest';
+import { JSONCorrector } from './json-corrector';
+import { prettyJSON } from '../../test';
+
+describe('Module: JSONCorrector', () => {
+  it('should collect add patches and apply them', () => {
+    const file = JSON.stringify({
+      a: {
+        b: 'b',
+      },
+    });
+
+    const corrector = new JSONCorrector(file);
+    corrector.add('a.c', 'c');
+    corrector.add('a.d', 'd');
+
+    expect(corrector.fix).to.eql({
+      startIndex: 0,
+      endIndex: file.length,
+      insert: prettyJSON({
+        a: {
+          b: 'b',
+          c: 'c',
+          d: 'd',
+        },
+      }),
+    });
+  });
+
+  it('should collect add patches that deeply add new properties and apply them', () => {
+    const file = JSON.stringify({
+      a: {
+        b: 'b',
+      },
+    });
+
+    const corrector = new JSONCorrector(file);
+    corrector.add('c.d.e', 'e');
+    corrector.add('c.d.f', 'f');
+
+    expect(corrector.fix).to.eql({
+      startIndex: 0,
+      endIndex: file.length,
+      insert: prettyJSON({
+        a: {
+          b: 'b',
+        },
+        c: {
+          d: {
+            e: 'e',
+            f: 'f',
+          },
+        },
+      }),
+    });
+  });
+
+  it('should forcefully replace the wrong type with a new one', () => {
+    const file = JSON.stringify({
+      a: {
+        b: 'b',
+      },
+    });
+
+    const corrector = new JSONCorrector(file);
+    corrector.add('a.b.c', 'c');
+    corrector.add('a.b.d', 'd');
+
+    expect(corrector.fix).to.eql({
+      startIndex: 0,
+      endIndex: file.length,
+      insert: prettyJSON({
+        a: {
+          b: {
+            c: 'c',
+            d: 'd',
+          },
+        },
+      }),
+    });
+  });
+
+  it('should remove keys', () => {
+    const file = JSON.stringify({
+      a: {
+        b: 'b',
+      },
+      c: {
+        d: 'd',
+        e: 'e',
+      },
+      f: {
+        g: 'g',
+      },
+    });
+
+    const corrector = new JSONCorrector(file);
+    corrector.remove('a.b');
+    corrector.remove('c.d');
+    corrector.remove('f');
+
+    expect(corrector.fix).to.eql({
+      startIndex: 0,
+      endIndex: file.length,
+      insert: prettyJSON({
+        a: {},
+        c: { e: 'e' },
+      }),
+    });
+  });
+});

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

@@ -0,0 +1,106 @@
+import { set as lodashSet, unset as lodashUnset } from 'lodash';
+import { Fix } from '../../types';
+import { BaseCorrector } from './base-corrector';
+
+type Operation = AddOperation | RemoveOperation;
+
+type AddOperation = {
+  type: 'add';
+  path: string;
+  value: any;
+};
+
+type RemoveOperation = {
+  type: 'remove';
+  path: string;
+};
+
+// This function mutates json. So use it in a reducer and consider it a
+// fire and forget.
+function applyPatch(json: any, operation: Operation) {
+  switch (operation.type) {
+    case 'add': {
+      return lodashSet(json, operation.path, operation.value);
+    }
+
+    case 'remove': {
+      lodashUnset(json, operation.path);
+      return json;
+    }
+  }
+}
+
+/**
+ * The JSONCorrector collects patches and then creates a Fix object
+ * that represents the application of all the collected patches on the
+ * source document.
+ *
+ * Fixes are assumed to not be overlapping.
+ */
+export class JSONCorrector implements BaseCorrector {
+  private readonly patches: Operation[] = [];
+
+  constructor(public source: string) {}
+
+  /**
+   * corrector.fix is the data representation of all the changes to source.
+   */
+  public get fix(): Fix {
+    if (this.patches.length === 0) return [];
+
+    const json = this.patches.reduce(applyPatch, JSON.parse(this.source));
+
+    return {
+      startIndex: 0,
+      endIndex: this.source.length,
+      insert: JSON.stringify(json, null, 2),
+    };
+  }
+
+  /**
+   * Add value at dot delited JSON path
+   *
+   * @example
+   * corrector.add('missing.key', 'TO DO')
+   */
+  add(path: string, value: any): void {
+    this.patches.push({
+      type: 'add',
+      path,
+      value,
+    });
+  }
+
+  /**
+   * Replace a value at dot delited JSON path.
+   *
+   * @example
+   * corrector.replace('missing.key', 'TO DO')
+   */
+  replace(path: string, value: any): void {
+    this.patches.push(
+      {
+        type: 'remove',
+        path,
+      },
+      {
+        type: 'add',
+        path,
+        value,
+      },
+    );
+  }
+
+  /**
+   * Remove key from JSON object
+   *
+   * @example
+   * corrector.remove('unneeded.key')
+   */
+  remove(path: string): void {
+    this.patches.push({
+      type: 'remove',
+      path,
+    });
+  }
+}