@platformos/platformos-check-common 0.0.17 → 0.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformos/platformos-check-common",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,7 +26,7 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@platformos/liquid-html-parser": "0.0.15",
+    "@platformos/liquid-html-parser": "0.0.17",
     "graphql": "^16.12.0",
     "js-yaml": "^4.1.1",
     "jsonc-parser": "^3.3.1",

package/src/checks/index.ts

@@ -30,7 +30,7 @@ import { ValidJSON } from './valid-json';
 import { ValidDocParamTypes } from './valid-doc-param-types';
 import { ValidRenderPartialArgumentTypes } from './valid-render-partial-argument-types';
 import { VariableName } from './variable-name';
-import { MetadataParamsCheck } from './metadata-params';
+import { PartialCallArguments } from './partial-call-arguments';
 import { GraphQLVariablesCheck } from './graphql-variables';
 import { GraphQLCheck } from './graphql';
 import { UnknownProperty } from './unknown-property';
@@ -39,6 +39,8 @@ import { DuplicateFunctionArguments } from './duplicate-function-arguments';
 import { MissingRenderPartialArguments } from './missing-render-partial-arguments';
 import { NestedGraphQLQuery } from './nested-graphql-query';
 import { MissingPage } from './missing-page';
+import { ValidFrontmatter } from './valid-frontmatter';
+import { JsonLiteralQuoteStyle } from './json-literal-quote-style';
 
 export const allChecks: (
   | LiquidCheckDefinition
@@ -71,7 +73,7 @@ export const allChecks: (
   ValidDocParamTypes,
   ValidRenderPartialArgumentTypes,
   VariableName,
-  MetadataParamsCheck,
+  PartialCallArguments,
   GraphQLVariablesCheck,
   GraphQLCheck,
   UnknownProperty,
@@ -79,6 +81,8 @@ export const allChecks: (
   MissingRenderPartialArguments,
   NestedGraphQLQuery,
   MissingPage,
+  ValidFrontmatter,
+  JsonLiteralQuoteStyle,
 ];
 
 /**

package/src/checks/json-literal-quote-style/index.spec.ts

@@ -0,0 +1,129 @@
+import { expect, describe, it } from 'vitest';
+import { JsonLiteralQuoteStyle } from './index';
+import { applyFix, runLiquidCheck } from '../../test';
+
+describe('Module: JsonLiteralQuoteStyle', () => {
+  it('should report single-quoted keys in an inline hash literal', async () => {
+    const sourceCode = `{% assign a = {'a': 5} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      'Use double quotes for string literals inside object/array literals (e.g. \'{"key": "value"}\', not "{\'key\': \'value\'}").',
+    );
+  });
+
+  it('should report single-quoted string values in an inline hash literal', async () => {
+    const sourceCode = `{% assign a = {"key": 'value'} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(1);
+  });
+
+  it('should report both single-quoted keys and values', async () => {
+    const sourceCode = `{% assign a = {'a': 'b', 'c': 'd'} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(4);
+  });
+
+  it('should report single-quoted strings in nested hash literals', async () => {
+    const sourceCode = `{% assign a = {"outer": {'inner': 1}} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(1);
+  });
+
+  it('should report single-quoted strings inside array literals', async () => {
+    const sourceCode = `{% assign a = ['x', 'y'] %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(2);
+  });
+
+  it('should not report double-quoted strings in object literals', async () => {
+    const sourceCode = `{% assign a = {"a": "b", "c": [1, "d"]} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('should not report bare keys in object literals', async () => {
+    const sourceCode = `{% assign a = {a: 2} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('should not report single-quoted strings outside of inline JSON literals', async () => {
+    const sourceCode = `
+      {% assign a = 'plain string' %}
+      {% assign b = 'pass' | upcase %}
+      {{ 'hello' }}
+    `;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('should not report parse_json style JSON-in-a-string', async () => {
+    const sourceCode = `{% assign a = '{"a": 5}' | parse_json %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('should fix single-quoted keys to double-quoted keys', async () => {
+    const sourceCode = `{% assign a = {'a': 5} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+    const fixed = applyFix(sourceCode, offenses[0]);
+
+    expect(fixed).to.equal(`{% assign a = {"a": 5} %}`);
+  });
+
+  it('should fix single-quoted string values to double-quoted values', async () => {
+    const sourceCode = `{% assign a = {"key": 'value'} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+    const fixed = applyFix(sourceCode, offenses[0]);
+
+    expect(fixed).to.equal(`{% assign a = {"key": "value"} %}`);
+  });
+
+  it('should properly escape embedded double quotes when fixing', async () => {
+    const sourceCode = `{% assign a = {'msg': 'she said "hi"'} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+    expect(offenses).to.have.length(2);
+
+    const valueOffense = offenses.find((o) =>
+      sourceCode.slice(o.start.index, o.end.index).includes('she said'),
+    );
+    expect(valueOffense).to.not.be.undefined;
+
+    const fixedValue = applyFix(sourceCode, valueOffense!);
+    expect(fixedValue).to.equal(`{% assign a = {'msg': "she said \\"hi\\""} %}`);
+  });
+
+  it('should report single-quoted strings in function return literals', async () => {
+    const sourceCode = `
+      {% function result = my_func %}
+        {% return {'a': 5} %}
+      {% endfunction %}
+    `;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(1);
+  });
+});

package/src/checks/json-literal-quote-style/index.ts

@@ -0,0 +1,45 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+
+export const JsonLiteralQuoteStyle: LiquidCheckDefinition = {
+  meta: {
+    code: 'JsonLiteralQuoteStyle',
+    name: 'Use double quotes in JSON literals',
+    docs: {
+      description:
+        'Enforces double-quoted string literals inside inline object/array literals (e.g. {% assign a = {"a": 5} %}). Single-quoted strings inside these literals are not valid JSON.',
+      recommended: true,
+      url: undefined,
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async String(node, ancestors) {
+        if (!node.single) return;
+
+        // Only flag strings that are inside an inline object/array literal.
+        const insideJsonLiteral = ancestors.some(
+          (ancestor) =>
+            ancestor.type === NodeTypes.JsonHashLiteral ||
+            ancestor.type === NodeTypes.JsonArrayLiteral,
+        );
+        if (!insideJsonLiteral) return;
+
+        context.report({
+          message:
+            'Use double quotes for string literals inside object/array literals (e.g. \'{"key": "value"}\', not "{\'key\': \'value\'}").',
+          startIndex: node.position.start,
+          endIndex: node.position.end,
+          fix: (corrector) => {
+            corrector.replace(node.position.start, node.position.end, JSON.stringify(node.value));
+          },
+        });
+      },
+    };
+  },
+};