@aurorajs.dev/catalyst-cli 1.0.2 → 2.0.0

package/dist/templates/frontend/application/src/@aurora/pipes/validation-message.pipe.spec.ts

@@ -0,0 +1,197 @@
+import { TestBed } from '@angular/core/testing';
+import { TranslocoService } from '@jsverse/transloco';
+import { ValidationMessagePipe } from './validation-message.pipe';
+
+/**
+ * Mock that echoes the resolved key and params so tests can assert both the
+ * transloco key chosen and the interpolation params passed to it.
+ * Also tracks how many times translate() is called, so memoization can be verified.
+ */
+class TranslocoServiceMock {
+  lang = 'en';
+  translateCallCount = 0;
+
+  getActiveLang(): string {
+    return this.lang;
+  }
+  translate(key: string, params: Record<string, unknown> = {}): string {
+    this.translateCallCount++;
+    return `${key}|${JSON.stringify(params)}`;
+  }
+}
+
+describe('ValidationMessagePipe', () => {
+  let pipe: ValidationMessagePipe;
+  let translocoMock: TranslocoServiceMock;
+
+  beforeEach(() => {
+    translocoMock = new TranslocoServiceMock();
+    TestBed.configureTestingModule({
+      providers: [ValidationMessagePipe, { provide: TranslocoService, useValue: translocoMock }],
+    });
+    pipe = TestBed.runInInjectionContext(() => new ValidationMessagePipe());
+  });
+
+  // ─── Null / empty guard ───────────────────────────────────────────────────
+
+  it('returns empty string for null error', () => {
+    expect(pipe.transform(null)).toBe('');
+  });
+
+  it('returns empty string for undefined error', () => {
+    expect(pipe.transform(undefined)).toBe('');
+  });
+
+  // ─── Validator kinds emitted by the generator ─────────────────────────────
+
+  it('maps "required" kind to Validations.Required with no params', () => {
+    expect(pipe.transform({ kind: 'required' })).toBe('Validations.Required|{}');
+  });
+
+  it('maps "minLength" kind to Validations.MinLength with min param', () => {
+    expect(pipe.transform({ kind: 'minLength', minLength: 8 })).toBe(
+      'Validations.MinLength|{"min":8}',
+    );
+  });
+
+  it('maps "maxLength" kind to Validations.MaxLength with max param', () => {
+    expect(pipe.transform({ kind: 'maxLength', maxLength: 64 })).toBe(
+      'Validations.MaxLength|{"max":64}',
+    );
+  });
+
+  it('maps "min" kind to Validations.Min with min param', () => {
+    expect(pipe.transform({ kind: 'min', min: 5 })).toBe('Validations.Min|{"min":5}');
+  });
+
+  it('maps "max" kind to Validations.Max with max param', () => {
+    expect(pipe.transform({ kind: 'max', max: 99 })).toBe('Validations.Max|{"max":99}');
+  });
+
+  it('maps "email" kind to Validations.Email with no params', () => {
+    expect(pipe.transform({ kind: 'email' })).toBe('Validations.Email|{}');
+  });
+
+  it('maps "pattern" kind to Validations.Pattern with no params', () => {
+    expect(pipe.transform({ kind: 'pattern' })).toBe('Validations.Pattern|{}');
+  });
+
+  // ─── Fallback path ────────────────────────────────────────────────────────
+
+  it('falls back to error.message when kind is unknown and message is present', () => {
+    expect(pipe.transform({ kind: 'somethingWeird', message: 'Custom error' })).toBe(
+      'Custom error',
+    );
+  });
+
+  it('falls back to Validations.Default when kind is unknown and no message', () => {
+    expect(pipe.transform({ kind: 'somethingWeird' })).toBe('Validations.Default|{}');
+  });
+
+  // ─── Memoization — same error ref + same lang = no re-translate ───────────
+
+  it('returns cached result when called twice with the same error reference and same lang', () => {
+    const error = { kind: 'required' };
+
+    pipe.transform(error);
+    const callsAfterFirst = translocoMock.translateCallCount;
+
+    pipe.transform(error);
+    // translate() must NOT have been called again — cache hit.
+    expect(translocoMock.translateCallCount).toBe(callsAfterFirst);
+  });
+
+  // ─── Memoization — lang change invalidates cache ──────────────────────────
+
+  it('re-resolves when the active language changes', () => {
+    const error = { kind: 'required' };
+
+    pipe.transform(error); // fills cache, lang='en'
+
+    translocoMock.lang = 'es';
+    const result = pipe.transform(error); // must call translate again
+
+    // The mock just echoes the key, so the output format is the same.
+    // What matters is that the pipe DID call translate() again (lang changed).
+    expect(result).toBe('Validations.Required|{}');
+    // translate() must have been called at least twice total.
+    expect(translocoMock.translateCallCount).toBeGreaterThanOrEqual(2);
+  });
+
+  // ─── Memoization — different error object (new ref) re-resolves ───────────
+
+  it('re-resolves when a new error object reference is passed even with same kind', () => {
+    pipe.transform({ kind: 'required' });
+    const callsAfterFirst = translocoMock.translateCallCount;
+
+    // Different object reference — must NOT use the cache.
+    pipe.transform({ kind: 'required' });
+    expect(translocoMock.translateCallCount).toBeGreaterThan(callsAfterFirst);
+  });
+
+  // ─── Fix D: cache key must fold in params so mutated same-ref re-resolves ──
+
+  it('re-resolves when the same error object reference has a mutated payload', () => {
+    // Construct a mutable error object and mutate it in place.
+    // This simulates a reactive form where the validator reuses the same object
+    // but updates the params (e.g. dynamically changing maxLength).
+    const error: { kind: string; maxLength: number } = { kind: 'maxLength', maxLength: 64 };
+
+    const firstResult = pipe.transform(error);
+    expect(firstResult).toBe('Validations.MaxLength|{"max":64}');
+
+    const callsAfterFirst = translocoMock.translateCallCount;
+
+    // Mutate the payload in place — SAME object reference, DIFFERENT params.
+    error.maxLength = 128;
+
+    const secondResult = pipe.transform(error);
+    // Must have called translate() again because the payload changed.
+    expect(translocoMock.translateCallCount).toBeGreaterThan(callsAfterFirst);
+    // And must produce a message reflecting the NEW max value.
+    expect(secondResult).toBe('Validations.MaxLength|{"max":128}');
+  });
+
+  // ─── Fix D: lastLang reset in null-error branch ──────────────────────────
+
+  it('resets cached state when a null error clears the cache, so the next call re-translates', () => {
+    const error = { kind: 'required' };
+    pipe.transform(error); // fills cache
+    pipe.transform(null); // clears
+
+    const callsAfterClear = translocoMock.translateCallCount;
+    // Call again with the SAME reference — should re-translate because cache was cleared.
+    pipe.transform(error);
+    expect(translocoMock.translateCallCount).toBeGreaterThan(callsAfterClear);
+  });
+
+  // ─── Fix E: throwing params() must not crash transform ───────────────────
+  // A custom validator registered via provideValidationMessages may supply a
+  // params() function that throws (BigInt, circular reference, etc.).
+  // JSON.stringify(rule.params(error)) in the cache-key path would propagate
+  // the throw into change detection.  After the fix, transform() must be safe.
+
+  it('does not throw when the matched rule params() function throws, and returns a translated message', () => {
+    // Register a rule whose params() always throws.
+    // Access the rules registry directly and inject a throwing rule for testing.
+    const throwingRule = {
+      key: 'Validations.Custom',
+      params: (_error: unknown): Record<string, unknown> => {
+        throw new Error('Cannot serialize BigInt');
+      },
+    };
+    // Inject the rule directly into the pipe's rules map (test-only access).
+    // biome-ignore lint/suspicious/noExplicitAny: test-only internal access
+    (pipe as unknown as Record<string, unknown>)['rules'] = {
+      throwingKind: throwingRule,
+    };
+
+    const error = { kind: 'throwingKind' };
+
+    // Before fix: JSON.stringify(rule.params(error)) throws → propagates.
+    // After fix: the throw is caught; transform() returns a valid string.
+    expect(() => pipe.transform(error)).not.toThrow();
+    const result = pipe.transform(error);
+    expect(typeof result).toBe('string');
+  });
+});

package/dist/templates/frontend/application/src/@aurora/pipes/validation-message.pipe.ts

@@ -1,5 +1,5 @@
 import { inject, InjectionToken, Pipe, type PipeTransform } from '@angular/core';
-import { type ValidationErrors } from '@angular/forms';
+import { ValidationError } from '@angular/forms/signals';
 import { TranslocoService } from '@jsverse/transloco';
 
 /**
@@ -26,11 +26,21 @@ export interface ValidationMessageRule {
 export type ValidationMessageRules = Record<string, ValidationMessageRule>;
 
 /**
- * Default rules for built-in Angular validators.
+ * Default rules for built-in validators.
+ *
+ * Covers BOTH form systems so messages survive the gradual Signal Forms
+ * migration: classic Reactive Forms emit lowercase keys (`minlength`,
+ * `maxlength`) carrying a `requiredLength` payload, while Signal Forms
+ * (`@angular/forms/signals`) emit `kind`-cased keys (`minLength`, `maxLength`)
+ * whose limit lives on a same-named property. The `required`, `min`, `max`,
+ * `email` and `pattern` keys are shared verbatim — both systems agree on the
+ * casing and on where the numeric limit sits.
+ *
  * Override or extend via `provideValidationMessages()`.
  */
 export const DEFAULT_VALIDATION_RULES: ValidationMessageRules = {
   required: { key: 'Validations.Required' },
+  // Classic Reactive Forms keys.
   minlength: {
     key: 'Validations.MinLength',
     params: (err: { requiredLength: number }) => ({ min: err.requiredLength }),
@@ -39,6 +49,15 @@ export const DEFAULT_VALIDATION_RULES: ValidationMessageRules = {
     key: 'Validations.MaxLength',
     params: (err: { requiredLength: number }) => ({ max: err.requiredLength }),
   },
+  // Signal Forms keys (validation error `kind`).
+  minLength: {
+    key: 'Validations.MinLength',
+    params: (err: { minLength: number }) => ({ min: err.minLength }),
+  },
+  maxLength: {
+    key: 'Validations.MaxLength',
+    params: (err: { maxLength: number }) => ({ max: err.maxLength }),
+  },
   min: {
     key: 'Validations.Min',
     params: (err: { min: number }) => ({ min: err.min }),
@@ -75,15 +94,44 @@ export function provideValidationMessages(rules: ValidationMessageRules) {
   };
 }
 
+/** Loose structural shape — for unit-test fixtures and dynamic param access. */
+interface LooseValidationError {
+  kind: string;
+  [key: string]: unknown;
+}
+
+/**
+ * A Signal Forms (`@angular/forms/signals`) validation error: a `kind` (the
+ * validator that failed, e.g. `'required'`, `'maxLength'`) plus its payload
+ * (e.g. `maxLength: 64`).
+ *
+ * A UNION on purpose. `ValidationError.WithFieldTree` is what `field().errors()`
+ * yields in form templates — a SEALED type with no index signature. A type
+ * without its own index signature is NOT assignable to a loose
+ * `{ [key: string]: unknown }` (even when every property would satisfy
+ * `unknown`), so a loose supertype alone breaks the template type-check;
+ * `WithFieldTree` alone breaks the unit tests (plain `{ kind, maxLength }`
+ * fixtures don't satisfy the sealed shape). The union accepts both. `message`
+ * is read through a local `as { message?: string }` cast (Signal Forms types it
+ * `string | LogicFn<…>`, not assignable to a narrow `string`).
+ */
+export type FormValidationError = ValidationError.WithFieldTree | LooseValidationError;
+
 /**
- * Impure pipe that resolves the first validation error to a translated message.
- * Uses the `validations` nested key in the global transloco scope.
+ * Impure pipe that resolves a single Signal Forms validation error to a
+ * translated message, reusing the same `VALIDATION_MESSAGE_RULES` as the
+ * classic {@link ValidationMessageLegacyPipe}. The schema declares only the rules
+ * (no message); the message is keyed off `error.kind` and translated via
+ * transloco — so i18n stays in one place and stays reactive to language change.
+ *
+ * Falls back to the schema-provided `error.message` (if any), then to the
+ * generic `Validations.Default` key.
  *
  * @example
  * ```html
- * <hlm-field-error>
- *   {{ signalForm.get('name')?.errors | validationMessage }}
- * </hlm-field-error>
+ * @for (error of form.name().errors(); track error.kind) {
+ *   <hlm-field-error [validator]="error.kind">{{ error | validationMessage }}</hlm-field-error>
+ * }
  * ```
  */
 @Pipe({ name: 'validationMessage', pure: false })
@@ -91,32 +139,60 @@ export class ValidationMessagePipe implements PipeTransform {
   private readonly transloco = inject(TranslocoService);
   private readonly rules = inject(VALIDATION_MESSAGE_RULES);
 
-  private lastErrors: ValidationErrors | null = null;
+  // Cache fields — mirrors the memoization in ValidationMessageLegacyPipe.
+  // Cache key: (error object reference, active language, resolved params signature).
+  // The params signature detects mutations on the same error object reference
+  // (e.g. a dynamically-updated maxLength) that would produce a stale message
+  // if only the reference and language were compared.
+  private lastError: FormValidationError | null = null;
   private lastLang = '';
+  private lastParamsSig = '';
   private lastMessage = '';
 
-  transform(errors: ValidationErrors | null | undefined): string {
-    if (!errors) {
+  transform(error: FormValidationError | null | undefined): string {
+    if (!error) {
+      this.lastError = null;
+      this.lastLang = '';
+      this.lastParamsSig = '';
       this.lastMessage = '';
-      this.lastErrors = null;
       return '';
     }
 
     const lang = this.transloco.getActiveLang();
-    if (errors === this.lastErrors && lang === this.lastLang) return this.lastMessage;
-    this.lastErrors = errors;
-    this.lastLang = lang;
+    const rule = this.rules[error.kind];
 
-    const firstKey = Object.keys(errors)[0];
-    const rule = this.rules[firstKey];
+    // params() and JSON.stringify() can both throw for custom validators
+    // (e.g. BigInt values or circular references passed via provideValidationMessages).
+    // A throw here would propagate into Angular change detection and crash the view.
+    // Fall back to a reference-only sentinel so the cache still invalidates on
+    // new error objects; the translate() call below will still resolve the message.
+    let params: Record<string, unknown>;
+    let paramsSig: string;
+    try {
+      params = rule?.params ? rule.params(error) : {};
+      paramsSig = JSON.stringify(params);
+    } catch {
+      params = {};
+      paramsSig = `__unserializable__${String(error)}`;
+    }
 
-    if (rule) {
-      const params = rule.params ? rule.params(errors[firstKey]) : {};
-      this.lastMessage = this.transloco.translate(rule.key, params);
-    } else {
-      this.lastMessage = this.transloco.translate('Validations.Default');
+    if (error === this.lastError && lang === this.lastLang && paramsSig === this.lastParamsSig) {
+      return this.lastMessage;
     }
 
+    const message: string = rule
+      ? (this.transloco.translate(rule.key, params) ?? '')
+      : ((error as { message?: string }).message ??
+        this.transloco.translate('Validations.Default') ??
+        '');
+
+    // Assign cache fields ONLY after translate() succeeds — avoids poisoning
+    // the cache if translate() throws for any reason.
+    this.lastError = error;
+    this.lastLang = lang;
+    this.lastParamsSig = paramsSig;
+    this.lastMessage = message;
+
     return this.lastMessage;
   }
 }

package/dist/templates/frontend/application/src/@aurora/query-dsl/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Barrel-shim of the Aurora Query DSL — re-exports the vocabulary + statement
+ * types from their canonical upstream home, `@aurorajs.dev/core-front` (F5
+ * upstreaming; the local definitions this shim replaces were the F4
+ * merge-window stopgap). Builders, composables and hand-written call sites
+ * keep importing from `@aurora/query-dsl` (HR-BARRELS-002) — only this shim
+ * knows the source package, keeping `@aurora` the frontend's stable port
+ * surface (HR-PORTS-001).
+ */
+export {
+  AGGREGATE_FUNCTION,
+  LOGICAL_OPERATOR,
+  ORDER_DIRECTION,
+  WHERE_OPERATOR,
+} from '@aurorajs.dev/core-front';
+export type {
+  AggregateField,
+  AggregateFunction,
+  AggregationBlock,
+  FieldWhere,
+  LogicalOperator,
+  LogicalWhere,
+  OrderClause,
+  OrderDirection,
+  QueryStatement,
+  RelationNode,
+  RelationsBlock,
+  ScalarValue,
+  WhereClause,
+  WhereLeaf,
+  WhereOperator,
+} from '@aurorajs.dev/core-front';

package/dist/templates/frontend/application/src/@aurora/query-dsl/query-statement.spec.ts

@@ -0,0 +1,94 @@
+import type { QueryStatement } from '.';
+import { LOGICAL_OPERATOR, ORDER_DIRECTION, WHERE_OPERATOR } from '.';
+
+/**
+ * Contract spec for the frontend-local Aurora Query DSL vocabulary and types
+ * (design D1: local in `@aurora`, no `@aurorajs.dev/core-front` release).
+ *
+ * The vocabulary and grammar MUST mirror the server-side source of truth
+ * (`packages/core-back/src/domain/persistence/query-dsl/`): bare operator
+ * keys, `and`/`or`/`not` connectors, `order: [{ field, dir }]` with dot-paths,
+ * and the recursive `relations` node. The type-level assertions below are the
+ * anti-theater anchor: they fail the (type-checked) test build if the types
+ * regress to the Sequelize shapes (`[Operator.x]`, `[['col','DIR']]`,
+ * `$assoc.col$`).
+ */
+describe('aurora query DSL vocabulary', () => {
+  it('exposes exactly the bare where-operator keys of the server DSL', () => {
+    expect(WHERE_OPERATOR).toEqual({
+      I_LIKE: 'iLike',
+      EQ: 'eq',
+      NE: 'ne',
+      GT: 'gt',
+      GTE: 'gte',
+      LT: 'lt',
+      LTE: 'lte',
+      IN: 'in',
+      NOT_IN: 'notIn',
+      BETWEEN: 'between',
+      IS_NULL: 'isNull',
+      CONTAINS: 'contains',
+      OVERLAP: 'overlap',
+    });
+  });
+
+  it('exposes exactly the bare logical connectors', () => {
+    expect(LOGICAL_OPERATOR).toEqual({
+      AND: 'and',
+      OR: 'or',
+      NOT: 'not',
+    });
+  });
+
+  it('exposes lowercase order directions', () => {
+    expect(ORDER_DIRECTION).toEqual({
+      ASC: 'asc',
+      DESC: 'desc',
+    });
+  });
+});
+
+describe('QueryStatement type contract', () => {
+  it('accepts the canonical DSL statement shape (compile-time anchor)', () => {
+    // `satisfies` makes this a compile-time contract: if the local types drift
+    // from the server grammar, the test BUILD fails before any assertion runs.
+    const statement = {
+      where: {
+        and: [
+          { name: { iLike: '%tag%' } },
+          { isActive: { eq: true } },
+          { id: { in: ['a', 'b'] } },
+          // Relation key nested in `where` = EXISTS filter on the parent rows.
+          { role: { name: { iLike: '%admin%' } } },
+          { or: [{ code: { eq: 'X' } }, { not: { deletedAt: { isNull: false } } }] },
+        ],
+      },
+      // `relations` shapes the loaded children WITHOUT filtering parents.
+      relations: {
+        role: true,
+        account: { relations: { user: true }, limit: 5, order: [{ field: 'name', dir: 'asc' }] },
+      },
+      // Dot-path in `field` is the DSL form for ordering by a relation column.
+      order: [
+        { field: 'role.name', dir: 'asc' },
+        { field: 'rowId', dir: 'desc' },
+      ],
+      limit: 10,
+      offset: 0,
+    } satisfies QueryStatement;
+
+    expect(statement.order[0]).toEqual({ field: 'role.name', dir: 'asc' });
+    expect(statement.relations.role).toBe(true);
+  });
+
+  // The "rejects the legacy Sequelize shapes at the type level" negative
+  // assertions used to live HERE as `@ts-expect-error` lines — but this file
+  // runs through the Angular unit-test builder (esbuild transform), which
+  // strips types before execution. `@ts-expect-error` is a `tsc` directive:
+  // it was never actually type-checked by the test runner, so the test always
+  // passed regardless of whether the DSL types rejected the legacy shapes
+  // (decorative coverage, F4 round1 ITEM 4). The negatives now live in
+  // `query-statement.type-contract.ts` — a plain `.ts` module (not
+  // `.spec.ts`) that IS type-checked, by `ng build` and by
+  // `tsc -p tsconfig.app.json --noEmit`.
+});

package/dist/templates/frontend/application/src/@aurora/query-dsl/query-statement.type-contract.ts

@@ -0,0 +1,38 @@
+import type { OrderClause, QueryStatement } from '.';
+
+/**
+ * Type-level regression anchor for the Aurora Query DSL shapes — NOT a spec
+ * file on purpose.
+ *
+ * The equivalent negative assertions used to live as `@ts-expect-error` lines
+ * inside `query-statement.spec.ts`, but that test runs through the
+ * Angular unit-test builder (`@angular/build:unit-test`, esbuild-based
+ * transform) which strips types before execution — `@ts-expect-error` is a
+ * `tsc` directive, so it was NEVER type-checked there and the "test" always
+ * passed regardless of whether the DSL types actually rejected the legacy
+ * shapes (decorative coverage, F4 round1 ITEM 4).
+ *
+ * This file lives under `src/@aurora/` as a plain `.ts` module (excluded from
+ * `tsconfig.spec.json`, included by `tsconfig.app.json`), so it IS
+ * type-checked — by `ng build` (AOT requires full program type information)
+ * and by `tsc -p tsconfig.app.json --noEmit`. Confirmed empirically: deleting
+ * one `@ts-expect-error` below while keeping its invalid line makes `tsc -p
+ * tsconfig.app.json --noEmit` fail with a real `TS2322`; keeping the directive
+ * while widening the type it guards makes `tsc` fail with "Unused
+ * '@ts-expect-error' directive" — both directions are live, not decorative.
+ *
+ * No runtime behavior, no exports — this module exists purely to be
+ * type-checked. `void` on each binding satisfies `noUnusedLocals`.
+ */
+
+// @ts-expect-error — bracketed operator keys ('[iLike]') are not DSL leaves
+const bracketedWhere = { name: { '[iLike]': '%x%' } } satisfies QueryStatement['where'];
+void bracketedWhere;
+
+// @ts-expect-error — Sequelize order arrays ([['col','DIR']]) are not [{field,dir}]
+const arrayOrder = [['name', 'ASC']] satisfies OrderClause[];
+void arrayOrder;
+
+// @ts-expect-error — 'ASC'/'DESC' uppercase directions are not part of the DSL
+const upperDirOrder = [{ field: 'name', dir: 'ASC' }] satisfies OrderClause[];
+void upperDirOrder;

package/dist/templates/frontend/application/src/app/app.config.ts

@@ -1,4 +1,4 @@
-import { provideHttpClient } from '@angular/common/http';
+import { provideHttpClient, withXhr } from '@angular/common/http';
 import {
   ApplicationConfig,
   inject,
@@ -7,23 +7,31 @@ import {
   provideBrowserGlobalErrorListeners,
 } from '@angular/core';
 import { provideRouter } from '@angular/router';
+import { provideCalendarI18n } from '@aurora/lib';
+import { HealthService } from '@aurora/modules/health';
 import { provideTransloco, TranslocoService } from '@jsverse/transloco';
+import { provideSpartanHlm } from '@spartan-ng/helm/utils';
+import { environment } from 'environments/environment';
 import { forkJoin, lastValueFrom } from 'rxjs';
-import { availableLangs } from '../../transloco.config';
 import { routes } from './app.routes';
 import { provideAurora } from './aurora.provider';
+import { buildTranslocoLangConfig } from './transloco-lang.factory';
 import { TranslocoHttpLoader } from './transloco-loader';
 
+const translocoLangConfig = buildTranslocoLangConfig(environment.lang);
+
 export const appConfig: ApplicationConfig = {
   providers: [
     provideBrowserGlobalErrorListeners(),
+    provideSpartanHlm(),
+    provideCalendarI18n(environment.calendar.weekStartsOn),
     provideRouter(routes),
-    provideHttpClient(),
+    provideHttpClient(withXhr()),
     provideTransloco({
       config: {
-        availableLangs: [...availableLangs],
-        // TODO: set when we have iam account management ready
-        defaultLang: 'es',
+        availableLangs: translocoLangConfig.availableLangs,
+        defaultLang: translocoLangConfig.defaultLang,
+        fallbackLang: translocoLangConfig.fallbackLang,
         reRenderOnLangChange: true,
         prodMode: !isDevMode(),
         scopes: { keepCasing: true },
@@ -38,6 +46,10 @@ export const appConfig: ApplicationConfig = {
       return lastValueFrom(forkJoin([transloco.load(lang), transloco.load(`navigation/${lang}`)]));
     }),
 
+    // Fetch health data (version + status) from the backend at startup.
+    // The endpoint is public — no auth gate needed.
+    provideAppInitializer(() => inject(HealthService).fetch()),
+
     /* #region customizations */
     provideAurora(),
     /* #endregion customizations */

package/dist/templates/frontend/application/src/app/app.routes.ts

@@ -1,5 +1,5 @@
 import { Routes } from '@angular/router';
-import { authorizationCodeCallbackGuard, noLocalAuthGuard } from '@aurora';
+import { authorizationCodeCallbackGuard, noLocalAuthGuard } from '@aurora/modules/authentication';
 
 export const routes: Routes = [
   // This route is used as the callback URL for the authorization code flow.

package/dist/templates/frontend/application/src/app/app.ts

@@ -1,10 +1,9 @@
-import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { Component } from '@angular/core';
 import { RouterOutlet } from '@angular/router';
 
 @Component({
   selector: 'app-root',
   imports: [RouterOutlet],
-  changeDetection: ChangeDetectionStrategy.OnPush,
   template: '<router-outlet />',
 })
 export class App {}

package/dist/templates/frontend/application/src/app/aurora-widget.providers.ts

@@ -0,0 +1,21 @@
+import type { EnvironmentProviders } from '@angular/core';
+/**
+ * Composition-root aggregator of every bounded context's Aurora widget providers.
+ *
+ * Widgets are a FRAMEWORK primitive — the registry token and `AuroraWidgetDef` contract live in
+ * `@aurora`, and any surface that honours the contract can host them, not just the dashboard page.
+ * Hence this aggregator is named for the framework (`aurora-widget`), deliberately NOT coupled to
+ * the dashboard feature.
+ *
+ * Each BC that publishes widgets exports a `<bc>.widgets.ts` with a `provideWidget(...)` array;
+ * spread them ALL here. `aurora.provider.ts` then registers the whole set with a single
+ * `...auroraWidgetProviders`, so adding a BC's widgets touches only THIS file and the composition
+ * root stays stable.
+ *
+ * Why here (and not inside a BC or in `@aurora`): aggregating across BCs is a composition concern,
+ * and only the composition-root layer may import every BC. Putting it inside one BC would couple
+ * that BC to the others; putting it in `@aurora` would invert the framework→app dependency
+ * (HR-PORTS-001). The cross-BC fan-in belongs at the app root, alongside `aurora.provider.ts`.
+ */
+export const auroraWidgetProviders: EnvironmentProviders[] = [
+];

package/dist/templates/frontend/application/src/app/aurora.provider.spec.ts

@@ -24,8 +24,7 @@ vi.mock('environments/environment', () => ({
   },
 }));
 
-import { authorizationCodeGuard } from '../@aurora/modules/authentication/guards/adapters/authorization-code.guard';
-import { authenticationPasswordGuard } from '../@aurora/modules/authentication/guards/adapters/authentication-password.guard';
+import { authenticationPasswordGuard, authorizationCodeGuard } from '@aurora';
 import { AUTH_STRATEGY } from '../environments/environment.type';
 
 // Import the REAL exported function from the production provider.