feat(core): add useDoubleQuotes option for enum change messages

Author: adambenhassen

packages/core/__tests__/diff/enum.test.ts

@@ -274,4 +274,195 @@ describe('enum', () => {
     expect(change.criticality.reason).toBeDefined();
     expect(change.message).toEqual(`Enum value 'C' was added to enum 'enumA'`);
   });
-});
+
+  describe('useDoubleQuotes option', () => {
+    test('value added with double quotes', async () => {
+      const a = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A
+          B
+        }
+      `);
+
+      const b = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A
+          B
+          C
+        }
+      `);
+
+      const changes = await diff(a, b, [], { useDoubleQuotes: true });
+      const change = findFirstChangeByPath(changes, 'enumA.C');
+
+      expect(changes.length).toEqual(1);
+      expect(change.criticality.level).toEqual(CriticalityLevel.Dangerous);
+      expect(change.message).toEqual(`Enum value "C" was added to enum "enumA"`);
+    });
+
+    test('value removed with double quotes', async () => {
+      const a = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A
+          B
+        }
+      `);
+
+      const b = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A
+        }
+      `);
+
+      const changes = await diff(a, b, [], { useDoubleQuotes: true });
+      const change = findFirstChangeByPath(changes, 'enumA.B');
+
+      expect(changes.length).toEqual(1);
+      expect(change.criticality.level).toEqual(CriticalityLevel.Breaking);
+      expect(change.message).toEqual(`Enum value "B" was removed from enum "enumA"`);
+    });
+
+    test('deprecation reason changed with double quotes', async () => {
+      const a = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A @deprecated(reason: "Old Reason")
+          B
+        }
+      `);
+
+      const b = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A @deprecated(reason: "New Reason")
+          B
+        }
+      `);
+
+      const changes = await diff(a, b, [], { useDoubleQuotes: true });
+      const change = findFirstChangeByPath(changes, 'enumA.A');
+
+      expect(changes.length).toEqual(1);
+      expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+      expect(change.message).toEqual(
+        `Enum value "enumA.A" deprecation reason changed from "Old Reason" to "New Reason"`,
+      );
+    });
+
+    test('deprecation reason added with double quotes', async () => {
+      const a = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A
+          B
+        }
+      `);
+
+      const b = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A @deprecated(reason: "New Reason")
+          B
+        }
+      `);
+
+      const changes = await diff(a, b, [], { useDoubleQuotes: true });
+      const change = findFirstChangeByPath(changes, 'enumA.A');
+
+      expect(changes.length).toEqual(2);
+      expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+      expect(change.message).toEqual(
+        `Enum value "enumA.A" was deprecated with reason "New Reason"`,
+      );
+    });
+
+    test('deprecation reason removed with double quotes', async () => {
+      const a = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A @deprecated(reason: "New Reason")
+          B
+        }
+      `);
+
+      const b = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A
+          B
+        }
+      `);
+
+      const changes = await diff(a, b, [], { useDoubleQuotes: true });
+      const change = findFirstChangeByPath(changes, 'enumA.A');
+
+      expect(changes.length).toEqual(2);
+      expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+      expect(change.message).toEqual(`Deprecation reason was removed from enum value "enumA.A"`);
+    });
+
+    test('removal of a deprecated field with double quotes', async () => {
+      const a = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          A @deprecated(reason: "New Reason")
+          B
+        }
+      `);
+
+      const b = buildSchema(/* GraphQL */ `
+        type Query {
+          fieldA: String
+        }
+
+        enum enumA {
+          B
+        }
+      `);
+
+      const changes = await diff(a, b, [], { useDoubleQuotes: true });
+      const change = findFirstChangeByPath(changes, 'enumA.A');
+
+      expect(changes.length).toEqual(1);
+      expect(change.criticality.level).toEqual(CriticalityLevel.Breaking);
+      expect(change.message).toEqual(`Enum value "A" (deprecated) was removed from enum "enumA"`);
+    });
+  });
+});

packages/core/__tests__/utils/string.test.ts

@@ -1,4 +1,4 @@
-import { safeString } from '../../src/utils/string.js';
+import { fmt, safeString } from '../../src/utils/string.js';
 
 test('scalars', () => {
   expect(safeString(0)).toBe('0');
@@ -33,3 +33,32 @@ test('array', () => {
     '[ { foo: 42 } ]',
   );
 });
+
+describe('fmt', () => {
+  test('uses single quotes by default', () => {
+    expect(fmt('test')).toBe("'test'");
+    expect(fmt('enumA.B')).toBe("'enumA.B'");
+  });
+
+  test('uses single quotes when config is undefined', () => {
+    expect(fmt('test', undefined)).toBe("'test'");
+    expect(fmt('enumA.B', undefined)).toBe("'enumA.B'");
+  });
+
+  test('uses single quotes when useDoubleQuotes is false', () => {
+    expect(fmt('test', { useDoubleQuotes: false })).toBe("'test'");
+    expect(fmt('enumA.B', { useDoubleQuotes: false })).toBe("'enumA.B'");
+  });
+
+  test('uses double quotes when useDoubleQuotes is true', () => {
+    expect(fmt('test', { useDoubleQuotes: true })).toBe('"test"');
+    expect(fmt('enumA.B', { useDoubleQuotes: true })).toBe('"enumA.B"');
+  });
+
+  test('formats various string types correctly', () => {
+    expect(fmt('', { useDoubleQuotes: true })).toBe('""');
+    expect(fmt('', { useDoubleQuotes: false })).toBe("''");
+    expect(fmt('Old Reason', { useDoubleQuotes: true })).toBe('"Old Reason"');
+    expect(fmt('Old Reason', { useDoubleQuotes: false })).toBe("'Old Reason'");
+  });
+});