Implement additional configuration for C# plugin related to JSON attributes, remove redundant dependency on GraphQL namespace (#6342)

seclerp · web-flow · commit b64475b1b967 · 2021-08-03T09:32:54.000+03:00
diff --git a/.changeset/eighty-starfishes-drum.md b/.changeset/eighty-starfishes-drum.md
@@ -0,0 +1,5 @@
+---
+'@graphql-codegen/c-sharp': minor
+---
+
+Add options for JSON attributes configuration
diff --git a/packages/plugins/c-sharp/c-sharp/src/config.ts b/packages/plugins/c-sharp/c-sharp/src/config.ts
@@ -1,4 +1,5 @@
 import { RawConfig, EnumValuesMap } from '@graphql-codegen/visitor-plugin-common';
+import { JsonAttributesSource } from './json-attributes';
 
 /**
  * @description This plugin generates C# `class` identifier for your schema types.
@@ -77,4 +78,36 @@ export interface CSharpResolversPluginRawConfig extends RawConfig {
    * ```
    */
   emitRecords?: boolean;
+
+  /**
+   * @default true
+   * @description Should JSON attributes be emitted for produced types and properties ot not
+   *
+   * @exampleMarkdown
+   * ```yml
+   * generates:
+   *   src/main/c-sharp/my-org/my-app/Types.cs:
+   *     plugins:
+   *       - c-sharp
+   *     config:
+   *       emitJsonAttributes: false
+   * ```
+   */
+  emitJsonAttributes?: boolean;
+
+  /**
+   * @default Newtonsoft.Json
+   * @description Library that should be used to emit JSON attributes. Ignored when `emitJsonAttributes` is `false` or not specified
+   *
+   * @exampleMarkdown
+   * ```yml
+   * generates:
+   *   src/main/c-sharp/my-org/my-app/Types.cs:
+   *     plugins:
+   *       - c-sharp
+   *     config:
+   *       jsonAttributesSource: System.Text.Json
+   * ```
+   */
+  jsonAttributesSource?: JsonAttributesSource;
 }
diff --git a/packages/plugins/c-sharp/c-sharp/src/json-attributes.ts b/packages/plugins/c-sharp/c-sharp/src/json-attributes.ts
@@ -0,0 +1,36 @@
+﻿export type JsonAttributesSource = 'Newtonsoft.Json' | 'System.Text.Json';
+
+function unsupportedSource(attributesSource: JsonAttributesSource): void {
+  throw new Error(`Unsupported JSON attributes source: ${attributesSource}`);
+}
+
+export class JsonAttributesSourceConfiguration {
+  readonly namespace: string;
+  readonly propertyAttribute: string;
+  readonly requiredAttribute: string;
+
+  constructor(namespace: string, propertyAttribute: string, requiredAttribute: string) {
+    this.namespace = namespace;
+    this.propertyAttribute = propertyAttribute;
+    this.requiredAttribute = requiredAttribute;
+  }
+}
+
+const newtonsoftConfiguration = new JsonAttributesSourceConfiguration(
+  'Newtonsoft.Json',
+  'JsonProperty',
+  'JsonRequired'
+);
+
+// System.Text.Json does not have support of `JsonRequired` alternative (as for .NET 5)
+const systemTextJsonConfiguration = new JsonAttributesSourceConfiguration('System.Text.Json', 'JsonPropertyName', null);
+
+export function getJsonAttributeSourceConfiguration(attributesSource: JsonAttributesSource) {
+  switch (attributesSource) {
+    case 'Newtonsoft.Json':
+      return newtonsoftConfiguration;
+    case 'System.Text.Json':
+      return systemTextJsonConfiguration;
+  }
+  unsupportedSource(attributesSource);
+}
diff --git a/packages/plugins/c-sharp/c-sharp/src/visitor.ts b/packages/plugins/c-sharp/c-sharp/src/visitor.ts
@@ -39,17 +39,25 @@ import {
   getListTypeField,
 } from '../../common/common';
 import { pascalCase } from 'change-case-all';
+import {
+  JsonAttributesSource,
+  JsonAttributesSourceConfiguration,
+  getJsonAttributeSourceConfiguration,
+} from './json-attributes';
 
 export interface CSharpResolverParsedConfig extends ParsedConfig {
   namespaceName: string;
   className: string;
   listType: string;
   enumValues: EnumValuesMap;
   emitRecords: boolean;
+  emitJsonAttributes: boolean;
+  jsonAttributesSource: JsonAttributesSource;
 }
 
 export class CSharpResolversVisitor extends BaseVisitor<CSharpResolversPluginRawConfig, CSharpResolverParsedConfig> {
   private readonly keywords = new Set(csharpKeywords);
+  private readonly jsonAttributesConfiguration: JsonAttributesSourceConfiguration;
 
   constructor(rawConfig: CSharpResolversPluginRawConfig, private _schema: GraphQLSchema) {
     super(rawConfig, {
@@ -58,8 +66,14 @@ export class CSharpResolversVisitor extends BaseVisitor<CSharpResolversPluginRaw
       namespaceName: rawConfig.namespaceName || 'GraphQLCodeGen',
       className: rawConfig.className || 'Types',
       emitRecords: rawConfig.emitRecords || false,
+      emitJsonAttributes: rawConfig.emitJsonAttributes ?? true,
+      jsonAttributesSource: rawConfig.jsonAttributesSource || 'Newtonsoft.Json',
       scalars: buildScalarsFromConfig(_schema, rawConfig, C_SHARP_SCALARS),
     });
+
+    if (this._parsedConfig.emitJsonAttributes) {
+      this.jsonAttributesConfiguration = getJsonAttributeSourceConfiguration(this._parsedConfig.jsonAttributesSource);
+    }
   }
 
   /**
@@ -78,7 +92,11 @@ export class CSharpResolversVisitor extends BaseVisitor<CSharpResolversPluginRaw
   }
 
   public getImports(): string {
-    const allImports = ['System', 'System.Collections.Generic', 'Newtonsoft.Json', 'GraphQL'];
+    const allImports = ['System', 'System.Collections.Generic', 'System.ComponentModel.DataAnnotations'];
+    if (this._parsedConfig.emitJsonAttributes) {
+      const jsonAttributesNamespace = this.jsonAttributesConfiguration.namespace;
+      allImports.push(jsonAttributesNamespace);
+    }
     return allImports.map(i => `using ${i};`).join('\n') + '\n';
   }
 
@@ -143,12 +161,25 @@ export class CSharpResolversVisitor extends BaseVisitor<CSharpResolversPluginRaw
       attributes.push(`[Obsolete("${deprecationReason}")]`);
     }
 
-    if (node.kind === Kind.FIELD_DEFINITION) {
-      attributes.push(`[JsonProperty("${node.name.value}")]`);
+    if (this._parsedConfig.emitJsonAttributes) {
+      if (node.kind === Kind.FIELD_DEFINITION) {
+        const jsonPropertyAttribute = this.jsonAttributesConfiguration.propertyAttribute;
+        if (jsonPropertyAttribute != null) {
+          attributes.push(`[${jsonPropertyAttribute}("${node.name.value}")]`);
+        }
+      }
     }
 
     if (node.kind === Kind.INPUT_VALUE_DEFINITION && fieldType.isOuterTypeRequired) {
-      attributes.push(`[JsonRequired]`);
+      // Should be always inserted for required fields to use in `GetInputObject()` when JSON attributes are not used
+      // or there are no JSON attributes in selected attribute source that provides `JsonRequired` alternative
+      attributes.push('[Required]');
+      if (this._parsedConfig.emitJsonAttributes) {
+        const jsonRequiredAttribute = this.jsonAttributesConfiguration.requiredAttribute;
+        if (jsonRequiredAttribute != null) {
+          attributes.push(`[${jsonRequiredAttribute}]`);
+        }
+      }
     }
 
     if (commentText || attributes.length > 0) {
@@ -377,8 +408,15 @@ ${classMembers}
     {
       var value = propertyInfo.GetValue(this);
       var defaultValue = propertyInfo.PropertyType.IsValueType ? Activator.CreateInstance(propertyInfo.PropertyType) : null;
-
-      var requiredProp = propertyInfo.GetCustomAttributes(typeof(JsonRequiredAttribute), false).Length > 0;
+${
+  this._parsedConfig.emitJsonAttributes && this.jsonAttributesConfiguration.requiredAttribute != null
+    ? `
+      var requiredProp = propertyInfo.GetCustomAttributes(typeof(${this.jsonAttributesConfiguration.requiredAttribute}Attribute), false).Length > 0;
+`
+    : `
+      var requiredProp = propertyInfo.GetCustomAttributes(typeof(RequiredAttribute), false).Length > 0;
+`
+}
       if (requiredProp || value != defaultValue)
       {
         d[propertyInfo.Name] = value;
diff --git a/packages/plugins/c-sharp/c-sharp/test/c-sharp.spec.ts b/packages/plugins/c-sharp/c-sharp/test/c-sharp.spec.ts
@@ -2,6 +2,8 @@ import '@graphql-codegen/testing';
 import { buildSchema } from 'graphql';
 import { plugin } from '../src/index';
 import { CSharpResolversPluginRawConfig } from '../src/config';
+import { getJsonAttributeSourceConfiguration } from '../src/json-attributes';
+import each from 'jest-each';
 
 describe('C#', () => {
   describe('Using directives', () => {
@@ -15,9 +17,36 @@ describe('C#', () => {
 
       expect(result).toContain('using System;');
       expect(result).toContain('using System.Collections.Generic;');
+    });
+
+    it('Should include default JSON using directives', async () => {
+      const schema = buildSchema(/* GraphQL */ `
+        enum ns {
+          dummy
+        }
+      `);
+      const result = await plugin(schema, [], {}, { outputFile: '' });
+
       expect(result).toContain('using Newtonsoft.Json;');
-      expect(result).toContain('using GraphQL;');
     });
+
+    each(['Newtonsoft.Json', 'System.Text.Json']).it(
+      `Should include configured '%s' using directives`,
+      async source => {
+        const schema = buildSchema(/* GraphQL */ `
+          enum ns {
+            dummy
+          }
+        `);
+        const config: CSharpResolversPluginRawConfig = {
+          jsonAttributesSource: source,
+        };
+        const result = await plugin(schema, [], config, { outputFile: '' });
+        const jsonConfig = getJsonAttributeSourceConfiguration(source);
+
+        expect(result).toContain(`using ${jsonConfig.namespace};`);
+      }
+    );
   });
 
   describe('Namespaces', () => {
@@ -232,6 +261,7 @@ describe('C#', () => {
         /// <summary>
         /// User id
         /// </summary>
+        [Required]
         [JsonRequired]
         public int id { get; set; }
       `);
@@ -293,20 +323,46 @@ describe('C#', () => {
       expect(result).toContain('public class @public {');
     });
 
-    it('Should generate properties for types', async () => {
+    each(['Newtonsoft.Json', 'System.Text.Json']).it(
+      `Should generate properties for types using '%s' source`,
+      async source => {
+        const schema = buildSchema(/* GraphQL */ `
+          type User {
+            id: Int
+            email: String
+          }
+        `);
+        const config: CSharpResolversPluginRawConfig = {
+          jsonAttributesSource: source,
+        };
+        const result = await plugin(schema, [], config, { outputFile: '' });
+        const jsonConfig = getJsonAttributeSourceConfiguration(source);
+
+        expect(result).toBeSimilarStringTo(`
+          [${jsonConfig.propertyAttribute}("id")]
+          public int? id { get; set; }
+          [${jsonConfig.propertyAttribute}("email")]
+          public string email { get; set; }
+        `);
+      }
+    );
+
+    it(`Should generate properties for types without JSON attributes`, async () => {
       const schema = buildSchema(/* GraphQL */ `
         type User {
           id: Int
           email: String
         }
       `);
-      const result = await plugin(schema, [], {}, { outputFile: '' });
+      const config: CSharpResolversPluginRawConfig = {
+        emitJsonAttributes: false,
+      };
+      const result = await plugin(schema, [], config, { outputFile: '' });
+
       expect(result).toBeSimilarStringTo(`
-        [JsonProperty("id")]
-        public int? id { get; set; }
-        [JsonProperty("email")]
-        public string email { get; set; }
-      `);
+          public int? id { get; set; }
+          public string email { get; set; }
+        `);
     });
 
     it('Should generate summary header for class and properties', async () => {
@@ -406,7 +462,50 @@ describe('C#', () => {
 
   describe('GraphQL Value Types', () => {
     describe('Scalar', () => {
-      it('Should generate properties for mandatory scalar types', async () => {
+      each(['Newtonsoft.Json', 'System.Text.Json']).it(
+        `Should generate properties for mandatory scalar types using '%s' source`,
+        async source => {
+          const schema = buildSchema(/* GraphQL */ `
+            input BasicTypeInput {
+              intReq: Int!
+              fltReq: Float!
+              idReq: ID!
+              strReq: String!
+              boolReq: Boolean!
+            }
+          `);
+
+          const config: CSharpResolversPluginRawConfig = {
+            jsonAttributesSource: source,
+          };
+          const result = await plugin(schema, [], config, { outputFile: '' });
+          const jsonConfig = getJsonAttributeSourceConfiguration(source);
+          const attributes =
+            `
+            [Required]
+          ` +
+            (jsonConfig.requiredAttribute == null
+              ? ``
+              : `
+            [${jsonConfig.requiredAttribute}]
+          `);
+
+          expect(result).toBeSimilarStringTo(`
+            ${attributes}
+            public int intReq { get; set; }
+            ${attributes}
+            public double fltReq { get; set; }
+            ${attributes}
+            public string idReq { get; set; }
+            ${attributes}
+            public string strReq { get; set; }
+            ${attributes}
+            public bool boolReq { get; set; }
+          `);
+        }
+      );
+
+      it(`Should generate properties for mandatory scalar types with JSON attributes disabled`, async () => {
         const schema = buildSchema(/* GraphQL */ `
           input BasicTypeInput {
             intReq: Int!
@@ -416,18 +515,21 @@ describe('C#', () => {
             boolReq: Boolean!
           }
         `);
-        const result = await plugin(schema, [], {}, { outputFile: '' });
+        const config: CSharpResolversPluginRawConfig = {
+          emitJsonAttributes: false,
+        };
+        const result = await plugin(schema, [], config, { outputFile: '' });
 
         expect(result).toBeSimilarStringTo(`
-          [JsonRequired]
+          [Required]
           public int intReq { get; set; }
-          [JsonRequired]
+          [Required]
           public double fltReq { get; set; }
-          [JsonRequired]
+          [Required]
           public string idReq { get; set; }
-          [JsonRequired]
+          [Required]
           public string strReq { get; set; }
-          [JsonRequired]
+          [Required]
           public bool boolReq { get; set; }
         `);
       });
@@ -514,8 +616,10 @@ describe('C#', () => {
         expect(result).toBeSimilarStringTo(`
           public IEnumerable<int> arr1 { get; set; }
           public IEnumerable<double?> arr2 { get; set; }
+          [Required]
           [JsonRequired]
           public IEnumerable<int?> arr3 { get; set; }
+          [Required]
           [JsonRequired]
           public IEnumerable<bool> arr4 { get; set; }
         `);
@@ -539,8 +643,10 @@ describe('C#', () => {
 
         expect(result).toBeSimilarStringTo(`
           public IEnumerable<IEnumerable<int>> arr1 { get; set; }
+          [Required]
           [JsonRequired]
           public IEnumerable<IEnumerable<IEnumerable<double?>>> arr2 { get; set; }
+          [Required]
           [JsonRequired]
           public IEnumerable<IEnumerable<Complex>> arr3 { get; set; }
         `);

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'@graphql-codegen/c-sharp': minor
 +---
++
 +Add options for JSON attributes configuration