@carlonicora/nestjs-neo4jsonapi 1.31.2 → 1.32.0

package/dist/tools/migrate-entity/lib/descriptor-generator.js

@@ -25,22 +25,52 @@ function generateDescriptor(parsed, entityDir, options = {}) {
             }
         }
     }
-    // Build field configs
-    const fields = buildFieldConfigs(entityType, serialiser, mapper);
-    // Build computed configs
-    const computed = buildComputedConfigs(mapper, serialiser);
+    // Get S3 transforms from serialiser
+    const s3Transforms = serialiser?.s3Transforms || [];
+    // Build field configs with S3 transforms applied
+    const fields = buildFieldConfigs(entityType, serialiser, mapper, s3Transforms);
+    // Build computed configs and virtual fields
+    const { computed, virtualFields } = buildComputedConfigs(mapper, serialiser, entityType);
     // Build relationship configs using Cypher relationships when available
     const relationships = buildRelationshipConfigs(serialiser, cypherRelationships, options.verbose);
+    // Determine which services to include (only include S3Service if transforms are used)
+    const rawServices = serialiser?.services || [];
+    const services = s3Transforms.length > 0 ? rawServices : rawServices.filter((s) => s !== "S3Service");
+    // Log S3 transforms if verbose
+    if (options.verbose && s3Transforms.length > 0) {
+        console.log(`  Auto-generated ${s3Transforms.length} S3 transform(s):`);
+        for (const transform of s3Transforms) {
+            console.log(`    - ${transform.fieldName}: ${transform.isArray ? "array" : "single"} URL signing`);
+        }
+    }
+    // Warn about custom methods that may need manual migration (skip S3-related methods if transforms were generated)
+    const s3TransformFields = new Set(s3Transforms.map((t) => t.fieldName));
+    const s3RelatedMethods = ["getSignedUrl", "getSignedUrls", "generateSignedUrl", "signUrl", "signUrls"];
+    if (serialiser?.customMethods && serialiser.customMethods.length > 0) {
+        const unmigratableMethods = serialiser.customMethods.filter((method) => {
+            // Skip S3-related methods if we have transforms for URL fields
+            if (s3Transforms.length > 0 && s3RelatedMethods.some((s3m) => method.toLowerCase().includes(s3m.toLowerCase()))) {
+                return false;
+            }
+            return true;
+        });
+        if (unmigratableMethods.length > 0) {
+            console.warn(`    ⚠️  Serialiser has custom methods that may need manual migration:`);
+            for (const method of unmigratableMethods) {
+                console.warn(`      - ${method}() → Consider adding field transform`);
+            }
+        }
+    }
     // Generate imports (pass entityName for correct file path in self-meta import)
-    const imports = generateImports(parsed, relationships, entityDir, options.entityName);
+    const imports = generateImports(parsed, relationships, entityDir, options.entityName, services);
     // Generate the descriptor code
-    const code = generateDescriptorCode(meta, entityType.name, fields, computed, relationships);
+    const code = generateDescriptorCode(meta, entityType.name, fields, computed, virtualFields, relationships, services);
     return { code, imports };
 }
 /**
  * Builds field configurations from entity type, serialiser, and mapper.
  */
-function buildFieldConfigs(entityType, serialiser, mapper) {
+function buildFieldConfigs(entityType, serialiser, mapper, s3Transforms = []) {
     const fields = [];
     // Get attribute names from serialiser (these are JSON:API attributes)
     const attributeNames = new Set(serialiser?.attributes.map((a) => a.name) || []);
@@ -48,6 +78,8 @@ function buildFieldConfigs(entityType, serialiser, mapper) {
     const metaNames = new Set(serialiser?.meta.map((m) => m.name) || []);
     // Get mapper field names for mapping
     const mapperFields = new Map(mapper?.fields.filter((f) => !f.isComputed).map((f) => [f.name, f]) || []);
+    // Create a map of S3 transforms by field name
+    const s3TransformMap = new Map(s3Transforms.map((t) => [t.fieldName, t]));
     // Process entity type fields
     for (const field of entityType.fields) {
         // Skip if this is a computed field (handled separately)
@@ -63,33 +95,98 @@ function buildFieldConfigs(entityType, serialiser, mapper) {
         const cypherType = mapToCypherType(field.type);
         // Check for default values (e.g., aiStatus)
         const defaultValue = getDefaultValue(field.name, mapper);
+        // Check for S3 transforms
+        const s3Transform = s3TransformMap.get(field.name);
+        const transform = s3Transform ? generateS3TransformCode(field.name, s3Transform.isArray) : undefined;
         fields.push({
             name: field.name,
             type: cypherType,
             required: isRequired,
             default: defaultValue,
             meta: isMeta,
+            transform,
         });
     }
     return fields;
 }
 /**
- * Builds computed field configurations from mapper.
+ * Generates S3 transform function code for a field.
+ *
+ * Handles the `~` prefix convention: URLs starting with `~` are already
+ * signed or external URLs that should be returned as-is (without the prefix).
+ */
+function generateS3TransformCode(fieldName, isArray) {
+    if (isArray) {
+        // Array URL transform with ~ prefix handling
+        return `async (data, services) => {
+        if (!data.${fieldName}?.length) return [];
+        return Promise.all(
+          data.${fieldName}.map(async (url: string) => {
+            if (url.startsWith("~")) return url.substring(1);
+            return services.S3Service.generateSignedUrl({ key: url, isPublic: true });
+          }),
+        );
+      }`;
+    }
+    else {
+        // Single URL transform with ~ prefix handling
+        return `async (data, services) => {
+        if (!data.${fieldName}) return undefined;
+        if (data.${fieldName}.startsWith("~")) return data.${fieldName}.substring(1);
+        return await services.S3Service.generateSignedUrl({ key: data.${fieldName}, isPublic: true });
+      }`;
+    }
+}
+/**
+ * Builds computed field configurations and virtual fields from mapper and serialiser.
+ *
+ * Includes:
+ * 1. Mapper-based computed fields (e.g., params.record.has patterns)
+ * 2. Virtual fields: Serialiser attributes where name differs from mapping (e.g., avatarUrl -> avatar)
+ *    These are output-only fields that don't exist in the entity type.
  */
-function buildComputedConfigs(mapper, serialiser) {
+function buildComputedConfigs(mapper, serialiser, entityType) {
     const computed = [];
-    if (!mapper)
-        return computed;
+    const virtualFields = [];
+    const addedNames = new Set();
     // Get meta names from serialiser
     const metaNames = new Set(serialiser?.meta.map((m) => m.name) || []);
-    for (const field of mapper.fields.filter((f) => f.isComputed)) {
-        computed.push({
-            name: field.name,
-            compute: field.mapping,
-            meta: metaNames.has(field.name),
-        });
+    // Get entity field names (to distinguish computed-only fields)
+    const entityFieldNames = new Set(entityType.fields.map((f) => f.name));
+    // 1. Add mapper-based computed fields
+    if (mapper) {
+        for (const field of mapper.fields.filter((f) => f.isComputed)) {
+            computed.push({
+                name: field.name,
+                compute: field.mapping,
+                meta: metaNames.has(field.name),
+            });
+            addedNames.add(field.name);
+        }
     }
-    return computed;
+    // 2. Serialiser attributes where name != mapping AND name not in entity type
+    // These are output-only fields like `avatarUrl` that return `data.avatar`.
+    // We generate them as virtualFields (new feature in defineEntity).
+    if (serialiser) {
+        for (const attr of serialiser.attributes) {
+            // Skip if already added from mapper
+            if (addedNames.has(attr.name))
+                continue;
+            // Skip if this field exists in entity type (it's a regular field, not computed)
+            if (entityFieldNames.has(attr.name))
+                continue;
+            // If the serialiser attribute name differs from its mapping, it's a virtual field
+            if (attr.name !== attr.mapping) {
+                virtualFields.push({
+                    name: attr.name,
+                    compute: `params.data.${attr.mapping}`,
+                    meta: metaNames.has(attr.name),
+                });
+                addedNames.add(attr.name);
+            }
+        }
+    }
+    return { computed, virtualFields };
 }
 /**
  * Builds relationship configurations from serialiser, using Cypher relationships when available.
@@ -147,13 +244,27 @@ function buildRelationshipConfigs(serialiser, cypherRelationships = [], verbose)
 }
 /**
  * Maps TypeScript type to Cypher type.
+ * Handles both scalar types and array types.
  */
 function mapToCypherType(tsType) {
+    // Handle array types first (e.g., string[], number[])
+    if (tsType.endsWith("[]")) {
+        const baseType = tsType.slice(0, -2);
+        const mappedBase = mapScalarToCypherType(baseType);
+        return `${mappedBase}[]`;
+    }
+    return mapScalarToCypherType(tsType);
+}
+/**
+ * Maps a scalar TypeScript type to Cypher type.
+ */
+function mapScalarToCypherType(tsType) {
     const typeMap = {
         string: "string",
         number: "number",
         boolean: "boolean",
-        Date: "date",
+        Date: "datetime",
+        object: "json",
     };
     return typeMap[tsType] || "string";
 }
@@ -168,15 +279,20 @@ function getDefaultValue(fieldName, mapper) {
     return knownDefaults[fieldName];
 }
 /**
- * Converts Model import name to meta variable name.
+ * Converts Model/Descriptor import name to model reference.
+ * Returns either a meta variable name or a Descriptor.model reference.
  */
 function modelToMetaName(relName, modelImport) {
-    // Special cases
+    // Special cases for framework-provided relationships
     if (relName === "author")
         return "authorMeta";
     if (relName === "user" || relName === "editors")
         return "userMeta";
-    // General case: UserModel -> userMeta
+    // Already migrated entity: CompanyDescriptor -> CompanyDescriptor.model
+    if (modelImport.endsWith("Descriptor")) {
+        return `${modelImport}.model`;
+    }
+    // Old pattern: UserModel -> userMeta
     const baseName = modelImport.replace("Model", "").toLowerCase();
     return `${baseName}Meta`;
 }
@@ -203,10 +319,23 @@ function inferRelationshipDetails(relName) {
  * - Group 3: Entity-specific imports (src/features/...)
  * - Group 4: Self-meta import (relative path)
  */
-function generateImports(parsed, relationships, entityDir, entityName) {
+function generateImports(parsed, relationships, entityDir, entityName, services = []) {
     const { meta } = parsed;
     // Collect all framework imports into a single barrel import
     const frameworkImports = new Set(["defineEntity", "Entity"]);
+    // Add service imports
+    // Note: S3Service is NOT exported from common, it has its own foundation module
+    const serviceImports = [];
+    for (const service of services) {
+        if (service === "S3Service") {
+            // S3Service comes from its own module
+            serviceImports.push(`import { S3Service } from "../../s3";`);
+        }
+        else {
+            // Other services come from common
+            frameworkImports.add(service);
+        }
+    }
     // Check if AiStatus is needed
     const hasAiStatus = parsed.entityType.fields.some((f) => f.name === "aiStatus");
     if (hasAiStatus) {
@@ -216,38 +345,85 @@ function generateImports(parsed, relationships, entityDir, entityName) {
     const externalImports = [];
     const featureImports = [];
     for (const rel of relationships) {
-        const metaName = rel.model;
-        const baseName = metaName.replace("Meta", "");
-        // Framework-provided metas (user, author, owner, company)
-        if (["user", "author", "owner", "company"].includes(baseName)) {
-            frameworkImports.add(metaName);
-            // Also add the type if it's a relationship field type
-            const typeName = baseName.charAt(0).toUpperCase() + baseName.slice(1);
-            if (parsed.entityType.relationshipFields.some((f) => f.type.includes(typeName))) {
-                frameworkImports.add(typeName);
+        const modelRef = rel.model;
+        // Already-migrated entity: CompanyDescriptor.model -> need to import CompanyDescriptor
+        if (modelRef.endsWith(".model")) {
+            const descriptorName = modelRef.replace(".model", "");
+            const descriptorImport = findDescriptorImport(parsed, descriptorName);
+            if (descriptorImport) {
+                featureImports.push(descriptorImport);
             }
+            continue;
+        }
+        // Meta-based reference: xxxMeta
+        const baseName = modelRef.replace("Meta", "");
+        // Known foundation metas and their import paths
+        const foundationMetaPaths = {
+            user: "../../user/entities/user.meta",
+            author: "../../user/entities/user.meta",
+            owner: "../../user/entities/user.meta",
+            assignee: "../../user/entities/user.meta",
+            company: "../../company/entities/company.meta",
+        };
+        if (foundationMetaPaths[baseName]) {
+            // Foundation-provided metas: import from their meta files
+            featureImports.push(`import { ${modelRef} } from "${foundationMetaPaths[baseName]}";`);
         }
         else {
             // Feature-specific metas need separate imports
-            const metaImport = findMetaImport(parsed, metaName);
+            const metaImport = findMetaImport(parsed, modelRef);
             if (metaImport) {
                 featureImports.push(metaImport);
             }
         }
     }
     // Add relationship type imports from entity type definition
+    // Collect types that need imports from original entity or foundation paths
+    const relationshipTypeImports = [];
+    // Known foundation entity types and their import paths
+    const foundationEntityPaths = {
+        Company: "../../company/entities/company",
+        User: "../../user/entities/user",
+        // Alias types map to User
+        Author: "../../user/entities/user",
+        Owner: "../../user/entities/user",
+        Assignee: "../../user/entities/user",
+    };
     for (const field of parsed.entityType.relationshipFields) {
         const typeName = field.type.replace("[]", "");
-        // Add framework types (Company, User)
-        if (["Company", "User"].includes(typeName)) {
-            frameworkImports.add(typeName);
+        // For known foundation types, generate type-only imports
+        if (foundationEntityPaths[typeName]) {
+            const importPath = foundationEntityPaths[typeName];
+            relationshipTypeImports.push(`import type { ${typeName} } from "${importPath}";`);
+            continue;
+        }
+        // For all other relationship types, find the original import from entity
+        // Use type-only imports to avoid circular dependencies
+        for (const imp of parsed.entityType.imports) {
+            // Skip imports from the package barrel - these should use internal paths
+            if (imp.includes("@carlonicora/nestjs-neo4jsonapi")) {
+                continue;
+            }
+            // Match imports like "import { Feature } from ..." or "import { Module } from ..."
+            if (imp.includes(`{ ${typeName} }`) || imp.includes(`{ ${typeName},`) || imp.includes(`, ${typeName} }`)) {
+                // Convert to type-only import
+                const typeImport = imp.replace(/^import\s+\{/, "import type {");
+                relationshipTypeImports.push(typeImport);
+                break;
+            }
         }
     }
     // Build the imports array
     const imports = [];
     // Group 1: Single barrel import from framework
+    // Use internal imports (../../../common) to avoid circular dependency when the package
+    // barrel re-exports from ./foundations which tries to load this entity again
     const frameworkImportList = Array.from(frameworkImports).sort();
-    imports.push(`import {\n  ${frameworkImportList.join(",\n  ")},\n} from "@carlonicora/nestjs-neo4jsonapi";`);
+    imports.push(`import {\n  ${frameworkImportList.join(",\n  ")},\n} from "../../../common";`);
+    // Group 1b: Service imports that have their own modules (e.g., S3Service)
+    if (serviceImports.length > 0) {
+        imports.push(...serviceImports);
+    }
     // Group 2: External type imports (from original entity imports that aren't framework)
     for (const imp of parsed.entityType.imports) {
         if (imp.includes("@only35/shared") || (imp.includes("@") && !imp.includes("@carlonicora/nestjs-neo4jsonapi"))) {
@@ -257,7 +433,13 @@ function generateImports(parsed, relationships, entityDir, entityName) {
     if (externalImports.length > 0) {
         imports.push(...[...new Set(externalImports)]);
     }
-    // Group 3: Entity-specific imports (src/features/...)
+    // Group 3: Relationship type imports (Feature, Module, etc.) from original entity
+    // Use "import type" to avoid runtime circular dependencies - these are only needed for TypeScript types
+    if (relationshipTypeImports.length > 0) {
+        const typeOnlyImports = [...new Set(relationshipTypeImports)].map((imp) => imp.startsWith("import type ") ? imp : imp.replace(/^import\s+/, "import type "));
+        imports.push(...typeOnlyImports);
+    }
+    // Group 4: Entity-specific imports (src/features/...)
     for (const imp of parsed.entityType.imports) {
         if (imp.includes("src/features/") && !imp.includes(".meta")) {
             featureImports.push(imp);
@@ -274,9 +456,10 @@ function generateImports(parsed, relationships, entityDir, entityName) {
 }
 /**
  * Finds the meta import statement for a given meta name.
+ * Derives the path from serialiser model imports by converting .model to .meta
  */
 function findMetaImport(parsed, metaName) {
-    // Check serialiser imports
+    // Check if serialiser already imports this meta directly
     if (parsed.serialiser) {
         for (const imp of parsed.serialiser.imports) {
             if (imp.includes(`.meta"`) || imp.includes(`.meta'`)) {
@@ -292,26 +475,77 @@ function findMetaImport(parsed, metaName) {
             }
         }
     }
-    // Fallback: construct import from meta name
     const baseName = metaName.replace("Meta", "");
-    if (baseName === "author" || baseName === "user") {
+    // Framework-provided metas
+    if (["author", "user", "company"].includes(baseName)) {
         return `import { ${metaName} } from "@carlonicora/nestjs-neo4jsonapi";`;
     }
+    // Try to derive meta import from serialiser model imports
+    // e.g., FeatureModel from ".../feature.model" -> featureMeta from ".../feature.meta"
+    if (parsed.serialiser) {
+        const modelName = baseName.charAt(0).toUpperCase() + baseName.slice(1) + "Model";
+        for (const imp of parsed.serialiser.imports) {
+            if (imp.includes(modelName)) {
+                // Extract path and convert to meta path
+                const pathMatch = imp.match(/from\s+["']([^"']+)["']/);
+                if (pathMatch) {
+                    const modelPath = pathMatch[1];
+                    const metaPath = modelPath.replace(/\.model$/, ".meta");
+                    return `import { ${metaName} } from "${metaPath}";`;
+                }
+            }
+        }
+    }
+    // Last resort: construct path heuristically from known foundations structure
     if (baseName === "topic") {
         return `import { ${metaName} } from "src/features/topic/entities/topic.meta";`;
     }
     if (baseName === "expertise") {
         return `import { ${metaName} } from "src/features/expertise/entities/expertise.meta";`;
     }
-    if (baseName === "company") {
-        return `import { ${metaName} } from "@carlonicora/nestjs-neo4jsonapi";`;
+    if (baseName === "feature") {
+        return `import { ${metaName} } from "../../feature/entities/feature.meta";`;
+    }
+    if (baseName === "module") {
+        return `import { ${metaName} } from "../../module/entities/module.meta";`;
+    }
+    if (baseName === "role") {
+        return `import { ${metaName} } from "../../role/entities/role.meta";`;
+    }
+    if (baseName === "configuration") {
+        return `import { ${metaName} } from "../../configuration/entities/configuration.meta";`;
+    }
+    if (baseName === "referencerole") {
+        return `import { ${metaName} } from "../../reference-role/entities/reference.role.meta";`;
+    }
+    // Generic fallback: assume foundation-style path
+    return `import { ${metaName} } from "../../${baseName}/entities/${baseName}.meta";`;
+}
+/**
+ * Finds the descriptor import statement for an already-migrated entity.
+ * Looks for existing imports like: import { CompanyDescriptor } from "../../company/entities/company";
+ */
+function findDescriptorImport(parsed, descriptorName) {
+    // Check if serialiser already imports this descriptor
+    if (parsed.serialiser) {
+        for (const imp of parsed.serialiser.imports) {
+            if (imp.includes(descriptorName)) {
+                // Extract the path and return just this descriptor import
+                const pathMatch = imp.match(/from\s+["']([^"']+)["']/);
+                if (pathMatch) {
+                    return `import { ${descriptorName} } from "${pathMatch[1]}";`;
+                }
+            }
+        }
     }
-    return null;
+    // Derive path from descriptor name (e.g., CompanyDescriptor -> ../../company/entities/company)
+    const baseName = descriptorName.replace("Descriptor", "").toLowerCase();
+    return `import { ${descriptorName} } from "../../${baseName}/entities/${baseName}";`;
 }
 /**
  * Generates the complete descriptor code.
  */
-function generateDescriptorCode(meta, entityName, fields, computed, relationships) {
+function generateDescriptorCode(meta, entityName, fields, computed, virtualFields, relationships, services = []) {
     const descriptorName = `${meta.labelName}Descriptor`;
     const metaName = `${meta.nodeName}Meta`;
     let code = `
@@ -324,6 +558,12 @@ function generateDescriptorCode(meta, entityName, fields, computed, relationship
 export const ${descriptorName} = defineEntity<${entityName}>()({
   ...${metaName},
 `;
+    // Add injectServices if services exist
+    if (services.length > 0) {
+        code += `
+  injectServices: [${services.join(", ")}],
+`;
+    }
     // Add fields
     if (fields.length > 0) {
         code += `
@@ -331,14 +571,30 @@ export const ${descriptorName} = defineEntity<${entityName}>()({
   fields: {
 `;
         for (const field of fields) {
-            code += `    ${field.name}: { type: "${field.type}"`;
-            if (field.required)
-                code += `, required: true`;
-            if (field.default)
-                code += `, default: ${field.default}`;
-            if (field.meta)
-                code += `, meta: true`;
-            code += ` },\n`;
+            if (field.transform) {
+                // Multi-line format for fields with transforms
+                code += `    ${field.name}: {\n`;
+                code += `      type: "${field.type}",\n`;
+                if (field.required)
+                    code += `      required: true,\n`;
+                if (field.default)
+                    code += `      default: ${field.default},\n`;
+                if (field.meta)
+                    code += `      meta: true,\n`;
+                code += `      transform: ${field.transform},\n`;
+                code += `    },\n`;
+            }
+            else {
+                // Single-line format for simple fields
+                code += `    ${field.name}: { type: "${field.type}"`;
+                if (field.required)
+                    code += `, required: true`;
+                if (field.default)
+                    code += `, default: ${field.default}`;
+                if (field.meta)
+                    code += `, meta: true`;
+                code += ` },\n`;
+            }
         }
         code += `  },
 `;
@@ -357,6 +613,22 @@ export const ${descriptorName} = defineEntity<${entityName}>()({
             code += `    },\n`;
         }
         code += `  },
+`;
+    }
+    // Add virtual fields (output-only computed values with arbitrary names)
+    if (virtualFields.length > 0) {
+        code += `
+  // Virtual fields (output-only, not in entity type)
+  virtualFields: {
+`;
+        for (const vf of virtualFields) {
+            code += `    ${vf.name}: {\n`;
+            code += `      compute: (params) => ${vf.compute},\n`;
+            if (vf.meta)
+                code += `      meta: true,\n`;
+            code += `    },\n`;
+        }
+        code += `  },
 `;
     }
     // Add relationships
@@ -371,10 +643,23 @@ export const ${descriptorName} = defineEntity<${entityName}>()({
             code += `      direction: "${rel.direction}",\n`;
             code += `      relationship: "${rel.relationship}",\n`;
             code += `      cardinality: "${rel.cardinality}",\n`;
+            if (rel.required === false)
+                code += `      required: false,\n`;
             if (rel.contextKey)
                 code += `      contextKey: "${rel.contextKey}",\n`;
             if (rel.dtoKey)
                 code += `      dtoKey: "${rel.dtoKey}",\n`;
+            // Add edge fields if present
+            if (rel.fields && rel.fields.length > 0) {
+                code += `      fields: [\n`;
+                for (const field of rel.fields) {
+                    code += `        { name: "${field.name}", type: "${field.type}"`;
+                    if (field.required)
+                        code += `, required: true`;
+                    code += ` },\n`;
+                }
+                code += `      ],\n`;
+            }
             code += `    },\n`;
         }
         code += `  },
@@ -413,15 +698,59 @@ export const ${metaName}: DataMeta = {
  */
 function generateEntityFile(parsed, entityDir, options = {}) {
     const descriptor = generateDescriptor(parsed, entityDir, options);
-    // Start with imports
-    let content = descriptor.imports.join("\n") + "\n\n";
+    // Start with imports - extend with alias-related imports
+    const imports = [...descriptor.imports];
+    if (parsed.aliasModels.length > 0) {
+        // Add defineEntityAlias to the framework imports (already in first import line)
+        const firstImport = imports[0];
+        if (firstImport && firstImport.includes("defineEntity")) {
+            imports[0] = firstImport.replace("defineEntity,", "defineEntity,\n  defineEntityAlias,");
+        }
+        // Add alias meta imports to the self-meta import line
+        // The self-meta import is the one that imports from "./{entityName}.meta" (the last import added by generateImports)
+        const selfMetaPattern = new RegExp(`from\\s+["']\\.\\/[^"']+\\.meta["']`);
+        const metaImportIndex = imports.findIndex((imp) => selfMetaPattern.test(imp));
+        if (metaImportIndex !== -1) {
+            const existingMetaImport = imports[metaImportIndex];
+            const aliasMetaNames = parsed.aliasModels.map((a) => a.metaName);
+            const baseMeta = `${parsed.meta.nodeName}Meta`;
+            // Reconstruct meta import with all metas
+            const allMetas = [baseMeta, ...aliasMetaNames];
+            const pathMatch = existingMetaImport.match(/from\s+["']([^"']+)["']/);
+            if (pathMatch) {
+                imports[metaImportIndex] = `import { ${allMetas.join(", ")} } from "${pathMatch[1]}";`;
+            }
+        }
+    }
+    let content = imports.join("\n") + "\n\n";
     // Add the entity type definition (keep from original)
     content += generateEntityTypeDefinition(parsed);
     content += "\n";
     // Add the descriptor
     content += descriptor.code;
+    // Add alias descriptors if any
+    if (parsed.aliasModels.length > 0) {
+        content += generateAliasDescriptors(parsed);
+    }
     return content;
 }
+/**
+ * Generates alias descriptor exports for entities with alias models.
+ *
+ * Example output:
+ * ```typescript
+ * export const OwnerDescriptor = defineEntityAlias(UserDescriptor, ownerMeta);
+ * export const AuthorDescriptor = defineEntityAlias(UserDescriptor, authorMeta);
+ * ```
+ */
+function generateAliasDescriptors(parsed) {
+    const baseDescriptorName = `${parsed.meta.labelName}Descriptor`;
+    let code = "\n// Alias descriptors for relationship endpoints\n";
+    for (const alias of parsed.aliasModels) {
+        code += `export const ${alias.descriptorName} = defineEntityAlias(${baseDescriptorName}, ${alias.metaName});\n`;
+    }
+    return code;
+}
 /**
  * Generates the entity type definition from parsed data.
  */