@aws-amplify/data-schema 1.17.5 → 1.19.0

package/dist/cjs/SchemaProcessor.js

@@ -257,10 +257,15 @@ function customOperationToGql(typeName, typeDef, authorization, isCustom = false
             refererTypeName: typeName,
         });
     }
-    if (Object.keys(fieldArgs).length > 0) {
-        const { gqlFields, implicitTypes: implied } = processFields(typeName, fieldArgs, {}, {});
-        callSignature += `(${gqlFields.join(', ')})`;
-        implicitTypes.push(...implied);
+    const { inputTypes, argDefinitions, collectedEnums } = generateInputTypes(typeName, fieldArgs, getRefType);
+    // Handle collected enums
+    for (const [enumName, enumDef] of collectedEnums) {
+        if (!implicitTypes.some(([name]) => name === enumName)) {
+            implicitTypes.push([enumName, enumDef]);
+        }
+    }
+    if (argDefinitions.length > 0) {
+        callSignature += `(${argDefinitions.join(', ')})`;
     }
     const handler = handlers && handlers[0];
     const brand = handler && (0, util_1.getBrand)(handler);
@@ -335,6 +340,7 @@ function customOperationToGql(typeName, typeDef, authorization, isCustom = false
         customTypeAuthRules,
         lambdaFunctionDefinition,
         customSqlDataSourceStrategy,
+        inputTypes,
     };
 }
 /**
@@ -858,6 +864,134 @@ const mergeCustomTypeAuthRules = (existing, added) => {
         existing[typeName] = authRules;
     }
 };
+/**
+ * Generates input types for custom operations in the schema.
+ *
+ * Processes operation arguments to create corresponding input types,
+ * handling referenced and inline custom types, enums, and nested structures.
+ * Manages circular references and prevents duplicate processing.
+ *
+ **/
+function generateInputTypes(operationName, args, getRefType) {
+    const inputTypes = [];
+    const argDefinitions = [];
+    const collectedEnums = new Map();
+    const processedTypes = new Set(); // Track processed types to avoid duplicates
+    const processNonScalarFields = (fields, originalTypeName, isParentRef = false, parentChain = []) => {
+        const processedFields = {};
+        for (const [fieldName, fieldDef] of Object.entries(fields)) {
+            if (isRefField(fieldDef)) {
+                const refType = getRefType(fieldDef.data.link, originalTypeName);
+                if (refType.type === 'CustomType') {
+                    const nestedInputTypeName = `${fieldDef.data.link}Input`;
+                    processedFields[fieldName] = {
+                        data: { type: 'ref', link: nestedInputTypeName },
+                    };
+                    // Process the nested type if it hasn't been processed and isn't a circular reference
+                    if (!parentChain.includes(nestedInputTypeName) &&
+                        !processedTypes.has(nestedInputTypeName)) {
+                        processedTypes.add(nestedInputTypeName);
+                        const nestedFields = processNonScalarFields(refType.def.data.fields, fieldDef.data.link, true, [...parentChain, nestedInputTypeName]);
+                        inputTypes.push({
+                            name: nestedInputTypeName,
+                            fields: nestedFields,
+                        });
+                    }
+                }
+                else if (refType.type === 'Enum') {
+                    processedFields[fieldName] = {
+                        data: { type: 'ref', link: fieldDef.data.link },
+                    };
+                }
+                else {
+                    throw new Error(`Unsupported reference type '${refType.type}' for field '${fieldName}'. ` +
+                        `Only references to CustomType and Enum are supported.`);
+                }
+            }
+            else if (isCustomType(fieldDef)) {
+                // Handle inline custom types
+                const nestedInputTypeName = `${capitalize(originalTypeName)}${capitalize(fieldName)}Input`;
+                processedFields[fieldName] = {
+                    data: { type: 'ref', link: nestedInputTypeName },
+                };
+                if (!processedTypes.has(nestedInputTypeName)) {
+                    processedTypes.add(nestedInputTypeName);
+                    const nestedFields = processNonScalarFields(fieldDef.data.fields, `${capitalize(originalTypeName)}${capitalize(fieldName)}`, isParentRef, [...parentChain, nestedInputTypeName]);
+                    inputTypes.push({
+                        name: nestedInputTypeName,
+                        fields: nestedFields,
+                    });
+                }
+            }
+            else if (isEnumType(fieldDef)) {
+                // Handle enum types
+                const enumName = `${capitalize(originalTypeName)}${capitalize(fieldName)}`;
+                if (!collectedEnums.has(enumName) && !isParentRef) {
+                    collectedEnums.set(enumName, fieldDef);
+                }
+                processedFields[fieldName] = { data: { type: 'ref', link: enumName } };
+            }
+            else {
+                processedFields[fieldName] = fieldDef;
+            }
+        }
+        return processedFields;
+    };
+    // Process top-level arguments
+    for (const [argName, argDef] of Object.entries(args)) {
+        if (isRefField(argDef)) {
+            const refType = getRefType(argDef.data.link, operationName);
+            if (refType.type === 'CustomType') {
+                const inputTypeName = `${argDef.data.link}Input`;
+                argDefinitions.push(`${argName}: ${inputTypeName}`);
+                // Process the input type if it hasn't been processed yet
+                if (!processedTypes.has(inputTypeName)) {
+                    processedTypes.add(inputTypeName);
+                    const fields = processNonScalarFields(refType.def.data.fields, argDef.data.link, true, [inputTypeName]);
+                    inputTypes.push({
+                        name: inputTypeName,
+                        fields,
+                    });
+                }
+            }
+            else if (refType.type === 'Enum') {
+                argDefinitions.push(`${argName}: ${argDef.data.link}`);
+            }
+            else {
+                throw new Error(`Unsupported reference type '${refType.type}' for argument '${argName}' in '${operationName}'. ` +
+                    `Only references to CustomType and Enum are supported.`);
+            }
+        }
+        else if (isEnumType(argDef)) {
+            // Handle top-level enum arguments
+            const enumName = `${capitalize(operationName)}${capitalize(argName)}`;
+            if (!collectedEnums.has(enumName)) {
+                collectedEnums.set(enumName, argDef);
+            }
+            argDefinitions.push(`${argName}: ${enumName}`);
+        }
+        else if (isCustomType(argDef)) {
+            // Handle top-level custom type arguments
+            const inputTypeName = `${capitalize(operationName)}${capitalize(argName)}Input`;
+            argDefinitions.push(`${argName}: ${inputTypeName}`);
+            if (!processedTypes.has(inputTypeName)) {
+                processedTypes.add(inputTypeName);
+                const fields = processNonScalarFields(argDef.data.fields, `${capitalize(operationName)}${capitalize(argName)}`, false, [inputTypeName]);
+                inputTypes.push({
+                    name: inputTypeName,
+                    fields,
+                });
+            }
+        }
+        else if (isScalarField(argDef)) {
+            argDefinitions.push(`${argName}: ${scalarFieldToGql(argDef.data)}`);
+        }
+        else {
+            throw new Error(`Unsupported argument type for ${argName}`);
+        }
+    }
+    return { inputTypes, argDefinitions, collectedEnums };
+}
 const schemaPreprocessor = (schema) => {
     const gqlModels = [];
     const customQueries = [];
@@ -889,6 +1023,7 @@ const schemaPreprocessor = (schema) => {
     const topLevelTypes = sortTopLevelTypes(Object.entries(schema.data.types));
     const { schemaAuth, functionSchemaAccess } = extractFunctionSchemaAccess(schema.data.authorization);
     const getRefType = getRefTypeForSchema(schema);
+    const uniqueInputTypes = new Map();
     for (const [typeName, typeDef] of topLevelTypes) {
         const mostRelevantAuthRules = typeDef.data?.authorization?.length > 0
             ? typeDef.data.authorization
@@ -921,7 +1056,13 @@ const schemaPreprocessor = (schema) => {
             else if (isCustomOperation(typeDef)) {
                 // TODO: add generation route logic.
                 const { typeName: opType } = typeDef.data;
-                const { gqlField, implicitTypes, customTypeAuthRules, jsFunctionForField, lambdaFunctionDefinition, customSqlDataSourceStrategy, } = transformCustomOperations(typeDef, typeName, mostRelevantAuthRules, databaseType, getRefType);
+                const { gqlField, implicitTypes, customTypeAuthRules, jsFunctionForField, lambdaFunctionDefinition, customSqlDataSourceStrategy, inputTypes, } = transformCustomOperations(typeDef, typeName, mostRelevantAuthRules, databaseType, getRefType);
+                // Process input types without duplicates
+                for (const { name, fields } of inputTypes) {
+                    if (!uniqueInputTypes.has(name)) {
+                        uniqueInputTypes.set(name, fields);
+                    }
+                }
                 topLevelTypes.push(...implicitTypes);
                 mergeCustomTypeAuthRules(customTypeInheritedAuthRules, customTypeAuthRules);
                 if (customTypeAuthRules) {
@@ -1011,6 +1152,12 @@ const schemaPreprocessor = (schema) => {
             gqlModels.push(model);
         }
     }
+    // Generate input types after processing all custom operations
+    for (const [name, fields] of uniqueInputTypes) {
+        const { gqlFields } = processFields(name, fields, {}, {}, undefined, undefined, undefined, databaseEngine);
+        const inputTypeDefinition = `input ${name} {\n  ${gqlFields.join('\n  ')}\n}`;
+        gqlModels.push(inputTypeDefinition);
+    }
     const customOperations = {
         queries: customQueries,
         mutations: customMutations,
@@ -1205,7 +1352,7 @@ function transformCustomOperations(typeDef, typeName, authRules, databaseType, g
         opType, typeName);
     }
     const isCustom = Boolean(jsFunctionForField);
-    const { gqlField, implicitTypes, customTypeAuthRules, lambdaFunctionDefinition, customSqlDataSourceStrategy, } = customOperationToGql(typeName, typeDef, authRules, isCustom, databaseType, getRefType);
+    const { gqlField, implicitTypes, customTypeAuthRules, lambdaFunctionDefinition, customSqlDataSourceStrategy, inputTypes, } = customOperationToGql(typeName, typeDef, authRules, isCustom, databaseType, getRefType);
     return {
         gqlField,
         implicitTypes,
@@ -1213,6 +1360,7 @@ function transformCustomOperations(typeDef, typeName, authRules, databaseType, g
         jsFunctionForField,
         lambdaFunctionDefinition,
         customSqlDataSourceStrategy,
+        inputTypes,
     };
 }
 function generateCustomOperationTypes({ queries, mutations, subscriptions, }) {