@platformos/platformos-check-common 0.0.7 → 0.0.8

package/src/context-utils.spec.ts

@@ -1,103 +1,75 @@
 import { beforeEach, describe, expect, it } from 'vitest';
-import {
-  makeGetDefaultLocale,
-  makeGetDefaultTranslations,
-  makeGetMetafieldDefinitions,
-} from './context-utils';
+import { makeGetDefaultLocale, makeGetDefaultTranslations } from './context-utils';
 import { MockFileSystem } from './test';
 import { AbstractFileSystem } from '@platformos/platformos-common';
 
 describe('Unit: getDefaultLocale', () => {
-  let fs: AbstractFileSystem;
-  beforeEach(() => {
-    fs = new MockFileSystem(
+  it('should always return en (en.yml is the reference locale file)', async () => {
+    const fs: AbstractFileSystem = new MockFileSystem(
       {
-        'gitRootTheme/locales/en.default.json': JSON.stringify({ beverage: 'coffee' }),
-        'gitRootTheme/locales/fr.json': JSON.stringify({ beverage: 'coffee' }),
-        'gitRootTheme/snippet/foo.liquid': JSON.stringify({ beverage: 'coffee' }),
-        'frenchDefault/locales/fr.default.json': JSON.stringify({ beverage: 'café' }),
-        'frenchDefault/snippet/foo.liquid': JSON.stringify({ beverage: 'coffee' }),
-        '.shopify/metafields.json': JSON.stringify({
-          product: [
-            {
-              key: 'color',
-              name: 'color',
-              namespace: 'custom',
-              description: 'the color of the product',
-              type: {
-                category: 'COLOR',
-                name: 'color',
-              },
-            },
-          ],
-        }),
+        'app/translations/en.yml': 'en:\n  beverage: coffee\n',
+        'app/translations/fr.yml': 'fr:\n  beverage: café\n',
       },
-      'shopify-vfs:/',
+      'platformos-vfs:/',
     );
-  });
 
-  it('should return the correct translations depending on the root', async () => {
-    let getDefaultLocale = makeGetDefaultLocale(fs, 'shopify-vfs:/gitRootTheme');
+    const getDefaultLocale = makeGetDefaultLocale(fs, 'platformos-vfs:/');
     expect(await getDefaultLocale()).to.eql('en');
-
-    getDefaultLocale = makeGetDefaultLocale(fs, 'shopify-vfs:/frenchDefault');
-    expect(await getDefaultLocale()).to.eql('fr');
   });
 
-  describe('Unit: makeGetMetafieldDefinitions', () => {
-    it('should return metafield definitions in correct format', async () => {
-      const getMetafieldDefinitions = makeGetMetafieldDefinitions(fs);
-
-      let definitions = await getMetafieldDefinitions('shopify-vfs:/');
+  it('should return en even when no translation files exist', async () => {
+    const fs: AbstractFileSystem = new MockFileSystem({}, 'platformos-vfs:/');
+    const getDefaultLocale = makeGetDefaultLocale(fs, 'platformos-vfs:/');
+    expect(await getDefaultLocale()).to.eql('en');
+  });
 
-      expect(definitions.product).toHaveLength(1);
-      expect(definitions.product[0]).deep.equals({
-        key: 'color',
-        name: 'color',
-        namespace: 'custom',
-        description: 'the color of the product',
-        type: {
-          category: 'COLOR',
-          name: 'color',
+  describe('Unit: getDefaultTranslationsFactory', () => {
+    it('should return translations from en.yml stripped of the locale prefix', async () => {
+      const fs: AbstractFileSystem = new MockFileSystem(
+        {
+          'app/translations/en.yml': 'en:\n  beverage: coffee\n',
+          'app/translations/fr.yml': 'fr:\n  beverage: café\n',
         },
-      });
+        'platformos-vfs:/',
+      );
+
+      const getDefaultTranslations = makeGetDefaultTranslations(fs, [], 'platformos-vfs:/');
+      expect(await getDefaultTranslations()).to.eql({ beverage: 'coffee' });
     });
 
-    it("should return no metafield definitions if file isn't in correct format", async () => {
-      fs = new MockFileSystem(
+    it('should return empty object when no en.yml exists', async () => {
+      const fs: AbstractFileSystem = new MockFileSystem(
         {
-          '.shopify/metafields.json': JSON.stringify('uhoh'),
+          'app/translations/fr.yml': 'fr:\n  beverage: café\n',
         },
-        'shopify-vfs:/',
+        'platformos-vfs:/',
       );
-      const getMetafieldDefinitions = makeGetMetafieldDefinitions(fs);
 
-      let definitions = await getMetafieldDefinitions('shopify-vfs:/');
-
-      expect(definitions).deep.equals({
-        article: [],
-        blog: [],
-        collection: [],
-        company: [],
-        company_location: [],
-        location: [],
-        market: [],
-        order: [],
-        page: [],
-        product: [],
-        variant: [],
-        shop: [],
-      });
+      const getDefaultTranslations = makeGetDefaultTranslations(fs, [], 'platformos-vfs:/');
+      expect(await getDefaultTranslations()).to.eql({});
     });
-  });
 
-  describe('Unit: getDefaultTranslationsFactory', () => {
-    it('should return the correct translations depending on the root', async () => {
-      let getDefaultTranslations = makeGetDefaultTranslations(fs, [], 'shopify-vfs:/gitRootTheme');
-      expect(await getDefaultTranslations()).to.eql({ beverage: 'coffee' });
+    it('should prefer translations from the in-memory app buffer over the filesystem', async () => {
+      const fs: AbstractFileSystem = new MockFileSystem(
+        {
+          'app/translations/en.yml': 'en:\n  beverage: coffee\n',
+        },
+        'platformos-vfs:/',
+      );
 
-      getDefaultTranslations = makeGetDefaultTranslations(fs, [], 'shopify-vfs:/frenchDefault');
-      expect(await getDefaultTranslations()).to.eql({ beverage: 'café' });
+      // Simulate an open buffer with different content
+      const { toSourceCode } = await import('./to-source-code');
+      const bufferedSourceCode = toSourceCode(
+        'platformos-vfs:/app/translations/en.yml',
+        'en:\n  beverage: tea\n',
+      );
+
+      const getDefaultTranslations = makeGetDefaultTranslations(
+        fs,
+        [bufferedSourceCode],
+        'platformos-vfs:/',
+      );
+      expect(await getDefaultTranslations()).to.eql({ beverage: 'tea' });
     });
   });
 });

package/src/context-utils.ts

@@ -1,15 +1,7 @@
-import { URI, Utils } from 'vscode-uri';
+import { load } from 'js-yaml';
 import { AbstractFileSystem, FileTuple, FileType, UriString } from '@platformos/platformos-common';
-import { parseJSON } from './json';
 import { join } from './path';
-import {
-  MetafieldCategory,
-  MetafieldDefinitionMap,
-  SourceCodeType,
-  Theme,
-  Translations,
-} from './types';
-import { isError } from './utils';
+import { SourceCodeType, App, Translations } from './types';
 
 export type FileExists = (uri: string) => Promise<boolean>;
 
@@ -33,71 +25,49 @@ export const makeFileSize = (fs: AbstractFileSystem) =>
     }
   };
 
-export const makeGetDefaultLocaleFileUri = getDefaultLocaleFileUriFactoryFactory('default.json');
-export const makeGetDefaultSchemaLocaleFileUri =
-  getDefaultLocaleFileUriFactoryFactory('.default.schema.json');
-function getDefaultLocaleFileUriFactoryFactory(postfix = '.default.json') {
-  return function getDefaultLocaleFileUriFactory(fs: AbstractFileSystem) {
-    return (rootUri: string) => getDefaultLocaleFile(fs, rootUri, postfix);
-  };
-}
+export const makeGetDefaultLocaleFileUri = (fs: AbstractFileSystem) => (rootUri: string) =>
+  getDefaultLocaleFile(fs, rootUri);
 
-export const makeGetDefaultLocale = getDefaultLocaleFactoryFactory('.default.json');
-export const makeGetDefaultSchemaLocale = getDefaultLocaleFactoryFactory('.default.schema.json');
-function getDefaultLocaleFactoryFactory(postfix = '.default.json') {
-  return function getDefaultLocaleFactory(fs: AbstractFileSystem, rootUri: string) {
-    return cached(() => getDefaultLocale(fs, rootUri, postfix));
-  };
-}
+export const makeGetDefaultLocale = (fs: AbstractFileSystem, rootUri: string) =>
+  cached(() => getDefaultLocale(fs, rootUri));
 
-export const makeGetDefaultTranslations = getDefaultTranslationsFactoryFactory('.default.json');
-export const makeGetDefaultSchemaTranslations =
-  getDefaultTranslationsFactoryFactory('.default.schema.json');
-// prettier-ignore
-function getDefaultTranslationsFactoryFactory(postfix = '.default.json') {
-  return function getDefaultTranslationsFactory(fs: AbstractFileSystem, theme: Theme, rootUri: string) {
-    return cached(() => getDefaultTranslations(fs, theme, rootUri, postfix));
-  };
-}
+export const makeGetDefaultTranslations = (fs: AbstractFileSystem, app: App, rootUri: string) =>
+  cached(() => getDefaultTranslations(fs, app, rootUri));
 
 async function getDefaultLocaleFile(
   fs: AbstractFileSystem,
   rootUri: string,
-  postfix = '.default.json',
-) {
-  const files = await fs.readDirectory(join(rootUri, 'locales'));
-  return files.find(([uri]) => uri.endsWith(postfix))?.[0];
-}
-
-async function getDefaultLocale(
-  fs: AbstractFileSystem,
-  rootUri: string,
-  postfix: string,
-): Promise<string> {
+): Promise<string | undefined> {
+  const enYmlUri = join(rootUri, 'app/translations/en.yml');
   try {
-    const defaultLocaleFile = await getDefaultLocaleFile(fs, rootUri, postfix);
-    if (!defaultLocaleFile) return 'en';
-    const defaultLocaleFileName = Utils.basename(URI.parse(defaultLocaleFile));
-    return defaultLocaleFileName.split('.')[0];
-  } catch (error) {
-    console.error(error);
-    return 'en';
+    await fs.stat(enYmlUri);
+    return enYmlUri;
+  } catch {
+    return undefined;
   }
 }
 
+async function getDefaultLocale(_fs: AbstractFileSystem, _rootUri: string): Promise<string> {
+  // In platformOS, en.yml is always the reference translation file
+  return 'en';
+}
+
 async function getDefaultTranslations(
   fs: AbstractFileSystem,
-  theme: Theme,
+  app: App,
   rootUri: string,
-  postfix: string,
 ): Promise<Translations> {
   try {
-    const bufferTranslations = getDefaultTranslationsFromBuffer(theme, postfix);
+    const bufferTranslations = getDefaultTranslationsFromBuffer(app);
     if (bufferTranslations) return bufferTranslations;
-    const defaultLocaleFile = await getDefaultLocaleFile(fs, rootUri, postfix);
+    const defaultLocaleFile = await getDefaultLocaleFile(fs, rootUri);
     if (!defaultLocaleFile) return {};
-    const defaultTranslationsFile = await fs.readFile(defaultLocaleFile);
-    return parseJSON(defaultTranslationsFile, {});
+    const yamlContent = await fs.readFile(defaultLocaleFile);
+    const data = load(yamlContent) as Record<string, any>;
+    if (!data || typeof data !== 'object') return {};
+    // YAML translation files wrap content under the locale key: { en: { hello: 'Hello' } }
+    const localeKey = Object.keys(data)[0];
+    return (localeKey && data[localeKey]) ?? {};
   } catch (error) {
     console.error(error);
     return {};
@@ -105,17 +75,19 @@ async function getDefaultTranslations(
 }
 
 /** It might be that you have an open buffer, we prefer translations from there if available */
-function getDefaultTranslationsFromBuffer(theme: Theme, postfix: string): Translations | undefined {
-  const defaultTranslationsSourceCode = theme.find(
-    (sourceCode) =>
-      sourceCode.type === SourceCodeType.JSON &&
-      sourceCode.uri.match(/locales/) &&
-      sourceCode.uri.endsWith(postfix),
+function getDefaultTranslationsFromBuffer(app: App): Translations | undefined {
+  const defaultTranslationsSourceCode = app.find(
+    (sourceCode) => sourceCode.type === SourceCodeType.YAML && sourceCode.uri.endsWith('/en.yml'),
   );
   if (!defaultTranslationsSourceCode) return undefined;
-  const translations = parseJSON(defaultTranslationsSourceCode.source);
-  if (isError(translations)) return undefined;
-  return translations;
+  try {
+    const data = load(defaultTranslationsSourceCode.source) as Record<string, any>;
+    if (!data || typeof data !== 'object') return undefined;
+    const localeKey = Object.keys(data)[0];
+    return (localeKey && data[localeKey]) ?? undefined;
+  } catch {
+    return undefined;
+  }
 }
 
 function cached<T>(fn: () => Promise<T>): () => Promise<T>;
@@ -157,64 +129,3 @@ const ignoredFolders = ['.git', 'node_modules', 'dist', 'build', 'tmp', 'vendor'
 function isIgnored([uri, type]: FileTuple) {
   return type === FileType.Directory && ignoredFolders.some((folder) => uri.endsWith(folder));
 }
-
-export const FETCHED_METAFIELD_CATEGORIES: MetafieldCategory[] = [
-  'article',
-  'blog',
-  'collection',
-  'company',
-  'company_location',
-  'location',
-  'market',
-  'order',
-  'page',
-  'product',
-  'variant',
-  'shop',
-];
-
-export const makeGetMetafieldDefinitions = (fs: AbstractFileSystem) =>
-  async function (rootUri: string): Promise<MetafieldDefinitionMap> {
-    const definitions = {
-      article: [],
-      blog: [],
-      collection: [],
-      company: [],
-      company_location: [],
-      location: [],
-      market: [],
-      order: [],
-      page: [],
-      product: [],
-      variant: [],
-      shop: [],
-    } as MetafieldDefinitionMap;
-
-    try {
-      const content = await fs.readFile(join(rootUri, '.shopify', 'metafields.json'));
-      const json = parseJSON(content);
-
-      if (isError(json)) return definitions;
-
-      return FETCHED_METAFIELD_CATEGORIES.reduce((definitions, group) => {
-        try {
-          definitions[group] = json[group].map((definition: any) => ({
-            key: definition.key,
-            name: definition.name,
-            namespace: definition.namespace,
-            description: definition.description,
-            type: {
-              category: definition.type.category,
-              name: definition.type.name,
-            },
-          }));
-        } catch (error) {
-          // If there are errors in the file, we ignore it
-        }
-
-        return definitions;
-      }, definitions);
-    } catch (err) {
-      return definitions;
-    }
-  };

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

@@ -259,4 +259,39 @@ ${buildComment('theme-check-enable')}
       });
     });
   });
+
+  describe('platformos-check prefix', () => {
+    it('should disable checks using platformos-check-disable prefix', async () => {
+      for (const buildComment of commentTypes) {
+        const file = `${buildComment('platformos-check-disable LiquidFilter')}
+{{ 'asset' | random_filter }}
+{% render 'something' %}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(1);
+        expectRenderMarkupOffense(offenses, 'something.liquid');
+      }
+    });
+
+    it('should disable all checks using platformos-check-disable prefix', async () => {
+      for (const buildComment of commentTypes) {
+        const file = `${buildComment('platformos-check-disable')}
+{{ 'asset' | random_filter }}
+{% render 'something' %}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(0);
+      }
+    });
+
+    it('should disable next line using platformos-check-disable-next-line prefix', async () => {
+      const file = `{% # platformos-check-disable-next-line %}
+{% render 'something' %}
+{% render 'other-thing' %}`;
+
+      const offenses = await check({ 'code.liquid': file }, checks);
+      expect(offenses).to.have.length(1);
+      expectRenderMarkupOffense(offenses, 'other-thing.liquid');
+    });
+  });
 });

package/src/disabled-checks/index.ts

@@ -24,7 +24,9 @@ export function createDisabledChecksModule() {
     node: LiquidTag | LiquidRawTag,
   ) {
     const [_, command, checksJoined] =
-      value.trim().match(/^(?:theme\-check\-(disable-next-line|disable|enable)) ?(.*)/) || [];
+      value
+        .trim()
+        .match(/^(?:(?:platformos|theme)\-check\-(disable-next-line|disable|enable)) ?(.*)/) || [];
 
     const checks = checksJoined ? checksJoined.split(/,[ ]*/) : [SPECIFIC_CHECK_NOT_DEFINED];
 
@@ -133,7 +135,7 @@ export function findNextLinePosition(
    * E.g. The following disables check for `elsif` tag
    *
    * {% if condition %}
-   *   {% #theme-check-disable-next-line %}
+   *   {% #platformos-check-disable-next-line %}
    * {% elsif other_condition %}
    *   {{ prouduct }}
    * {% endif %}

package/src/find-root.ts

@@ -5,13 +5,11 @@ 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')),
-    ),
+    fileExists(path.join(dir, '.pos')),
+    fileExists(path.join(dir, '.platformos-check.yml')),
+    fileExists(path.join(dir, 'app')),
+    // modules/ is a root indicator only when not inside app/ (app/modules/ is a valid subdirectory)
+    and(fileExists(path.join(dir, 'modules')), Promise.resolve(path.basename(dir) !== 'app')),
   );
 }
 
@@ -25,24 +23,16 @@ async function or(...promises: Promise<boolean>[]) {
   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.
+ * Returns the root of a platformOS app. The root is the directory that contains
+ * a `.pos` sentinel file, a `.platformos-check.yml` config file, an `app/` directory,
+ * or a `modules/` directory (when not inside `app/`).
  *
- * So you can think of this function as the function that infers where a .theme-check.yml
- * should be.
+ * Note: `modules/` inside `app/` (i.e. `app/modules/`) is a valid subdirectory and
+ * should not be treated as a root indicator.
  *
- * Note: that this is not the theme root. The config file might have a `root` entry in it
- * that points to somewhere else.
+ * Note: this is not the app root itself. The config file might have a `root` entry that
+ * points to somewhere else.
  */
 export async function findRoot(curr: UriString, fileExists: FileExists): Promise<UriString | null> {
   const currIsRoot = await isRoot(curr, fileExists);

package/src/fixes/autofix.spec.ts

@@ -4,7 +4,7 @@ import { Offense, SourceCodeType } from '../types';
 
 describe('Module: autofix', () => {
   it('should apply a list of all safe changes', async () => {
-    const mockTheme = {
+    const mockApp = {
       'a.liquid': 'Banana world',
       'b.json': prettyJSON({ a: 'b' }),
     };
@@ -69,7 +69,7 @@ describe('Module: autofix', () => {
       },
     ];
 
-    const fixed = await autofix(mockTheme, offenses);
+    const fixed = await autofix(mockApp, offenses);
     expect(fixed['a.liquid']).to.eql('Bananananana world');
     expect(fixed['b.json']).to.eql(
       prettyJSON({

package/src/fixes/autofix.ts

@@ -1,4 +1,4 @@
-import { FixApplicator, Offense, SourceCodeType, Theme } from '../types';
+import { FixApplicator, Offense, SourceCodeType, App } from '../types';
 import { WithRequired } from '../utils/types';
 import { createCorrector } from './correctors';
 import { flattenFixes } from './utils';
@@ -8,13 +8,13 @@ type FixableOffense<S extends SourceCodeType> = S extends SourceCodeType
   : never;
 
 /**
- * Takes a theme, list of offenses and a fixApplicator and runs all the
- * safe ones on the theme.
+ * Takes an app, list of offenses and a fixApplicator and runs all the
+ * safe ones on the app.
  *
  * Note that offense.fix is assumed to be safe, unlike offense.suggest
  * options.
  */
-export async function autofix(sourceCodes: Theme, offenses: Offense[], applyFixes: FixApplicator) {
+export async function autofix(sourceCodes: App, offenses: Offense[], applyFixes: FixApplicator) {
   const fixableOffenses = offenses.filter(
     (offense): offense is FixableOffense<SourceCodeType> => 'fix' in offense && !!offense.fix,
   );

package/src/fixes/correctors/index.ts

@@ -18,6 +18,10 @@ export function createCorrector<S extends SourceCodeType>(
     }
     case SourceCodeType.GraphQL:
       return new GraphQLCorrector(source) as Corrector<typeof sourceCodeType>;
+    case SourceCodeType.YAML: {
+      // YAML autofix is not yet supported; this case should not be reached
+      throw new Error('YAML autofix is not supported');
+    }
     default: {
       return assertNever(sourceCodeType);
     }

package/src/ignore.spec.ts

@@ -188,7 +188,6 @@ function config({
   globalIgnore?: string[];
 }): Config {
   return {
-    context: 'theme',
     settings: {
       MockCheck: {
         enabled: true,