HCK-9559: add enums FE (#37)

* add enums FE

* rename const

Author: taras-dubyk

forward_engineering/constants/feScriptConstants.js

@@ -0,0 +1,5 @@
+const GRAPHQL_SCHEMA_SCRIPT_INDENT = '  ';
+
+module.exports = {
+	GRAPHQL_SCHEMA_SCRIPT_INDENT,
+};

forward_engineering/helpers/descriptionsHelper.js

@@ -11,10 +11,12 @@ function getStatementDescription({ description }) {
 		return '';
 	}
 
-	const isMultiLine = description.includes('\n');
+	const trimmedDescription = description.trim();
+	const escapedDescription = trimmedDescription.replace(/"/g, '\\"');
+	const isMultiLine = escapedDescription.includes('\n');
 
 	// Format the description based on whether it is multi-line or single-line
-	const formattedDescription = isMultiLine ? `"""\n${description}\n"""` : `"${description}"`;
+	const formattedDescription = isMultiLine ? `"""\n${escapedDescription}\n"""` : `"${escapedDescription}"`;
 
 	return formattedDescription;
 }

forward_engineering/helpers/feStatementFormatHelper.js

@@ -0,0 +1,57 @@
+const { commentOutDeactivatedRootFEStatement } = require('./deactivatedItemsHelper');
+const { getStatementDescription } = require('./descriptionsHelper');
+const { addIndentToStatement } = require('./feStatementIndentHelper');
+
+/**
+ * @typedef { import("../types/types").FEStatement } FEStatement
+ */
+
+/**
+ * Combines the description and statement, and comments out the statement if it is deactivated.
+ * Adds formatted nested statements if they exist.
+ *
+ * @param {Object} param0
+ * @param {FEStatement} param0.feStatement - The forward engineering statement object.
+ * @returns {string} - The final formatted statement.
+ */
+function formatFEStatement({ feStatement }) {
+	const {
+		statement,
+		description,
+		isActivated = true,
+		nestedStatements,
+		useCurlyBracketsForNestedStatements = true,
+	} = feStatement;
+	let result = '';
+
+	if (description?.trim()) {
+		const formattedDescription = getStatementDescription({ description });
+		result += `${formattedDescription}\n`;
+	}
+
+	result += statement;
+
+	if (nestedStatements?.length > 0) {
+		const formattedNestedStatements = nestedStatements
+			.map(nestedStatement =>
+				addIndentToStatement({ statement: formatFEStatement({ feStatement: nestedStatement }) }),
+			)
+			.join('\n');
+
+		if (useCurlyBracketsForNestedStatements) {
+			result += ` {\n${formattedNestedStatements}\n}`;
+		} else {
+			result += `\n${formattedNestedStatements}`;
+		}
+	}
+
+	if (!isActivated) {
+		result = commentOutDeactivatedRootFEStatement({ statement: result, isActivated });
+	}
+
+	return result;
+}
+
+module.exports = {
+	formatFEStatement,
+};

forward_engineering/helpers/feStatementHelper.js

@@ -0,0 +1,20 @@
+const { GRAPHQL_SCHEMA_SCRIPT_INDENT } = require('../constants/feScriptConstants');
+
+/**
+ * Adds indentation to each line of a given statement.
+ *
+ * @param {Object} param0
+ * @param {string} param0.statement - The statement to which indentation will be added.
+ * @param {string} [param0.indent=GRAPHQL_SCHEMA_SCRIPT_INDENT] - The indentation string to use. Defaults to GRAPHQL_INDENT.
+ * @returns {string} - The indented statement.
+ */
+function addIndentToStatement({ statement, indent = GRAPHQL_SCHEMA_SCRIPT_INDENT }) {
+	return statement
+		.split('\n')
+		.map(line => `${indent}${line}`)
+		.join('\n');
+}
+
+module.exports = {
+	addIndentToStatement,
+};

forward_engineering/helpers/feStatementIndentHelper.js

@@ -0,0 +1,18 @@
+/**
+ * Joins an array of statements into a single line.
+ * Trims each statement, filters out empty statements, and joins them with a space.
+ *
+ * @param {Object} param0
+ * @param {string[]} param0.statements - The array of statements to join.
+ * @returns {string} - The joined statements as a single line.
+ */
+function joinInlineStatements({ statements }) {
+	return statements
+		.map(statement => statement.trim())
+		.filter(statement => typeof statement === 'string' && statement.length > 0)
+		.join(' ');
+}
+
+module.exports = {
+	joinInlineStatements,
+};

forward_engineering/helpers/feStatementJoinHelper.js

@@ -0,0 +1,70 @@
+/**
+ * @typedef { import("../types/types").FEStatement } FEStatement
+ */
+
+const { joinInlineStatements } = require('../helpers/feStatementJoinHelper');
+
+/**
+ * @typedef {Object} EnumValue
+ * @property {string} value - The name of the enum value.
+ * @property {string} description - The description of the enum value.
+ * @property {Object} valueDirectives - The directives of the enum value.
+ */
+
+/**
+ * @typedef {Object} EnumDefinition
+ * @property {string} description - The description of the enum.
+ * @property {boolean} isActivated - Indicates if the enum is activated.
+ * @property {Object} typeDirectives - The directives of the enum.
+ * @property {EnumValue[]} enumValues - The values of the emu,.
+ */
+
+/**
+ * @typedef {Object.<string, EnumDefinition>} EnumDefinitions
+ */
+
+/**
+ * Gets the enums as an array of FEStatements.
+ *
+ * @param {Object} param0
+ * @param {EnumDefinitions} param0.enumsDefinitions - The enums object.
+ * @returns {FEStatement[]}
+ */
+function getEnums({ enumsDefinitions }) {
+	return Object.entries(enumsDefinitions).map(([name, enumDefinition]) => mapEnum({ name, enumDefinition }));
+}
+
+/**
+ * Maps a enum to an FEStatement.
+ *
+ * @param {Object} param0
+ * @param {string} param0.name - The name of the enum.
+ * @param {EnumDefinition} param0.enumDefinition - The enum definition object.
+ * @returns {FEStatement}
+ */
+function mapEnum({ name, enumDefinition }) {
+	return {
+		statement: joinInlineStatements({ statements: [`enum ${name}`] }), // TODO: add directives
+		description: enumDefinition.description,
+		isActivated: enumDefinition.isActivated,
+		nestedStatements: mapEnumValues({ enumValues: enumDefinition.enumValues }),
+	};
+}
+
+/**
+ * Maps the enum values to an array of FEStatement.
+ *
+ * @param {Object} param0
+ * @param {EnumValue[]} param0.enumValues - The enum values.
+ * @returns {FEStatement[]}
+ */
+function mapEnumValues({ enumValues = [] }) {
+	return enumValues.map(({ value, description }) => ({
+		statement: joinInlineStatements({ statements: [value] }), // TODO: add directives
+		description: description,
+	}));
+}
+
+module.exports = {
+	getEnums,
+};

forward_engineering/mappers/enums.js

@@ -1,5 +1,6 @@
-const { formatFEStatement } = require('../helpers/feStatementHelper');
+const { formatFEStatement } = require('../helpers/feStatementFormatHelper');
 const { getCustomScalars } = require('./customScalars');
+const { getEnums } = require('./enums');
 
 /**
  * Gets the type definition statements from model definitions.
@@ -12,8 +13,9 @@ function getTypeDefinitionStatements({ modelDefinitions }) {
 	const customScalars = getCustomScalars({
 		customScalars: getModelDefinitionsBySubtype({ modelDefinitions, subtype: 'scalar' }),
 	});
+	const enums = getEnums({ enumsDefinitions: getModelDefinitionsBySubtype({ modelDefinitions, subtype: 'enum' }) });
 
-	const typeDefinitions = [...customScalars]; // TODO: Add other types here
+	const typeDefinitions = [...customScalars, ...enums];
 	const formattedTypeDefinitions = typeDefinitions
 		.map(typeDefinition => formatFEStatement({ feStatement: typeDefinition }))
 		.join('\n\n');

forward_engineering/mappers/typeDefinitions.js

@@ -1,5 +1,7 @@
 export type FEStatement = {
 	statement: string;
 	description: string;
-	isActivated: boolean;
+	isActivated?: boolean;
+	nestedStatements?: FEStatement[];
+	useCurlyBracketsForNestedStatements?: boolean;
 }