feat(appsync): support enumeration types for code-first approach (#10023)

Support `Enum Types` for code-first approach. `Enum Types` are special types of Intermediate Types in CDK.

<details>
<summary> Desired GraphQL Enum</summary>

```gql
enum Episode {
  NEWHOPE
  EMPIRE
  JEDI
}
```

</details>

The above GraphQL Enumeration Type can be expressed in CDK as the following:

<details>
<summary>CDK Code</summary>

```ts
const episode = new appsync.EnumType('Episode', {
  definition: [
    'NEWHOPE',
    'EMPIRE',
    'JEDI',
  ],
}); 
api.addType(episode);
```

</details>

Discussion on the addField API can be found [here](#10023 (comment)). 

----

*By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license*

Author: BryanPan342

packages/@aws-cdk/aws-appsync/README.md

@@ -563,6 +563,7 @@ Types will be the meat of your GraphQL Schema as they are the types defined by y
 Intermediate Types include:
 - [**Interface Types**](#Interface-Types)
 - [**Object Types**](#Object-Types)
+- [**Enum Types**](#Enum-Types)
 - [**Input Types**](#Input-Types)
 - [**Union Types**](#Union-Types)
 
@@ -581,6 +582,8 @@ const node = new appsync.InterfaceType('Node', {
 });
 ```
 
+To learn more about **Interface Types**, read the docs [here](https://graphql.org/learn/schema/#interfaces).
+
 ##### Object Types
 
 **Object Types** are types that you declare. For example, in the [code-first example](#code-first-example)
@@ -644,6 +647,39 @@ You can create Object Types in three ways:
     ```
     > This method allows for reusability and modularity, ideal for reducing code duplication.
 
+To learn more about **Object Types**, read the docs [here](https://graphql.org/learn/schema/#object-types-and-fields).
+
+### Enum Types
+
+**Enum Types** are a special type of Intermediate Type. They restrict a particular
+set of allowed values for other Intermediate Types.
+
+```gql
+enum Episode {
+  NEWHOPE
+  EMPIRE
+  JEDI
+}
+```
+
+> This means that wherever we use the type Episode in our schema, we expect it to
+> be exactly one of NEWHOPE, EMPIRE, or JEDI.
+
+The above GraphQL Enumeration Type can be expressed in CDK as the following:
+
+```ts
+const episode = new appsync.EnumType('Episode', {
+  definition: [
+    'NEWHOPE',
+    'EMPIRE',
+    'JEDI',
+  ],
+}); 
+api.addType(episode);
+```
+
+To learn more about **Enum Types**, read the docs [here](https://graphql.org/learn/schema/#enumeration-types).
+
 ##### Input Types
 
 **Input Types** are special types of Intermediate Types. They give users an

packages/@aws-cdk/aws-appsync/lib/schema-intermediate.ts

@@ -13,7 +13,7 @@ import { BaseTypeOptions, GraphqlType, ResolvableFieldOptions } from './schema-f
  *
  * @experimental
  */
-export interface IntermediateTypeProps {
+export interface IntermediateTypeOptions {
   /**
    * the attributes of this type
    */
@@ -52,22 +52,12 @@ export class InterfaceType implements IIntermediateType {
    */
   protected modes?: AuthorizationType[];
 
-  public constructor(name: string, props: IntermediateTypeProps) {
+  public constructor(name: string, props: IntermediateTypeOptions) {
     this.name = name;
     this.definition = props.definition;
     this.directives = props.directives;
   }
 
-  /**
-   * Method called when the stringifying Intermediate Types for schema generation
-   *
-   * @internal
-   */
-  public _bindToGraphqlApi(api: GraphqlApi): IIntermediateType {
-    this.modes = api.modes;
-    return this;
-  }
-
   /**
    * Create a GraphQL Type representing this Intermediate Type
    *
@@ -111,6 +101,16 @@ export class InterfaceType implements IIntermediateType {
     }
     this.definition[options.fieldName] = options.field;
   }
+
+  /**
+   * Method called when the stringifying Intermediate Types for schema generation
+   *
+   * @internal
+   */
+  public _bindToGraphqlApi(api: GraphqlApi): IIntermediateType {
+    this.modes = api.modes;
+    return this;
+  }
 }
 
 /**
@@ -123,7 +123,7 @@ export class InterfaceType implements IIntermediateType {
  *
  * @experimental
  */
-export interface ObjectTypeProps extends IntermediateTypeProps {
+export interface ObjectTypeOptions extends IntermediateTypeOptions {
   /**
    * The Interface Types this Object Type implements
    *
@@ -149,7 +149,7 @@ export class ObjectType extends InterfaceType implements IIntermediateType {
    */
   public resolvers?: Resolver[];
 
-  public constructor(name: string, props: ObjectTypeProps) {
+  public constructor(name: string, props: ObjectTypeOptions) {
     const options = {
       definition: props.interfaceTypes?.reduce((def, interfaceType) => {
         return Object.assign({}, def, interfaceType.definition);
@@ -234,7 +234,7 @@ export class InputType implements IIntermediateType {
    */
   protected modes?: AuthorizationType[];
 
-  public constructor(name: string, props: IntermediateTypeProps) {
+  public constructor(name: string, props: IntermediateTypeOptions) {
     this.name = name;
     this.definition = props.definition;
   }
@@ -253,16 +253,6 @@ export class InputType implements IIntermediateType {
     });
   }
 
-  /**
-   * Method called when the stringifying Intermediate Types for schema generation
-   *
-   * @internal
-   */
-  public _bindToGraphqlApi(api: GraphqlApi): IIntermediateType {
-    this.modes = api.modes;
-    return this;
-  }
-
   /**
    * Generate the string of this input type
    */
@@ -289,13 +279,21 @@ export class InputType implements IIntermediateType {
     }
     this.definition[options.fieldName] = options.field;
   }
+
+  /**
+   * Method called when the stringifying Intermediate Types for schema generation
+   *
+   * @internal
+   */
+  public _bindToGraphqlApi(api: GraphqlApi): IIntermediateType {
+    this.modes = api.modes;
+    return this;
+  }
 }
 
 /**
  * Properties for configuring an Union Type
  *
- * @param definition - the object types for this union type
- *
  * @experimental
  */
 export interface UnionTypeOptions {
@@ -348,16 +346,6 @@ export class UnionType implements IIntermediateType {
     });
   }
 
-  /**
-   * Method called when the stringifying Intermediate Types for schema generation
-   *
-   * @internal
-   */
-  public _bindToGraphqlApi(api: GraphqlApi): IIntermediateType {
-    this.modes = api.modes;
-    return this;
-  }
-
   /**
    * Generate the string of this Union type
    */
@@ -387,4 +375,108 @@ export class UnionType implements IIntermediateType {
     }
     this.definition[options.field?.toString() + 'id'] = options.field;
   }
+
+  /**
+   * Method called when the stringifying Intermediate Types for schema generation
+   *
+   * @internal
+   */
+  public _bindToGraphqlApi(api: GraphqlApi): IIntermediateType {
+    this.modes = api.modes;
+    return this;
+  }
+}
+
+/**
+ * Properties for configuring an Enum Type
+ *
+ * @experimental
+ */
+export interface EnumTypeOptions {
+  /**
+   * the attributes of this type
+   */
+  readonly definition: string[];
+}
+
+/**
+ * Enum Types are abstract types that includes a set of fields
+ * that represent the strings this type can create.
+ *
+ * @experimental
+ */
+export class EnumType implements IIntermediateType {
+  /**
+   * the name of this type
+   */
+  public readonly name: string;
+  /**
+   * the attributes of this type
+   */
+  public readonly definition: { [key: string]: IField };
+  /**
+   * the authorization modes for this intermediate type
+   */
+  protected modes?: AuthorizationType[];
+
+  public constructor(name: string, options: EnumTypeOptions) {
+    this.name = name;
+    this.definition = {};
+    options.definition.map((fieldName: string) => this.addField({ fieldName }));
+  }
+
+  /**
+   * Create an GraphQL Type representing this Enum Type
+   */
+  public attribute(options?: BaseTypeOptions): GraphqlType {
+    return GraphqlType.intermediate({
+      isList: options?.isList,
+      isRequired: options?.isRequired,
+      isRequiredList: options?.isRequiredList,
+      intermediateType: this,
+    });
+  }
+
+  /**
+   * Generate the string of this enum type
+   */
+  public toString(): string {
+    return shapeAddition({
+      prefix: 'enum',
+      name: this.name,
+      fields: Object.keys(this.definition),
+      modes: this.modes,
+    });
+  }
+
+  /**
+   * Add a field to this Enum Type
+   *
+   * To add a field to this Enum Type, you must only configure
+   * addField with the fieldName options.
+   *
+   * @param options the options to add a field
+   */
+  public addField(options: AddFieldOptions): void {
+    if (options.field) {
+      throw new Error('Enum Type fields consist of strings. Use the fieldName option instead of the field option.');
+    }
+    if (!options.fieldName) {
+      throw new Error('When adding a field to an Enum Type, you must configure the fieldName option.');
+    }
+    if (options.fieldName.indexOf(' ') > -1) {
+      throw new Error(`Enum Type values cannot have whitespace. Received: ${options.fieldName}`);
+    }
+    this.definition[options.fieldName] = GraphqlType.string();
+  }
+
+  /**
+   * Method called when the stringifying Intermediate Types for schema generation
+   *
+   * @internal
+   */
+  public _bindToGraphqlApi(api: GraphqlApi): IIntermediateType {
+    this.modes = api.modes;
+    return this;
+  }
 }