@aurorajs.dev/catalyst-cli 1.1.3 → 2.0.0

package/dist/templates/codegen/backend/additional-@app/__module_name__/application/__additional_api_action__/__additional_api_name__.handler.ts.eta

@@ -17,21 +17,29 @@
   if (isQuery) {
     importsArray.push({
       items: [bcPascal + modPascal],
-      path: '@api/graphql',
+      path: '@api/graphql.js',
     });
   } else {
     importsArray.push({
       items: [bcPascal + 'Update' + modPascal + 'ByIdInput'],
-      path: '@api/graphql',
+      path: '@api/graphql.js',
     });
     importsArray.push({
       items: [bcPascal + 'Update' + modPascal + 'ByIdDto'],
-      path: it.config.API_CONTAINER + '/' + it.fmt.toKebabCase(it.schema.boundedContextName) + '/' + it.fmt.toKebabCase(it.schema.moduleName),
+      path: it.config.API_CONTAINER + '/' + it.fmt.toKebabCase(it.schema.boundedContextName) + '/' + it.fmt.toKebabCase(it.schema.moduleName) + '/index.js',
+    });
+    importsArray.push({
+      items: ['ApplySchema'],
+      path: it.config.AURORA_CORE_BACK,
+    });
+    importsArray.push({
+      items: [it.schema.aggregateName + 'FieldSchema'],
+      path: it.config.APP_CONTAINER + '/' + it.fmt.toKebabCase(it.schema.boundedContextName) + '/' + it.fmt.toKebabCase(it.schema.moduleName) + '/domain/index.js',
     });
   }
 
   if (it.schema.hasTenant) {
-    importsArray.push({ items: 'IamAccountResponse', path: it.config.APP_CONTAINER + '/iam/account' });
+    importsArray.push({ items: 'IamAccount', path: '@api/graphql.js' });
   }
 _%>
 <%~ it.gen.importManager({ imports: importsArray }) %>
@@ -41,17 +49,27 @@ export class <%= apiClass %>Handler
   // TODO: inject services needed for this operation
   constructor() {}
 
+<% if (!isQuery) { -%>
+  // @ApplySchema runs the aggregate's FieldSchema over `payload`. Two behaviours to know: it
+  // REWRITES values (a `password` key is bcrypt-hashed right here, so never forward this payload
+  // to another decorated handler), and it rejects with 400 a key matching a `readOnly` property,
+  // or a `createOnly` one under 'update'. Yours to adjust: switch `operation` to 'create',
+  // declare `payloadIndex: N` if `payload` moves off argument 0, or remove the decorator when
+  // `payload` is not aggregate-shaped — removal is required, not cosmetic: a primitive arrives
+  // mangled, because the pipeline copies it with a spread.
+  @ApplySchema({ schema: <%= it.schema.aggregateName %>FieldSchema, operation: 'update' })
+<% } -%>
   async main(
 <% if (isQuery) { -%>
 <% if (it.schema.hasTenant) { -%>
-    account: IamAccountResponse,
+    account: IamAccount,
 <% } -%>
     queryStatement?: QueryStatement,
     constraint?: QueryStatement,
 <% } else { -%>
     payload: <%= bcPascal %>Update<%= modPascal %>ByIdInput | <%= bcPascal %>Update<%= modPascal %>ByIdDto,
 <% if (it.schema.hasTenant) { -%>
-    account: IamAccountResponse,
+    account: IamAccount,
 <% } -%>
     constraint?: QueryStatement,
 <% } -%>

package/dist/templates/codegen/frontend/module/__module_name__/__module_name__.columns.ts.eta

@@ -41,10 +41,12 @@
   // can ABORT `catalyst generate` outright if that widget modulePath is
   // not yet scaffolded on disk. Many-to-one/BelongsTo and many-to-many are
   // widget-agnostic (they always emit a column regardless of widget.type),
-  // matching their pre-change behavior.
+  // matching their pre-change behavior. The `fk` branch defers to
+  // `it.filters.isForeignKeyRelationshipProperty` (T-122) -- the resolver
+  // and list templates consult the SAME predicate so all three stay in
+  // lockstep.
   const getRelationBranchKind = (p) => {
-    const isBelongsToOneToOne = p.relationship?.type === 'one-to-one' && Boolean(p.relationship.field);
-    if (p.relationship?.type === 'many-to-one' || isBelongsToOneToOne) return 'fk';
+    if (it.filters.isForeignKeyRelationshipProperty(p)) return 'fk';
     if (p.relationship?.type === 'one-to-one' && !p.relationship?.field && !p.widget) return 'hasOne';
     if (p.relationship?.type === 'many-to-many') return 'm2m';
     return null;

package/dist/templates/codegen/frontend/module/__module_name__/data-access/__module_name__.resolvers.ts.eta

@@ -82,10 +82,13 @@
     .map(m => `${m.propPlural}: true`);
   const hasM2mInclude = m2mRelationEntries.length > 0;
 
-  // SPEC-17: at least one many-to-one FK → resolver pre-loads the relation via
-  // the DSL `relations` node so the first page already carries the related
-  // entity's name (no flicker).
-  const hasManyToOneFk = (it.schema.aggregateProperties || []).some(p => p.relationship?.type === 'many-to-one');
+  // SPEC-17: at least one FK relation (many-to-one, or one-to-one with
+  // `field`) → resolver pre-loads the relation via the DSL `relations` node
+  // so the first page already carries the related entity's name (no
+  // flicker). T-122: unified via `it.filters.hasForeignKeyRelationshipProperties`
+  // -- previously many-to-one only, leaving a one-to-one+field FK's column
+  // (emitted by columns.ts.eta) never actually requested from the server.
+  const hasForeignKey = it.filters.hasForeignKeyRelationshipProperties(it.schema.aggregateProperties || []);
   const ownModPascal = it.fmt.toPascalCase(it.schema.moduleName);
 
   // Sync option relations preload all rows via queryGet (returns T[] directly);
@@ -100,7 +103,7 @@
   // exists (sync queryGet returns T[] directly, no pipe needed).
   const auroraItems = ['buildSortOrder', 'DEFAULT_PAGE_SIZE', 'queryFindById', 'queryPaginate', 'type DataTableData'];
   if (hasSyncOptionRel) auroraItems.push('queryGet');
-  if (hasManyToOneFk) auroraItems.push('getRelationsNode');
+  if (hasForeignKey) auroraItems.push('getRelationsNode');
 
   const aggregateTypeItems = ['type ' + aggregate];
   for (const meta of relMeta) {
@@ -145,7 +148,7 @@
     importsArray.push({ items: ['environment'], path: 'environments/environment' });
   }
 
-  if (hasManyToOneFk) {
+  if (hasForeignKey) {
     importsArray.push({ items: ['get' + ownModPascal + 'StandaloneColumns'], path: '../' + modKebab + '.columns' });
   }
 
@@ -227,7 +230,7 @@ export const <%= modCamel %>ListResolver: ResolveFn<{
 <%= emitOptionsTypeFields() %>
 }> = () => {
   const { queryPagination, paginationKey } = <%= modUpperSnake %>_LIST_CONFIG;
-<% if (hasManyToOneFk) { -%>
+<% if (hasForeignKey) { -%>
   const relations = getRelationsNode(get<%= ownModPascal %>StandaloneColumns());
 <% } -%>
   const pagination$ = queryPaginate<<%= aggregate %>>(queryPagination, paginationKey, {
@@ -235,7 +238,7 @@ export const <%= modCamel %>ListResolver: ResolveFn<{
       offset: 0,
       limit: DEFAULT_PAGE_SIZE,
       order: buildSortOrder([]),
-<% if (hasManyToOneFk) { -%>
+<% if (hasForeignKey) { -%>
       relations,
 <% } -%>
     },
@@ -306,7 +309,7 @@ export const <%= modCamel %>DetailResolver: ResolveFn<{
 <% } else { -%>
 export const <%= modCamel %>ListResolver: ResolveFn<DataTableData<<%= aggregate %>>> = () => {
   const { queryPagination, paginationKey } = <%= modUpperSnake %>_LIST_CONFIG;
-<% if (hasManyToOneFk) { -%>
+<% if (hasForeignKey) { -%>
   const relations = getRelationsNode(get<%= ownModPascal %>StandaloneColumns());
 <% } -%>
   return queryPaginate<<%= aggregate %>>(queryPagination, paginationKey, {
@@ -314,7 +317,7 @@ export const <%= modCamel %>ListResolver: ResolveFn<DataTableData<<%= aggregate
       offset: 0,
       limit: DEFAULT_PAGE_SIZE,
       order: buildSortOrder([]),
-<% if (hasManyToOneFk) { -%>
+<% if (hasForeignKey) { -%>
       relations,
 <% } -%>
     },

package/dist/templates/codegen/frontend/module/__module_name__/features/__module_name__-detail.component.ts.eta

@@ -523,6 +523,16 @@ export default class <%= modPascal %>DetailComponent {
   // form always needs an explicit locale to edit — the target translation
   // when editing one, the base language for the base row.
   protected readonly editLang = computed<string>(() => this.translationLangIso6392() ?? environment.lang.base);
+  // The mode this save actually travels as, forwarded to the form's
+  // `transportMode` input (see __module_name__-form.component.ts.eta) —
+  // distinct from `mode()`, which stays the route/presentation mode read by
+  // the header/breadcrumb/verb. Creating the FIRST translation of an
+  // EXISTING row (`new/:id/:langId`) sends an UPDATE: the row already
+  // exists, only a translation is being added, so the transport diverges
+  // from the route even though the user-facing action is still "create".
+  protected readonly effectiveMode = computed<'new' | 'edit'>(() =>
+    this.mode() === 'new' && this.translationLangIso6392() !== null ? 'edit' : this.mode(),
+  );
 <% } -%>
 <% if (hasDeleteTranslation) { -%>
 
@@ -731,12 +741,11 @@ export default class <%= modPascal %>DetailComponent {
          Creating the translation of an EXISTING row (new/:id/:langId) must
          UPDATE that row: the base row already exists, so a create would
          collide on the id. */
-      const effectiveMode = this.mode() === 'new' && this.translationLangIso6392() !== null ? 'edit' : this.mode();
-      await this.shell.save(value, effectiveMode);
+      await this.shell.save(value, this.effectiveMode());
       // verb keys off the USER's action (mode()), not the transport
-      // (effectiveMode) — creating the FIRST translation of an existing row
-      // is still a create from the user's perspective, even though it goes
-      // over the wire as an update.
+      // (effectiveMode()) — creating the FIRST translation of an existing
+      // row is still a create from the user's perspective, even though it
+      // goes over the wire as an update.
       const verb = this.mode() === 'new' ? 'Created.<%= it.genderKey %>' : 'Saved.<%= it.genderKey %>';
 <% } else { -%>
       await this.shell.save(value, this.mode());

package/dist/templates/codegen/frontend/module/__module_name__/features/__module_name__-form-embed.component.ts.eta

@@ -34,6 +34,12 @@
     );
   }
   const embedFkField = ownFkProp.name;
+  // createOnly (add-create-only-property-semantics): the parent FK
+  // is injected into the payload below in every mode. A `createOnly` FK must
+  // NOT be sent on an update transport — same "omit the key entirely" rule
+  // every other createOnly field follows. Decided at codegen time so a
+  // module whose FK is not createOnly emits the exact same code as before.
+  const embedFkIsCreateOnly = ownFkProp.createOnly === true;
   // Modified schema-view for downstream filters and form-body inclusion:
   // exclude the FK property so it never renders or enters the FormGroup.
   const embedAggregateProperties = (it.schema.aggregateProperties || []).filter(
@@ -44,7 +50,6 @@
   // ================================================================
   // Detect which field types are present (for conditional imports).
   // ================================================================
-  const formFields = it.filters.getFormDetailFieldsProperties(embedAggregateProperties);
   const formGroupFields = it.filters.getFormGroupFieldsProperties(embedAggregateProperties);
 
   // SPEC-12: tabs are only honored in view mode. Dialog mode emits a codegen
@@ -56,12 +61,13 @@
   const tabIds = useFormTabs ? it.filters.getTabsFromProperties(embedAggregateProperties) : [];
 
   // Per-tab metadata used to emit signals, computeds, and findFirstTabWithErrors.
+  // getEmittedFormFieldsForTab consults the SAME predicate form-body.eta
+  // dispatches through (isFormFieldRenderable), so a field with no dispatch
+  // branch (e.g. a bare jsonb) or one excluded upstream (GRID_SELECT_MULTIPLE_ELEMENTS)
+  // never feeds a tab's HasErrors computed.
   const tabMeta = tabIds.map(id => {
     const fieldNames = it.filters
-      .getFormDetailFieldsPropertiesForTab(embedAggregateProperties, id)
-      .filter(p => it.predicates.isAllowProperty(it.schema.moduleName, p))
-      .filter(p => !(p.type === it.propertyType.ID && !p.widget))
-      .filter(p => p.widget?.type !== it.widgetType.GRID_ELEMENTS_MANAGER)
+      .getEmittedFormFieldsForTab(it.schema.moduleName, embedAggregateProperties, id)
       .map(p => it.fmt.toCamelCase(it.mappers.getPropertyName(p)));
     return {
       id,
@@ -94,23 +100,33 @@
     it.widgetType.ASYNC_MULTIPLE_SEARCH_SELECT,
   ]);
 
-  // Properties that render via a basic-type partial (fields directory) — exclude
-  // primary-key ids without widget (canonical form-body filter) AND
-  // exclude relational widgets (those go through relationship partials,
-  // which carry their own imports).
-  const renderedFields = formFields.filter(p =>
-    !(p.type === it.propertyType.ID && !p.widget) &&
+  // Properties that ACTUALLY emit markup in form-body.eta's dispatch — the
+  // SAME predicate the body itself consults (it.filters.isFormFieldRenderable),
+  // so this import gate and the body can never drift again. In the tabbed
+  // flow the body only ever draws fields grouped per tab, so a renderable
+  // field with no widget.tab (or one outside the aggregate's declared tabs)
+  // is excluded too — it would otherwise open import gates for a control
+  // that never renders.
+  const emittedFormFields = it.filters.getEmittedFormFields(
+    it.schema.moduleName,
+    embedAggregateProperties,
+    useFormTabs,
+  );
+
+  // Properties that render via a basic-type partial (fields directory) —
+  // relational widgets go through relationship partials instead, which
+  // carry their own imports.
+  const renderedFields = emittedFormFields.filter(p =>
     !RELATIONAL_TYPES.has(p.widget?.type)
   );
 
   // Properties that render via a relationship partial (5 SPEC-09 types).
-  // grid-select-multiple-elements is excluded: it renders OUTSIDE the form
-  // in the detail shell as its own <section hlmCard>, so the form has no
-  // I/O contract for it (returns to a dumb leaf — no 10-port passthrough).
-  const relationalFields = formFields.filter(p =>
-    p.relationship &&
-    RELATIONAL_TYPES.has(p.widget?.type) &&
-    p.widget?.type !== it.widgetType.GRID_SELECT_MULTIPLE_ELEMENTS
+  // grid-select-multiple-elements never reaches emittedFormFields — excluded
+  // by isFormFieldRenderable, since it renders OUTSIDE the form in the
+  // detail shell as its own <section hlmCard> (the form has no I/O contract
+  // for it — returns to a dumb leaf, no 10-port passthrough).
+  const relationalFields = emittedFormFields.filter(p =>
+    p.relationship && RELATIONAL_TYPES.has(p.widget?.type)
   );
 
   // Per-relation metadata used downstream to declare inputs/computeds.
@@ -119,6 +135,7 @@
     const relSingular = it.fmt.toCamelCase(relRaw);
     const relPascal = it.fmt.toPascalCase(relRaw);
     const targetAggregate = p.relationship.aggregateName;
+    const needsItemToString = p.widget.type === it.widgetType.SELECT || p.widget.type === it.widgetType.MULTIPLE_SELECT;
     return {
       property: p,
       propCamel: it.fmt.toCamelCase(it.mappers.getPropertyName(p)),
@@ -130,7 +147,14 @@
       // the detail shell, not in the form.
       needsColumns: p.widget.type === it.widgetType.GRID_SELECT_ELEMENT,
       needsOnSearch: ASYNC_SEARCH_SELECT_TYPES.has(p.widget.type),
-      needsItemToString: p.widget.type === it.widgetType.SELECT || p.widget.type === it.widgetType.MULTIPLE_SELECT,
+      needsItemToString,
+      // Resolved through the same cross-schema helper select.eta/multiple-select.eta
+      // use, so the trigger's itemToString matches the option list they render.
+      // Falls back to the default when the relationship carries no modulePath (a
+      // synthetic/test property, or a not-yet-resolved cross-BC relation).
+      displayFieldTemplate: needsItemToString && p.relationship?.modulePath
+        ? it.crossSchema.getTargetDisplayFieldTemplate(p.relationship.modulePath)
+        : '{name}',
     };
   });
 
@@ -138,7 +162,12 @@
   // These need an Option[] input declared (the partial already binds [options]="propCamel()").
   // Scoped to SEARCH_SELECT_TYPES only: select/multiple-select/grid-select-element partials
   // compute relSingular+Options unconditionally and do NOT support the no-relationship path.
-  const scalarArrayRelFields = formFields.filter(p =>
+  // Based on emittedFormFields (not the wider visible set): hasSearchSelectField and its
+  // three siblings below OR-in scalarArrayRelFields, so it IS an import gate and must honor
+  // the same tab-scoped emission set. A search-select-family widget already passes
+  // isFormFieldRenderable (the widget branch is checked before the array type branch), so in a
+  // non-tabbed form both sets hold the same properties.
+  const scalarArrayRelFields = emittedFormFields.filter(p =>
     p.type === it.propertyType.ARRAY &&
     !p.relationship &&
     SEARCH_SELECT_TYPES.has(p.widget?.type)
@@ -163,14 +192,44 @@
   const hasAnyRelationalField = relationalFields.length > 0;
   const needsDataTableColumnDef = hasGridSelectElementField;
 
-  const hasAnyRenderedField = renderedFields.length > 0;
+  // <hlm-field> and `| validationMessage` (field-errors.eta) are emitted by
+  // every field partial — the 9 under partials/fields/ (all but
+  // boolean-field.eta, whose control needs no ValidationMessagePipe) AND the
+  // 6 under partials/relationships/ — so both gates below key on the FULL
+  // emitted set, not the scalar-only renderedFields.
+  const hasAnyEmittedField = emittedFormFields.length > 0;
+  const hasAnyNonBooleanEmittedField = emittedFormFields.some(p => p.type !== 'boolean');
+
   const hasTextField = renderedFields.some(p => p.type === 'text');
   const hasBooleanField = renderedFields.some(p => p.type === 'boolean');
   const hasEnumField = renderedFields.some(p => p.type === 'enum' || (p.type === 'array' && p.arrayOptions?.type === 'enum'));
   const hasDateField = renderedFields.some(p => p.type === 'date');
   const hasDateTimeField = renderedFields.some(p => p.type === 'dateTime');
-  const hasInputField = renderedFields.some(p => ['varchar', 'char', 'int', 'smallint', 'bigint', 'decimal', 'float', 'password', 'timestamp'].includes(p.type));
-  const hasNonBooleanField = renderedFields.some(p => p.type !== 'boolean');
+  const hasPasswordField = renderedFields.some(p => p.type === 'password');
+  // password renders via <aurora-password-input> (partials/fields/password-field.eta),
+  // never through <hlm-input> — excluded here to mirror the standalone form template
+  // (__module_name__-form.component.ts.eta), which never included it either.
+  const hasInputField = renderedFields.some(p => ['varchar', 'char', 'int', 'smallint', 'bigint', 'decimal', 'float', 'timestamp'].includes(p.type));
+
+  // Build the emitted controls once so the signal model type, its defaults,
+  // the form() schema and the @aurora imports the class body needs all stay
+  // in lockstep. The embed never carries m2m controls
+  // (allowManyToManyRelationShip: false). Computed here, ahead of the import
+  // gates, because the model has NO tab dimension: it is derived from
+  // formGroupFields, not from the tab-scoped emittedFormFields the template
+  // body renders.
+  const emittedFields = formGroupFields
+    .filter((property) => it.predicates.isAllowProperty(it.schema.moduleName, property, { allowManyToManyRelationShip: false }))
+    .map((property) => {
+      const name = it.fmt.toCamelCase(it.mappers.getPropertyName(property));
+      return {
+        property,
+        name,
+        valueType: it.pickModel.getControlValueType(property),
+        default: it.pickModel.getPickModelDefault(property),
+        validators: it.validators.getSignalFormValidators(property, 'path.' + name),
+      };
+    });
 
   // ================================================================
   // Build imports array — dumb form, no Apollo / no router / no shell helpers
@@ -186,26 +245,43 @@
       .filter((property) => it.predicates.isAllowProperty(it.schema.moduleName, property, { allowManyToManyRelationShip: false }))
       .flatMap((property) => it.validators.getSignalFormValidatorNames(property))
   )].sort();
-  const signalsImports = ['form', 'FormField', 'submit', ...signalFormValidatorNames];
+  // `form` and `submit` drive the class body unconditionally (the model and
+  // the submit() method exist even with zero controls). `FormField` is a
+  // template-only directive — needed only when a control actually binds it.
+  const signalsImports = ['form', 'submit', ...signalFormValidatorNames];
+  if (hasAnyEmittedField) signalsImports.push('FormField');
+  // createOnly (add-create-only-property-semantics): same rationale as the
+  // standalone form — disable the control in edit mode via disabled(),
+  // never a read-only marker. Checking the plain `formGroupFields` (not the
+  // isAllowProperty-filtered set `emittedFields` computes below) is safe
+  // here: the loader refuses `createOnly` on every `type: 'relationship'`
+  // property (`schema-loader.ts`), so a createOnly field can only
+  // be a plain scalar or a many-to-one FK's scalar entry, and the allow
+  // gate never excludes either of those — it has nothing left to filter out.
+  const hasCreateOnlyFormFields = it.filters.hasCreateOnlyProperties(formGroupFields);
+  if (hasCreateOnlyFormFields) signalsImports.push('disabled');
 
   const auroraImports = [];
-  if (hasNonBooleanField) auroraImports.push('ValidationMessagePipe');
+  if (hasAnyNonBooleanEmittedField) auroraImports.push('ValidationMessagePipe');
   if (hasAnySearchSelectField) auroraImports.push('ToOptionsPipe');
   if (hasSearchSelectField) auroraImports.push('SearchSelect');
   if (hasMultipleSearchSelectField) auroraImports.push('MultipleSearchSelect');
   if (hasAsyncSearchSelectField) auroraImports.push('AsyncSearchSelect');
   if (hasAsyncMultipleSearchSelectField) auroraImports.push('AsyncMultipleSearchSelect');
   if (hasGridSelectElementField) auroraImports.push('GridSelectElement');
+  if (hasPasswordField) auroraImports.push('AuroraPasswordInput');
+  if (hasPasswordField) auroraImports.push('HlmPasswordStrength');
   if (hasSelectField) auroraImports.push('itemLabelOf');
   if (hasDateField) auroraImports.push('DatePicker');
   // DateTime fields render via <au-datetime-picker> (@aurora).
   if (hasDateTimeField) auroraImports.push('DateTimePicker');
-  /* The server applies no formatting to a date field, so a read yields the raw
-     Postgres timestamptz text while the write side demands the canonical shape.
-     The model is seeded through these normalizers so an untouched field still
-     round-trips something the server accepts. */
-  if (hasDateField) auroraImports.push('toWireDate');
-  if (hasDateTimeField) auroraImports.push('toWireDateTime');
+  /* GraphQLISODateTime is a passthrough (no @Scalar() implementation), so the
+     Postgres driver's raw text reaches the browser unchanged — a dateTime
+     reads back as "2026-08-30 22:00:00+00". That text always carries an
+     explicit offset, and both the picker (valueAsDate: new Date(iso)) and the
+     server's write handler (DateTimeTypeHandler.sanitize) parse it correctly
+     on their own: nothing is normalized on the way into the form model. Do
+     not reintroduce a wrapper for date or dateTime. */
   if (needsDataTableColumnDef) auroraImports.push('type DataTableColumnDef');
   if (hasScalarArrayRelFields && !auroraImports.includes('Option')) auroraImports.push('Option');
 
@@ -230,8 +306,10 @@
     importsArray.push({ items: ['environment'], path: 'environments/environment' });
   }
 
-  // Conditional Spartan imports — only emit what at least one rendered field uses.
-  if (hasAnyRenderedField) {
+  // Conditional Spartan imports — only emit what at least one emitted field uses.
+  // <hlm-field> wraps every field/relationship partial, so this gates on the
+  // full emitted set, not the scalar-only renderedFields.
+  if (hasAnyEmittedField) {
     importsArray.push({ items: ['HlmFieldImports'], path: '@spartan-ng/helm/field' });
   }
   if (hasInputField) {
@@ -254,12 +332,11 @@
   // ================================================================
   // Build component imports list for @Component.imports — mirrors importsArray
   // ================================================================
-  const componentImports = [
-    'FormField',
-    'TranslocoDirective',
-  ];
-  if (hasNonBooleanField) componentImports.push('ValidationMessagePipe');
-  if (hasAnyRenderedField) componentImports.push('HlmFieldImports');
+  const componentImports = [];
+  if (hasAnyEmittedField) componentImports.push('FormField');
+  componentImports.push('TranslocoDirective');
+  if (hasAnyNonBooleanEmittedField) componentImports.push('ValidationMessagePipe');
+  if (hasAnyEmittedField) componentImports.push('HlmFieldImports');
   if (hasInputField) componentImports.push('HlmInputImports');
   if (hasTextField) componentImports.push('HlmTextareaImports');
   if (hasBooleanField) componentImports.push('HlmSwitchImports');
@@ -273,6 +350,8 @@
   if (hasAsyncSearchSelectField) componentImports.push('AsyncSearchSelect');
   if (hasAsyncMultipleSearchSelectField) componentImports.push('AsyncMultipleSearchSelect');
   if (hasGridSelectElementField) componentImports.push('GridSelectElement');
+  if (hasPasswordField) componentImports.push('AuroraPasswordInput');
+  if (hasPasswordField) componentImports.push('HlmPasswordStrength');
   if (hasAnySearchSelectField) componentImports.push('ToOptionsPipe');
   if (useFormTabs) {
     componentImports.push('HlmTabsImports');
@@ -298,6 +377,13 @@ export class <%= modPascal %>FormEmbedComponent {
   // inputs
   readonly initial = input<<%= aggregate %> | null>(null);
   readonly mode = input.required<'new' | 'edit'>();
+  // createOnly (add-create-only-property-semantics): same rationale as the
+  // standalone form (see __module_name__-form.component.ts.eta) — `mode`
+  // stays the ROUTE/presentation mode, `transportMode` is the mode this
+  // save actually travels as when the two diverge. Optional and always
+  // declared (like `mode`): falls back to `mode()` wherever the caller has
+  // nothing different to report.
+  readonly transportMode = input<'new' | 'edit'>();
   readonly parentValue = input.required<string>();
 <% if (isEmbeddedI18n) { -%>
   // Embedded stores the full per-locale map on the row and the backend
@@ -331,7 +417,9 @@ export class <%= modPascal %>FormEmbedComponent {
 <% if (hasSelectField) { -%>
 
 <% for (const meta of relMeta) { -%>
-<% if (meta.needsItemToString) { -%>
+<% if (meta.needsItemToString && meta.displayFieldTemplate !== '{name}') { -%>
+  protected readonly <%= meta.relSingular %>ItemToString = itemLabelOf(this.<%= meta.relSingular %>Options, '<%= meta.displayFieldTemplate %>');
+<% } else if (meta.needsItemToString) { -%>
   protected readonly <%= meta.relSingular %>ItemToString = itemLabelOf(this.<%= meta.relSingular %>Options);
 <% } -%>
 <% } -%>
@@ -344,23 +432,14 @@ export class <%= modPascal %>FormEmbedComponent {
 <% } -%>
 <% } -%>
 <%_
-  // Build the emitted controls once so the signal model type, its defaults, and
-  // the form() schema stay in lockstep. The embed never carries m2m controls
-  // (allowManyToManyRelationShip: false).
-  const emittedFields = formGroupFields
-    .filter((property) => it.predicates.isAllowProperty(it.schema.moduleName, property, { allowManyToManyRelationShip: false }))
-    .map((property) => {
-      const name = it.fmt.toCamelCase(it.mappers.getPropertyName(property));
-      return {
-        property,
-        name,
-        valueType: it.pickModel.getControlValueType(property),
-        default: it.pickModel.getPickModelDefault(property),
-        validators: it.validators.getSignalFormValidators(property, 'path.' + name),
-      };
-    });
   const hasAnyValidator = emittedFields.some((f) => f.validators.length > 0);
 
+  // createOnly (add-create-only-property-semantics): stays in the model in
+  // BOTH modes; only the disabled state of the control and the emitted
+  // payload differ by mode.
+  const createOnlyFields = emittedFields.filter((f) => f.property.createOnly === true);
+  const hasCreateOnlyFields = createOnlyFields.length > 0;
+
   // Embedded i18n fields — same rationale as the main form template: the
   // model keeps the SCALAR control name as the editable field, but its
   // initial value and its submit payload are sliced from / merged into the
@@ -396,10 +475,6 @@ export class <%= modPascal %>FormEmbedComponent {
       <%= f.name %>: <%= embeddedI18nByName.get(f.name).mapConst %>[this.editLang()] ?? <%= embeddedI18nByName.get(f.name).mapConst %>[environment.lang.base] ?? <%= f.default %>,
 <% } else if (f.property.type === it.propertyType.ARRAY && !f.property.relationship && RELATIONAL_TYPES.has(f.property.widget?.type)) { -%>
       <%= f.name %>: (init?.<%= f.name %> ?? []).flatMap((v) => (v != null ? [v] : [])),
-<% } else if (f.property.type === it.propertyType.DATE) { -%>
-      <%= f.name %>: toWireDate(init?.<%= f.name %>),
-<% } else if (f.property.type === it.propertyType.DATE_TIME) { -%>
-      <%= f.name %>: toWireDateTime(init?.<%= f.name %>),
 <% } else { -%>
       <%= f.name %>: init?.<%= f.name %> ?? <%= f.default %>,
 <% } -%>
@@ -407,17 +482,23 @@ export class <%= modPascal %>FormEmbedComponent {
     };
   });
 
-<% if (hasAnyValidator) { -%>
+<% if (hasAnyValidator || hasCreateOnlyFields) { -%>
   readonly signalForm = form(this.model, (path) => {
 <% for (const f of emittedFields) { -%>
 <% for (const validator of f.validators) { -%>
     <%= validator %>;
 <% } -%>
+<% } -%>
+<% for (const f of createOnlyFields) { -%>
+    disabled(path.<%= f.name %>, { when: () => (this.transportMode() ?? this.mode()) === 'edit' });
 <% } -%>
   });
 <% } else { -%>
   readonly signalForm = form(this.model);
 <% } -%>
+<% if (hasPasswordField) { -%>
+  protected readonly passwordRules = { minLength: 8, digit: true, specialCharacter: true, lowerCase: true, upperCase: true };
+<% } -%>
 <% if (useFormTabs) { -%>
 
   readonly activeTab = signal<string>('<%= tabMeta[0].id %>');
@@ -453,11 +534,55 @@ export class <%= modPascal %>FormEmbedComponent {
       }
 <% } -%>
 <% } -%>
+
+<%_
+  // createOnly (add-create-only-property-semantics): omit the key entirely
+  // in edit mode, never null/undefined it. Never ALSO embedded-i18n: the
+  // loader refuses `isI18n` + `createOnly` unconditionally (schema-loader.ts),
+  // so `createOnlyFields` and `embeddedI18nFields` are disjoint by
+  // construction — no separate "non-i18n" filter is needed to avoid a
+  // duplicate binding against `rest`.
+_%>
+<% if (hasCreateOnlyFields) { -%>
+      const { <%= createOnlyFields.map((f) => f.name).join(', ') %>, ...createOnlyRest } = rest;
+      const payload = {
+        ...((this.transportMode() ?? this.mode()) === 'edit' ? createOnlyRest : rest),
+        <%= embeddedI18nFields.map((f) => f.i18nName).join(', ') %>,
+<% if (embedFkIsCreateOnly) { -%>
+        ...((this.transportMode() ?? this.mode()) === 'edit' ? {} : { <%= embedFkField %>: this.parentValue() }),
+<% } else { -%>
+        <%= embedFkField %>: this.parentValue(),
+<% } -%>
+      } as unknown as <%= aggregate %>;
+      this.save.emit(payload);
+<% } else { -%>
+<% if (embedFkIsCreateOnly) { -%>
+      const payload = { ...rest, <%= embeddedI18nFields.map((f) => f.i18nName).join(', ') %>, ...((this.transportMode() ?? this.mode()) === 'edit' ? {} : { <%= embedFkField %>: this.parentValue() }) } as unknown as <%= aggregate %>;
+<% } else { -%>
       const payload = { ...rest, <%= embeddedI18nFields.map((f) => f.i18nName).join(', ') %>, <%= embedFkField %>: this.parentValue() } as unknown as <%= aggregate %>;
+<% } -%>
+      this.save.emit(payload);
+<% } -%>
+<% } else { -%>
+<% if (hasCreateOnlyFields) { -%>
+      const { <%= createOnlyFields.map((f) => f.name).join(', ') %>, ...createOnlyRest } = this.model();
+      const payload = {
+        ...((this.transportMode() ?? this.mode()) === 'edit' ? createOnlyRest : this.model()),
+<% if (embedFkIsCreateOnly) { -%>
+        ...((this.transportMode() ?? this.mode()) === 'edit' ? {} : { <%= embedFkField %>: this.parentValue() }),
+<% } else { -%>
+        <%= embedFkField %>: this.parentValue(),
+<% } -%>
+      } as unknown as <%= aggregate %>;
       this.save.emit(payload);
+<% } else { -%>
+<% if (embedFkIsCreateOnly) { -%>
+      const payload = { ...this.model(), ...((this.transportMode() ?? this.mode()) === 'edit' ? {} : { <%= embedFkField %>: this.parentValue() }) } as unknown as <%= aggregate %>;
 <% } else { -%>
       const payload = { ...this.model(), <%= embedFkField %>: this.parentValue() } as unknown as <%= aggregate %>;
+<% } -%>
       this.save.emit(payload);
+<% } -%>
 <% } -%>
     });
 <% if (useFormTabs) { -%>