fix(core): Handle string and closure translation relation targets

`getEntityNamesWithCustomFields()` called every `translations` relation target
as a function to read its `.name`. TypeORM also allows a bare string target and
a closure returning a string (both used to break circular imports, e.g.
`@OneToMany('ArticleTranslation', ...)`). The former threw
`relation.type is not a function` — and since this runs unconditionally at the
top of `runPluginConfigurations()`, one such relation anywhere in the process
aborted every bootstrap; the latter yielded `undefined` and silently failed to
exclude the translation entity, re-introducing the duplicate-`customFields`
schema error this exclusion exists to prevent.

Added `getRelationTargetName()` which resolves all three shapes to the entity
name, guarding `typeof type === 'function'` the same way `getEntityTranslation`
in validate-custom-fields-config.ts does. Tests cover string, closure-returning-
string, and constructor-closure targets.

Relates to vendurehq#4965

Author: grolmus

packages/core/src/bootstrap.spec.ts

@@ -1,4 +1,5 @@
-import { describe, expect, it } from 'vitest';
+import { getMetadataArgsStorage } from 'typeorm';
+import { afterEach, describe, expect, it } from 'vitest';
 
 import { runPluginConfigurations } from './bootstrap';
 import { CustomFieldConfig } from './config/custom-field/custom-field-types';
@@ -11,6 +12,37 @@ import { VendurePlugin } from './plugin/vendure-plugin';
 
 void coreEntitiesMap;
 
+/**
+ * Registers a `translations` relation (and a matching `customFields` embedded on the
+ * translation target) directly in the TypeORM metadata, so we can exercise the different
+ * shapes TypeORM allows for a relation target — a constructor closure, a bare string name,
+ * or a closure returning a string — without declaring throwaway `@Entity` classes that would
+ * pollute the global metadata for every other test in the process. Returns a cleanup fn.
+ */
+function registerTranslationRelation(baseName: string, type: unknown): () => void {
+    const storage = getMetadataArgsStorage();
+    const base = { name: baseName };
+    const translationTarget = { name: `${baseName}Translation` };
+    storage.relations.push({
+        target: base,
+        propertyName: 'translations',
+        relationType: 'one-to-many',
+        type,
+        isLazy: false,
+        options: {},
+    } as any);
+    storage.embeddeds.push({
+        target: translationTarget,
+        propertyName: 'customFields',
+        prefix: undefined,
+        type: () => Object,
+    } as any);
+    return () => {
+        storage.relations.pop();
+        storage.embeddeds.pop();
+    };
+}
+
 function makeConfig(partial: {
     plugins?: RuntimeVendureConfig['plugins'];
     customFields?: Record<string, CustomFieldConfig[]>;
@@ -46,6 +78,45 @@ describe('runPluginConfigurations()', () => {
         expect(config.customFields.Product).toBe(existing);
     });
 
+    // OSS-408: a `translations` relation target need not be a constructor closure. TypeORM also
+    // accepts a bare string name and a closure returning one (both used to break circular imports).
+    // Building the exclusion set must handle all three, or one such relation anywhere in the
+    // process throws `relation.type is not a function` and kills every bootstrap (Michael's review).
+    describe('translation relation target shapes', () => {
+        let cleanup: (() => void) | undefined;
+        afterEach(() => {
+            cleanup?.();
+            cleanup = undefined;
+        });
+
+        it('does not throw on a string relation target', async () => {
+            cleanup = registerTranslationRelation('Oss408StringTarget', 'Oss408StringTargetTranslation');
+            const config = makeConfig({});
+            await expect(runPluginConfigurations(config)).resolves.toBeDefined();
+            // and the translation entity is still excluded from auto-init
+            expect(config.customFields.Oss408StringTargetTranslation).toBeUndefined();
+        });
+
+        it('does not throw on a closure returning a string target, and still excludes it', async () => {
+            cleanup = registerTranslationRelation(
+                'Oss408ClosureString',
+                () => 'Oss408ClosureStringTranslation',
+            );
+            const config = makeConfig({});
+            await expect(runPluginConfigurations(config)).resolves.toBeDefined();
+            expect(config.customFields.Oss408ClosureStringTranslation).toBeUndefined();
+        });
+
+        it('still excludes a constructor-closure translation target', async () => {
+            cleanup = registerTranslationRelation('Oss408Closure', () => ({
+                name: 'Oss408ClosureTranslation',
+            }));
+            const config = makeConfig({});
+            await runPluginConfigurations(config);
+            expect(config.customFields.Oss408ClosureTranslation).toBeUndefined();
+        });
+    });
+
     it('lets a plugin extend a supported entity without a guard', async () => {
         @VendurePlugin({
             configuration: cfg => {

packages/core/src/entity/register-custom-entity-fields.ts

@@ -14,6 +14,7 @@ import {
     ManyToOne,
 } from 'typeorm';
 import { EmbeddedMetadataArgs } from 'typeorm/metadata-args/EmbeddedMetadataArgs';
+import { RelationMetadataArgs } from 'typeorm/metadata-args/RelationMetadataArgs';
 import { DateUtils } from 'typeorm/util/DateUtils';
 
 import { CustomFieldConfig, CustomFields } from '../config/custom-field/custom-field-types';
@@ -49,7 +50,8 @@ export function getEntityNamesWithCustomFields(): string[] {
     const translationEntityNames = new Set(
         metadataArgsStorage.relations
             .filter(relation => relation.propertyName === 'translations')
-            .map(relation => (relation.type as () => Function)().name),
+            .map(relation => getRelationTargetName(relation.type))
+            .filter((name): name is string => name != null),
     );
     const names = metadataArgsStorage.embeddeds
         .filter(embedded => embedded.propertyName === 'customFields')
@@ -58,6 +60,27 @@ export function getEntityNamesWithCustomFields(): string[] {
     return Array.from(new Set(names));
 }
 
+/**
+ * Resolves a TypeORM relation target to the target entity's name. The target may be a
+ * constructor closure (`() => ProductTranslation`, the usual form), a bare string name, or a
+ * closure returning a string — the latter two are both legal and commonly used to break
+ * circular imports (`@OneToMany('ArticleTranslation', ...)`). Calling a non-function, as the
+ * previous code did unconditionally, threw `relation.type is not a function` and aborted
+ * bootstrap; a closure returning a string yielded `undefined` and silently failed to exclude
+ * the translation entity.
+ */
+function getRelationTargetName(type: RelationMetadataArgs['type']): string | undefined {
+    const resolved: unknown = typeof type === 'function' ? (type as () => unknown)() : type;
+    if (typeof resolved === 'string') {
+        return resolved;
+    }
+    if (typeof resolved === 'function') {
+        return resolved.name;
+    }
+    // Anything else that carries a `name` (e.g. an EntitySchema-like object).
+    return (resolved as { name?: string } | undefined)?.name;
+}
+
 /**
  * Dynamically add columns to the custom field entity based on the CustomFields config.
  */