added config for yup strict option

Author: Code-Hex

src/config.ts

@@ -4,7 +4,7 @@ export type ValidationSchema = "yup";
 
 export interface ValidationSchemaPluginConfig extends TypeScriptPluginConfig {
   /**
-   * @description specify generate schema.
+   * @description specify generate schema
    * @default yup
    *
    * @exampleMarkdown
@@ -63,4 +63,28 @@ export interface ValidationSchemaPluginConfig extends TypeScriptPluginConfig {
    * ```
    */
   enumsAsTypes?: boolean;
+  /**
+   * @description this is for yup schema. use this when you specified `schema: yup`
+   */
+  yup?: YupSchemaPluginConfig
+}
+
+interface YupSchemaPluginConfig {
+  /**
+   * @description Generates yup schema as strict.
+   * @default false
+   * @see https://github.com/jquense/yup#schemastrictenabled-boolean--false-schema
+   *
+   * @exampleMarkdown
+   * ```yml
+   * generates:
+   *   path/to/file.ts:
+   *     plugins:
+   *       - graphql-codegen-validation-schema
+   *     config:
+   *       yup:
+   *         strict: true
+   * ```
+   */
+  strict?: boolean
 }

src/yup/index.ts

@@ -40,7 +40,7 @@ export const YupSchemaVisitor = (
 
       const shape = node.fields
         ?.map((field) =>
-          generateInputObjectFieldYupSchema(tsVisitor, schema, field, 2)
+          generateInputObjectFieldYupSchema(config, tsVisitor, schema, field, 2)
         )
         .join(",\n");
 
@@ -63,9 +63,7 @@ export const YupSchemaVisitor = (
           .withName(`${enumname}Schema`)
           .withContent(
             `yup.mixed().oneOf([${node.values
-              ?.map(
-                (enumOption) => `'${enumOption.name.value}'`
-              )
+              ?.map((enumOption) => `'${enumOption.name.value}'`)
               .join(", ")}])`
           ).string;
       }
@@ -108,13 +106,15 @@ export const YupSchemaVisitor = (
 };
 
 const generateInputObjectFieldYupSchema = (
+  config: ValidationSchemaPluginConfig,
   tsVisitor: TsVisitor,
   schema: GraphQLSchema,
   field: InputValueDefinitionNode,
   indentCount: number
 ): string => {
   // TOOD(codehex): handle directive
   const gen = generateInputObjectFieldTypeYupSchema(
+    config,
     tsVisitor,
     schema,
     field.type
@@ -126,17 +126,19 @@ const generateInputObjectFieldYupSchema = (
 };
 
 const generateInputObjectFieldTypeYupSchema = (
+  config: ValidationSchemaPluginConfig,
   tsVisitor: TsVisitor,
   schema: GraphQLSchema,
   type: TypeNode,
   parentType?: TypeNode
 ): string => {
   if (isListType(type)) {
     const gen = generateInputObjectFieldTypeYupSchema(
+      config,
       tsVisitor,
       schema,
       type.type,
-      type,
+      type
     );
     if (!isNonNullType(parentType)) {
       return `yup.array().of(${maybeLazy(type.type, gen)}).optional()`;
@@ -145,21 +147,23 @@ const generateInputObjectFieldTypeYupSchema = (
   }
   if (isNonNullType(type)) {
     const gen = generateInputObjectFieldTypeYupSchema(
+      config,
       tsVisitor,
       schema,
       type.type,
-      type,
+      type
     );
     return maybeLazy(type.type, `${gen}.defined()`);
   }
   if (isNamedType(type)) {
-    return generateNameNodeYupSchema(tsVisitor, schema, type.name);
+    return generateNameNodeYupSchema(config, tsVisitor, schema, type.name);
   }
   console.warn("unhandled type:", type);
   return "";
 };
 
 const generateNameNodeYupSchema = (
+  config: ValidationSchemaPluginConfig,
   tsVisitor: TsVisitor,
   schema: GraphQLSchema,
   node: NameNode
@@ -176,7 +180,8 @@ const generateNameNodeYupSchema = (
     return `${enumName}Schema`;
   }
 
-  return yup4Scalar(tsVisitor, node.value);
+  const primitive = yup4Scalar(tsVisitor, node.value);
+  return config.yup?.strict ? `${primitive}.strict(true)` : primitive;
 };
 
 const maybeLazy = (type: TypeNode, schema: string): string => {

tests/yup.spec.ts

@@ -216,22 +216,43 @@ describe("yup", () => {
       "export const PageTypeSchema = yup.mixed().oneOf(['PUBLIC', 'BASIC_AUTH'])"
     );
   });
-  // describe("with importFrom", () => {
-  //   it("Should work", async () => {
-  //     const schema = buildSchema(/* GraphQL */ `
-  //       "custom enum"
-  //       enum MyEnum {
-  //         "this is a"
-  //         A
-  //         "this is b"
-  //         B
-  //       }
-  //     `);
-  //     const result = (await plugin(schema, [], {
-  //       importFrom: "./generated-types",
-  //     })) as Types.ComplexPluginOutput;
+  it("with yup.strict", async () => {
+    const schema = buildSchema(/* GraphQL */ `
+      input PrimitiveInput {
+        a: ID
+        b: String
+        c: Boolean
+        d: Int
+        e: Float
+        f: F!
+      }
 
-  //     expect(1).toBe(1)
-  //   });
-  // });
+      input F {
+        a: String!
+      }
+    `);
+    const result = await plugin(
+      schema,
+      [],
+      {
+        yup: {
+          strict: true,
+        },
+      },
+      {}
+    );
+    const wantContains = [
+      "export function PrimitiveInputSchema(): yup.SchemaOf<PrimitiveInput>",
+      "a: yup.string().strict(true),",
+      "b: yup.string().strict(true),",
+      "c: yup.boolean().strict(true),",
+      "d: yup.number().strict(true),",
+      "e: yup.number().strict(true),",
+      "f: FSchema().defined()",
+      "a: yup.string().strict(true).defined()", // for FSchema
+    ];
+    for (const wantContain of wantContains) {
+      expect(result.content).toContain(wantContain);
+    }
+  });
 });