@aws-amplify/data-schema 1.20.0 → 1.20.2

package/dist/esm/SchemaProcessor.mjs

@@ -600,19 +600,26 @@ function getAppSyncAuthDirectiveFromRule(rule) {
 }
 function mapToNativeAppSyncAuthDirectives(authorization, isCustomHandler) {
     const rules = new Set();
+    const groupProvider = new Map();
     for (const entry of authorization) {
         const rule = accessData(entry);
         isCustomHandler && validateCustomHandlerAuthRule(rule);
         const provider = getAppSyncAuthDirectiveFromRule(rule);
         if (rule.groups) {
-            // example: (cognito_groups: ["Bloggers", "Readers"])
-            rules.add(`${provider}(cognito_groups: [${rule.groups
-                .map((group) => `"${group}"`)
-                .join(', ')}])`);
+            if (!groupProvider.has(provider)) {
+                groupProvider.set(provider, new Set());
+            }
+            rule.groups.forEach((group) => groupProvider.get(provider)?.add(group));
         }
         else {
             rules.add(provider);
         }
+        groupProvider.forEach((groups, provider) => {
+            rules.add(`${provider}(cognito_groups: [${Array.from(groups)
+                .map((group) => `"${group}"`)
+                .join(', ')}])`);
+            // example: (cognito_groups: ["Bloggers", "Readers"])
+        });
     }
     const authString = [...rules].join(' ');
     return { authString };
@@ -947,8 +954,19 @@ function generateInputTypes(operationName, args, getRefType) {
         if (isRefField(argDef)) {
             const refType = getRefType(argDef.data.link, operationName);
             if (refType.type === 'CustomType') {
+                const { valueRequired, array, arrayRequired } = argDef.data;
                 const inputTypeName = `${argDef.data.link}Input`;
-                argDefinitions.push(`${argName}: ${inputTypeName}`);
+                let field = inputTypeName;
+                if (valueRequired === true) {
+                    field += '!';
+                }
+                if (array) {
+                    field = `[${field}]`;
+                    if (arrayRequired === true) {
+                        field += '!';
+                    }
+                }
+                argDefinitions.push(`${argName}: ${field}`);
                 // Process the input type if it hasn't been processed yet
                 if (!processedTypes.has(inputTypeName)) {
                     processedTypes.add(inputTypeName);
@@ -960,7 +978,18 @@ function generateInputTypes(operationName, args, getRefType) {
                 }
             }
             else if (refType.type === 'Enum') {
-                argDefinitions.push(`${argName}: ${argDef.data.link}`);
+                const { valueRequired, array, arrayRequired } = argDef.data;
+                let field = argDef.data.link;
+                if (valueRequired === true) {
+                    field += '!';
+                }
+                if (array) {
+                    field = `[${field}]`;
+                    if (arrayRequired === true) {
+                        field += '!';
+                    }
+                }
+                argDefinitions.push(`${argName}: ${field}`);
             }
             else {
                 throw new Error(`Unsupported reference type '${refType.type}' for argument '${argName}' in '${operationName}'. ` +