Rename unidirectional to unilateral

cli/commands.js

@@ -109,8 +109,8 @@ const defaultCommands = {
         desc: 'Skip the user management module during app generation',
       },
       {
-        option: '--unidirectional-relationships',
-        desc: 'Generate unidirectional relationships',
+        option: '--unilateral-relationships',
+        desc: 'Generate unilateral relationships',
       },
     ],
     desc: `Create entities from the JDL file/URL/content passed in argument.

cli/import-jdl.js

@@ -344,7 +344,7 @@ class JDLProcessor {
       databaseType: this.options.db,
       applicationType: this.options.applicationType,
       skipUserManagement: this.options.skipUserManagement,
-      unidirectionalRelationships: this.options.unidirectionalRelationships,
+      unilateralRelationships: this.options.unilateralRelationships,
       generatorVersion: packagejs.version,
       skipFileGeneration: true,
     };

generators/entity/index.js

@@ -534,7 +534,7 @@ class EntityGenerator extends BaseBlueprintGenerator {
           otherEntity.otherRelationships.push(relationship);
 
           if (
-            relationship.unidirectional &&
+            relationship.unilateral &&
             (relationship.relationshipType === 'many-to-many' ||
               // OneToOne is back reference is require due to filtering
               relationship.relationshipType === 'one-to-one' ||

jdl/converters/jdl-to-json/jdl-to-json-relationship-converter.js

@@ -38,7 +38,7 @@ module.exports = {
  * @param {Array<JDLRelationship>} jdlRelationships - the relationships to convert.
  * @param {Array<String>} entityNames - all the entities' names.
  * @param {Object} convertOptions - Convert options.
- * @param {Boolean} [convertOptions.unidirectionalRelationships] - Whether to generate unidirectional relationships
+ * @param {Boolean} [convertOptions.unilateralRelationships] - Whether to generate unilateral relationships
  * @return {Map<String, Array<Object>>} a map having for keys entity names and for values arrays of JSON relationships.
  */
 function convert(jdlRelationships = [], entityNames = [], convertOptions = {}) {
@@ -78,19 +78,19 @@ function getRelatedRelationships(relationships, entityNames) {
 }
 
 function setRelationshipsFromEntity(relatedRelationships, entityName, convertOptions) {
-  const { unidirectionalRelationships } = convertOptions;
+  const { unilateralRelationships } = convertOptions;
   relatedRelationships.from.forEach(relationshipToConvert => {
     const otherSplitField = extractField(relationshipToConvert.injectedFieldInTo);
     const convertedRelationship = {
       relationshipType: _.kebabCase(relationshipToConvert.type),
       otherEntityName: camelCase(relationshipToConvert.to),
     };
-    if (!unidirectionalRelationships || otherSplitField.relationshipName) {
+    if (!unilateralRelationships || otherSplitField.relationshipName) {
       convertedRelationship.otherEntityRelationshipName =
         lowerFirst(otherSplitField.relationshipName) || camelCase(relationshipToConvert.from);
     }
-    if (unidirectionalRelationships) {
-      convertedRelationship.unidirectional = !otherSplitField.relationshipName;
+    if (unilateralRelationships) {
+      convertedRelationship.unilateral = !otherSplitField.relationshipName;
     }
     if (relationshipToConvert.isInjectedFieldInFromRequired) {
       convertedRelationship.relationshipValidateRules = REQUIRED;
@@ -107,7 +107,7 @@ function setRelationshipsFromEntity(relatedRelationships, entityName, convertOpt
       convertedRelationship.ownerSide = true;
     } else if (relationshipToConvert.type === MANY_TO_MANY) {
       if (!relationshipToConvert.injectedFieldInTo) {
-        if (!convertOptions.unidirectionalRelationships && !builtInEntities.has(relationshipToConvert.to.toLowerCase())) {
+        if (!convertOptions.unilateralRelationships && !builtInEntities.has(relationshipToConvert.to.toLowerCase())) {
           convertedRelationship.otherEntityRelationshipName = lowerFirst(relationshipToConvert.from);
           const convertedOtherEntityRelationships = convertedRelationships.get(relationshipToConvert.to);
           const otherSideRelationship = {
@@ -139,7 +139,7 @@ function setRelationshipsToEntity(relatedRelationships, entityName, convertOptio
       relationshipType: _.kebabCase(relationshipType),
       otherEntityName: camelCase(relationshipToConvert.from),
     };
-    if (!convertOptions.unidirectionalRelationships || otherSplitField.relationshipName) {
+    if (!convertOptions.unilateralRelationships || otherSplitField.relationshipName) {
       convertedRelationship.otherEntityRelationshipName =
         lowerFirst(otherSplitField.relationshipName) || camelCase(relationshipToConvert.to);
     }

jdl/converters/jdl-to-json/jdl-with-applications-to-json-converter.js

@@ -38,7 +38,7 @@ module.exports = {
  * Converts a JDLObject to ready-to-be exported JSON entities.
  * @param {Object} args - the configuration object, keys:
  * @param {JDLObject} args.jdlObject - the JDLObject to convert to JSON
- * @param {Boolean} [args.unidirectionalRelationships] - Whether to generate unidirectional relationships
+ * @param {Boolean} [args.unilateralRelationships] - Whether to generate unilateral relationships
  * @returns {Map} entities that can be exported to JSON
  */
 function convert(args = {}) {
@@ -51,10 +51,10 @@ function convert(args = {}) {
     const applicationNames = jdlObject.getApplications().map(jdlApplication => jdlApplication.getConfigurationOptionValue('baseName'));
     return new Map(applicationNames.map(applicationName => [applicationName, []]));
   }
-  const { unidirectionalRelationships } = args;
+  const { unilateralRelationships } = args;
   setBasicEntityInformation();
   setFields();
-  setRelationships({ unidirectionalRelationships });
+  setRelationships({ unilateralRelationships });
   setApplicationToEntities();
   const entitiesForEachApplication = getEntitiesForEachApplicationMap();
   setOptions(entitiesForEachApplication);

jdl/converters/jdl-to-json/jdl-without-application-to-json-converter.js

@@ -40,19 +40,19 @@ module.exports = {
  * @param {String} args.applicationName - the application's name
  * @param {String} args.databaseType - the database type
  * @param {string} args.applicationType - the application's type
- * @param {Boolean} [args.unidirectionalRelationships] - Whether to generate unidirectional relationships
+ * @param {Boolean} [args.unilateralRelationships] - Whether to generate unilateral relationships
  * @returns {Map} entities that can be exported to JSON
  */
 function convert(args = {}) {
   if (!args.jdlObject || !args.applicationName || !args.databaseType) {
     throw new Error("The JDL object, the application's name and its the database type are mandatory.");
   }
   init(args);
-  const { unidirectionalRelationships } = args;
+  const { unilateralRelationships } = args;
   setBasicEntityInformation();
   setOptions();
   setFields();
-  setRelationships({ unidirectionalRelationships });
+  setRelationships({ unilateralRelationships });
   setApplicationToEntities();
   return new Map([[args.applicationName, Object.values(entities)]]);
 }

jdl/converters/parsed-jdl-to-jdl-object/parsed-jdl-to-jdl-object-converter.js

@@ -56,21 +56,21 @@ let applicationsPerEntityName;
  * @param {String} configurationObject.databaseType - The application's database type
  * @param {String} configurationObject.generatorVersion - The generator's version
  * @param {Boolean} configurationObject.skippedUserManagement - Whether user management is skipped
- * @param {Boolean} [configurationObject.unidirectionalRelationships] - Whether to generate unidirectional relationships
+ * @param {Boolean} [configurationObject.unilateralRelationships] - Whether to generate unilateral relationships
  * @return {JDLObject} the built JDL object.
  */
 function parseFromConfigurationObject(configurationObject) {
   parsedContent = configurationObject.parsedContent || configurationObject.document;
   if (!parsedContent) {
     throw new Error('The parsed JDL content must be passed.');
   }
-  const { unidirectionalRelationships } = configurationObject;
+  const { unilateralRelationships } = configurationObject;
   init(configurationObject);
   fillApplications();
   fillDeployments();
   fillEnums();
   fillClassesAndFields();
-  fillAssociations({ unidirectionalRelationships });
+  fillAssociations({ unilateralRelationships });
   fillOptions();
   return jdlObject;
 }
@@ -194,8 +194,8 @@ function getConstantValueFromConstantName(constantName) {
 }
 
 function fillAssociations(conversionOptions = {}) {
-  const { unidirectionalRelationships = configuration.databaseType === DatabaseTypes.NEO4J } = conversionOptions;
-  const jdlRelationships = convertRelationships(parsedContent.relationships, convertAnnotationsToOptions, { unidirectionalRelationships });
+  const { unilateralRelationships = configuration.databaseType === DatabaseTypes.NEO4J } = conversionOptions;
+  const jdlRelationships = convertRelationships(parsedContent.relationships, convertAnnotationsToOptions, { unilateralRelationships });
   jdlRelationships.forEach(jdlRelationship => {
     jdlObject.addRelationship(jdlRelationship, configuration.skippedUserManagement);
   });

jdl/converters/parsed-jdl-to-jdl-object/relationship-converter.js

@@ -29,14 +29,14 @@ module.exports = { convertRelationships };
  * @param {Array<Object>} parsedRelationships - the parsed relationships.
  * @param {Function} annotationToOptionConverter - the function that can convert annotations to options.
  * @param {Object} conversionOptions - conversion options
- * @param {Boolean} conversionOptions.unidirectionalRelationships - whether to generate bidirectional one-to-many.
+ * @param {Boolean} conversionOptions.unilateralRelationships - whether to generate bidirectional one-to-many.
  * @return {Array<JDLRelationship>} the converted JDL relationships.
  */
 function convertRelationships(parsedRelationships, annotationToOptionConverter, conversionOptions = {}) {
   if (!parsedRelationships) {
     throw new Error('Relationships have to be passed so as to be converted.');
   }
-  const { unidirectionalRelationships } = conversionOptions;
+  const { unilateralRelationships } = conversionOptions;
   return parsedRelationships.map(parsedRelationship => {
     const relationshipConfiguration = {
       from: parsedRelationship.from.name,
@@ -53,7 +53,7 @@ function convertRelationships(parsedRelationships, annotationToOptionConverter,
         source: annotationToOptionConverter.call(undefined, parsedRelationship.options.source),
         destination: annotationToOptionConverter.call(undefined, parsedRelationship.options.destination),
       },
-      unidirectionalRelationships,
+      unilateralRelationships,
     };
     if (!relationshipConfiguration.injectedFieldInFrom && !relationshipConfiguration.injectedFieldInTo) {
       relationshipConfiguration.injectedFieldInFrom = lowerFirst(relationshipConfiguration.to);

jdl/jdl-importer.js

@@ -50,7 +50,7 @@ module.exports = {
  * @param {String} configuration.generatorVersion - deprecated, the generator's version, optional if parsing applications
  * @param {String} configuration.forceNoFiltering - whether to force filtering
  * @param {Boolean} configuration.skipFileGeneration - whether not to generate the .yo-rc.json file
- * @param {Boolean} [configuration.unidirectionalRelationships] - Whether to generate unidirectional relationships
+ * @param {Boolean} [configuration.unilateralRelationships] - Whether to generate unilateral relationships
  * @returns {Object} a JDL importer.
  * @throws {Error} if files aren't passed.
  */
@@ -77,7 +77,7 @@ function createImporterFromFiles(files, configuration) {
  * @param {String} configuration.generatorVersion - deprecated, the generator's version, optional if parsing applications
  * @param {String} configuration.forceNoFiltering - whether to force filtering
  * @param {Boolean} configuration.skipFileGeneration - whether not to generate the .yo-rc.json file
- * @param {Boolean} [configuration.unidirectionalRelationships] - Whether to generate unidirectional relationships
+ * @param {Boolean} [configuration.unilateralRelationships] - Whether to generate unilateral relationships
  * @param {Array} configuration.blueprints - the blueprints used.
  * @returns {Object} a JDL importer.
  * @throws {Error} if the content isn't passed.
@@ -134,7 +134,7 @@ function getJDLObject(parsedJDLContent, configuration) {
   let applicationType = configuration.applicationType;
   let generatorVersion = configuration.generatorVersion;
   let databaseType = configuration.databaseType;
-  const unidirectionalRelationships = configuration.unidirectionalRelationships;
+  const unilateralRelationships = configuration.unilateralRelationships;
   let skippedUserManagement = false;
 
   if (configuration.application) {
@@ -152,13 +152,13 @@ function getJDLObject(parsedJDLContent, configuration) {
     generatorVersion,
     skippedUserManagement,
     databaseType,
-    unidirectionalRelationships,
+    unilateralRelationships,
   });
 }
 
 function checkForErrors(jdlObject, configuration, logger = console) {
   let validator;
-  const { unidirectionalRelationships } = configuration;
+  const { unilateralRelationships } = configuration;
   if (jdlObject.getApplicationQuantity() === 0) {
     let application = configuration.application;
     if (!application && doesFileExist('.yo-rc.json')) {
@@ -191,16 +191,16 @@ function checkForErrors(jdlObject, configuration, logger = console) {
         blueprints,
       },
       logger,
-      { unidirectionalRelationships }
+      { unilateralRelationships }
     );
   } else {
-    validator = JDLWithApplicationValidator.createValidator(jdlObject, logger, { unidirectionalRelationships });
+    validator = JDLWithApplicationValidator.createValidator(jdlObject, logger, { unilateralRelationships });
   }
   validator.checkForErrors();
 }
 
 function importOnlyEntities(jdlObject, configuration) {
-  const { unidirectionalRelationships } = configuration;
+  const { unilateralRelationships } = configuration;
   let { applicationName, applicationType, databaseType } = configuration;
 
   let application = configuration.application;
@@ -224,14 +224,14 @@ function importOnlyEntities(jdlObject, configuration) {
     applicationName,
     applicationType,
     databaseType,
-    unidirectionalRelationships,
+    unilateralRelationships,
   });
   const jsonEntities = entitiesPerApplicationMap.get(applicationName);
   return exportJSONEntities(jsonEntities, configuration);
 }
 
 function importOneApplicationAndEntities(jdlObject, configuration) {
-  const { skipFileGeneration, unidirectionalRelationships } = configuration;
+  const { skipFileGeneration, unilateralRelationships } = configuration;
 
   const importState = {
     exportedApplications: [],
@@ -248,7 +248,7 @@ function importOneApplicationAndEntities(jdlObject, configuration) {
   const applicationName = jdlApplication.getConfigurationOptionValue('baseName');
   const entitiesPerApplicationMap = JDLWithApplicationsToJSONConverter.convert({
     jdlObject,
-    unidirectionalRelationships,
+    unilateralRelationships,
   });
   const jsonEntities = entitiesPerApplicationMap.get(applicationName);
   importState.exportedApplicationsWithEntities[applicationName] = {
@@ -269,7 +269,7 @@ function importOneApplicationAndEntities(jdlObject, configuration) {
 }
 
 function importApplicationsAndEntities(jdlObject, configuration) {
-  const { skipFileGeneration, unidirectionalRelationships } = configuration;
+  const { skipFileGeneration, unilateralRelationships } = configuration;
 
   const importState = {
     exportedApplications: [],
@@ -285,7 +285,7 @@ function importApplicationsAndEntities(jdlObject, configuration) {
   }
   const entitiesPerApplicationMap = JDLWithApplicationsToJSONConverter.convert({
     jdlObject,
-    unidirectionalRelationships,
+    unilateralRelationships,
   });
   entitiesPerApplicationMap.forEach((jsonEntities, applicationName) => {
     const jdlApplication = jdlObject.getApplication(applicationName);

jdl/models/jdl-relationship.js

@@ -33,7 +33,7 @@ module.exports = class JDLRelationship {
     if (
       merged.type === RelationshipTypes.ONE_TO_MANY &&
       (!merged.injectedFieldInFrom || !merged.injectedFieldInTo) &&
-      !merged.unidirectionalRelationships
+      !merged.unilateralRelationships
     ) {
       logger.warn(
         `In the One-to-Many relationship from ${merged.from} to ${merged.to}, ` +
@@ -172,7 +172,7 @@ function defaults() {
     },
     commentInFrom: '',
     commentInTo: '',
-    unidirectionalRelationships: false,
+    unilateralRelationships: false,
   };
 }
 

jdl/validators/jdl-with-application-validator.js

@@ -48,7 +48,7 @@ function createValidator(jdlObject, logger = console, options = {}) {
   if (!jdlObject) {
     throw new Error('A JDL object must be passed to check for business errors.');
   }
-  const { unidirectionalRelationships } = options;
+  const { unilateralRelationships } = options;
 
   return {
     checkForErrors: () => {
@@ -60,7 +60,7 @@ function createValidator(jdlObject, logger = console, options = {}) {
           return;
         }
         checkForEntityErrors(jdlApplication);
-        checkForRelationshipErrors(jdlApplication, { unidirectionalRelationships });
+        checkForRelationshipErrors(jdlApplication, { unilateralRelationships });
         checkForEnumErrors();
         checkDeploymentsErrors();
         checkForOptionErrors(jdlApplication);
@@ -144,11 +144,11 @@ function createValidator(jdlObject, logger = console, options = {}) {
     if (jdlObject.getRelationshipQuantity() === 0) {
       return;
     }
-    const { unidirectionalRelationships } = options;
+    const { unilateralRelationships } = options;
     const skippedUserManagement = jdlApplication.getConfigurationOptionValue('skipUserManagement');
     const validator = new RelationshipValidator();
     jdlObject.forEachRelationship(jdlRelationship => {
-      validator.validate(jdlRelationship, { skippedUserManagement, unidirectionalRelationships });
+      validator.validate(jdlRelationship, { skippedUserManagement, unilateralRelationships });
       checkForAbsentEntities({
         jdlRelationship,
         doesEntityExist: entityName => !!jdlObject.getEntity(entityName),

jdl/validators/jdl-without-application-validator.js

@@ -54,7 +54,7 @@ function createValidator(jdlObject, applicationSettings = {}, logger = console,
   if (!jdlObject) {
     throw new Error('A JDL object must be passed to check for business errors.');
   }
-  const { unidirectionalRelationships } = options;
+  const { unilateralRelationships } = options;
 
   if (applicationSettings.blueprints && applicationSettings.blueprints.length !== 0) {
     return {
@@ -67,7 +67,7 @@ function createValidator(jdlObject, applicationSettings = {}, logger = console,
   return {
     checkForErrors: () => {
       checkForEntityErrors();
-      checkForRelationshipErrors({ unidirectionalRelationships });
+      checkForRelationshipErrors({ unilateralRelationships });
       checkForEnumErrors();
       checkDeploymentsErrors();
       checkForOptionErrors();
@@ -128,12 +128,12 @@ function createValidator(jdlObject, applicationSettings = {}, logger = console,
     if (jdlObject.getRelationshipQuantity() === 0) {
       return;
     }
-    const { unidirectionalRelationships } = options;
+    const { unilateralRelationships } = options;
     const skippedUserManagement =
       applicationSettings.skippedUserManagement || jdlObject.getOptionsForName(OptionNames.SKIP_USER_MANAGEMENT)[0];
     const validator = new RelationshipValidator();
     jdlObject.forEachRelationship(jdlRelationship => {
-      validator.validate(jdlRelationship, { skippedUserManagement, unidirectionalRelationships });
+      validator.validate(jdlRelationship, { skippedUserManagement, unilateralRelationships });
       checkForAbsentEntities({
         jdlRelationship,
         doesEntityExist: entityName => !!jdlObject.getEntity(entityName),