@carlonicora/nextjs-jsonapi 1.50.0 → 1.52.0

package/scripts/generate-web-module/templates/components/selector.template.ts

@@ -13,7 +13,10 @@ import { FrontendTemplateData } from "../../types/template-data.interface";
  * @returns Generated file content
  */
 export function generateSelectorTemplate(data: FrontendTemplateData): string {
-  const { names } = data;
+  const { names, fields, extendsContent } = data;
+  const hasNameField = extendsContent || fields.some((f) => f.name === "name");
+  const i18nKey = names.pluralCamel.toLowerCase();
+  const displayProp = hasNameField ? "name" : "id";
 
   return `"use client";
 
@@ -103,7 +106,7 @@ export default function ${names.pascalCase}Selector({
       return;
     }
 
-    form.setValue(id, { id: ${names.camelCase}.id, name: ${names.camelCase}.name });
+    form.setValue(id, { id: ${names.camelCase}.id, name: ${names.camelCase}.${displayProp} });
     setOpen(false);
 
     setTimeout(() => {
@@ -125,7 +128,7 @@ export default function ${names.pascalCase}Selector({
                   className="h-auto min-h-10 w-full justify-between px-3 py-2"
                 >
                   <span className={field.value ? "" : "text-muted-foreground"}>
-                    {field.value?.name ?? placeholder ?? t(\`generic.search.placeholder\`, { type: t(\`types.${names.pluralKebab}\`, { count: 1 }) })}
+                    {field.value?.name ?? placeholder ?? t(\`generic.search.placeholder\`, { type: t(\`entities.${i18nKey}\`, { count: 1 }) })}
                   </span>
                   <ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
                 </Button>
@@ -140,7 +143,7 @@ export default function ${names.pascalCase}Selector({
             <PopoverContent className="w-(--radix-popover-trigger-width) p-0" align="start">
               <Command shouldFilter={false}>
                 <CommandInput
-                  placeholder={t(\`generic.search.placeholder\`, { type: t(\`types.${names.pluralKebab}\`, { count: 1 }) })}
+                  placeholder={t(\`generic.search.placeholder\`, { type: t(\`entities.${i18nKey}\`, { count: 1 }) })}
                   value={searchTerm}
                   onValueChange={setSearchTerm}
                 />
@@ -162,7 +165,7 @@ export default function ${names.pascalCase}Selector({
                           onSelect={() => set${names.pascalCase}(${names.camelCase})}
                           className="hover:bg-muted data-selected:hover:bg-muted bg-transparent data-selected:bg-transparent cursor-pointer"
                         >
-                          {${names.camelCase}.name}
+                          {${names.camelCase}.${displayProp}}
                         </CommandItem>
                       ))}
                     </CommandGroup>

package/scripts/generate-web-module/templates/context.template.ts

@@ -13,7 +13,9 @@ import { FrontendTemplateData } from "../types/template-data.interface";
  * @returns Generated file content
  */
 export function generateContextTemplate(data: FrontendTemplateData): string {
-  const { names, extendsContent } = data;
+  const { names, fields, extendsContent } = data;
+  const hasNameField = extendsContent || fields.some((f) => f.name === "name");
+  const i18nKey = names.pluralCamel.toLowerCase();
 
   return `"use client";
 
@@ -61,13 +63,13 @@ export const ${names.pascalCase}Provider = ({ children, dehydrated${names.pascal
     const response: BreadcrumbItemData[] = [];
 
     response.push({
-      name: t(\`types.${names.pluralCamel}\`, { count: 2 }),
+      name: t(\`entities.${i18nKey}\`, { count: 2 }),
       href: generateUrl({ page: Modules.${names.pascalCase} }),
     });
 
     if (${names.camelCase})
       response.push({
-        name: ${names.camelCase}.name,
+        name: ${hasNameField ? `${names.camelCase}.name` : `${names.camelCase}.id`},
         href: generateUrl({ page: Modules.${names.pascalCase}, id: ${names.camelCase}.id }),
       });
 
@@ -76,13 +78,13 @@ export const ${names.pascalCase}Provider = ({ children, dehydrated${names.pascal
 
   const title = () => {
     const response: any = {
-      type: t(\`types.${names.pluralCamel}\`, { count: ${names.camelCase} ? 1 : 2 }),
+      type: t(\`entities.${i18nKey}\`, { count: ${names.camelCase} ? 1 : 2 }),
     };
 
     const functions: ReactNode[] = [];
 
-    if (${names.camelCase}) {
-      response.element = ${names.camelCase}.name;
+    if (${names.camelCase}) {${hasNameField ? `
+      response.element = ${names.camelCase}.name;` : ""}
 
       functions.push(<${names.pascalCase}Deleter key={\`${names.pascalCase}Deleter\`} ${names.camelCase}={${names.camelCase}} />);
       functions.push(<${names.pascalCase}Editor key={\`${names.pascalCase}Editor\`} ${names.camelCase}={${names.camelCase}} propagateChanges={set${names.pascalCase}} />);

package/scripts/generate-web-module/templates/data/aliases.template.ts

@@ -0,0 +1,33 @@
+/**
+ * Aliases Template
+ *
+ * Generates {Module}Aliases.ts const object for type-safe alias references.
+ * Only generated when the module has aliased relationships.
+ */
+
+import { FrontendTemplateData } from "../../types/template-data.interface";
+import { toCamelCase, toKebabCase, pluralize } from "../../transformers/name-transformer";
+
+/**
+ * Generate the aliases file content
+ *
+ * @param data - Frontend template data
+ * @returns Generated file content, or null if no aliases exist
+ */
+export function generateAliasesTemplate(data: FrontendTemplateData): string | null {
+  const { names, relationships } = data;
+
+  const aliasedRels = relationships.filter((rel) => rel.alias);
+  if (aliasedRels.length === 0) return null;
+
+  const entries = aliasedRels.map((rel) => {
+    const endpoint = rel.single
+      ? toKebabCase(rel.alias!)
+      : pluralize(toKebabCase(rel.alias!));
+    const property = toCamelCase(rel.alias!);
+
+    return `  ${rel.alias}: {\n    endpoint: "${endpoint}",\n    property: "${property}",\n  },`;
+  });
+
+  return `export const ${names.pascalCase}Aliases = {\n${entries.join("\n")}\n} as const;\n`;
+}

package/scripts/generate-web-module/templates/data/fields.template.ts

@@ -47,10 +47,10 @@ function generateEnumEntries(data: FrontendTemplateData): string {
 
   // Add relationship fields
   relationships.forEach((rel) => {
-    const effectiveName = rel.variant || rel.name;
+    const effectiveName = rel.alias || rel.variant || rel.name;
     const key = rel.single
       ? toCamelCase(effectiveName)
-      : pluralize(toCamelCase(rel.name));
+      : pluralize(toCamelCase(effectiveName));
     entries.push(`  ${key} = "${key}",`);
   });
 

package/scripts/generate-web-module/templates/data/index.ts

@@ -8,3 +8,4 @@ export * from "./interface.template";
 export * from "./model.template";
 export * from "./service.template";
 export * from "./fields.template";
+export * from "./aliases.template";

package/scripts/generate-web-module/templates/data/interface.template.ts

@@ -35,11 +35,14 @@ function generateImports(data: FrontendTemplateData): string {
   const { names, extendsContent, relationships } = data;
   const imports: string[] = [];
 
-  // Relationship interface imports (skip self-referential - interface is defined in this file)
+  // Relationship interface imports (deduplicated, skip self-referential)
+  const seenInterfaces = new Set<string>();
   relationships.forEach((rel) => {
     if (rel.name === names.pascalCase) {
       return; // Skip self-reference - interface defined in this file
     }
+    if (seenInterfaces.has(rel.interfaceName)) return;
+    seenInterfaces.add(rel.interfaceName);
     imports.push(`import { ${rel.interfaceName} } from "${rel.interfaceImportPath}";`);
   });
 
@@ -73,7 +76,7 @@ function generateInputType(data: FrontendTemplateData): string {
 
   // Add relationship IDs and relationship property fields
   relationships.forEach((rel) => {
-    const effectiveName = rel.variant || rel.name;
+    const effectiveName = rel.alias || rel.variant || rel.name;
     if (rel.single) {
       const key = `${toCamelCase(effectiveName)}Id`;
       const optional = rel.nullable ? "?" : "";
@@ -87,7 +90,8 @@ function generateInputType(data: FrontendTemplateData): string {
         });
       }
     } else {
-      const key = `${toCamelCase(rel.name)}Ids`;
+      const effectiveMany = rel.alias || rel.name;
+      const key = `${toCamelCase(effectiveMany)}Ids`;
       fieldLines.push(`  ${key}?: string[];`);
     }
   });
@@ -122,7 +126,7 @@ function generateInterface(data: FrontendTemplateData): string {
 
   // Add relationship getters
   relationships.forEach((rel) => {
-    const effectiveName = rel.variant || rel.name;
+    const effectiveName = rel.alias || rel.variant || rel.name;
     if (rel.single) {
       const propertyName = toCamelCase(effectiveName);
 
@@ -136,7 +140,8 @@ function generateInterface(data: FrontendTemplateData): string {
       const type = rel.nullable ? `(${baseType}) | undefined` : baseType;
       getterLines.push(`  get ${propertyName}(): ${type};`);
     } else {
-      const propertyName = pluralize(toCamelCase(rel.name));
+      const effectiveMany = rel.alias || rel.name;
+      const propertyName = pluralize(toCamelCase(effectiveMany));
       // Use intersection type if relationship has fields (edge properties)
       if (rel.fields && rel.fields.length > 0) {
         const metaFields = rel.fields.map((f) => `${f.name}?: ${f.tsType}`).join("; ");

package/scripts/generate-web-module/templates/data/model.template.ts

@@ -51,11 +51,14 @@ function generateImports(data: FrontendTemplateData): string {
     `import { ${names.pascalCase}Input, ${names.pascalCase}Interface } from "@/features/${data.importTargetDir}/${names.kebabCase}/data/${names.pascalCase}Interface";`,
   );
 
-  // Relationship interface imports (skip self-referential - already imported above)
+  // Relationship interface imports (deduplicated, skip self-referential)
+  const seenInterfaces = new Set<string>();
   relationships.forEach((rel) => {
     if (rel.name === names.pascalCase) {
       return; // Skip self-reference - interface already imported
     }
+    if (seenInterfaces.has(rel.interfaceName)) return;
+    seenInterfaces.add(rel.interfaceName);
     imports.push(`import { ${rel.interfaceName} } from "${rel.interfaceImportPath}";`);
   });
 
@@ -91,7 +94,7 @@ function generatePrivateFields(data: FrontendTemplateData): string {
   // Relationship private members
   if (!extendsContent) {
     relationships.forEach((rel) => {
-      const effectiveName = rel.variant || rel.name;
+      const effectiveName = rel.alias || rel.variant || rel.name;
       if (rel.single) {
         const propName = toCamelCase(effectiveName);
         // Use intersection type if relationship has fields
@@ -102,7 +105,8 @@ function generatePrivateFields(data: FrontendTemplateData): string {
         }
         lines.push(`  private _${propName}?: ${typeDecl};`);
       } else {
-        const propName = pluralize(toCamelCase(rel.name));
+        const effectiveMany = rel.alias || rel.name;
+        const propName = pluralize(toCamelCase(effectiveMany));
         // Use intersection type if relationship has fields (edge properties)
         if (rel.fields && rel.fields.length > 0) {
           const metaFields = rel.fields.map((f) => `${f.name}?: ${f.tsType}`).join("; ");
@@ -139,7 +143,7 @@ function generateGetters(data: FrontendTemplateData): string {
   // Relationship getters (only for non-Content extending)
   if (!extendsContent) {
     relationships.forEach((rel) => {
-      const effectiveName = rel.variant || rel.name;
+      const effectiveName = rel.alias || rel.variant || rel.name;
       if (rel.single) {
         const propName = toCamelCase(effectiveName);
 
@@ -161,7 +165,8 @@ function generateGetters(data: FrontendTemplateData): string {
   }`);
         }
       } else {
-        const propName = pluralize(toCamelCase(rel.name));
+        const effectiveMany = rel.alias || rel.name;
+        const propName = pluralize(toCamelCase(effectiveMany));
         // Use intersection type if relationship has fields (edge properties)
         if (rel.fields && rel.fields.length > 0) {
           const metaFields = rel.fields.map((f) => `${f.name}?: ${f.tsType}`).join("; ");
@@ -197,7 +202,7 @@ function generateRehydrateMethod(data: FrontendTemplateData): string {
     : fields;
 
   fieldsToInclude.forEach((field) => {
-    if (field.isContentField || field.name === "content") {
+    if (field.isContentField) {
       // Content fields need JSON parsing
       lines.push(
         `    this._${field.name} = data.jsonApi.attributes.${field.name} ? JSON.parse(data.jsonApi.attributes.${field.name}) : undefined;`,
@@ -215,17 +220,19 @@ function generateRehydrateMethod(data: FrontendTemplateData): string {
   if (!extendsContent && relationships.length > 0) {
     lines.push(``);
     relationships.forEach((rel) => {
-      const effectiveName = rel.variant || rel.name;
+      const effectiveName = rel.alias || rel.variant || rel.name;
       if (rel.single) {
         const propName = toCamelCase(effectiveName);
-        const relationshipKey = effectiveName.toLowerCase();
+        const relationshipKey = toCamelCase(effectiveName);
 
         // Use _readIncludedWithMeta for relationships with fields
         if (rel.fields && rel.fields.length > 0) {
           const metaType = `{ ${rel.fields.map((f) => `${f.name}?: ${f.tsType}`).join("; ")} }`;
-          const nullableCast = rel.nullable ? ` as (${rel.interfaceName} & ${metaType}) | undefined` : "";
+          const singleCast = rel.nullable
+            ? ` as (${rel.interfaceName} & ${metaType}) | undefined`
+            : ` as ${rel.interfaceName} & ${metaType}`;
           lines.push(
-            `    this._${propName} = this._readIncludedWithMeta<${rel.interfaceName}, ${metaType}>(data, "${relationshipKey}", Modules.${rel.name})${nullableCast};`,
+            `    this._${propName} = this._readIncludedWithMeta<${rel.interfaceName}, ${metaType}>(data, "${relationshipKey}", Modules.${rel.name})${singleCast};`,
           );
         } else {
           lines.push(
@@ -233,8 +240,9 @@ function generateRehydrateMethod(data: FrontendTemplateData): string {
           );
         }
       } else {
-        const propName = pluralize(toCamelCase(rel.name));
-        const relationshipKey = pluralize(rel.name.toLowerCase());
+        const effectiveMany = rel.alias || rel.name;
+        const propName = pluralize(toCamelCase(effectiveMany));
+        const relationshipKey = toCamelCase(effectiveMany);
 
         // Use _readIncludedWithMeta for relationships with fields (edge properties)
         if (rel.fields && rel.fields.length > 0) {
@@ -290,7 +298,7 @@ function generateCreateJsonApiMethod(data: FrontendTemplateData): string {
     : fields;
 
   fieldsToInclude.forEach((field) => {
-    if (field.isContentField || field.name === "content") {
+    if (field.isContentField) {
       lines.push(
         `    if (data.${field.name} !== undefined) response.data.attributes.${field.name} = JSON.stringify(data.${field.name});`,
       );
@@ -307,8 +315,8 @@ function generateCreateJsonApiMethod(data: FrontendTemplateData): string {
   if (relationshipsToSerialize.length > 0) {
     lines.push(``);
     relationshipsToSerialize.forEach((rel) => {
-      const effectiveName = rel.variant || rel.name;
-      const payloadKey = rel.single ? `${toCamelCase(effectiveName)}Id` : `${toCamelCase(rel.name)}Ids`;
+      const effectiveName = rel.alias || rel.variant || rel.name;
+      const payloadKey = rel.single ? `${toCamelCase(effectiveName)}Id` : `${toCamelCase(effectiveName)}Ids`;
       const relationshipKey = toCamelCase(effectiveName);
 
       if (rel.single) {
@@ -355,7 +363,7 @@ function generateCreateJsonApiMethod(data: FrontendTemplateData): string {
  * Get default value for a field type
  */
 function getDefaultValue(field: FrontendField): string {
-  if (field.isContentField || field.name === "content") {
+  if (field.isContentField) {
     return "[]";
   }
 

package/scripts/generate-web-module/templates/data/service.template.ts

@@ -108,6 +108,11 @@ function generateRelationshipMethods(data: FrontendTemplateData): string {
 
   return relationshipServiceMethods
     .map((method) => {
+      // For aliases, use a raw string endpoint; for standard relationships, use Modules reference
+      const endpointValue = method.aliasEndpoint
+        ? `"${method.aliasEndpoint}"`
+        : `Modules.${method.relationshipName}`;
+
       return `  static async ${method.methodName}(params: {
     ${method.paramName}: string;
     search?: string;
@@ -116,7 +121,7 @@ function generateRelationshipMethods(data: FrontendTemplateData): string {
     prev?: PreviousRef;
   }): Promise<${names.pascalCase}Interface[]> {
     const endpoint = new EndpointCreator({
-      endpoint: Modules.${method.relationshipName},
+      endpoint: ${endpointValue},
       id: params.${method.paramName},
       childEndpoint: Modules.${names.pascalCase},
     });

package/scripts/generate-web-module/templates/index.ts

@@ -10,6 +10,7 @@ export {
   generateModelTemplate,
   generateServiceTemplate,
   generateFieldsTemplate,
+  generateAliasesTemplate,
 } from "./data";
 
 // Component templates

package/scripts/generate-web-module/templates/pages/detail-page.template.ts

@@ -13,14 +13,15 @@ import { FrontendTemplateData } from "../../types/template-data.interface";
  * @returns Generated file content
  */
 export function generateDetailPageTemplate(data: FrontendTemplateData): string {
-  const { names } = data;
+  const { names, fields, extendsContent } = data;
+  const hasNameField = extendsContent || fields.some((f) => f.name === "name");
+  const i18nKey = names.pluralCamel.toLowerCase();
 
   return `import ${names.pascalCase}Container from "@/features/${data.importTargetDir}/${names.kebabCase}/components/containers/${names.pascalCase}Container";
 import { ${names.pascalCase}Provider } from "@/features/${data.importTargetDir}/${names.kebabCase}/contexts/${names.pascalCase}Context";
 import { ${names.pascalCase}Interface } from "@/features/${data.importTargetDir}/${names.kebabCase}/data/${names.pascalCase}Interface";
 import { ${names.pascalCase}Service } from "@/features/${data.importTargetDir}/${names.kebabCase}/data/${names.pascalCase}Service";
 import { generateSpecificMetadata } from "@/utils/metadata";
-import { PageContainer } from "@carlonicora/nextjs-jsonapi/components";
 import { Modules } from "@carlonicora/nextjs-jsonapi/core";
 import { Action } from "@carlonicora/nextjs-jsonapi/core";
 import { ServerSession } from "@carlonicora/nextjs-jsonapi/server";
@@ -41,8 +42,8 @@ export async function generateMetadata(props: { params: Promise<{ id: string }>
     action: Action.Read,
     data: ${names.camelCase},
   }))
-    ? \`[\${t(\`types.${names.pluralCamel}\`, { count: 1 })}] \${${names.camelCase}.name}\`
-    : \`\${t(\`types.${names.pluralCamel}\`, { count: 1 })}\`;
+    ? \`[\${t(\`entities.${i18nKey}\`, { count: 1 })}]${hasNameField ? ` \${${names.camelCase}.name}` : ""}\`
+    : \`\${t(\`entities.${i18nKey}\`, { count: 1 })}\`;
 
   return await generateSpecificMetadata({ title: title });
 }
@@ -55,9 +56,7 @@ export default async function ${names.pascalCase}Page(props: { params: Promise<{
 
   return (
     <${names.pascalCase}Provider dehydrated${names.pascalCase}={${names.camelCase}.dehydrate()}>
-      <PageContainer>
-        <${names.pascalCase}Container />
-      </PageContainer>
+      <${names.pascalCase}Container />
     </${names.pascalCase}Provider>
   );
 }

package/scripts/generate-web-module/templates/pages/list-page.template.ts

@@ -17,7 +17,7 @@ export function generateListPageTemplate(data: FrontendTemplateData): string {
 
   return `import ${names.pascalCase}ListContainer from "@/features/${data.importTargetDir}/${names.kebabCase}/components/containers/${names.pascalCase}ListContainer";
 import { ${names.pascalCase}Provider } from "@/features/${data.importTargetDir}/${names.kebabCase}/contexts/${names.pascalCase}Context";
-import { PageContainer } from "@carlonicora/nextjs-jsonapi/components";
+import { RoundPageContainer } from "@carlonicora/nextjs-jsonapi/components";
 import { Modules } from "@carlonicora/nextjs-jsonapi/core";
 import { Action } from "@carlonicora/nextjs-jsonapi/core";
 import { ServerSession } from "@carlonicora/nextjs-jsonapi/server";
@@ -27,9 +27,9 @@ export default async function ${names.pluralPascal}ListPage() {
 
   return (
     <${names.pascalCase}Provider>
-      <PageContainer testId="page-${names.pluralKebab}-container">
+      <RoundPageContainer module={Modules.${names.pascalCase}}>
         <${names.pascalCase}ListContainer />
-      </PageContainer>
+      </RoundPageContainer>
     </${names.pascalCase}Provider>
   );
 }

package/scripts/generate-web-module/transformers/field-mapper.ts

@@ -23,7 +23,7 @@ import {
  */
 export function mapField(field: JsonFieldDefinition, moduleName: string): FrontendField {
   const formComponent = getFormComponent(field.name, field.type);
-  const isContent = isContentField(field.name);
+  const isContent = isContentField(field.name, field.type);
 
   return {
     name: field.name,
@@ -56,7 +56,7 @@ export function mapFields(fields: JsonFieldDefinition[], moduleName: string): Fr
  */
 export function buildZodSchema(field: JsonFieldDefinition, moduleName: string): string {
   // Content fields always use z.any()
-  if (isContentField(field.name)) {
+  if (isContentField(field.name, field.type)) {
     return "z.any()";
   }
 
@@ -87,12 +87,12 @@ export function buildZodSchema(field: JsonFieldDefinition, moduleName: string):
     return base;
   }
 
-  // Date fields
+  // Date fields — use z.date() not z.coerce.date() to avoid react-hook-form type inference issues
   if (field.type === "date") {
     if (field.nullable) {
-      return `z.coerce.date().optional()`;
+      return `z.date().optional()`;
     }
-    return `z.coerce.date()`;
+    return `z.date()`;
   }
 
   // Default case

package/scripts/generate-web-module/transformers/i18n-generator.ts

@@ -90,7 +90,7 @@ export function buildI18nMessages(i18nKeys: I18nKeySet): Record<string, any> {
         relationships: i18nKeys.relationships,
       },
     },
-    types: {
+    entities: {
       [pluralLowercaseKey]: i18nKeys.type.icuPlural,
     },
   };
@@ -136,7 +136,7 @@ export function getFieldErrorKey(moduleName: string, fieldName: string): string
  * @returns Translation key path
  */
 export function getTypeKey(pluralKebab: string): string {
-  return `types.${pluralKebab}`;
+  return `entities.${pluralKebab}`;
 }
 
 /**

package/scripts/generate-web-module/transformers/import-resolver.ts

@@ -171,6 +171,7 @@ export interface ModuleFilePaths {
   model: string;
   service: string;
   fields: string;
+  aliases: string;
   editor: string;
   deleter: string;
   selector: string;
@@ -211,6 +212,7 @@ export function buildFilePaths(
     model: `${basePath}/data/${names.pascalCase}.ts`,
     service: `${basePath}/data/${names.pascalCase}Service.ts`,
     fields: `${basePath}/data/${names.pascalCase}Fields.ts`,
+    aliases: `${basePath}/data/${names.pascalCase}Aliases.ts`,
 
     // Components
     editor: `${basePath}/components/forms/${names.pascalCase}Editor.tsx`,

package/scripts/generate-web-module/transformers/relationship-resolver.ts

@@ -35,7 +35,7 @@ export function isFoundationImport(directory: string): boolean {
  * @param rel - JSON relationship definition
  * @returns Frontend relationship representation
  */
-export function resolveRelationship(rel: JsonRelationshipDefinition): FrontendRelationship {
+export function resolveRelationship(rel: JsonRelationshipDefinition, targetHasNameMap?: Map<string, boolean>): FrontendRelationship {
   const isAuthor = rel.variant === AUTHOR_VARIANT;
   const effectiveName = rel.alias || rel.variant || rel.name;
   const effectiveNameLower = toCamelCase(effectiveName);
@@ -50,19 +50,18 @@ export function resolveRelationship(rel: JsonRelationshipDefinition): FrontendRe
   if (rel.single) {
     payloadFieldId = `${effectiveNameLower}Id`;
   } else {
-    payloadFieldId = `${toCamelCase(rel.name)}Ids`;
+    payloadFieldId = `${effectiveNameLower}Ids`;
   }
 
-  // Selector component name
+  // Selector component name - always based on target entity name, not alias
   // Foundation components use MultiSelect, generated modules use MultiSelector
   let selectorComponent: string;
-  const selectorBaseName = rel.alias || rel.name;
   if (rel.single) {
-    selectorComponent = `${selectorBaseName}Selector`;
+    selectorComponent = `${rel.name}Selector`;
   } else {
     selectorComponent = isFoundationImport(rel.directory)
-      ? `${selectorBaseName}MultiSelect`
-      : `${selectorBaseName}MultiSelector`;
+      ? `${rel.name}MultiSelect`
+      : `${rel.name}MultiSelector`;
   }
 
   // Zod schema
@@ -122,6 +121,7 @@ export function resolveRelationship(rel: JsonRelationshipDefinition): FrontendRe
     interfaceName: `${rel.name}Interface`,
     modelKebab,
     fields,
+    targetHasName: targetHasNameMap?.get(rel.name) ?? true, // Foundation entities default to true
   };
 }
 
@@ -131,8 +131,8 @@ export function resolveRelationship(rel: JsonRelationshipDefinition): FrontendRe
  * @param relationships - Array of JSON relationship definitions
  * @returns Array of frontend relationship representations
  */
-export function resolveRelationships(relationships: JsonRelationshipDefinition[]): FrontendRelationship[] {
-  return relationships.map(resolveRelationship);
+export function resolveRelationships(relationships: JsonRelationshipDefinition[], targetHasNameMap?: Map<string, boolean>): FrontendRelationship[] {
+  return relationships.map((rel) => resolveRelationship(rel, targetHasNameMap));
 }
 
 /**
@@ -157,14 +157,18 @@ export function mapDirectoryToWebPath(directory: string): string {
  * @param relationships - Array of frontend relationships
  * @returns Array of service method definitions
  */
-export function generateServiceMethods(relationships: FrontendRelationship[]): RelationshipServiceMethod[] {
+export function generateServiceMethods(relationships: FrontendRelationship[], conflictingAliases?: Set<string>): RelationshipServiceMethod[] {
   return relationships.map((rel) => {
     const effectiveName = rel.alias || rel.variant || rel.name;
+    // Only use alias endpoint when the alias conflicts with another alias targeting the same entity
+    const needsAliasEndpoint = rel.alias && (conflictingAliases?.has(rel.alias) ?? false);
     return {
       methodName: `findManyBy${toPascalCase(effectiveName)}`,
       paramName: `${toCamelCase(effectiveName)}Id`,
       relationshipName: rel.name,
       relationshipEndpoint: pluralize(toKebabCase(rel.name)),
+      // For conflicting aliases, use a raw string endpoint (e.g., "created-by") instead of Modules reference
+      aliasEndpoint: needsAliasEndpoint ? toKebabCase(rel.alias!) : undefined,
     };
   });
 }
@@ -219,7 +223,7 @@ export function getRelationshipFormJsx(rel: FrontendRelationship, moduleName: st
     return `<${rel.name}MultiSelector
   id="${rel.formFieldId}"
   form={form}
-  label={t(\`types.${pluralize(toKebabCase(rel.name))}\`, { count: 2 })}
+  label={t(\`entities.${pluralize(rel.name.toLowerCase())}\`, { count: 2 })}
 />`;
   }
 }
@@ -242,13 +246,15 @@ export function getDefaultValueExpression(rel: FrontendRelationship, modelVarNam
         ? { id: ${modelVarName}.${propertyName}.id, name: ${modelVarName}.${propertyName}.name, avatar: ${modelVarName}.${propertyName}.avatar }
         : undefined`;
     }
+    const displayProp = rel.targetHasName ? "name" : "id";
     return `${modelVarName}?.${propertyName}
-        ? { id: ${modelVarName}.${propertyName}.id, name: ${modelVarName}.${propertyName}.name }
+        ? { id: ${modelVarName}.${propertyName}.id, name: ${modelVarName}.${propertyName}.${displayProp} }
         : undefined`;
   } else {
     // Multi-select
+    const displayProp = rel.targetHasName ? "name" : "id";
     return `${modelVarName}?.${pluralPropertyName}
-        ? ${modelVarName}.${pluralPropertyName}.map((item) => ({ id: item.id, name: item.name }))
+        ? ${modelVarName}.${pluralPropertyName}.map((item) => ({ id: item.id, name: item.${displayProp} }))
         : []`;
   }
 }

package/scripts/generate-web-module/types/field-mapping.types.ts

@@ -98,19 +98,32 @@ export function getZodBase(jsonType: string): string {
  * Get form component for a field
  */
 export function getFormComponent(fieldName: string, fieldType: string): FormComponentType {
-  // Check for special field names first
+  // Check for special field names first, but only if the type is compatible
+  // (e.g., "content" as a string field should NOT use BlockNoteEditor)
   if (SPECIAL_FIELD_COMPONENTS[fieldName]) {
-    return SPECIAL_FIELD_COMPONENTS[fieldName];
+    const specialComponent = SPECIAL_FIELD_COMPONENTS[fieldName];
+    if (specialComponent === "BlockNoteEditor" && isContentField(fieldName, fieldType)) {
+      return specialComponent;
+    } else if (specialComponent !== "BlockNoteEditor") {
+      return specialComponent;
+    }
   }
   // Fall back to type-based component
   return TYPE_TO_FORM_COMPONENT[fieldType] || "FormInput";
 }
 
 /**
- * Check if a field name indicates BlockNoteEditor should be used
+ * Check if a field indicates BlockNoteEditor should be used.
+ * Only fields named "content" with non-primitive types (not string/number/boolean/date)
+ * are treated as rich-content (JSON/BlockNote) fields.
  */
-export function isContentField(fieldName: string): boolean {
-  return fieldName === "content";
+export function isContentField(fieldName: string, fieldType?: string): boolean {
+  if (fieldName !== "content") return false;
+  // If no type provided, assume it's a content field (backwards compat)
+  if (!fieldType) return true;
+  // Primitive types are NOT content fields even when named "content"
+  const primitiveTypes = ["string", "number", "boolean", "date", "datetime"];
+  return !primitiveTypes.includes(fieldType);
 }
 
 /**
@@ -120,7 +133,7 @@ export function buildZodSchema(fieldType: string, nullable: boolean, fieldName:
   const base = getZodBase(fieldType);
 
   // Content fields use z.any()
-  if (isContentField(fieldName)) {
+  if (isContentField(fieldName, fieldType)) {
     return "z.any()";
   }
 

package/scripts/generate-web-module/types/template-data.interface.ts

@@ -67,6 +67,7 @@ export interface FrontendRelationship {
   interfaceName: string; // e.g., "UserInterface"
   modelKebab: string; // e.g., "user"
   fields?: FrontendField[]; // Relationship property fields (stored on edges)
+  targetHasName: boolean; // Whether the target entity has a "name" field (or extends Content)
 }
 
 /**
@@ -162,6 +163,7 @@ export interface RelationshipServiceMethod {
   paramName: string; // e.g., "authorId"
   relationshipName: string; // e.g., "User"
   relationshipEndpoint: string; // e.g., "users"
+  aliasEndpoint?: string; // e.g., "created-by" — when set, uses raw string instead of Modules reference
 }
 
 /**