jdl: allow namespaced options

jdl/integration-test.spec.ts

@@ -28,7 +28,8 @@ import { parseFromContent, parseFromFiles } from './readers/jdl-reader.js';
 import DocumentParser from './converters/parsed-jdl-to-jdl-object/parsed-jdl-to-jdl-object-converter.js';
 import exportToJDL from './exporters/jdl-exporter.js';
 import { basicHelpers as helpers } from '../test/support/index.mjs';
-import { convert } from './converters/jdl-to-json/jdl-without-application-to-json-converter.js';
+import { convert as convertWithoutApplication } from './converters/jdl-to-json/jdl-without-application-to-json-converter.js';
+import { ApplicationWithEntities, createImporterFromContent } from './jdl-importer.js';
 
 const { MONOLITH } = applicationTypes;
 const __filename = fileURLToPath(import.meta.url);
@@ -62,18 +63,18 @@ describe('jdl - integration tests', () => {
 
   context('when parsing entities JDL', () => {
     const applicationName = 'jhipster';
-    const jdl = `
+    context('with bidirectional relationship', () => {
+      let result: Map<any, any[]>;
+      const jdl = `
 entity A {}
 entity B {}
 relationship ManyToOne {
   A to B
 }
 `;
-    context('with bidirectional relationship', () => {
-      let result: Map<any, any[]>;
 
       beforeEach(() => {
-        result = convert({
+        result = convertWithoutApplication({
           applicationName,
           databaseType: 'sql',
           jdlObject: DocumentParser.parseFromConfigurationObject({
@@ -84,8 +85,8 @@ relationship ManyToOne {
       });
 
       it('should add relationship at both sides', () => {
-        jestExpect(result.get('jhipster')![0].relationships.length).toBe(1);
-        jestExpect(result.get('jhipster')![1].relationships.length).toBe(1);
+        jestExpect(result.get(applicationName)![0].relationships.length).toBe(1);
+        jestExpect(result.get(applicationName)![1].relationships.length).toBe(1);
       });
 
       it('should result matching', () => {
@@ -155,7 +156,7 @@ relationship ManyToOne {
 `;
 
       beforeEach(() => {
-        result = convert({
+        result = convertWithoutApplication({
           applicationName,
           databaseType: 'sql',
           jdlObject: DocumentParser.parseFromConfigurationObject({
@@ -166,8 +167,8 @@ relationship ManyToOne {
       });
 
       it('should add relationship at one side', () => {
-        jestExpect(result.get('jhipster')![0].relationships.length).toBe(1);
-        jestExpect(result.get('jhipster')![1].relationships.length).toBe(0);
+        jestExpect(result.get(applicationName)![0].relationships.length).toBe(1);
+        jestExpect(result.get(applicationName)![1].relationships.length).toBe(0);
       });
 
       it('should result matching', () => {
@@ -231,7 +232,7 @@ relationship ManyToOne {
 `;
 
       beforeEach(() => {
-        result = convert({
+        result = convertWithoutApplication({
           applicationName,
           databaseType: 'sql',
           jdlObject: DocumentParser.parseFromConfigurationObject({
@@ -242,8 +243,8 @@ relationship ManyToOne {
       });
 
       it('should add relationship at both sides', () => {
-        jestExpect(result.get('jhipster')![0].relationships.length).toBe(1);
-        jestExpect(result.get('jhipster')![1].relationships.length).toBe(1);
+        jestExpect(result.get(applicationName)![0].relationships.length).toBe(1);
+        jestExpect(result.get(applicationName)![1].relationships.length).toBe(1);
       });
 
       it('should result matching', () => {
@@ -303,6 +304,69 @@ Map {
     },
   ],
 }
+`);
+      });
+    });
+  });
+
+  context('when parsing JDL with blueprint configs', () => {
+    const applicationName = 'jhipster';
+
+    context('without blueprint', () => {
+      const jdl = `
+application {
+  config {
+    baseName jhipster
+    foo:stringConfig stringValue
+  }
+}
+`;
+
+      it('should throw error', () => {
+        const importer = createImporterFromContent(jdl);
+        jestExpect(() => importer.import()).toThrowError({ message: 'Blueprint config foo:stringConfig requires the blueprint foo' });
+      });
+    });
+
+    context('with blueprint', () => {
+      let result: Record<string, ApplicationWithEntities>;
+      const jdl = `
+application {
+  config {
+    baseName jhipster
+    blueprints [foo]
+    foo:stringConfig stringValue
+    foo:trueConfig true
+    foo:falseConfig false
+    foo:listConfig [item]
+    foo:integerConfig 123
+  }
+}
+`;
+
+      beforeEach(() => {
+        const importer = createImporterFromContent(jdl);
+        const importState = importer.import();
+        result = importState.exportedApplicationsWithEntities;
+      });
+
+      it('should result matching', () => {
+        jestExpect(result[applicationName].config).toMatchInlineSnapshot(`
+{
+  "baseName": "jhipster",
+  "blueprints": [
+    {
+      "name": "generator-jhipster-foo",
+    },
+  ],
+  "generator-jhipster-foo:falseConfig": false,
+  "generator-jhipster-foo:integerConfig": 123,
+  "generator-jhipster-foo:listConfig": [
+    "item",
+  ],
+  "generator-jhipster-foo:stringConfig": "stringValue",
+  "generator-jhipster-foo:trueConfig": true,
+}
 `);
       });
     });

jdl/models/jdl-application-configuration-factory.ts

@@ -31,7 +31,7 @@ export default function createApplicationConfigurationFromObject(configurationOb
   const configuration = new JDLApplicationConfiguration();
   Object.keys(configurationObject).forEach(optionName => {
     const optionValue = configurationObject[optionName];
-    if (!applicationDefinition.doesOptionExist(optionName)) {
+    if (!applicationDefinition.doesOptionExist(optionName) && !optionName.includes(':')) {
       logger.debug(`Unrecognized application option name and value: '${optionName}' and '${optionValue}'.`);
       return;
     }
@@ -41,7 +41,21 @@ export default function createApplicationConfigurationFromObject(configurationOb
 }
 
 function createJDLConfigurationOption(name, value) {
-  const type = applicationDefinition.getTypeForOption(name);
+  let type = applicationDefinition.getTypeForOption(name);
+  if (type === 'unknown') {
+    if (typeof value === 'boolean') {
+      type = 'boolean';
+    } else if (/^\d*$/.test(value)) {
+      value = parseInt(value, 10);
+      type = 'integer';
+    } else if (Array.isArray(value)) {
+      type = 'list';
+    } else if (typeof value === 'string') {
+      type = 'string';
+    } else {
+      throw new Error(`Unknown value type for option ${name}`);
+    }
+  }
   switch (type) {
     case 'string':
       return new StringJDLApplicationConfigurationOption(name, value, applicationDefinition.shouldTheValueBeQuoted(name));

jdl/models/jdl-application-configuration-option.ts

@@ -18,15 +18,15 @@
  */
 
 export default class JDLApplicationConfigurationOption {
-  name: any;
+  name: string;
   value: any;
 
   /**
    * Creates a new application option.
    * @param {String} name - the option's name.
    * @param {any} value - the option's value, can be virtually anything: a String, an Int, a boolean...
    */
-  constructor(name, value) {
+  constructor(name: string, value) {
     this.name = name;
     this.value = value;
   }

jdl/models/jdl-application-configuration.ts

@@ -18,24 +18,25 @@
  */
 
 import ApplicationOptions from '../jhipster/application-options.js';
+import JDLApplicationConfigurationOption from './jdl-application-configuration-option.js';
 
 const { OptionNames } = ApplicationOptions;
 
 export default class JDLApplicationConfiguration {
-  options: any;
+  options: Record<string, JDLApplicationConfigurationOption>;
 
   constructor() {
     this.options = {};
   }
 
-  hasOption(optionName) {
+  hasOption(optionName: string) {
     if (!optionName) {
       return false;
     }
     return optionName in this.options;
   }
 
-  getOption(optionName) {
+  getOption(optionName: string) {
     if (!optionName) {
       throw new Error('An option name has to be passed to get the option.');
     }
@@ -45,14 +46,14 @@ export default class JDLApplicationConfiguration {
     return this.options[optionName];
   }
 
-  setOption(option) {
+  setOption(option: JDLApplicationConfigurationOption) {
     if (!option) {
       throw new Error('An option has to be passed to set an option.');
     }
     this.options[option.name] = option;
   }
 
-  forEachOption(passedFunction) {
+  forEachOption(passedFunction: (option: JDLApplicationConfigurationOption) => void) {
     if (!passedFunction) {
       return;
     }

jdl/models/jdl-application-definition.ts

@@ -1,7 +1,7 @@
 import { jhipsterOptionTypes, jhipsterOptionValues, jhipsterQuotedOptionNames } from '../jhipster/application-options.js';
 
 export type JDLApplicationOptionValue = string | number | boolean | undefined | never[] | Record<string, string>;
-export type JDLApplicationOptionTypeValue = 'string' | 'integer' | 'boolean' | 'list';
+export type JDLApplicationOptionTypeValue = 'string' | 'integer' | 'boolean' | 'list' | 'unknown';
 export type JDLApplicationOptionType = { type: JDLApplicationOptionTypeValue };
 
 export default class JDLApplicationDefinition {
@@ -18,6 +18,9 @@ export default class JDLApplicationDefinition {
     if (!optionName) {
       throw new Error('A name has to be passed to get the option type.');
     }
+    if (optionName.includes(':')) {
+      return 'unknown';
+    }
     if (!this.optionTypes[optionName]) {
       throw new Error(`Unrecognised application option name: ${optionName}.`);
     }

jdl/models/jdl-application.ts

@@ -18,11 +18,13 @@
  */
 
 import createApplicationConfigurationFromObject from './jdl-application-configuration-factory.js';
+import JDLApplicationConfigurationOption from './jdl-application-configuration-option.js';
+import JDLApplicationConfiguration from './jdl-application-configuration.js';
 import JDLApplicationEntities from './jdl-application-entities.js';
 import JDLOptions from './jdl-options.js';
 
 export default class JDLApplication {
-  config: any;
+  config: JDLApplicationConfiguration;
   entityNames: any;
   options: any;
 
@@ -51,10 +53,10 @@ export default class JDLApplication {
       return undefined;
     }
     const option = this.config.getOption(optionName);
-    return option.getValue();
+    return option!.getValue();
   }
 
-  forEachConfigurationOption(passedFunction) {
+  forEachConfigurationOption(passedFunction: (option: JDLApplicationConfigurationOption) => void) {
     this.config.forEachOption(passedFunction);
   }
 

jdl/models/jdl-object.ts

@@ -227,7 +227,7 @@ export default class JDLObject {
     return this.options.getOptionsForName(optionName);
   }
 
-  forEachOption(passedFunction) {
+  forEachOption(passedFunction: (option: any) => void) {
     if (!passedFunction) {
       return;
     }

jdl/models/list-jdl-application-configuration-option.ts

@@ -25,7 +25,7 @@ export default class ListJDLApplicationConfigurationOption extends JDLApplicatio
     super(name, new Set(value));
   }
 
-  getValue() {
+  getValue(): any[] {
     return Array.from(this.value);
   }
 

jdl/parsing/lexer/application-tokens.ts

@@ -74,6 +74,7 @@ const {
 const applicationConfigCategoryToken = createTokenFromConfig({ name: 'CONFIG_KEY', pattern: Lexer.NA });
 
 const applicationConfigTokens: Pick<ITokenConfig, 'name' | 'pattern'>[] = [
+  { name: 'BLUEPRINT_CONFIGS', pattern: /\w*:\w*/ },
   { name: 'BASE_NAME', pattern: BASE_NAME },
   { name: 'BLUEPRINTS', pattern: BLUEPRINTS },
   { name: 'BLUEPRINT', pattern: BLUEPRINT },

jdl/parsing/lexer/token-creator.ts

@@ -32,7 +32,7 @@ export default function createTokenFromConfig(config: ITokenConfig) {
   // library with a separate lexing phase.
   // See: https://github.com/SAP/chevrotain/blob/master/examples/lexer/keywords_vs_identifiers/keywords_vs_identifiers.js
   // a Concise way to resolve the problem without manually adding the "longer_alt" property dozens of times.
-  if (isString(config.pattern) && namePattern.test(config.pattern)) {
+  if ((isString(config.pattern) && namePattern.test(config.pattern)) || config.name === 'BLUEPRINT_CONFIGS') {
     config.longer_alt = NAME;
     if (!config.categories) {
       config.categories = [];

jdl/parsing/validator.ts

@@ -51,8 +51,9 @@ const JWT_SECRET_KEY_PATTERN = /^\S+$/;
 const REMEMBER_ME_KEY_PATTERN = /^\S+$/;
 const NUMERIC = /^\d$/;
 const BASIC_NPM_PACKAGE_NAME_PATTERN = /^(@[a-z0-9-][a-z0-9-._]*\/)?[a-z0-9-][a-z0-9-._]*$/;
+const BLUEPRINT_CONFIGS_PATTERN = /^((\d*)|([A-Za-z][A-Za-z0-9]*))$/;
 
-export type JDLValidatorOptionType = 'BOOLEAN' | 'INTEGER' | 'list' | 'NAME' | 'qualifiedName' | 'STRING';
+export type JDLValidatorOptionType = 'BOOLEAN' | 'INTEGER' | 'list' | 'NAME' | 'qualifiedName' | 'STRING' | 'UNKNOWN';
 
 export type JDLValidatorOption = {
   type: JDLValidatorOptionType;
@@ -61,6 +62,11 @@ export type JDLValidatorOption = {
 };
 
 const configPropsValidations: Record<string, JDLValidatorOption> = {
+  BLUEPRINT_CONFIGS: {
+    type: 'UNKNOWN',
+    pattern: BLUEPRINT_CONFIGS_PATTERN,
+    msg: 'blueprint configs',
+  },
   APPLICATION_TYPE: {
     type: 'NAME',
     pattern: ALPHABETIC_LOWER,
@@ -369,6 +375,8 @@ class JDLSyntaxValidatorVisitor extends BaseJDLCSTVisitorWithDefaults {
 
   checkExpectedValueType(expected, actual) {
     switch (expected) {
+      case 'UNKNOWN':
+        return true;
       case 'NAME':
         if (
           actual.name !== 'qualifiedName' &&

jdl/validators/entity-validator.ts

@@ -29,6 +29,9 @@ export default class EntityValidator extends Validator {
 
   validate(jdlEntity) {
     super.validate(jdlEntity);
+  }
+
+  validateBusiness(jdlEntity) {
     checkForReservedClassName(jdlEntity);
   }
 }

jdl/validators/enum-validator.spec.ts

@@ -56,7 +56,7 @@ describe('jdl - EnumValidator', () => {
       context('with a reserved class name as name', () => {
         it('should fail', () => {
           expect(() => {
-            validator.validate(new JDLEnum({ name: 'Catch' }));
+            validator.validateBusiness(new JDLEnum({ name: 'Catch' }));
           }).to.throw(/^The enum name 'Catch' is reserved keyword and can not be used as enum class name\.$/);
         });
       });

jdl/validators/enum-validator.ts

@@ -28,6 +28,9 @@ export default class EnumValidator extends Validator {
 
   validate(jdlEnum) {
     super.validate(jdlEnum);
+  }
+
+  validateBusiness(jdlEnum) {
     checkForReservedClassName(jdlEnum);
   }
 }