fix: schema processor to preserve array type for custom types (#629)

Author: soberm

.changeset/happy-apes-count.md

@@ -0,0 +1,5 @@
+---
+'@aws-amplify/data-schema': minor
+---
+
+fix: array fields within custom types lose their array structure when generating input types

packages/data-schema/__tests__/ModelSchema.test.ts

@@ -408,4 +408,110 @@ describe('custom operation argument inputs', () => {
     expect(schema.transform().schema).toMatchSnapshot();
   });
 
-})
+});
+
+describe('nested array fields in custom types', () => {
+
+  it('when a custom type has an array ref field the input type preserves the array', () => {
+    const fn1 = defineFunctionStub({});
+
+    const schema = a
+      .schema({
+        testType: a.customType({
+          testField: a.string().required(),
+        }),
+
+        containerType: a.customType({
+          items: a.ref('testType').array(),
+        }),
+
+        testMutation: a
+          .mutation()
+          .arguments({
+            container: a.ref('containerType'),
+          })
+          .returns(a.string())
+          .handler(a.handler.function(fn1))
+      })
+      .authorization((allow) => allow.owner());
+
+    expect(schema.transform().schema).toMatchSnapshot();
+  });
+
+  it('when a custom type has a required array ref field the input type is a required array', () => {
+    const fn1 = defineFunctionStub({});
+
+    const schema = a
+      .schema({
+        testType: a.customType({
+          testField: a.string().required(),
+        }),
+
+        containerType: a.customType({
+          items: a.ref('testType').array().required(),
+        }),
+
+        testMutation: a
+          .mutation()
+          .arguments({
+            container: a.ref('containerType'),
+          })
+          .returns(a.string())
+          .handler(a.handler.function(fn1))
+      })
+      .authorization((allow) => allow.owner());
+
+    expect(schema.transform().schema).toMatchSnapshot();
+  });
+
+  it('when a custom type has an array of required ref fields the input type is an array of required refs', () => {
+    const fn1 = defineFunctionStub({});
+
+    const schema = a
+      .schema({
+        testType: a.customType({
+          testField: a.string().required(),
+        }),
+
+        containerType: a.customType({
+          items: a.ref('testType').required().array(),
+        }),
+
+        testMutation: a
+          .mutation()
+          .arguments({
+            container: a.ref('containerType'),
+          })
+          .returns(a.string())
+          .handler(a.handler.function(fn1))
+      })
+      .authorization((allow) => allow.owner());
+
+    expect(schema.transform().schema).toMatchSnapshot();
+  });
+
+  it('when a custom type has an array enum ref field the input type preserves the array', () => {
+    const fn1 = defineFunctionStub({});
+
+    const schema = a
+      .schema({
+        testEnum: a.enum(['VALUE1', 'VALUE2']),
+
+        containerType: a.customType({
+          statuses: a.ref('testEnum').array(),
+        }),
+
+        testMutation: a
+          .mutation()
+          .arguments({
+            container: a.ref('containerType'),
+          })
+          .returns(a.string())
+          .handler(a.handler.function(fn1))
+      })
+      .authorization((allow) => allow.owner());
+
+    expect(schema.transform().schema).toMatchSnapshot();
+  });
+
+});

packages/data-schema/__tests__/__snapshots__/ModelSchema.test.ts.snap

@@ -167,3 +167,95 @@ exports[`empty model auth inherits global auth 1`] = `
   someOwnerField: String
 }"
 `;
+
+exports[`nested array fields in custom types when a custom type has a required array ref field the input type is a required array 1`] = `
+"type testType 
+{
+  testField: String!
+}
+
+type containerType 
+{
+  items: [testType]!
+}
+
+input testTypeInput {
+  testField: String!
+}
+
+input containerTypeInput {
+  items: [testTypeInput]!
+}
+
+type Mutation {
+  testMutation(container: containerTypeInput): String @function(name: "FnTestMutation") @auth(rules: [{allow: owner, ownerField: "owner"}])
+}"
+`;
+
+exports[`nested array fields in custom types when a custom type has an array enum ref field the input type preserves the array 1`] = `
+"enum testEnum {
+  VALUE1
+  VALUE2
+}
+
+type containerType 
+{
+  statuses: [testEnum]
+}
+
+input containerTypeInput {
+  statuses: [testEnum]
+}
+
+type Mutation {
+  testMutation(container: containerTypeInput): String @function(name: "FnTestMutation") @auth(rules: [{allow: owner, ownerField: "owner"}])
+}"
+`;
+
+exports[`nested array fields in custom types when a custom type has an array of required ref fields the input type is an array of required refs 1`] = `
+"type testType 
+{
+  testField: String!
+}
+
+type containerType 
+{
+  items: [testType!]
+}
+
+input testTypeInput {
+  testField: String!
+}
+
+input containerTypeInput {
+  items: [testTypeInput!]
+}
+
+type Mutation {
+  testMutation(container: containerTypeInput): String @function(name: "FnTestMutation") @auth(rules: [{allow: owner, ownerField: "owner"}])
+}"
+`;
+
+exports[`nested array fields in custom types when a custom type has an array ref field the input type preserves the array 1`] = `
+"type testType 
+{
+  testField: String!
+}
+
+type containerType 
+{
+  items: [testType]
+}
+
+input testTypeInput {
+  testField: String!
+}
+
+input containerTypeInput {
+  items: [testTypeInput]
+}
+
+type Mutation {
+  testMutation(container: containerTypeInput): String @function(name: "FnTestMutation") @auth(rules: [{allow: owner, ownerField: "owner"}])
+}"
+`;

packages/data-schema/src/SchemaProcessor.ts

@@ -1391,7 +1391,13 @@ function generateInputTypes(
         if (refType.type === 'CustomType') {
           const nestedInputTypeName = `${fieldDef.data.link}Input`;
           processedFields[fieldName] = {
-            data: { type: 'ref', link: nestedInputTypeName },
+            data: { 
+              type: 'ref', 
+              link: nestedInputTypeName,
+              array: fieldDef.data.array,
+              arrayRequired: fieldDef.data.arrayRequired,
+              valueRequired: fieldDef.data.valueRequired
+            },
           };
 
           // Process the nested type if it hasn't been processed and isn't a circular reference
@@ -1413,7 +1419,13 @@ function generateInputTypes(
           }
         } else if (refType.type === 'Enum') {
           processedFields[fieldName] = {
-            data: { type: 'ref', link: fieldDef.data.link },
+            data: { 
+              type: 'ref', 
+              link: fieldDef.data.link,
+              array: fieldDef.data.array,
+              arrayRequired: fieldDef.data.arrayRequired,
+              valueRequired: fieldDef.data.valueRequired
+            },
           };
         } else {
           throw new Error(
@@ -1425,7 +1437,10 @@ function generateInputTypes(
         // Handle inline custom types
         const nestedInputTypeName = `${capitalize(originalTypeName)}${capitalize(fieldName)}Input`;
         processedFields[fieldName] = {
-          data: { type: 'ref', link: nestedInputTypeName },
+          data: { 
+            type: 'ref', 
+            link: nestedInputTypeName
+          },
         };
 
         if (!processedTypes.has(nestedInputTypeName)) {