External definitions

Author: pdesmarets

forward_engineering/helpers/componentsHelpers/parametersHelper.js

@@ -32,7 +32,7 @@ function mapParameter(data, required) {
 		name: data.parameterName,
 		in: getIn(data.type),
 		description: data.description,
-		required: (required || data.required) || undefined,
+		required: !!(required || data.required) || undefined,
 		deprecated: data.deprecated,
 		allowEmptyValue: data.allowEmptyValue,
 		style: data.style,

forward_engineering/helpers/typeHelper.js

@@ -71,10 +71,44 @@ function getTypeProps(data, key) {
 function getRef({ $ref: ref }) {
 	if (ref.startsWith('#')) {
 		ref = ref.replace('#model/definitions', '#/components');
+
+		return { $ref: prepareReferenceName(ref) };
 	}
 
-	return { $ref: prepareReferenceName(ref) };
-}
+	const [ pathToFile, relativePath] = ref.split('#/');
+	if (!relativePath) {
+		return { $ref: prepareReferenceName(ref) };
+	}
+
+	let path = relativePath.split('/');
+	if (path[0] === 'definitions') {
+		if (path[2] === 'schemas') {
+			return { $ref: `${pathToFile}#/components/schemas/${path.slice(4).join('/')}` };
+		}
+
+		path = ['', ...path];
+	}
+
+	const schemaIndex = path.indexOf('schema');
+	const schemaPath = schemaIndex === -1 ? [] : path.slice(schemaIndex);
+	const pathWithoutProperties = path.slice(0, schemaIndex).filter(item => item !== 'properties');
+	const bucketWithRequest = (path[1] === 'definitions') ? path[1] : pathWithoutProperties.slice(0,2);
+
+	if (pathWithoutProperties[3] !== 'response') {
+		if (pathWithoutProperties[2] !== 'requestBody') {
+			return { $ref: `${pathToFile}#/paths/${[ ...pathWithoutProperties, ...schemaPath].join('/')}` };
+		}
+
+		return { $ref: `${pathToFile}#/paths/${[ ...bucketWithRequest, 'requestBody', 'content', ...pathWithoutProperties.slice(3), ...schemaPath].join('/')}` };
+	}
+
+	const response = pathWithoutProperties[2];
+	const pathToItem = pathWithoutProperties.slice(4)
+
+	const pathWithResponses = [ ...bucketWithRequest, 'responses', response, ...pathToItem, ...schemaPath ];
+
+	return { $ref: `${pathToFile}#/paths/${pathWithResponses.join('/')}` };
+};
 
 function hasRef(data = {}) {
 	return data.$ref ? true : false;

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "OpenAPI",
-	"version": "0.1.11",
-	"versionDate": "2019-12-26",
+	"version": "0.1.12",
+	"versionDate": "2020-01-03",
 	"author": "hackolade",
 	"engines": {
 		"hackolade": "3.3.0",
@@ -71,7 +71,8 @@
 			"disableRelationships": true,
 			"disableJsonPreview": false,
 			"enableErdToggle": true,
-			"enableStackedNestedCollections": true
+			"enableStackedNestedCollections": true,
+			"externalDefinitionsFromTargetSchema": true
 		}
 	},
 	"description": "Hackolade plugin for OpenAPI",

reverse_engineering/api.js

@@ -4,6 +4,7 @@ const commonHelper = require('./helpers/commonHelper');
 const dataHelper = require('./helpers/dataHelper');
 const errorHelper = require('./helpers/errorHelper');
 const adaptJsonSchema = require('./helpers/adaptJsonSchema/adaptJsonSchema');
+const resolveExternalDefinitionPathHelper = require('./helpers/resolveExternalDefinitionPathHelper');
 const validationHelper = require('../forward_engineering/helpers/validationHelper');
 
 module.exports = {
@@ -61,7 +62,11 @@ module.exports = {
         } catch(e) {
             callback(commonHelper.handleErrorObject(e, 'Adapt JSON Schema'), data);
         }
-    }
+    },
+
+	resolveExternalDefinitionPath(data, logger, callback) {
+		resolveExternalDefinitionPathHelper.resolvePath(data, callback);
+	}
 };
 
 const convertOpenAPISchemaToHackolade = (openAPISchema, fieldOrder) => {
@@ -74,7 +79,7 @@ const convertOpenAPISchemaToHackolade = (openAPISchema, fieldOrder) => {
 };
 
 const getOpenAPISchema = (data, filePath) => new Promise((resolve, reject) => {
-    const { extension, fileName } = commonHelper.getPathData(filePath);
+    const { extension, fileName } = commonHelper.getPathData(data, filePath);
 
     try {
         const openAPISchemaWithModelName = dataHelper.getOpenAPIJsonSchema(data, fileName, extension);

reverse_engineering/helpers/commonHelper.js

@@ -6,6 +6,7 @@ const yaml = require('js-yaml');
 const errorHelper = require('./errorHelper');
 
 const CHOICES = ['allOf', 'oneOf', 'anyOf', 'not'];
+const ALLOWED_EXTENSIONS = ['.json', '.yaml'];
 
 const getFileData = (filePath) => new Promise((resolve, reject) => {
     fs.readFile(filePath, 'utf-8', (error, content) => {
@@ -17,10 +18,43 @@ const getFileData = (filePath) => new Promise((resolve, reject) => {
     });
 });
 
-const getPathData = (filePath) => {
+const isJson = data => {
+	try {
+		JSON.parse(data);
+
+		return true;
+	} catch (err) {
+		return false;
+	}
+};
+
+const isYaml = data => {
+	try {
+		yaml.load(data);
+
+		return true;
+	} catch (err) {
+		return false;
+	}
+};
+
+const getPathData = (data, filePath) => {
     const extension = path.extname(filePath);
     const fileName = path.basename(filePath, extension);
-    return {extension, fileName };
+
+	if (ALLOWED_EXTENSIONS.includes(extension)) {
+		return { extension, fileName };
+	}
+
+	if (isJson(data)) {
+		return { extension: '.json', fileName };
+	}
+
+	if (isYaml(data)) {
+		return { extension: '.yaml', fileName };
+	}
+
+	return { extension, fileName };
 };
 
 const handleErrorObject = (error, title) => {

reverse_engineering/helpers/resolveExternalDefinitionPathHelper.js

@@ -0,0 +1,30 @@
+const resolvePath = (data, callback) => {
+	let path = (data.path || '').split('/');
+	if (!path[0]) {
+		path = path.slice(1);
+	}
+	if (!path[0]) {
+		return callback({
+			title: 'Resolve external definition path error',
+			message: 'External definition path is not valid'
+		}, data.path || '');
+	}
+	if (path[0] === 'components' || path[0] === 'definitions') {
+		return callback(null, 'definitions' + addPropertiesToPath(path.slice(1)));
+	}
+
+	const bucket = path[1];
+	const request = path[2];
+
+	if (path[3] === 'responses') {
+		return callback(null, `${bucket}/${request}/${path[4]}${addPropertiesToPath(['response', ...path.slice(5)])}`);
+	}
+
+	return callback(null, `${bucket}/${request}${addPropertiesToPath(path.slice(3))}`);
+};
+
+const addPropertiesToPath = path => path.length ? '/properties/' + path.join('/properties/') : '';
+
+module.exports = {
+	resolvePath
+};