HCK-9658: Adjust arguments modeling and FE script generation (#53)

* HCK-9658: re-configure properties for List argument type and required option, updated FE logic accordingly

* rename argument parameters according to the agreement

Author: VitaliiBedletskyi

forward_engineering/helpers/addRequiredHelper.js

@@ -0,0 +1,18 @@
+/**
+ * Adds required indicator.
+ *
+ * @param {Object} param0
+ * @param {string} param0.type - The type name statement.
+ * @param {boolean} param0.required - Indicates if the field is required.
+ * @returns {string} - The type name with required indicator.
+ */
+function addRequired({ type, required }) {
+	if (required) {
+		return `${type}!`;
+	}
+	return type;
+}
+
+module.exports = {
+	addRequired,
+};

forward_engineering/mappers/arguments.js

@@ -6,32 +6,45 @@ const { getDirectivesUsageStatement } = require('./directiveUsageStatements');
 const { getArgumentDefaultValue } = require('./argumentDefaultValue');
 const { joinInlineStatements } = require('../helpers/feStatementJoinHelper');
 const { formatFEStatement } = require('../helpers/feStatementFormatHelper');
+const { addRequired } = require('../helpers/addRequiredHelper');
 
 /**
  * Gets the type of the argument with the required keyword.
  * @param {Object} args - arguments object.
- * @param {Argument} args.argument - The argument to map.
+ * @param {Argument} args.graphqlArgument - The argument to map.
  * @param {IdToNameMap} [args.idToNameMap] - The ID to name map of all available types in model.
  * @returns {string} returns the type of the argument with the required keyword
  */
-const getArgumentType = ({ argument, idToNameMap = {} }) => {
-	const argumentType = idToNameMap[argument.type] || argument.type;
-	return argument.required ? argument.required.replace('<Type>', argumentType) : argumentType;
+const getArgumentType = ({ graphqlArgument, idToNameMap = {} }) => {
+	let argumentType = idToNameMap[graphqlArgument.type] || graphqlArgument.type;
+
+	if (argumentType === 'List') {
+		const firstListItem = graphqlArgument.listItems?.[0] || {};
+		const listItemType = idToNameMap[firstListItem.type] || firstListItem.type || '';
+
+		if (!listItemType) {
+			argumentType = '[]';
+		} else {
+			argumentType = `[${addRequired({ type: listItemType, required: firstListItem.required })}]`;
+		}
+	}
+
+	return addRequired({ type: argumentType, required: graphqlArgument.required });
 };
 
 /**
  * Maps an argument to a string with all configured properties.
  * @param {Object} args - arguments object.
- * @param {Argument} args.argument - The argument to map.
+ * @param {Argument} args.graphqlArgument - The argument to map.
  * @param {IdToNameMap} [args.idToNameMap] - The ID to name map of all available types in model.
  * @returns {FEStatement} returns the argument as a FEStatement
  */
-const mapArgument = ({ argument, idToNameMap = {} }) => {
-	const argumentName = `${argument.name}:`;
-	const argumentType = getArgumentType({ argument, idToNameMap });
-	const directivesStatement = getDirectivesUsageStatement({ directives: argument.directives });
-	const defaultValue = argument.default
-		? `= ${getArgumentDefaultValue({ type: argument.type, defaultValue: argument.default })}`
+const mapArgument = ({ graphqlArgument, idToNameMap = {} }) => {
+	const argumentName = `${graphqlArgument.name}:`;
+	const argumentType = getArgumentType({ graphqlArgument, idToNameMap });
+	const directivesStatement = getDirectivesUsageStatement({ directives: graphqlArgument.directives });
+	const defaultValue = graphqlArgument.default
+		? `= ${getArgumentDefaultValue({ type: graphqlArgument.type, defaultValue: graphqlArgument.default })}`
 		: '';
 
 	const statement = joinInlineStatements({
@@ -40,7 +53,7 @@ const mapArgument = ({ argument, idToNameMap = {} }) => {
 
 	return {
 		statement,
-		description: argument.description,
+		description: graphqlArgument.description || '',
 	};
 };
 
@@ -58,7 +71,11 @@ const getArguments = ({ graphqlArguments, idToNameMap = {} }) => {
 	const hasDescription = graphqlArguments.some(argument => argument.description);
 	const argumentStatements = graphqlArguments
 		.filter(argument => argument.name && argument.type)
-		.map(argument => mapArgument({ argument, idToNameMap }));
+		.map(graphqlArgument => mapArgument({ graphqlArgument, idToNameMap }));
+
+	if (argumentStatements.length === 0) {
+		return '';
+	}
 
 	if (!hasDescription) {
 		// For current state of code if arguments don't have any description we return them as a single line

forward_engineering/mappers/fields.js

@@ -7,6 +7,7 @@ const { getDefinitionNameFromReferencePath } = require('../helpers/referencesHel
 const { getArguments } = require('./arguments');
 const { getDirectivesUsageStatement } = require('./directiveUsageStatements');
 const { getFieldDefaultValueStatement } = require('./fieldDefaultValue');
+const { addRequired } = require('../helpers/addRequiredHelper');
 
 /**
  * @typedef {Object.<string, FieldData>} FieldsData
@@ -75,18 +76,18 @@ function mapField({ name, fieldData, required, definitionsIdToNameMap, addArgume
 function getFieldType({ field, required }) {
 	if (field.$ref) {
 		const definitionName = getDefinitionNameFromReferencePath({ referencePath: field.$ref });
-		return addRequiredField({ field: definitionName, required });
+		return addRequired({ type: definitionName, required });
 	}
 
 	if (field.type === 'List') {
 		const arrayItem = getFieldFromArrayItems({ items: field.items });
-		return addRequiredField({
-			field: `[${getFieldType({ field: arrayItem, required: arrayItem.required })}]`,
+		return addRequired({
+			type: `[${getFieldType({ field: arrayItem, required: arrayItem.required })}]`,
 			required,
 		});
 	}
 
-	return addRequiredField({ field: field.type, required });
+	return addRequired({ type: field.type, required });
 }
 
 /**
@@ -103,21 +104,6 @@ function getFieldFromArrayItems({ items }) {
 	return items;
 }
 
-/**
- * Adds required field indicator.
- *
- * @param {Object} param0
- * @param {string} param0.field - The field type statement.
- * @param {boolean} param0.required - Indicates if the field is required.
- * @returns {string} - The field with required indicator.
- */
-function addRequiredField({ field, required }) {
-	if (required) {
-		return `${field}!`;
-	}
-	return field;
-}
-
 module.exports = {
 	getObjectTypeFields: params => getFields({ ...params, addArguments: true, addDefaultValue: false }),
 	getInterfaceTypeFields: params => getFields({ ...params, addArguments: true, addDefaultValue: false }),

forward_engineering/types/types.d.ts

@@ -49,7 +49,10 @@ export type ArrayItem = FieldData & {
 };
 
 // Field arguments
-type ArgumentRequirements = '<Type>' | '<Type>!' | '[<Type>]' | '[<Type>]!' | '[<Type>!]' | '[<Type>!]!';
+type ArgumentListItem = {
+	type?: string;
+	required?: boolean;
+}
 
 export type Argument = {
 	id: string;
@@ -58,7 +61,8 @@ export type Argument = {
 	default?: string;
 	description?: string;
 	directives?: DirectivePropertyData[];
-	required?: ArgumentRequirements;
+	required?: boolean;
+	listItems?: ArgumentListItem[];
 };
 
 // Directives
@@ -175,4 +179,4 @@ export type ValidationResponseItem = {
 	context?: string; // The context of the entity, typically additional information.
 }
 
-export type ValidateScriptCallback = (error: Error | null, validationErrors?: ValidationResponseItem[]) => void;
+export type ValidateScriptCallback = (error: Error | null, validationErrors?: ValidationResponseItem[]) => void;