generator-jhipster 8.7.1 → 8.7.2

package/dist/generators/angular/templates/src/main/webapp/app/core/interceptor/notification.interceptor.ts.ejs

@@ -25,7 +25,7 @@ import { AlertService } from 'app/core/util/alert.service';
 
 @Injectable()
 export class NotificationInterceptor implements HttpInterceptor {
-  private alertService = inject(AlertService);
+  private readonly alertService = inject(AlertService);
 
   intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
     return next.handle(request).pipe(

package/dist/generators/angular/templates/src/main/webapp/app/core/tracker/tracker.service.ts.ejs

@@ -43,14 +43,14 @@ export class TrackerService {
   private rxStomp?: RxStomp;
   private routerSubscription: Subscription | null = null;
 
-  private router = inject(Router);
-  private accountService = inject(AccountService);
+  private readonly router = inject(Router);
+  private readonly accountService = inject(AccountService);
 <%_ if (authenticationTypeSession) { _%>
-  private csrfService = inject(CSRFService);
+  private readonly csrfService = inject(CSRFService);
 <%_ } else if (authenticationTypeJwt) { _%>
-  private authServerProvider = inject(AuthServerProvider);
+  private readonly authServerProvider = inject(AuthServerProvider);
 <%_ } _%>
-  private location = inject(Location);
+  private readonly location = inject(Location);
 
   setup(): void {
     this.rxStomp = new RxStomp();

package/dist/generators/angular/templates/src/main/webapp/app/core/util/alert.service.ts.ejs

@@ -52,9 +52,9 @@ export class AlertService {
   private alertId = 0;
   private alerts: Alert[] = [];
 
-  private sanitizer = inject(DomSanitizer);
+  private readonly sanitizer = inject(DomSanitizer);
 <%_ if (enableTranslation) { _%>
-  private translateService = inject(TranslateService);
+  private readonly translateService = inject(TranslateService);
 <%_ } _%>
 
   clear(): void {

package/dist/generators/angular/templates/src/main/webapp/app/entities/_entityFolder_/list/_entityFile_.component.ts.ejs

@@ -137,10 +137,10 @@ export class <%= componentName %> implements OnInit {
     isFirstFetch = computed(() => Object.keys(this.links()).length === 0);
 <%_ } _%>
 
-    public router = inject(Router);
-    protected <%= entityInstance %>Service = inject(<%= entityAngularName %>Service);
-    protected activatedRoute = inject(ActivatedRoute);
-    protected sortService = inject(SortService);
+    public readonly router = inject(Router);
+    protected readonly <%= entityInstance %>Service = inject(<%= entityAngularName %>Service);
+    protected readonly activatedRoute = inject(ActivatedRoute);
+    protected readonly sortService = inject(SortService);
 <%_ if (paginationInfiniteScroll) { _%>
     protected parseLinks = inject(ParseLinks);
 <%_ } _%>

package/dist/generators/angular/templates/src/main/webapp/app/entities/_entityFolder_/service/_entityFile_.service.ts.ejs

@@ -84,8 +84,8 @@ export type EntityArrayResponseType = HttpResponse<I<%= entityAngularName %>[]>;
 
 @Injectable({ providedIn: 'root' })
 export class <%= entityAngularName %>Service {
-    protected http = inject(HttpClient);
-    protected applicationConfigService = inject(ApplicationConfigService);
+    protected readonly http = inject(HttpClient);
+    protected readonly applicationConfigService = inject(ApplicationConfigService);
 
     protected resourceUrl = this.applicationConfigService.getEndpointFor('api/<%= entityApiUrl %>'<% if ((applicationTypeGateway || applicationTypeMicroservice) && locals.microserviceName) { %>, '<%= microserviceName.toLowerCase() %>'<% } %>);
 <%_ if (searchEngineAny) { _%>

package/dist/generators/angular/templates/src/main/webapp/app/home/home.component.ts.ejs

@@ -49,11 +49,11 @@ export default class HomeComponent implements OnInit<% if (!authenticationTypeOa
   private readonly destroy$ = new Subject<void>();
 <%_ } _%>
 
-  private accountService = inject(AccountService);
+  private readonly accountService = inject(AccountService);
 <%_ if (!authenticationTypeOauth2) { _%>
-  private router = inject(Router);
+  private readonly router = inject(Router);
 <%_ } else { _%>
-  private loginService = inject(LoginService);
+  private readonly loginService = inject(LoginService);
 <%_ } _%>
 
   ngOnInit(): void {

package/dist/generators/angular/templates/src/main/webapp/app/layouts/main/main.component.ts.ejs

@@ -40,18 +40,18 @@ import PageRibbonComponent from '../profiles/page-ribbon.component';
 })
 export default class MainComponent implements OnInit {
 <%_ if (enableTranslation) { _%>
-  private renderer: Renderer2;
+  private readonly renderer: Renderer2;
 <%_ } _%>
 
-  private router = inject(Router);
-  private appPageTitleStrategy = inject(AppPageTitleStrategy);
-  private accountService = inject(AccountService);
+  private readonly router = inject(Router);
+  private readonly appPageTitleStrategy = inject(AppPageTitleStrategy);
+  private readonly accountService = inject(AccountService);
 <%_ if (enableI18nRTL) { _%>
-  private findLanguageFromKeyPipe = inject(FindLanguageFromKeyPipe);
+  private readonly findLanguageFromKeyPipe = inject(FindLanguageFromKeyPipe);
 <%_ } _%>
 <%_ if (enableTranslation) { _%>
-  private translateService = inject(TranslateService);
-  private rootRenderer = inject(RendererFactory2);
+  private readonly translateService = inject(TranslateService);
+  private readonly rootRenderer = inject(RendererFactory2);
 <%_ } _%>
 <%_ if (enableTranslation) { _%>
 

package/dist/generators/angular/templates/src/main/webapp/app/layouts/navbar/navbar.component.ts.ejs

@@ -70,19 +70,19 @@ export default class NavbarComponent implements OnInit {
   <%_ } _%>
 <%_ } _%>
 
-  private loginService = inject(LoginService);
+  private readonly loginService = inject(LoginService);
 <%_ if (enableTranslation) { _%>
-  private translateService = inject(TranslateService);
-  private stateStorageService = inject(StateStorageService);
+  private readonly translateService = inject(TranslateService);
+  private readonly stateStorageService = inject(StateStorageService);
   <%_ if (applicationTypeGateway && microfrontend) { _%>
-  private injector = inject(Injector);
+  private readonly injector = inject(Injector);
   <%_ } _%>
 <%_ } _%>
 <%_ if (applicationTypeGateway && microfrontend) { _%>
-  private accountService = inject(AccountService);
+  private readonly accountService = inject(AccountService);
 <%_ } _%>
-  private profileService = inject(ProfileService);
-  private router = inject(Router);
+  private readonly profileService = inject(ProfileService);
+  private readonly router = inject(Router);
 
   constructor() {
     if (VERSION) {

package/dist/generators/angular/templates/src/main/webapp/app/layouts/profiles/page-ribbon.component.ts.ejs

@@ -39,7 +39,7 @@ import { ProfileService } from './profile.service';
 export default class PageRibbonComponent implements OnInit {
   ribbonEnv$?: Observable<string | undefined>;
 
-  private profileService = inject(ProfileService);
+  private readonly profileService = inject(ProfileService);
 
   ngOnInit(): void {
     this.ribbonEnv$ = this.profileService.getProfileInfo().pipe(map(profileInfo => profileInfo.ribbonEnv));

package/dist/generators/angular/templates/src/main/webapp/app/layouts/profiles/profile.service.ts.ejs

@@ -26,10 +26,10 @@ import { ProfileInfo, InfoResponse } from './profile-info.model';
 
 @Injectable({ providedIn: 'root' })
 export class ProfileService {
-  private http = inject(HttpClient);
-  private applicationConfigService = inject(ApplicationConfigService);
+  private readonly http = inject(HttpClient);
+  private readonly applicationConfigService = inject(ApplicationConfigService);
 
-  private infoUrl = this.applicationConfigService.getEndpointFor('management/info');
+  private readonly infoUrl = this.applicationConfigService.getEndpointFor('management/info');
   private profileInfo$?: Observable<ProfileInfo>;
 
   getProfileInfo(): Observable<ProfileInfo> {

package/dist/generators/angular/templates/src/main/webapp/app/login/login.component.ts.ejs

@@ -41,9 +41,9 @@ export default class LoginComponent implements OnInit, AfterViewInit {
     rememberMe: new FormControl(false, { nonNullable: true, validators: [Validators.required] }),
   });
 
-  private accountService = inject(AccountService);
-  private loginService = inject(LoginService);
-  private router = inject(Router);
+  private readonly accountService = inject(AccountService);
+  private readonly loginService = inject(LoginService);
+  private readonly router = inject(Router);
 
   ngOnInit(): void {
     // if already authenticated then navigate to home page

package/dist/generators/angular/templates/src/main/webapp/app/login/login.service.ts.ejs

@@ -44,14 +44,14 @@ import { Login } from './login.model';
 @Injectable({ providedIn: 'root' })
 export class LoginService {
 <%_ if (authenticationTypeSession) { _%>
-  private applicationConfigService = inject(ApplicationConfigService);
+  private readonly applicationConfigService = inject(ApplicationConfigService);
 <%_ } _%>
 <%_ if (authenticationTypeOauth2) { _%>
-  private location = inject(Location);
+  private readonly location = inject(Location);
 <%_ } else { _%>
-  private accountService = inject(AccountService);
+  private readonly accountService = inject(AccountService);
 <%_ } _%>
-  private authServerProvider = inject(AuthServerProvider);
+  private readonly authServerProvider = inject(AuthServerProvider);
 
 <%_ if (authenticationTypeOauth2) { _%>
   login(): void {

package/dist/generators/angular/templates/src/main/webapp/app/shared/alert/alert-error.component.ts.ejs

@@ -40,10 +40,10 @@ export class AlertErrorComponent implements OnDestroy {
   errorListener: Subscription;
   httpErrorListener: Subscription;
 
-  private alertService = inject(AlertService);
-  private eventManager = inject(EventManager);
+  private readonly alertService = inject(AlertService);
+  private readonly eventManager = inject(EventManager);
 <% if (enableTranslation) { %>
-  private translateService = inject(TranslateService);
+  private readonly translateService = inject(TranslateService);
 <% } %>
 
   constructor() {

package/dist/generators/angular/templates/src/main/webapp/app/shared/alert/alert.component.ts.ejs

@@ -31,7 +31,7 @@ import { AlertService, Alert } from 'app/core/util/alert.service';
 export class AlertComponent implements OnInit, OnDestroy {
   alerts = signal<Alert[]>([]);
 
-  private alertService = inject(AlertService);
+  private readonly alertService = inject(AlertService);
 
   ngOnInit(): void {
     this.alerts.set(this.alertService.get());

package/dist/generators/angular/templates/src/main/webapp/app/shared/auth/has-any-authority.directive.ts.ejs

@@ -38,8 +38,8 @@ import { AccountService } from 'app/core/auth/account.service';
 export default class HasAnyAuthorityDirective {
   public authorities = input<string | string[]>([], { alias: '<%= jhiPrefix %>HasAnyAuthority' });
 
-  private templateRef = inject(TemplateRef<any>);
-  private viewContainerRef = inject(ViewContainerRef);
+  private readonly templateRef = inject(TemplateRef<any>);
+  private readonly viewContainerRef = inject(ViewContainerRef);
 
   constructor() {
     const accountService = inject(AccountService);

package/dist/generators/angular/templates/src/main/webapp/app/shared/language/translate.directive.ts.ejs

@@ -36,8 +36,8 @@ export default class TranslateDirective implements OnChanges, OnInit, OnDestroy
 
   private readonly directiveDestroyed = new Subject();
 
-  private el = inject(ElementRef);
-  private translateService = inject(TranslateService);
+  private readonly el = inject(ElementRef);
+  private readonly translateService = inject(TranslateService);
 
   ngOnInit(): void {
     this.translateService.onLangChange.pipe(takeUntil(this.directiveDestroyed)).subscribe(() => {

package/dist/generators/angular/templates/src/main/webapp/app/shared/language/translation.module.ts.ejs

@@ -42,9 +42,9 @@ function lazyTranslatePartialLoader(http: HttpClient): TranslateLoader {
   ],
 })
 export class LazyTranslationModule {
-  private translateService = inject(TranslateService);
-  private translateLoader = inject(TranslateLoader);
-  private stateStorageService = inject(StateStorageService);
+  private readonly translateService = inject(TranslateService);
+  private readonly translateLoader = inject(TranslateLoader);
+  private readonly stateStorageService = inject(StateStorageService);
 
   constructor() {
     const { currentLang } = this.translateService.store;

package/dist/generators/angular/templates/src/main/webapp/app/shared/sort/sort-by.directive.ts.ejs

@@ -35,7 +35,7 @@ export class SortByDirective {
   protected sortAscIcon = faSortUp;
   protected sortDescIcon = faSortDown;
 
-  private sort = inject(SortDirective, { host: true });
+  private readonly sort = inject(SortDirective, { host: true });
 
   constructor() {
     effect(() => {

package/dist/generators/angular/templates/src/main/webapp/app/shared/sort/sort.service.ts.ejs

@@ -21,7 +21,7 @@ import { SortState } from './sort-state';
 
 @Injectable({ providedIn: 'root' })
 export class SortService {
-  private collator = new Intl.Collator(undefined, {
+  private readonly collator = new Intl.Collator(undefined, {
     numeric: true,
     sensitivity: 'base',
   });

package/dist/generators/base/api.d.ts

@@ -43,6 +43,9 @@ export type JHipsterGeneratorOptions = BaseOptions &
     jhipsterContext?: any;
     composeWithLocalBlueprint?: boolean;
 
+    /** boostrap options */
+    applyDefaults?: <const data = any>(data: data) => data;
+
     /* generate-blueprint options */
     localBlueprint?: boolean;
 
@@ -118,16 +121,19 @@ export type CascatedEditFileCallback<Generator = CoreGenerator> = (
   ...callbacks: EditFileCallback<Generator>[]
 ) => CascatedEditFileCallback<Generator>;
 
+type DataCallback<Type, DataType = ApplicationType<Entity>, Generator = CoreGenerator> = Type | ((this: Generator, data: DataType) => Type);
+
 export type WriteFileTemplate<DataType = ApplicationType<Entity>, Generator = CoreGenerator> =
   | string
   | ((this: Generator, data: DataType, filePath: string) => string)
   | {
+      condition?: DataCallback<boolean, DataType, Generator>;
       /** source file */
-      sourceFile?: string | ((this: Generator, data: DataType) => string);
+      sourceFile?: DataCallback<string, DataType, Generator>;
       /** destination file */
-      destinationFile?: string | ((this: Generator, destinationFile: DataType) => string);
+      destinationFile?: DataCallback<string, DataType, Generator>;
       /** @deprecated, use sourceFile instead */
-      file?: string | ((this: Generator, data: DataType) => string);
+      file?: DataCallback<string, DataType, Generator>;
       /** @deprecated, use destinationFile instead */
       renameTo?: string | ((this: Generator, data: DataType, filePath: string) => string);
       /** transforms (files processing) to be applied */
@@ -136,7 +142,7 @@ export type WriteFileTemplate<DataType = ApplicationType<Entity>, Generator = Co
       binary?: boolean;
       /** ejs options. Refer to https://ejs.co/#docs */
       options?: Record<string, object>;
-      override?: boolean | ((this: Generator, data: DataType) => boolean);
+      override?: DataCallback<boolean, DataType, Generator>;
     };
 
 export type WriteFileBlock<DataType = ApplicationType<Entity>, Generator = CoreGenerator> = {

package/dist/generators/base/generator.d.ts

@@ -16,6 +16,10 @@ export default class JHipsterBaseBlueprintGenerator<TaskTypes extends BaseTaskTy
      * Filter generator's tasks in case the blueprint should be responsible on queueing those tasks.
      */
     delegateTasksToBlueprint<TaskGroupType>(tasksGetter: () => TaskGroupType): TaskGroupType;
+    /**
+     * Utility method to get typed objects for autocomplete.
+     */
+    asAnyTaskGroup<const K extends string>(taskGroup: GenericTaskGroup<this, any, K>): GenericTaskGroup<any, any, K>;
     /**
      * Priority API stub for blueprints.
      *

package/dist/generators/base/generator.js

@@ -82,6 +82,12 @@ export default class JHipsterBaseBlueprintGenerator extends CoreGenerator {
     delegateTasksToBlueprint(tasksGetter) {
         return this.delegateToBlueprint ? {} : tasksGetter();
     }
+    /**
+     * Utility method to get typed objects for autocomplete.
+     */
+    asAnyTaskGroup(taskGroup) {
+        return taskGroup;
+    }
     /**
      * Priority API stub for blueprints.
      *
@@ -452,8 +458,11 @@ export default class JHipsterBaseBlueprintGenerator extends CoreGenerator {
     async _configureBlueprints() {
         let argvBlueprints = this.options.blueprints || '';
         // check for old single blueprint declaration
-        const { blueprint } = this.options;
+        let { blueprint } = this.options;
         if (blueprint) {
+            if (typeof blueprint === 'string') {
+                blueprint = [blueprint];
+            }
             this.log.warn('--blueprint option is deprecated. Please use --blueprints instead');
             argvBlueprints = union(blueprint, argvBlueprints.split(',')).join(',');
         }

package/dist/generators/base/shared-data.js

@@ -89,6 +89,8 @@ export default class SharedData {
             removeFiles,
             customizeRemoveFiles: [],
             cleanupFiles: async (cleanup) => {
+                if (!jhipsterOldVersion)
+                    return;
                 await Promise.all(Object.entries(cleanup).map(async ([version, files]) => {
                     const stringFiles = [];
                     for (const file of files) {

package/dist/generators/base/support/faker.d.ts

@@ -22,7 +22,7 @@ declare class RandexpWithFaker extends Randexp {
     faker: Faker;
     constructor(regexp: string | RegExp, flags: string | undefined, faker: Faker);
 }
-declare class FakerWithRandexp extends Faker {
+export declare class FakerWithRandexp extends Faker {
     createRandexp(regexp: string | RegExp, flags?: string): RandexpWithFaker;
 }
 /**

package/dist/generators/base/support/faker.js

@@ -34,7 +34,7 @@ class RandexpWithFaker extends Randexp {
         };
     }
 }
-class FakerWithRandexp extends Faker {
+export class FakerWithRandexp extends Faker {
     createRandexp(regexp, flags) {
         return new RandexpWithFaker(regexp, flags, this);
     }

package/dist/generators/base/support/timestamp.js

@@ -51,8 +51,16 @@ export function parseChangelog(changelogDate) {
     if (changelogDate.length !== 14) {
         throw new Error(`changelogDate ${changelogDate} is not a valid changelogDate.`);
     }
-    const formattedDate = `${changelogDate.substring(0, 4)}-${changelogDate.substring(4, 6)}-${changelogDate.substring(6, 8)}T${changelogDate.substring(8, 10)}:${changelogDate.substring(10, 12)}:${changelogDate.substring(12, 14)}+00:00`;
-    return new Date(Date.parse(formattedDate));
+    const zeroFallback = (val, fallback) => (/^0+$/.test(val) ? fallback : val);
+    const year = zeroFallback(changelogDate.substring(0, 4), '2024');
+    const month = zeroFallback(changelogDate.substring(4, 6), '01');
+    const day = zeroFallback(changelogDate.substring(6, 8), '01');
+    const formattedDate = `${year}-${month}-${day}T${changelogDate.substring(8, 10)}:${changelogDate.substring(10, 12)}:${changelogDate.substring(12, 14)}+00:00`;
+    const parsedTimestamp = Date.parse(formattedDate);
+    if (isNaN(parsedTimestamp)) {
+        throw new Error(`changelogDate ${changelogDate} is not a valid date.`);
+    }
+    return new Date(parsedTimestamp);
 }
 /**
  * Parse creationTimestamp option

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

@@ -118,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('-')) {

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

@@ -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)) {
@@ -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}"`;
         }
     }
@@ -306,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-relationship.d.ts

@@ -1,4 +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<Entity>, generator: CoreGenerator, ignoreMissingRequiredRelationship?: boolean): Relationship<Entity<import("../index.js").Field, never>>;
+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/task-type-inference.d.ts

@@ -5,21 +5,21 @@ 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>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['InitializingTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["InitializingTaskParam"]) => void;
-export declare function asPromptingTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['PromptingTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["PromptingTaskParam"]) => void;
-export declare function asConfiguringTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['ConfiguringTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["ConfiguringTaskParam"]) => void;
-export declare function asComposingTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['ComposingTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["ComposingTaskParam"]) => void;
-export declare function asLoadingTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['LoadingTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["LoadingTaskParam"]) => void;
-export declare function asPreparingTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['PreparingTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["PreparingTaskParam"]) => void;
-export declare function asPostPreparingTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['PostPreparingTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["PostPreparingTaskParam"]) => void;
-export declare function asPreparingEachEntityTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['PreparingEachEntityTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["PreparingEachEntityTaskParam"]) => void;
-export declare function asPreparingEachEntityFieldTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['PreparingEachEntityFieldTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["PreparingEachEntityFieldTaskParam"]) => void;
-export declare function asPreparingEachEntityRelationshipTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['PreparingEachEntityRelationshipTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["PreparingEachEntityRelationshipTaskParam"]) => void;
-export declare function asPostPreparingEachEntityTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['PostPreparingEachEntityTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["PostPreparingEachEntityTaskParam"]) => void;
-export declare function asDefaultTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['DefaultTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["DefaultTaskParam"]) => void;
-export declare function asWritingTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['WritingTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["WritingTaskParam"]) => void;
-export declare function asWritingEntitiesTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['WritingEntitiesTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["WritingEntitiesTaskParam"]) => void;
-export declare function asPostWritingTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['PostWritingTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["PostWritingTaskParam"]) => void;
-export declare function asPostWritingEntitiesTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['PostWritingEntitiesTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["PostWritingEntitiesTaskParam"]) => void;
-export declare function asInstallTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['InstallTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["InstallTaskParam"]) => void;
-export declare function asEndTask<E = Entity, A = ApplicationType<E>>(task: (this: CoreGenerator, params: TaskTypes<E, A>['EndTaskParam']) => void): (this: CoreGenerator, params: TaskTypes<E, A>["EndTaskParam"]) => void;
+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;