HCK-10331: add custom scalars RE

reverse_engineering/mappers/directiveName.js

@@ -0,0 +1,12 @@
+/**
+ * @param {Object} params
+ * @param {String} params.name
+ * @returns {string} The directive name with "@" prefix
+ */
+function getDirectiveName({ name }) {
+	return `@${name}`;
+}
+
+module.exports = {
+	getDirectiveName,
+};

reverse_engineering/mappers/directiveUsage.js

@@ -1,5 +1,6 @@
 const { astNodeKind } = require('../constants/graphqlAST');
 const { DIRECTIVE_FORMAT, ARGUMENT_VALUE_FORMAT } = require('../constants/properties');
+const { getDirectiveName } = require('./directiveName');
 
 /**
  * @import { DirectiveNode, ArgumentNode, ValueNode } from "graphql"
@@ -16,7 +17,7 @@ function mapDirectivesUsage({ directives = [] }) {
 	return directives.map(directive => {
 		return {
 			directiveFormat: DIRECTIVE_FORMAT.structured,
-			directiveName: directive.name.value,
+			directiveName: getDirectiveName({ name: directive.name.value }),
 			argumentValueFormat: ARGUMENT_VALUE_FORMAT.raw,
 			rawArgumentValues: getRawArguments({ argumentNodes: directive.arguments }),
 		};
@@ -39,7 +40,7 @@ function getRawArguments({ argumentNodes = [] }) {
  * @returns {string} The string representation of the value
  */
 function getArgumentValue(value) {
-	switch (value.astNodeKind) {
+	switch (value.kind) {
 		case astNodeKind.INT:
 		case astNodeKind.FLOAT:
 			return value.value;

reverse_engineering/mappers/typeDefinitions/customScalar.js

@@ -0,0 +1,35 @@
+/**
+ * @import { ScalarTypeDefinitionNode } from "graphql"
+ * @import { CustomScalarDefinition } from "../../types/types"
+ */
+
+const { mapDirectivesUsage } = require('../directiveUsage');
+
+/**
+ * Maps the custom scalar type definitions
+ * @param {Object} params
+ * @param {ScalarTypeDefinitionNode[]} params.customScalars - The custom scalars
+ * @returns {CustomScalarDefinition[]} The mapped custom scalar type definitions
+ */
+function getCustomScalarTypeDefinitions({ customScalars = [] }) {
+	return customScalars.map(scalar => mapCustomScalar({ scalar }));
+}
+
+/**
+ * Maps a single custom scalar definition
+ * @param {Object} params
+ * @param {ScalarTypeDefinitionNode} params.scalar - The scalar to map
+ * @returns {CustomScalarDefinition} The mapped custom scalar definition
+ */
+function mapCustomScalar({ scalar }) {
+	return {
+		type: 'scalar',
+		name: scalar.name.value,
+		description: scalar.description?.value || '',
+		typeDirectives: mapDirectivesUsage({ directives: scalar.directives }),
+	};
+}
+
+module.exports = {
+	getCustomScalarTypeDefinitions,
+};

reverse_engineering/mappers/typeDefinitions/directive.js

@@ -3,6 +3,8 @@
  * @import { DirectiveDefinition } from "../../types/types"
  */
 
+const { getDirectiveName } = require('../directiveName');
+
 const locationMap = {
 	'SCHEMA': 'schema',
 	'QUERY': 'query',
@@ -48,7 +50,7 @@ function mapDirective({ directive }) {
 
 	return {
 		type: 'directive',
-		name: directive.name.value,
+		name: getDirectiveName({ name: directive.name.value }),
 		description: directive.description?.value || '',
 		arguments: [], // TODO: implement argument mapping
 		directiveLocations: locations,

reverse_engineering/mappers/typeDefinitions/typeDefinitions.js

@@ -1,10 +1,11 @@
 const { astNodeKind } = require('../../constants/graphqlAST');
 const { findNodesByKind } = require('../../helpers/findNodesByKind');
 const { sortByName } = require('../../helpers/sortByName');
+const { getCustomScalarTypeDefinitions } = require('./customScalar');
 const { getDirectiveTypeDefinitions } = require('./directive');
 
 /**
- * @import { DirectiveDefinition, FieldsOrder } from "../../types/types"
+ * @import { FieldsOrder, DirectiveDefinition, CustomScalarDefinition } from "../../types/types"
  */
 
 /**
@@ -18,8 +19,11 @@ function getTypeDefinitions({ typeDefinitions, fieldsOrder }) {
 	const directives = getDirectiveTypeDefinitions({
 		directives: findNodesByKind({ nodes: typeDefinitions, kind: astNodeKind.DIRECTIVE_DEFINITION }),
 	});
+	const customScalars = getCustomScalarTypeDefinitions({
+		customScalars: findNodesByKind({ nodes: typeDefinitions, kind: astNodeKind.SCALAR_TYPE_DEFINITION }),
+	});
 
-	const definitions = getTypeDefinitionsStructure({ fieldsOrder, directives });
+	const definitions = getTypeDefinitionsStructure({ fieldsOrder, directives, customScalars });
 
 	return definitions;
 }
@@ -29,15 +33,21 @@ function getTypeDefinitions({ typeDefinitions, fieldsOrder }) {
  * @param {Object} params
  * @param {FieldsOrder} params.fieldsOrder - The fields order
  * @param {DirectiveDefinition[]} params.directives - The directive definitions
+ * @param {CustomScalarDefinition[]} params.customScalars - The custom scalar definitions
  * @returns {Object} The type definitions structure
  */
-function getTypeDefinitionsStructure({ fieldsOrder, directives }) {
+function getTypeDefinitionsStructure({ fieldsOrder, directives, customScalars }) {
 	const definitions = {
 		['Directives']: getDefinitionCategoryStructure({
 			fieldsOrder,
 			subtype: 'directive',
 			properties: directives,
 		}),
+		['Scalars']: getDefinitionCategoryStructure({
+			fieldsOrder,
+			subtype: 'scalar',
+			properties: customScalars,
+		}),
 	};
 
 	return {

reverse_engineering/types/types.d.ts

@@ -138,5 +138,12 @@ export type DirectiveDefinition = {
     directiveLocations: DirectiveLocations;
 }
 
+export type CustomScalarDefinition = {
+	type: 'scalar';
+    name: string;
+    description?: string;
+    typeDirectives?: DirectiveUsage[];
+}
+
 export type TestConnectionCallback = (err: Error | null) => void;
 export type DisconnectCallback = TestConnectionCallback;

test/reverse_engineering/mappers/directiveUsage.spec.js

@@ -18,7 +18,7 @@ describe('mapDirectivesUsage', () => {
 		const expected = [
 			{
 				directiveFormat: 'Structured',
-				directiveName: 'deprecated',
+				directiveName: '@deprecated',
 				argumentValueFormat: 'Raw',
 				rawArgumentValues: '',
 			},
@@ -34,23 +34,23 @@ describe('mapDirectivesUsage', () => {
 			arguments: [
 				{
 					name: { value: 'intArg' },
-					value: { astNodeKind: astNodeKind.INT, value: '42' },
+					value: { kind: astNodeKind.INT, value: '42' },
 				},
 				{
 					name: { value: 'stringArg' },
-					value: { astNodeKind: astNodeKind.STRING, value: 'hello' },
+					value: { kind: astNodeKind.STRING, value: 'hello' },
 				},
 				{
 					name: { value: 'boolArg' },
-					value: { astNodeKind: astNodeKind.BOOLEAN, value: true },
+					value: { kind: astNodeKind.BOOLEAN, value: true },
 				},
 			],
 		};
 
 		const expected = [
 			{
 				directiveFormat: 'Structured',
-				directiveName: 'test',
+				directiveName: '@test',
 				argumentValueFormat: 'Raw',
 				rawArgumentValues: 'intArg: 42, stringArg: "hello", boolArg: true',
 			},
@@ -67,21 +67,21 @@ describe('mapDirectivesUsage', () => {
 				{
 					name: { value: 'listArg' },
 					value: {
-						astNodeKind: astNodeKind.LIST,
+						kind: astNodeKind.LIST,
 						values: [
-							{ astNodeKind: astNodeKind.INT, value: '1' },
-							{ astNodeKind: astNodeKind.INT, value: '2' },
+							{ kind: astNodeKind.INT, value: '1' },
+							{ kind: astNodeKind.INT, value: '2' },
 						],
 					},
 				},
 				{
 					name: { value: 'objectArg' },
 					value: {
-						astNodeKind: astNodeKind.OBJECT,
+						kind: astNodeKind.OBJECT,
 						fields: [
 							{
 								name: { value: 'field1' },
-								value: { astNodeKind: astNodeKind.STRING, value: 'value1' },
+								value: { kind: astNodeKind.STRING, value: 'value1' },
 							},
 						],
 					},
@@ -92,7 +92,7 @@ describe('mapDirectivesUsage', () => {
 		const expected = [
 			{
 				directiveFormat: 'Structured',
-				directiveName: 'complex',
+				directiveName: '@complex',
 				argumentValueFormat: 'Raw',
 				rawArgumentValues: 'listArg: [1, 2], objectArg: {field1: "value1"}',
 			},
@@ -108,19 +108,19 @@ describe('mapDirectivesUsage', () => {
 			arguments: [
 				{
 					name: { value: 'varArg' },
-					value: { astNodeKind: astNodeKind.VARIABLE, name: { value: 'var' } },
+					value: { kind: astNodeKind.VARIABLE, name: { value: 'var' } },
 				},
 				{
 					name: { value: 'enumArg' },
-					value: { astNodeKind: astNodeKind.ENUM, value: 'ENUM_VALUE' },
+					value: { kind: astNodeKind.ENUM, value: 'ENUM_VALUE' },
 				},
 			],
 		};
 
 		const expected = [
 			{
 				directiveFormat: 'Structured',
-				directiveName: 'test',
+				directiveName: '@test',
 				argumentValueFormat: 'Raw',
 				rawArgumentValues: 'varArg: $var, enumArg: ENUM_VALUE',
 			},