HCK-10334: add RE of interfaces

reverse_engineering/mappers/implementsInterfaces.js

@@ -0,0 +1,23 @@
+/**
+ * @import {NamedTypeNode} from "graphql"
+ * @import {REImplementsInterface} from "../../shared/types/types"
+ */
+
+/**
+ * Maps the implements interfaces
+ *
+ * @param {object} params
+ * @param {NamedTypeNode[]} [params.implementsInterfaces] - The implements interfaces
+ * @returns {REImplementsInterface[]} The mapped implements interfaces
+ */
+function mapImplementsInterfaces({ implementsInterfaces = [] }) {
+	return implementsInterfaces.map(interfaceData => {
+		return {
+			interface: interfaceData.name.value,
+		};
+	});
+}
+
+module.exports = {
+	mapImplementsInterfaces,
+};

reverse_engineering/mappers/typeDefinitions/interface.js

@@ -0,0 +1,59 @@
+/**
+ * @import {InterfaceTypeDefinitionNode} from "graphql"
+ * @import {DefinitionNameToTypeNameMap, FieldsOrder, REInterfaceDefinition, REPropertiesSchema} from "../../../shared/types/types"
+ */
+
+const { sortByName } = require('../../helpers/sortByName');
+const { mapDirectivesUsage } = require('../directiveUsage');
+const { mapField } = require('../field');
+const { mapImplementsInterfaces } = require('../implementsInterfaces');
+
+/**
+ * Maps interface type definitions
+ *
+ * @param {object} params
+ * @param {InterfaceTypeDefinitionNode[]} params.interfaces - The interface types
+ * @param {DefinitionNameToTypeNameMap} params.definitionCategoryByNameMap - The definition category by name map
+ * @param {FieldsOrder} params.fieldsOrder - The fields order
+ * @returns {REInterfaceDefinition[]} The mapped interface definitions
+ */
+function getInterfaceDefinitions({ interfaces = [], definitionCategoryByNameMap, fieldsOrder }) {
+	return interfaces.map(interfaceType => mapInterface({ interfaceType, definitionCategoryByNameMap, fieldsOrder }));
+}
+
+/**
+ * Maps a single interface type definition
+ *
+ * @param {object} params
+ * @param {InterfaceTypeDefinitionNode} params.interfaceType - The interface to map
+ * @param {DefinitionNameToTypeNameMap} params.definitionCategoryByNameMap - The definition category by name map
+ * @param {FieldsOrder} params.fieldsOrder - The fields order
+ * @returns {REInterfaceDefinition} The mapped interface type definition
+ */
+function mapInterface({ interfaceType, definitionCategoryByNameMap, fieldsOrder }) {
+	const properties = interfaceType.fields
+		? interfaceType.fields.map(field => mapField({ field, definitionCategoryByNameMap }))
+		: [];
+	const required = properties.filter(property => property.required).map(property => property.name);
+	const convertedProperties = sortByName({ items: properties, fieldsOrder }).reduce(
+		(acc, property) => {
+			acc[property.name] = property;
+			return acc;
+		},
+		/** @type {REPropertiesSchema} */ {},
+	);
+
+	return {
+		type: 'interface',
+		name: interfaceType.name.value,
+		properties: convertedProperties,
+		required,
+		description: interfaceType.description?.value || '',
+		typeDirectives: mapDirectivesUsage({ directives: [...(interfaceType.directives || [])] }),
+		implementsInterfaces: mapImplementsInterfaces({ implementsInterfaces: [...(interfaceType.interfaces || [])] }),
+	};
+}
+
+module.exports = {
+	getInterfaceDefinitions,
+};

reverse_engineering/mappers/typeDefinitions/objectType.js

@@ -6,6 +6,7 @@
 const { sortByName } = require('../../helpers/sortByName');
 const { mapDirectivesUsage } = require('../directiveUsage');
 const { mapField } = require('../field');
+const { mapImplementsInterfaces } = require('../implementsInterfaces');
 
 /**
  * Maps object type definitions
@@ -49,7 +50,7 @@ function mapObjectType({ objectType, definitionCategoryByNameMap, fieldsOrder })
 		required,
 		description: objectType.description?.value || '',
 		typeDirectives: mapDirectivesUsage({ directives: [...(objectType.directives || [])] }),
-		// TODO: add interfaces
+		implementsInterfaces: mapImplementsInterfaces({ implementsInterfaces: [...(objectType.interfaces || [])] }),
 	};
 }
 

reverse_engineering/mappers/typeDefinitions/typeDefinitions.js

@@ -12,7 +12,9 @@
  * 		EnumStructureType,
  * 		ObjectStructureType,
  * 		ScalarStructureType,
- * REObjectTypeDefinition} from "../../../shared/types/types"
+ * REObjectTypeDefinition,
+ * InterfaceStructureType,
+ * REInterfaceDefinition} from "../../../shared/types/types"
  */
 
 const { astNodeKind } = require('../../constants/graphqlAST');
@@ -23,6 +25,7 @@ const { getCustomScalarTypeDefinitions } = require('./customScalar');
 const { getDirectiveTypeDefinitions } = require('./directive');
 const { getObjectTypeDefinitions } = require('./objectType');
 const { getEnumTypeDefinitions } = require('./enum');
+const { getInterfaceDefinitions } = require('./interface');
 
 /**
  * Gets the type definitions structure
@@ -56,7 +59,20 @@ function getTypeDefinitions({ typeDefinitions, fieldsOrder, rootTypeNames }) {
 		fieldsOrder,
 	});
 
-	const definitions = getTypeDefinitionsStructure({ fieldsOrder, directives, customScalars, enums, objectTypes });
+	const interfaces = getInterfaceDefinitions({
+		interfaces: findNodesByKind({ nodes: typeDefinitions, kind: astNodeKind.INTERFACE_TYPE_DEFINITION }),
+		definitionCategoryByNameMap,
+		fieldsOrder,
+	});
+
+	const definitions = getTypeDefinitionsStructure({
+		fieldsOrder,
+		directives,
+		customScalars,
+		enums,
+		objectTypes,
+		interfaces,
+	});
 
 	return definitions;
 }
@@ -70,9 +86,10 @@ function getTypeDefinitions({ typeDefinitions, fieldsOrder, rootTypeNames }) {
  * @param {RECustomScalarDefinition[]} params.customScalars - The custom scalar definitions
  * @param {REEnumDefinition[]} params.enums - The enum definitions
  * @param {REObjectTypeDefinition[]} params.objectTypes - The object type definitions
+ * @param {REInterfaceDefinition[]} params.interfaces - The interface definitions
  * @returns {REModelDefinitionsSchema} The type definitions structure
  */
-function getTypeDefinitionsStructure({ fieldsOrder, directives, customScalars, enums, objectTypes }) {
+function getTypeDefinitionsStructure({ fieldsOrder, directives, customScalars, enums, objectTypes, interfaces }) {
 	const definitions = {
 		['Directives']: /** @type {DirectiveStructureType} */ (
 			getDefinitionCategoryStructure({
@@ -102,6 +119,13 @@ function getTypeDefinitionsStructure({ fieldsOrder, directives, customScalars, e
 				properties: enums,
 			})
 		),
+		['Interfaces']: /** @type {InterfaceStructureType} */ (
+			getDefinitionCategoryStructure({
+				fieldsOrder,
+				subtype: 'interface',
+				properties: interfaces,
+			})
+		),
 	};
 
 	return {

shared/types/re.d.ts

@@ -124,23 +124,31 @@ export type REDirectiveDefinitionsSchema = Record<string, REDirectiveDefinition>
 export type RECustomScalarDefinitionsSchema = Record<string, RECustomScalarDefinition>;
 export type REObjectDefinitionsSchema = Record<string, REObjectTypeDefinition>;
 export type REEnumDefinitionsSchema = Record<string, REEnumDefinition>;
+export type REInterfaceDefinitionsSchema = Record<string, REInterfaceDefinition>;
 
-export type REDefinition = RECustomScalarDefinition | REDirectiveDefinition | REEnumDefinition | REObjectTypeDefinition;
+export type REDefinition =
+	| RECustomScalarDefinition
+	| REDirectiveDefinition
+	| REEnumDefinition
+	| REObjectTypeDefinition
+	| REInterfaceDefinition;
 
 export type REModelDefinitionsSchema = {
 	definitions: {
 		Directives: DirectiveStructureType;
 		Scalars: ScalarStructureType;
 		Objects: ObjectStructureType;
 		Enums: EnumStructureType;
+		Interfaces: InterfaceStructureType;
 	};
 };
 
 export type DefinitionREStructure =
 	| DirectiveStructureType
 	| ScalarStructureType
 	| EnumStructureType
-	| ObjectStructureType;
+	| ObjectStructureType
+	| InterfaceStructureType;
 
 type StructureType<T> = {
 	type: 'type';
@@ -160,6 +168,10 @@ export type EnumStructureType = StructureType<REEnumDefinitionsSchema> & {
 	subtype: 'enum';
 };
 
+export type InterfaceStructureType = StructureType<REEnumDefinitionsSchema> & {
+	subtype: 'interface';
+};
+
 export type RECustomScalarDefinition = CustomScalarDefinition<StructuredDirective> & {
 	type: 'scalar';
 	name: string;
@@ -188,6 +200,11 @@ export type REObjectTypeDefinition = REObjectLikeDefinition & {
 	name: string;
 };
 
+export type REInterfaceDefinition = REObjectLikeDefinition & {
+	type: 'interface';
+	name: string;
+};
+
 export type PreProcessedFieldData = FieldData<StructuredDirective> &
 	FieldTypeProperties & {
 		name: string;