generator-jhipster 8.7.0 → 8.7.2

package/dist/generators/base-application/support/prepare-entity.js

@@ -21,7 +21,8 @@ import pluralize from 'pluralize';
 import { getDatabaseTypeData, hibernateSnakeCase } from '../../server/support/index.js';
 import { createFaker, getMicroserviceAppName, mutateData, parseChangelog, stringHashCode, upperFirstCamelCase, } from '../../base/support/index.js';
 import { getEntityParentPathAddition, getTypescriptKeyType } from '../../client/support/index.js';
-import { applicationTypes, binaryOptions, databaseTypes, entityOptions, fieldTypes, searchEngineTypes, } from '../../../jdl/jhipster/index.js';
+import { applicationTypes, databaseTypes, entityOptions, fieldTypes, searchEngineTypes } from '../../../lib/jhipster/index.js';
+import { binaryOptions } from '../../../lib/jdl/core/built-in-options/index.js';
 import { fieldIsEnum } from './field-utils.js';
 import { fieldToReference } from './prepare-field.js';
 const NO_SEARCH_ENGINE = searchEngineTypes.NO;
@@ -117,7 +118,12 @@ export default function prepareEntity(entityWithConfig, generator, application)
     const entitySuffix = entityWithConfig.entitySuffix ?? application.entitySuffix;
     mutateData(entityWithConfig, entityDefaultConfig, BASE_TEMPLATE_DATA);
     if (entityWithConfig.changelogDate) {
-        entityWithConfig.changelogDateForRecent = parseChangelog(String(entityWithConfig.changelogDate));
+        try {
+            entityWithConfig.changelogDateForRecent = parseChangelog(String(entityWithConfig.changelogDate));
+        }
+        catch (error) {
+            throw new Error(`Error parsing changelog date for entity ${entityName}: ${error.message}`, { cause: error });
+        }
     }
     entityWithConfig.entityAngularJSSuffix = entityWithConfig.angularJSSuffix;
     if (entityWithConfig.entityAngularJSSuffix && !entityWithConfig.entityAngularJSSuffix.startsWith('-')) {
@@ -228,9 +234,9 @@ export default function prepareEntity(entityWithConfig, generator, application)
 }
 export function derivedPrimaryKeyProperties(primaryKey) {
     mutateData(primaryKey, {
-        hasUUID: primaryKey.fields && primaryKey.fields.some(field => field.fieldType === UUID),
-        hasLong: primaryKey.fields && primaryKey.fields.some(field => field.fieldType === LONG),
-        hasInteger: primaryKey.fields && primaryKey.fields.some(field => field.fieldType === INTEGER),
+        hasUUID: primaryKey.fields?.some(field => field.fieldType === UUID),
+        hasLong: primaryKey.fields?.some(field => field.fieldType === LONG),
+        hasInteger: primaryKey.fields?.some(field => field.fieldType === INTEGER),
         typeUUID: primaryKey.type === UUID,
         typeString: primaryKey.type === STRING,
         typeLong: primaryKey.type === LONG,
@@ -531,7 +537,7 @@ function preparePostEntityCommonDerivedPropertiesNotTyped(entity) {
         entity.fields.some(field => !field.id && !field.transient) ||
             entity.relationships.some(relationship => !relationship.id && relationship.persistableRelationship);
     entity.allReferences
-        .filter(reference => reference.relationship && reference.relationship.relatedField)
+        .filter(reference => reference.relationship?.relatedField)
         .forEach(reference => {
         reference.relatedReference = reference.relationship.relatedField.reference;
     });

package/dist/generators/base-application/support/prepare-field.d.ts

@@ -0,0 +1,25 @@
+export default function prepareField(entityWithConfig: any, field: any, generator: any): any;
+/**
+ * From an enum's values (with or without custom values), returns the enum's values without custom values.
+ * @param {String} [enumValues] - an enum's values.
+ * @return {Array<String>} the formatted enum's values.
+ */
+export declare function getEnumValuesWithCustomValues(enumValues: string): {
+    name: string;
+    value: string;
+}[];
+export declare function fieldToReference(entity: any, field: any, pathPrefix?: never[]): {
+    id: any;
+    entity: any;
+    field: any;
+    multiple: boolean;
+    owned: boolean;
+    doc: any;
+    readonly propertyJavadoc: any;
+    readonly propertyApiDescription: any;
+    label: any;
+    name: any;
+    type: any;
+    nameCapitalized: any;
+    path: any[];
+};

package/dist/generators/base-application/support/prepare-field.js

@@ -17,11 +17,11 @@
  * limitations under the License.
  */
 import { defaults, kebabCase, snakeCase, startCase, upperFirst } from 'lodash-es';
-import { fieldTypes, validations } from '../../../jdl/jhipster/index.js';
+import { fieldTypes, validations } from '../../../lib/jhipster/index.js';
 import { getTypescriptType, prepareField as prepareClientFieldForTemplates } from '../../client/support/index.js';
 import { prepareField as prepareServerFieldForTemplates } from '../../server/support/index.js';
-import { mutateData } from '../../base/support/config.js';
-import { fieldIsEnum } from './field-utils.js';
+import { mutateData } from '../../../lib/utils/object.js';
+import { fieldTypeValues, isFieldEnumType } from '../../../lib/application/field-types.js';
 import { prepareProperty } from './prepare-property.js';
 const { BlobTypes, CommonDBTypes, RelationalOnlyDBTypes } = fieldTypes;
 const { Validations: { MIN, MINLENGTH, MINBYTES, MAX, MAXBYTES, MAXLENGTH, PATTERN, REQUIRED, UNIQUE }, } = validations;
@@ -101,15 +101,24 @@ const fakeStringTemplateForFieldName = columnName => {
  */
 function generateFakeDataForField(field, faker, changelogDate, type = 'csv') {
     let data;
+    for (const prop of ['fieldValidateRulesMax', 'fieldValidateRulesMin', 'fieldValidateRulesMaxlength', 'fieldValidateRulesMinlength']) {
+        if (prop in field) {
+            try {
+                field[prop] = parseInt(field[prop], 10);
+            }
+            catch {
+                throw new Error(`Error parsing ${prop} for field ${field.fieldName}`);
+            }
+        }
+    }
     if (field.fakerTemplate) {
-        data = faker.faker(field.fakerTemplate);
+        data = faker.helpers.fake(field.fakerTemplate);
     }
-    else if (field.fieldValidate && field.fieldValidateRules.includes('pattern')) {
-        const re = field.createRandexp();
-        if (!re) {
+    else if (field.fieldValidate && field.fieldValidateRules?.includes('pattern')) {
+        const generated = field.generateFakeDataFromPattern();
+        if (!generated) {
             return undefined;
         }
-        const generated = re.gen();
         if (type === 'csv' || type === 'cypress') {
             data = generated.replace(/"/g, '');
         }
@@ -122,7 +131,7 @@ function generateFakeDataForField(field, faker, changelogDate, type = 'csv') {
         }
     }
     else if (field.fieldIsEnum) {
-        if (field.fieldValues.length !== 0) {
+        if (field.enumValues && field.enumValues.length > 0) {
             const enumValues = field.enumValues;
             data = enumValues[faker.number.int(enumValues.length - 1)].name;
         }
@@ -137,15 +146,15 @@ function generateFakeDataForField(field, faker, changelogDate, type = 'csv') {
     }
     else if ([FLOAT, '${floatType}', DOUBLE, BIG_DECIMAL].includes(field.fieldType)) {
         data = faker.number.float({
-            max: field.fieldValidateRulesMax ? parseInt(field.fieldValidateRulesMax, 10) : 32767,
-            min: field.fieldValidateRulesMin ? parseInt(field.fieldValidateRulesMin, 10) : 0,
+            max: field.fieldValidateRulesMax ?? 32767,
+            min: field.fieldValidateRulesMin ?? 0,
             multipleOf: 0.01,
         });
     }
     else if ([INTEGER, LONG, DURATION].includes(field.fieldType)) {
         data = faker.number.int({
-            max: field.fieldValidateRulesMax ? parseInt(field.fieldValidateRulesMax, 10) : 32767,
-            min: field.fieldValidateRulesMin ? parseInt(field.fieldValidateRulesMin, 10) : 0,
+            max: field.fieldValidateRulesMax ?? 32767,
+            min: field.fieldValidateRulesMin ?? 0,
         });
     }
     else if ([INSTANT, ZONED_DATE_TIME, LOCAL_DATE].includes(field.fieldType)) {
@@ -169,10 +178,10 @@ function generateFakeDataForField(field, faker, changelogDate, type = 'csv') {
             }
         }
     }
-    else if (field.fieldType === BYTES && field.fieldTypeBlobContent !== TEXT) {
+    else if (field.fieldTypeBinary && field.fieldTypeBlobContent !== TEXT) {
         data = '../fake-data/blob/hipster.png';
     }
-    else if (field.fieldType === BYTES && field.fieldTypeBlobContent === TEXT) {
+    else if (field.fieldTypeBinary && field.fieldTypeBlobContent === TEXT) {
         data = '../fake-data/blob/hipster.txt';
     }
     else if (field.fieldType === STRING) {
@@ -191,16 +200,16 @@ function generateFakeDataForField(field, faker, changelogDate, type = 'csv') {
         data = Buffer.from(data).toString('base64');
     }
     // Validation rules
-    if (data !== undefined && field.fieldValidate === true) {
+    if (data !== undefined && field.fieldValidate === true && field.fieldValidateRules) {
+        const { fieldValidateRulesMinlength = 0, fieldValidateRulesMaxlength } = field;
         // manage String max length
-        if (field.fieldValidateRules.includes(MAXLENGTH)) {
+        if (field.fieldValidateRules.includes(MAXLENGTH) && fieldValidateRulesMaxlength !== undefined) {
             const maxlength = field.fieldValidateRulesMaxlength;
             data = data.substring(0, maxlength);
         }
         // manage String min length
-        if (field.fieldValidateRules.includes(MINLENGTH)) {
-            const minlength = field.fieldValidateRulesMinlength;
-            data = data.length > minlength ? data : data + 'X'.repeat(minlength - data.length);
+        if (field.fieldValidateRules.includes(MINLENGTH) && fieldValidateRulesMinlength !== undefined) {
+            data = data.length > fieldValidateRulesMinlength ? data : data + 'X'.repeat(fieldValidateRulesMinlength - data.length);
         }
         // test if generated data is still compatible with the regexp as we potentially modify it with min/maxLength
         if (field.fieldValidateRules.includes(PATTERN) && !new RegExp(`^${field.fieldValidateRulesPattern}$`).test(data)) {
@@ -212,7 +221,7 @@ function generateFakeDataForField(field, faker, changelogDate, type = 'csv') {
         if (type === 'ts' && ![BOOLEAN, INTEGER, LONG, FLOAT, '${floatType}', DOUBLE, BIG_DECIMAL].includes(field.fieldType)) {
             data = `'${typeof data === 'string' ? data.replace(/\\/g, '\\\\').replace(/'/g, "\\'") : data}'`;
         }
-        else if (type === 'csv' && field.fieldValidate && field.fieldValidateRules.includes(PATTERN)) {
+        else if (type === 'csv' && field.fieldValidate && field.fieldValidateRules?.includes(PATTERN)) {
             data = `"${typeof data === 'string' ? data.replace(/"/g, '\\"') : data}"`;
         }
     }
@@ -265,7 +274,7 @@ export default function prepareField(entityWithConfig, field, generator) {
     if (entityWithConfig.prodDatabaseType || entityWithConfig.databaseType) {
         prepareServerFieldForTemplates(entityWithConfig, field, generator);
     }
-    prepareClientFieldForTemplates(entityWithConfig, field, generator);
+    prepareClientFieldForTemplates(entityWithConfig, field);
     return field;
 }
 function prepareCommonFieldForTemplates(entityWithConfig, field, generator) {
@@ -284,8 +293,12 @@ function prepareCommonFieldForTemplates(entityWithConfig, field, generator) {
         entity: entityWithConfig,
     });
     const fieldType = field.fieldType;
-    field.fieldIsEnum = !field.id && fieldIsEnum(fieldType);
-    if (field.fieldIsEnum) {
+    const fieldIsEnum = isFieldEnumType(field);
+    field.fieldIsEnum = fieldIsEnum;
+    if (fieldIsEnum) {
+        if (fieldTypeValues.includes(fieldType)) {
+            throw new Error(`Field type '${fieldType}' is a reserved keyword and can't be used as an enum name.`);
+        }
         field.enumFileName = kebabCase(field.fieldType);
         field.enumValues = getEnumValuesWithCustomValues(field.fieldValues);
     }
@@ -302,6 +315,21 @@ function prepareCommonFieldForTemplates(entityWithConfig, field, generator) {
         field.maxlength = field.fieldValidateRulesMaxlength || 255;
     }
     const faker = entityWithConfig.faker;
+    field.generateFakeDataFromPattern = () => {
+        // check if regex is valid. If not, issue warning and we skip fake data generation.
+        try {
+            new RegExp(field.fieldValidateRulesPattern);
+        }
+        catch {
+            generator.log.warn(`${field.fieldName} pattern is not valid: ${field.fieldValidateRulesPattern}. Skipping generating fake data. `);
+            return undefined;
+        }
+        const re = faker.createRandexp(field.fieldValidateRulesPattern);
+        if (!re) {
+            generator.log.warn(`Error creating generator for pattern ${field.fieldValidateRulesPattern}`);
+        }
+        return re?.gen();
+    };
     field.createRandexp = () => {
         // check if regex is valid. If not, issue warning and we skip fake data generation.
         try {

package/dist/generators/base-application/support/prepare-property.d.ts

@@ -0,0 +1,3 @@
+import type { Field } from '../../../lib/types/application/field.js';
+import type { Relationship } from '../../../lib/types/application/relationship.js';
+export declare const prepareProperty: (property: Field | Relationship) => void;

package/dist/generators/base-application/support/prepare-property.js

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 import { snakeCase, upperFirst } from 'lodash-es';
-import { mutateData } from '../../base/support/config.js';
+import { mutateData } from '../../../lib/utils/object.js';
 export const prepareProperty = (property) => {
     mutateData(property, {
         __override__: false,

package/dist/generators/base-application/support/prepare-relationship.d.ts

@@ -0,0 +1,4 @@
+import type CoreGenerator from '../../base-core/generator.js';
+import type { Relationship } from '../../../lib/types/application/relationship.js';
+import type { Entity } from '../../../lib/types/application/entity.js';
+export default function prepareRelationship(entityWithConfig: Entity, relationship: Relationship<Omit<Entity, 'relationships'>>, generator: CoreGenerator, ignoreMissingRequiredRelationship?: boolean): Relationship<Omit<Entity<import("../index.js").Field, never>, "relationships">>;

package/dist/generators/base-application/support/prepare-relationship.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * Copyright 2013-2024 the original author or authors from the JHipster project.
  *
@@ -18,11 +19,11 @@
  */
 import { lowerFirst, startCase, upperFirst } from 'lodash-es';
 import pluralize from 'pluralize';
-import { checkAndReturnRelationshipOnValue, databaseTypes, entityOptions, validations } from '../../../jdl/jhipster/index.js';
+import { checkAndReturnRelationshipOnValue, databaseTypes, entityOptions, validations } from '../../../lib/jhipster/index.js';
 import { getJoinTableName, hibernateSnakeCase } from '../../server/support/index.js';
-import { mutateData } from '../../base/support/config.js';
-import { stringifyApplicationData } from './debug.js';
+import { mutateData } from '../../../lib/utils/object.js';
 import { prepareProperty } from './prepare-property.js';
+import { stringifyApplicationData } from './debug.js';
 const { NEO4J, NO: DATABASE_NO } = databaseTypes;
 const { MapperTypes } = entityOptions;
 const { Validations: { REQUIRED }, } = validations;
@@ -31,7 +32,7 @@ function _defineOnUpdateAndOnDelete(relationship, generator) {
     relationship.onDelete = checkAndReturnRelationshipOnValue(relationship.options?.onDelete, generator);
     relationship.onUpdate = checkAndReturnRelationshipOnValue(relationship.options?.onUpdate, generator);
 }
-export default function prepareRelationship(entityWithConfig, relationship, generator, ignoreMissingRequiredRelationship) {
+export default function prepareRelationship(entityWithConfig, relationship, generator, ignoreMissingRequiredRelationship = false) {
     const entityName = entityWithConfig.name;
     const { otherEntityName, relationshipSide, relationshipType, relationshipName } = relationship;
     if (!relationship.otherEntity) {
@@ -183,7 +184,7 @@ export default function prepareRelationship(entityWithConfig, relationship, gene
         relationship.otherEntityModelName = relationship.otherEntityFileName;
         relationship.otherEntityPath = relationship.otherEntityFolderName;
     }
-    if (relationship.relationshipValidateRules && relationship.relationshipValidateRules.includes(REQUIRED)) {
+    if (relationship.relationshipValidateRules?.includes(REQUIRED)) {
         if (entityName.toLowerCase() === relationship.otherEntityName.toLowerCase()) {
             generator.log.warn(`Error at entity ${entityName}: required relationships to the same entity are not supported.`);
         }

package/dist/generators/base-application/support/relationship.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { ValidationResult } from '../../base/api.js';
+import type { Entity } from '../../../lib/types/application/entity.js';
+import type { Relationship } from '../../../lib/types/application/relationship.js';
+export declare const otherRelationshipType: (relationshipType: any) => any;
+export declare const findOtherRelationshipInRelationships: (entityName: string, relationship: Relationship, inRelationships: Relationship[]) => Relationship<import("../../../lib/types/base/entity.js").Entity> | undefined;
+export declare const loadEntitiesAnnotations: (entities: Entity[]) => void;
+export declare const loadEntitiesOtherSide: (entities: Entity[], { application }?: {
+    application?: any;
+}) => ValidationResult;
+export declare const addOtherRelationship: (entity: Entity, otherEntity: Entity, relationship: Relationship) => Relationship;

package/dist/generators/base-application/support/relationship.js

@@ -17,8 +17,8 @@
  * limitations under the License.
  */
 import { lowerFirst, upperFirst } from 'lodash-es';
-import { stringifyApplicationData } from './debug.js';
 import { findEntityInEntities } from './entity.js';
+import { stringifyApplicationData } from './debug.js';
 export const otherRelationshipType = relationshipType => relationshipType.split('-').reverse().join('-');
 export const findOtherRelationshipInRelationships = (entityName, relationship, inRelationships) => {
     return inRelationships.find(otherRelationship => {
@@ -61,7 +61,7 @@ export const loadEntitiesOtherSide = (entities, { application } = {}) => {
                     if (!application || application.authenticationTypeOauth2) {
                         errors.push("oauth2 applications with database and '--sync-user-with-idp' option");
                     }
-                    if (!application || !application.authenticationTypeOauth2) {
+                    if (!application?.authenticationTypeOauth2) {
                         errors.push('jwt and session authentication types in monolith or gateway applications with database');
                     }
                     throw new Error(`Error at entity ${entity.name}: relationships with built-in User entity is supported in ${errors}.`);
@@ -91,12 +91,12 @@ export const loadEntitiesOtherSide = (entities, { application } = {}) => {
 export const addOtherRelationship = (entity, otherEntity, relationship) => {
     relationship.otherEntityRelationshipName = relationship.otherEntityRelationshipName ?? lowerFirst(entity.name);
     const otherRelationship = {
-        otherEntity: entity,
         otherEntityName: lowerFirst(entity.name),
-        ownerSide: !relationship.ownerSide,
         otherEntityRelationshipName: relationship.relationshipName,
         relationshipName: relationship.otherEntityRelationshipName,
         relationshipType: otherRelationshipType(relationship.relationshipType),
+        otherEntity: entity,
+        ownerSide: !relationship.ownerSide,
         otherRelationship: relationship,
     };
     otherEntity.relationships = otherEntity.relationships ?? [];

package/dist/generators/base-application/support/task-type-inference.d.ts

@@ -0,0 +1,25 @@
+import type { ApplicationType } from '../../../lib/types/application/application.js';
+import type { TaskTypes } from '../../../lib/types/application/tasks.js';
+import type CoreGenerator from '../../base-core/generator.js';
+import type { WriteFileBlock, WriteFileSection } from '../../base/api.js';
+import type { Entity } from '../../../lib/types/application/entity.js';
+export declare function asWriteFilesSection<Data = ApplicationType<Entity>>(section: WriteFileSection<Data>): WriteFileSection<Data>;
+export declare function asWriteFilesBlock<Data = ApplicationType<Entity>>(section: WriteFileBlock<Data>): WriteFileBlock<Data>;
+export declare function asInitializingTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['InitializingTaskParam']) => void): (this: G, params: TaskTypes<E, A>["InitializingTaskParam"]) => void;
+export declare function asPromptingTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['PromptingTaskParam']) => void): (this: G, params: TaskTypes<E, A>["PromptingTaskParam"]) => void;
+export declare function asConfiguringTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['ConfiguringTaskParam']) => void): (this: G, params: TaskTypes<E, A>["ConfiguringTaskParam"]) => void;
+export declare function asComposingTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['ComposingTaskParam']) => void): (this: G, params: TaskTypes<E, A>["ComposingTaskParam"]) => void;
+export declare function asLoadingTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['LoadingTaskParam']) => void): (this: G, params: TaskTypes<E, A>["LoadingTaskParam"]) => void;
+export declare function asPreparingTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['PreparingTaskParam']) => void): (this: G, params: TaskTypes<E, A>["PreparingTaskParam"]) => void;
+export declare function asPostPreparingTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['PostPreparingTaskParam']) => void): (this: G, params: TaskTypes<E, A>["PostPreparingTaskParam"]) => void;
+export declare function asPreparingEachEntityTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['PreparingEachEntityTaskParam']) => void): (this: G, params: TaskTypes<E, A>["PreparingEachEntityTaskParam"]) => void;
+export declare function asPreparingEachEntityFieldTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['PreparingEachEntityFieldTaskParam']) => void): (this: G, params: TaskTypes<E, A>["PreparingEachEntityFieldTaskParam"]) => void;
+export declare function asPreparingEachEntityRelationshipTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['PreparingEachEntityRelationshipTaskParam']) => void): (this: G, params: TaskTypes<E, A>["PreparingEachEntityRelationshipTaskParam"]) => void;
+export declare function asPostPreparingEachEntityTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['PostPreparingEachEntityTaskParam']) => void): (this: G, params: TaskTypes<E, A>["PostPreparingEachEntityTaskParam"]) => void;
+export declare function asDefaultTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['DefaultTaskParam']) => void): (this: G, params: TaskTypes<E, A>["DefaultTaskParam"]) => void;
+export declare function asWritingTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['WritingTaskParam']) => void): (this: G, params: TaskTypes<E, A>["WritingTaskParam"]) => void;
+export declare function asWritingEntitiesTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['WritingEntitiesTaskParam']) => void): (this: G, params: TaskTypes<E, A>["WritingEntitiesTaskParam"]) => void;
+export declare function asPostWritingTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['PostWritingTaskParam']) => void): (this: G, params: TaskTypes<E, A>["PostWritingTaskParam"]) => void;
+export declare function asPostWritingEntitiesTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['PostWritingEntitiesTaskParam']) => void): (this: G, params: TaskTypes<E, A>["PostWritingEntitiesTaskParam"]) => void;
+export declare function asInstallTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['InstallTaskParam']) => void): (this: G, params: TaskTypes<E, A>["InstallTaskParam"]) => void;
+export declare function asEndTask<E = Entity, A = ApplicationType<E>, const G extends CoreGenerator = CoreGenerator>(task: (this: G, params: TaskTypes<E, A>['EndTaskParam']) => void): (this: G, params: TaskTypes<E, A>["EndTaskParam"]) => void;

package/dist/generators/base-application/types.d.ts

@@ -0,0 +1,191 @@
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+import type { ExportApplicationPropertiesFromCommand } from '../../lib/command/types.js';
+import type CoreGenerator from '../base-core/generator.ts';
+import type { ClientApplication } from '../client/types.js';
+import type { I18nApplication } from '../languages/types.js';
+import type { SpringBootApplication } from '../server/types.js';
+import type { OptionWithDerivedProperties } from './application-options.js';
+
+export type BaseApplication = {
+  jhipsterVersion: string;
+  baseName: string;
+  capitalizedBaseName: string;
+  dasherizedBaseName: string;
+  humanizedBaseName: string;
+  camelizedBaseName: string;
+  hipster: string;
+  lowercaseBaseName: string;
+  upperFirstCamelCaseBaseName: string;
+  documentationArchiveUrl: string;
+
+  projectVersion: string;
+  projectDescription: string;
+
+  jhiPrefix: string;
+  entitySuffix: string;
+  dtoSuffix: string;
+
+  skipCommitHook: boolean;
+  skipJhipsterDependencies: boolean;
+  fakerSeed?: string;
+
+  nodeVersion: string;
+  nodePackageManager: string;
+  nodeDependencies: Record<string, string>;
+
+  skipClient?: boolean;
+  skipServer?: boolean;
+  monorepository?: boolean;
+
+  /** Customize templates sourceFile and destinationFile */
+  customizeTemplatePaths: ((
+    this: CoreGenerator,
+    file: {
+      namespace: string;
+      sourceFile: string;
+      resolvedSourceFile: string;
+      destinationFile: string;
+      templatesRoots: string[];
+    },
+    context: any,
+  ) => undefined | { sourceFile: string; resolvedSourceFile: string; destinationFile: string; templatesRoots: string[] })[];
+} & I18nApplication;
+
+/* ApplicationType Start */
+type MicroservicesArchitectureApplication = {
+  microfrontend: boolean;
+  gatewayServerPort: number;
+};
+
+type GatewayApplication = MicroservicesArchitectureApplication & {
+  microfrontends: string[];
+};
+
+/*
+Deterministic option causes types to be too complex
+type ApplicationType = DeterministicOptionWithDerivedProperties<
+  'applicationType',
+  ['monolith', 'gateway', 'microservice'],
+  [Record<string, never>, GatewayApplication, MicroservicesArchitectureApplication]
+>;
+*/
+type ApplicationProperties = OptionWithDerivedProperties<'applicationType', ['monolith', 'gateway', 'microservice']> &
+  GatewayApplication &
+  MicroservicesArchitectureApplication;
+
+/* ApplicationType End */
+
+/* AuthenticationType Start */
+/*
+Deterministic option causes types to be too complex
+type UserManagement =
+  | {
+      skipUserManagement: true;
+      generateUserManagement: false;
+      generateBuiltInUserEntity?: false;
+      generateBuiltInAuthorityEntity: false;
+    }
+  | {
+      skipUserManagement: false;
+      generateBuiltInUserEntity?: boolean;
+      generateUserManagement: true;
+      user: any;
+      userManagement: any;
+      generateBuiltInAuthorityEntity: boolean;
+      authority: any;
+    };
+    */
+type UserManagement<Entity> = {
+  skipUserManagement: boolean;
+  generateUserManagement: boolean;
+  generateBuiltInUserEntity?: boolean;
+  generateBuiltInAuthorityEntity: boolean;
+  user: Entity;
+  userManagement: Entity;
+  authority: Entity;
+};
+type JwtApplication = {
+  jwtSecretKey: string;
+};
+
+type Oauth2Application = {
+  jwtSecretKey: string;
+  generateBuiltInUserEntity?: boolean;
+  user: any;
+  generateBuiltInAuthorityEntity: false;
+  generateUserManagement: false;
+};
+
+type SessionApplication = {
+  rememberMeKey: string;
+};
+
+/*
+Deterministic option causes types to be too complex
+type AuthenticationType = DeterministicOptionWithDerivedProperties<
+  'authenticationType',
+  ['jwt', 'oauth2', 'session'],
+  [JwtApplication, Oauth2Application, SessionApplication]
+>;
+*/
+type AuthenticationProperties<Entity> = OptionWithDerivedProperties<'authenticationType', ['jwt', 'oauth2', 'session']> &
+  UserManagement<Entity> &
+  JwtApplication &
+  Oauth2Application &
+  SessionApplication;
+
+/* AuthenticationType End */
+
+type QuirksApplication = {
+  cypressBootstrapEntities?: boolean;
+};
+
+export type CommonClientServerApplication<Entity> = BaseApplication &
+  QuirksApplication &
+  AuthenticationProperties<Entity> &
+  SpringBootApplication &
+  ClientApplication &
+  ExportApplicationPropertiesFromCommand<typeof import('../git/command.ts').default> &
+  ExportApplicationPropertiesFromCommand<typeof import('../project-name/command.ts').default> &
+  ApplicationProperties & {
+    clientRootDir: string;
+    clientSrcDir: string;
+    clientTestDir?: string;
+    clientDistDir?: string;
+    devServerPort: number;
+    pages: string[];
+
+    serverPort: number;
+    backendType?: string;
+    backendTypeJavaAny?: boolean;
+    backendTypeSpringBoot?: boolean;
+    temporaryDir?: string;
+
+    hipsterName?: string;
+    hipsterProductName?: string;
+    hipsterHomePageProductName?: string;
+    hipsterStackOverflowProductName?: string;
+    hipsterBugTrackerProductName?: string;
+    hipsterChatProductName?: string;
+    hipsterTwitterUsername?: string;
+    hipsterDocumentationLink?: string;
+    hipsterTwitterLink?: string;
+    hipsterProjectLink?: string;
+    hipsterStackoverflowLink?: string;
+    hipsterBugTrackerLink?: string;
+    hipsterChatLink?: string;
+
+    dockerServicesDir?: string;
+    dockerServices?: string[];
+    prettierExtensions?: string;
+
+    skipUserManagement?: boolean;
+    syncUserWithIdp?: boolean;
+    generateUserManagement?: boolean;
+  };
+
+type ServiceDiscoveryApplication = OptionWithDerivedProperties<'serviceDiscoveryType', ['no', 'eureka', 'consul']>;
+
+type MonitoringApplication = OptionWithDerivedProperties<'monitoring', ['no', 'elk', 'prometheus']>;
+
+export type PlatformApplication = ServiceDiscoveryApplication & MonitoringApplication;