generator-jhipster 7.1.0 → 7.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "generator-jhipster",
-  "version": "7.1.0",
+  "version": "7.4.0",
   "description": "Spring Boot + Angular/React/Vue in one handy generator",
   "keywords": [
     "yeoman-generator",
@@ -34,6 +34,20 @@
     "email": "",
     "url": "https://github.com/jdubois"
   },
+  "exports": {
+    ".": "./lib/index.js",
+    "./cli/": "./cli/",
+    "./generators/": "./generators/",
+    "./jdl/": "./jdl/",
+    "./lib/": "./lib/",
+    "./utils/": "./utils/",
+    "./package.json": "./package.json",
+    "./esm/cli": "./cli/program.js",
+    "./esm/generators/*": "./generators/*/esm.mjs",
+    "./esm/generators": "./lib/constants/generators.mjs",
+    "./esm/priorities": "./lib/constants/priorities.mjs",
+    "./esm/support": "./lib/support/index.cjs"
+  },
   "main": "lib/index.js",
   "bin": {
     "jhipster": "cli/jhipster.js"
@@ -43,83 +57,88 @@
     "generators",
     "jdl",
     "lib",
-    "utils"
+    "utils",
+    "!__*",
+    "!*.snap",
+    "!*.spec.?(c|m)js"
   ],
   "scripts": {
     "completion": "tabtab install --name jhipster --auto",
     "ejs-lint": "mocha test/ejslint.js",
     "ejslint": "ejslint",
-    "eslint": "eslint .",
+    "eslint": "eslint . --ext .js,.cjs,.mjs",
     "jdl:test": "mocha test/jdl --no-insight --forbid-only -p",
     "jdl:test-watch": "npm run jdl:test -- --watch",
     "jsdoc": "jsdoc --configure jsdoc-conf.json",
     "lint": "npm run eslint && npm run ejs-lint",
     "lint-fix": "npm run prettier:format && npm run eslint -- --fix",
-    "prettier:check": "prettier --check \"{,**/}*.{js,json,md,yml,java}\"",
-    "prettier:format": "prettier --write \"{,**/}*.{js,json,md,yml,java}\"",
+    "prettier:check": "prettier --check \"{,**/}*.{js,cjs,mjs,json,md,yml,java}\"",
+    "prettier:format": "prettier --write \"{,**/}*.{js,cjs,mjs,json,md,yml,java}\"",
     "pretest": "npm run lint",
-    "test": "mocha --no-insight --forbid-only --parallel",
-    "update-snapshots": "mocha --no-insight --parallel --updateSnapshot"
+    "test": "mocha test generators --no-insight --forbid-only --parallel --max-old-space-size=4096",
+    "update-snapshot": "mocha --no-insight --no-parallel --updateSnapshot --",
+    "update-snapshots": "npm run update-snapshot -- test generators"
   },
   "dependencies": {
-    "aws-sdk": "2.927.0",
-    "axios": "0.21.1",
-    "chalk": "4.1.1",
-    "chevrotain": "9.0.2",
-    "commander": "7.2.0",
-    "conf": "10.0.1",
-    "didyoumean": "1.2.1",
+    "aws-sdk": "2.1028.0",
+    "axios": "0.24.0",
+    "chalk": "4.1.2",
+    "chevrotain": "9.1.0",
+    "commander": "8.3.0",
+    "conf": "10.0.3",
+    "debug": "4.3.2",
+    "didyoumean": "1.2.2",
     "ejs": "3.1.6",
     "faker": "5.5.3",
-    "find-up": "5.0.0",
-    "glob": "7.1.7",
-    "gulp-filter": "7.0.0",
-    "insight": "0.10.3",
+    "glob": "7.2.0",
+    "insight": "0.11.1",
     "js-yaml": "4.1.0",
     "lodash": "4.17.21",
-    "mem-fs-editor": "^9.0.0",
+    "mem-fs-editor": "9.3.0",
     "minimatch": "3.0.4",
     "normalize-path": "3.0.0",
-    "ora": "5.4.1",
     "os-locale": "5.0.0",
+    "p-queue": "6.6.2",
+    "p-transform": "1.3.0",
     "parse-gitignore": "1.0.1",
     "pluralize": "8.0.0",
-    "prettier": "2.3.1",
-    "prettier-plugin-java": "1.2.0",
-    "prettier-plugin-packagejson": "2.2.11",
+    "prettier": "2.4.1",
+    "prettier-plugin-java": "1.6.0",
+    "prettier-plugin-packagejson": "2.2.15",
     "progress": "2.0.3",
     "randexp": "0.5.3",
     "semver": "7.3.5",
     "shelljs": "0.8.4",
+    "simple-git": "2.47.0",
     "then-request": "6.0.2",
     "uuid": "8.3.2",
     "winston": "3.3.3",
-    "yeoman-environment": "3.4.1",
-    "yeoman-generator": "5.3.0"
+    "yeoman-environment": "3.8.0",
+    "yeoman-generator": "5.4.2"
   },
   "devDependencies": {
     "chai": "4.3.4",
-    "ejs-lint": "1.2.0",
-    "eslint": "7.28.0",
-    "eslint-config-airbnb-base": "14.2.1",
+    "ejs-lint": "1.2.1",
+    "eslint": "8.2.0",
+    "eslint-config-airbnb-base": "15.0.0",
     "eslint-config-prettier": "8.3.0",
     "eslint-plugin-chai-friendly": "^0.7.1",
-    "eslint-plugin-import": "2.23.4",
+    "eslint-plugin-import": "2.25.3",
     "eslint-plugin-mocha": "9.0.0",
-    "eslint-plugin-prettier": "3.4.0",
-    "expect": "26.6.2",
+    "eslint-plugin-prettier": "4.0.0",
+    "expect": "27.3.1",
     "fs-extra": "10.0.0",
     "jsdoc": "3.6.7",
-    "mocha": "8.4.0",
-    "mocha-expect-snapshot": "1.0.0",
+    "mocha": "9.1.3",
+    "mocha-expect-snapshot": "1.1.1",
     "proxyquire": "2.1.3",
-    "sinon": "11.1.1",
+    "sinon": "12.0.1",
     "sinon-chai": "3.7.0",
     "yeoman-assert": "3.1.1",
-    "yeoman-test": "6.1.0"
+    "yeoman-test": "6.2.0"
   },
   "engines": {
-    "node": ">=12.12.0",
+    "node": "^12.20.0 || ^14.13.1 || >=16.0.0",
     "npm": ">=6.14.4"
   },
   "collective": {

package/utils/entity.js

@@ -28,10 +28,11 @@ const { PaginationTypes, ServiceTypes } = require('../jdl/jhipster/entity-option
 const { GATEWAY, MICROSERVICE } = require('../jdl/jhipster/application-types');
 const { MapperTypes } = require('../jdl/jhipster/entity-options');
 const { OAUTH2 } = require('../jdl/jhipster/authentication-types');
+const { ANGULAR_X } = require('../jdl/jhipster/client-framework-types');
 const { CommonDBTypes } = require('../jdl/jhipster/field-types');
 
 const { BOOLEAN, LONG, STRING, UUID } = CommonDBTypes;
-const { MAPSTRUCT } = MapperTypes;
+const { NO: NO_DTO, MAPSTRUCT } = MapperTypes;
 const { PAGINATION, INFINITE_SCROLL } = PaginationTypes;
 const { SERVICE_IMPL } = ServiceTypes;
 const NO_SERVICE = ServiceTypes.NO;
@@ -40,6 +41,7 @@ const NO_MAPPER = MapperTypes.NO;
 
 const BASE_TEMPLATE_DATA = {
   primaryKey: undefined,
+  entityPackage: undefined,
   skipUiGrouping: false,
   haveFieldWithJavadoc: false,
   existingEnum: false,
@@ -105,7 +107,7 @@ function _derivedProperties(entityWithConfig) {
 }
 
 function prepareEntityForTemplates(entityWithConfig, generator) {
-  const entityName = entityWithConfig.name;
+  const entityName = _.upperFirst(entityWithConfig.name);
   _.defaults(entityWithConfig, entityDefaultConfig, BASE_TEMPLATE_DATA);
 
   entityWithConfig.changelogDateForRecent = parseLiquibaseChangelogDate(entityWithConfig.changelogDate);
@@ -128,15 +130,17 @@ function prepareEntityForTemplates(entityWithConfig, generator) {
     entityWithConfig.skipServer = true;
   }
 
+  entityWithConfig.builtInUser = generator.isBuiltInUser(entityName);
+
   _.defaults(entityWithConfig, {
-    entityNameCapitalized: _.upperFirst(entityName),
+    entityNameCapitalized: entityName,
     entityClass: _.upperFirst(entityName),
     entityInstance: _.lowerFirst(entityName),
     entityTableName: generator.getTableName(entityName),
     entityNamePlural: pluralize(entityName),
   });
 
-  const dto = entityWithConfig.dto === MAPSTRUCT;
+  const dto = entityWithConfig.dto && entityWithConfig.dto !== NO_DTO;
   if (dto) {
     _.defaults(entityWithConfig, {
       dtoClass: generator.asDto(entityWithConfig.entityClass),
@@ -201,6 +205,16 @@ function prepareEntityForTemplates(entityWithConfig, generator) {
     entityWithConfig.i18nAlertHeaderPrefix = `${entityWithConfig.microserviceAppName}.${entityWithConfig.entityTranslationKey}`;
   }
 
+  const { microserviceName, entityFileName, microfrontend } = entityWithConfig;
+  entityWithConfig.entityApi = microserviceName ? `services/${microserviceName.toLowerCase()}/` : '';
+  entityWithConfig.entityPage =
+    microfrontend &&
+    microserviceName &&
+    entityWithConfig.clientFramework !== ANGULAR_X &&
+    (entityWithConfig.applicationType === MICROSERVICE || entityWithConfig.applicationType === GATEWAY)
+      ? `${microserviceName.toLowerCase()}/${entityFileName}`
+      : `${entityFileName}`;
+
   const hasBuiltInUserField = entityWithConfig.relationships.some(relationship => generator.isBuiltInUser(relationship.otherEntityName));
   entityWithConfig.saveUserSnapshot =
     entityWithConfig.applicationType === MICROSERVICE &&
@@ -446,6 +460,9 @@ function loadRequiredConfigIntoEntity(entity, config) {
     jhiPrefix: config.jhiPrefix,
     authenticationType: config.authenticationType,
     reactive: config.reactive,
+    microfrontend: config.microfrontend,
+    // Workaround different paths
+    clientFramework: config.clientFramework,
   });
   return entity;
 }

package/utils/field.js

@@ -98,7 +98,11 @@ const generateFakeDataForField = (field, faker, changelogDate, type = 'csv') =>
   if (field.fakerTemplate) {
     data = faker.faker(field.fakerTemplate);
   } else if (field.fieldValidate && field.fieldValidateRules.includes('pattern')) {
-    const generated = field.createRandexp().gen();
+    const re = field.createRandexp();
+    if (!re) {
+      return undefined;
+    }
+    const generated = re.gen();
     if (type === 'csv' || type === 'cypress') {
       data = generated.replace(/"/g, '');
     } else {
@@ -125,9 +129,12 @@ const generateFakeDataForField = (field, faker, changelogDate, type = 'csv') =>
     });
   } else if ([INSTANT, ZONED_DATE_TIME, LOCAL_DATE].includes(field.fieldType)) {
     // Iso: YYYY-MM-DDTHH:mm:ss.sssZ
-    const isoDate = faker.date.recent(1, changelogDate).toISOString();
+    const date = faker.date.recent(1, changelogDate);
+    const isoDate = date.toISOString();
     if (field.fieldType === LOCAL_DATE) {
       data = isoDate.split('T')[0];
+    } else if (type === 'json-serializable') {
+      data = date;
     } else {
       // Write the date without milliseconds so Java can parse it
       // See https://stackoverflow.com/a/34053802/150868
@@ -150,6 +157,10 @@ const generateFakeDataForField = (field, faker, changelogDate, type = 'csv') =>
     data = faker.datatype.boolean();
   }
 
+  if (field.fieldType === BYTES && type === 'json-serializable') {
+    data = Buffer.from(data).toString('base64');
+  }
+
   // Validation rules
   if (data !== undefined && field.fieldValidate === true) {
     // manage String max length
@@ -285,6 +296,9 @@ function prepareFieldForTemplates(entityWithConfig, field, generator) {
 
   field.fieldIsEnum = !field.id && fieldIsEnum(fieldType);
   field.fieldWithContentType = (fieldType === BYTES || fieldType === BYTE_BUFFER) && field.fieldTypeBlobContent !== TEXT;
+  if (field.fieldWithContentType) {
+    field.contentTypeFieldName = `${field.fieldName}ContentType`;
+  }
 
   if (field.fieldNameAsDatabaseColumn === undefined) {
     const fieldNameUnderscored = _.snakeCase(field.fieldName);
@@ -357,7 +371,17 @@ function prepareFieldForTemplates(entityWithConfig, field, generator) {
   }
 
   const faker = entityWithConfig.faker;
-  field.createRandexp = () => faker.createRandexp(field.fieldValidateRulesPattern);
+  field.createRandexp = () => {
+    // check if regex is valid. If not, issue warning and we skip fake data generation.
+    try {
+      // eslint-disable-next-line no-new
+      new RegExp(field.fieldValidateRulesPattern);
+    } catch (e) {
+      generator.warning(`${field.fieldName} pattern is not valid: ${field.fieldValidateRulesPattern}. Skipping generating fake data. `);
+      return undefined;
+    }
+    return faker.createRandexp(field.fieldValidateRulesPattern);
+  };
 
   field.uniqueValue = [];
 

package/utils/liquibase.js

@@ -19,6 +19,13 @@
 
 const _ = require('lodash');
 
+const { MYSQL, MARIADB, POSTGRESQL } = require('../jdl/jhipster/database-types');
+const { CommonDBTypes, RelationalOnlyDBTypes, BlobTypes } = require('../jdl/jhipster/field-types');
+
+const { STRING, INTEGER, LONG, BIG_DECIMAL, FLOAT, DOUBLE, UUID, BOOLEAN, LOCAL_DATE, ZONED_DATE_TIME, INSTANT, DURATION } = CommonDBTypes;
+const { BYTES } = RelationalOnlyDBTypes;
+const { TEXT } = BlobTypes;
+
 module.exports = {
   parseLiquibaseChangelogDate,
   formatDateForChangelog,
@@ -73,69 +80,69 @@ function formatDateForChangelog(now) {
 
 function parseLiquibaseColumnType(entity, field) {
   const fieldType = field.fieldType;
-  if (fieldType === 'String' || field.fieldIsEnum) {
+  if (fieldType === STRING || field.fieldIsEnum) {
     return `varchar(${field.fieldValidateRulesMaxlength || 255})`;
   }
 
-  if (fieldType === 'Integer') {
+  if (fieldType === INTEGER) {
     return 'integer';
   }
 
-  if (fieldType === 'Long') {
+  if (fieldType === LONG) {
     return 'bigint';
   }
 
-  if (fieldType === 'Float') {
+  if (fieldType === FLOAT) {
     // eslint-disable-next-line no-template-curly-in-string
     return '${floatType}';
   }
 
-  if (fieldType === 'Double') {
+  if (fieldType === DOUBLE) {
     return 'double';
   }
 
-  if (fieldType === 'BigDecimal') {
+  if (fieldType === BIG_DECIMAL) {
     return 'decimal(21,2)';
   }
 
-  if (fieldType === 'LocalDate') {
+  if (fieldType === LOCAL_DATE) {
     return 'date';
   }
 
-  if (fieldType === 'Instant') {
+  if (fieldType === INSTANT) {
     // eslint-disable-next-line no-template-curly-in-string
     return '${datetimeType}';
   }
 
-  if (fieldType === 'ZonedDateTime') {
+  if (fieldType === ZONED_DATE_TIME) {
     // eslint-disable-next-line no-template-curly-in-string
     return '${datetimeType}';
   }
 
-  if (fieldType === 'Duration') {
+  if (fieldType === DURATION) {
     return 'bigint';
   }
 
-  if (fieldType === 'UUID') {
+  if (fieldType === UUID) {
     // eslint-disable-next-line no-template-curly-in-string
     return '${uuidType}';
   }
 
-  if (fieldType === 'byte[]' && field.fieldTypeBlobContent !== 'text') {
+  if (fieldType === BYTES && field.fieldTypeBlobContent !== TEXT) {
     const { prodDatabaseType } = entity;
-    if (prodDatabaseType === 'mysql' || prodDatabaseType === 'postgresql' || prodDatabaseType === 'mariadb') {
+    if (prodDatabaseType === MYSQL || prodDatabaseType === POSTGRESQL || prodDatabaseType === MARIADB) {
       return 'longblob';
     }
 
     return 'blob';
   }
 
-  if (field.fieldTypeBlobContent === 'text') {
+  if (field.fieldTypeBlobContent === TEXT) {
     // eslint-disable-next-line no-template-curly-in-string
     return '${clobType}';
   }
 
-  if (fieldType === 'Boolean') {
+  if (fieldType === BOOLEAN) {
     return 'boolean';
   }
 
@@ -154,7 +161,11 @@ function parseLiquibaseLoadColumnType(entity, field) {
   }
 
   // eslint-disable-next-line no-template-curly-in-string
-  if (['date', '${datetimeType}', 'boolean'].includes(columnType)) {
+  if (['date', '${datetimeType}'].includes(columnType)) {
+    return 'date';
+  }
+
+  if (columnType === 'boolean') {
     return columnType;
   }
 
@@ -171,8 +182,8 @@ function parseLiquibaseLoadColumnType(entity, field) {
   if (
     // eslint-disable-next-line no-template-curly-in-string
     columnType === '${uuidType}' &&
-    prodDatabaseType !== 'mysql' &&
-    prodDatabaseType !== 'mariadb'
+    prodDatabaseType !== MYSQL &&
+    prodDatabaseType !== MARIADB
   ) {
     // eslint-disable-next-line no-template-curly-in-string
     return '${uuidType}';
@@ -184,8 +195,8 @@ function parseLiquibaseLoadColumnType(entity, field) {
 function prepareFieldForLiquibaseTemplates(entity, field) {
   _.defaults(field, {
     columnType: parseLiquibaseColumnType(entity, field),
-    shouldDropDefaultValue: field.fieldType === 'ZonedDateTime' || field.fieldType === 'Instant',
-    shouldCreateContentType: field.fieldType === 'byte[]' && field.fieldTypeBlobContent !== 'text',
+    shouldDropDefaultValue: field.fieldType === ZONED_DATE_TIME || field.fieldType === INSTANT,
+    shouldCreateContentType: field.fieldType === BYTES && field.fieldTypeBlobContent !== TEXT,
     nullable: !(field.fieldValidate === true && field.fieldValidateRules.includes('required')),
   });
   _.defaults(field, {

package/utils/multi-step-transform/index.js

@@ -0,0 +1,52 @@
+const { default: PQueue } = require('p-queue');
+const { PTransform } = require('p-transform');
+const { isFilePending } = require('mem-fs-editor/lib/state');
+
+const { TemplateFileFs } = require('./template-file-fs');
+
+module.exports.MultiStepTransform = class MultiStepTransform extends PTransform {
+  constructor(options = {}) {
+    super({ logName: 'jhipster:multi-step-transform', ...options });
+
+    this.twoStepTemplateQueue = new PQueue({ concurrency: 1, autoStart: false });
+    this.templateFileFs = new TemplateFileFs(options);
+
+    // Keep track of existing files, they should take precedence over multi-step templates.
+    this.pendingFiles = [];
+  }
+
+  async queuedTransform(file, enc) {
+    try {
+      if (file.contents && this.templateFileFs.isTemplate(file.path)) {
+        const templateFile = this.templateFileFs.add(file.path, file.contents.toString());
+        if (templateFile.rootTemplate) {
+          // If multi-step root, postpone.
+          this.twoStepTemplateQueue.add(() => {
+            if (this.pendingFiles.includes(templateFile.basePath)) {
+              return;
+            }
+            file.path = templateFile.basePath;
+            file.contents = Buffer.from(templateFile.render().concat('\n'));
+            this.push(file);
+          });
+        } else {
+          delete file.state;
+        }
+      } else {
+        if (isFilePending(file)) {
+          this.pendingFiles.push(file.path);
+        }
+        this.push(file);
+      }
+    } catch (error) {
+      this.destroy(error);
+    }
+  }
+
+  _flush(callback) {
+    // Clear normal queue before templates.
+    this.flushQueue()
+      .then(() => this.twoStepTemplateQueue.start().onIdle())
+      .then(() => super._flush(callback));
+  }
+};

package/utils/multi-step-transform/template-data.js

@@ -0,0 +1,60 @@
+module.exports.TemplateData = class TemplateData {
+  constructor(templateFile, defaultData = {}) {
+    this._templateFile = templateFile;
+    this._defaultData = defaultData;
+    this._sections = {};
+    this._defaultFragment = {};
+  }
+
+  registerSections(sections) {
+    this._sections = sections;
+    this._defaultFragment = Object.fromEntries(Object.keys(this._sections).map(section => [section, false]));
+    Object.keys(this._sections).forEach(section => {
+      this[section] = (fragmentData, suffix) => this.renderSection(section, fragmentData, suffix);
+    });
+  }
+
+  renderSection(section, fragmentData, suffix) {
+    if (typeof fragmentData === 'string') {
+      suffix = fragmentData;
+      fragmentData = {};
+    }
+    if (!this[`_${section}`]) {
+      this[`_${section}`] = this.render(
+        { ...fragmentData, fragment: { [section]: true }, section, sections: Object.keys(this._sections) },
+        suffix
+      );
+    }
+    return this[`_${section}`];
+  }
+
+  /**
+   * Render fragments using default join and suffix.
+   */
+  render(fragmentData = {}, suffix = '\n') {
+    const { join = '\n' } = fragmentData;
+    const renderedFragments = this.renderFragments(fragmentData).filter(fragment => fragment);
+    const section = fragmentData.section || this._defaultData.section;
+    if (section) {
+      const limit = this._sections[section];
+      if (limit && renderedFragments.length > limit) {
+        throw new Error(`${section} must have at most ${limit} fragments`);
+      }
+    }
+    const rendered = renderedFragments.join(join);
+    this.last = rendered;
+    return rendered && suffix ? `${rendered}${suffix}` : rendered;
+  }
+
+  /**
+   * Proxy to renderFragments for templates.
+   */
+  renderFragments(fragmentData = {}) {
+    const fragment = { ...this._defaultData.fragment, ...fragmentData.fragment };
+    if (this._defaultData.section && fragmentData.section) {
+      // Disable section passed by the parent.
+      fragment[this._defaultData.section] = false;
+    }
+    return this._templateFile.renderFragments({ ...this._defaultData, ...fragmentData, fragment });
+  }
+};

package/utils/multi-step-transform/template-file-fs.js

@@ -0,0 +1,43 @@
+const assert = require('assert');
+const minimatch = require('minimatch');
+const path = require('path');
+
+const { TemplateFile } = require('./template-file');
+
+module.exports.TemplateFileFs = class TemplateFileFs {
+  constructor(options = {}) {
+    this.extension = options.extension || 'jhi';
+    this.delimiter = options.delimiter || '&';
+    this.fragmentFiles = {};
+  }
+
+  isTemplate(filePath) {
+    return this.isRootTemplate(filePath) || this.isDerivedTemplate(filePath);
+  }
+
+  isRootTemplate(filePath) {
+    return path.extname(filePath) === `.${this.extension}`;
+  }
+
+  isDerivedTemplate(filePath) {
+    return minimatch(filePath, `**/*.${this.extension}.*`, { dot: true });
+  }
+
+  add(filePath, contents) {
+    assert(filePath, 'filePath is required');
+    assert(contents, 'contents is required');
+
+    const templateFile = this.get(filePath);
+    templateFile.compile(filePath, contents, { delimiter: this.delimiter });
+    if (!templateFile.rootTemplate) {
+      this.get(templateFile.parentPath).addFragment(templateFile);
+    }
+    return templateFile;
+  }
+
+  get(filePath) {
+    assert(filePath, 'filePath is required');
+    this.fragmentFiles[filePath] = this.fragmentFiles[filePath] || new TemplateFile(path.basename(filePath), this.extension);
+    return this.fragmentFiles[filePath];
+  }
+};

package/utils/multi-step-transform/template-file.js

@@ -0,0 +1,84 @@
+const assert = require('assert');
+const debugBuilder = require('debug');
+const ejs = require('ejs');
+const path = require('path');
+
+const { TemplateData } = require('./template-data');
+
+module.exports.TemplateFile = class TemplateFile {
+  constructor(filename, extension) {
+    this._filename = filename;
+    this._extension = extension;
+    this._compiled = () => '';
+    this._fragments = [];
+    this._fragmentName = filename.split(`.${this._extension}.`)[1] || '';
+    this._debug = debugBuilder(`jhipster.templates.${this._filename}`);
+
+    this.rootTemplate = !this._fragmentName;
+    if (!this.rootTemplate) {
+      this.depth = (this._fragmentName.match(/\./g) || []).length + 1;
+    } else {
+      this.depth = 0;
+    }
+  }
+
+  compile(filePath, contents, options) {
+    assert(filePath, 'filePath is required');
+    assert(contents, 'contents is required');
+    assert(options, 'options is required');
+
+    this.filePath = filePath;
+    if (this.rootTemplate) {
+      this.basePath = filePath.slice(0, -path.extname(filePath).length);
+    } else {
+      this.parentPath = filePath.slice(0, -path.extname(filePath).length);
+    }
+
+    if (this._debug.enabled) {
+      this._debug(filePath);
+      this._debug('======');
+      this._debug(contents);
+    }
+
+    this._compiled = ejs.compile(contents, options);
+  }
+
+  addFragment(templateFile) {
+    assert(templateFile, 'templateFile is required');
+
+    this._fragments.push(templateFile);
+  }
+
+  renderFragments(data) {
+    return this._fragments.map(templateFile => templateFile.render(data));
+  }
+
+  render(data = {}) {
+    const fragments = new TemplateData(this, data);
+    try {
+      const rendered = this._compiled({
+        fragment: false,
+        fragmentName: this._fragmentName,
+        fragments,
+        ...data,
+      })
+        .trimEnd()
+        .replace(/^(\r\n|\n|\r)+/, '');
+      if (this._debug.enabled) {
+        this._debug(`${this.filePath}`);
+        this._debug(`${JSON.stringify(data)}`);
+        this._debug('======');
+        this._debug(rendered);
+        this._debug('======');
+      }
+      return rendered;
+    } catch (error) {
+      /* eslint-disable no-console */
+      console.log(`Error rendering ${this._filename}`);
+      console.log(`Available sessions ${data.sections}`);
+      console.log(error);
+      /* eslint-enable no-console */
+      throw error;
+    }
+  }
+};

package/NOTICE

@@ -1,4 +0,0 @@
-JHipster
-Copyright 2013-2021 the original author or authors from the JHipster project.
-
-For more information on the JHipster project, see https://www.jhipster.tech/