@medusajs/index 3.0.0-snapshot-20250410105645 → 3.0.0-snapshot-20251104004624

package/dist/utils/build-config.js

@@ -6,6 +6,7 @@ exports.buildSchemaObjectRepresentation = buildSchemaObjectRepresentation;
 const modules_sdk_1 = require("@medusajs/framework/modules-sdk");
 const utils_1 = require("@medusajs/framework/utils");
 const _types_1 = require("../types");
+const base_graphql_schema_1 = require("./base-graphql-schema");
 exports.CustomDirectives = {
     Listeners: {
         configurationPropertyName: "listeners",
@@ -24,6 +25,52 @@ function makeSchemaExecutable(inputSchema) {
         typeDefs: cleanedSchema,
     });
 }
+/**
+ * Retrieve the property name of the source entity that corresponds to the target entity
+ * @param sourceEntityName - The name of the source entity
+ * @param targetEntityName - The name of the target entity
+ * @param entitiesMap - The map of entities configured in the module
+ * @param servicesEntityMap - The map of entities configured in the services
+ * @param node - The node of the source entity
+ * @returns The property name and if it is an array of the source entity property that corresponds to the target entity
+ */
+function retrieveEntityPropByType({ sourceEntityName, targetEntityName, entitiesMap, servicesEntityMap, node, }) {
+    if (!node && !entitiesMap && !servicesEntityMap) {
+        throw new Error("Index Module error, unable to retrieve the entity property by type. Please provide either the entitiesMap and servicesEntityMap or the node.");
+    }
+    const retrieveFieldNode = (node) => {
+        const astNode = node?.astNode;
+        const fields = astNode?.fields ?? [];
+        for (const field of fields) {
+            let type = field.type;
+            let isArray = false;
+            while (type.type) {
+                if (type.kind === utils_1.GraphQLUtils.Kind.LIST_TYPE) {
+                    isArray = true;
+                }
+                type = type.type;
+            }
+            if (type.name?.value === targetEntityName) {
+                return { name: field.name?.value, isArray };
+            }
+        }
+        return;
+    };
+    let prop;
+    if (node) {
+        prop = retrieveFieldNode(node);
+    }
+    if (entitiesMap && !prop) {
+        prop = retrieveFieldNode(entitiesMap[sourceEntityName]);
+    }
+    if (servicesEntityMap && !prop) {
+        prop = retrieveFieldNode(servicesEntityMap[sourceEntityName]);
+    }
+    return (prop && {
+        name: prop?.name,
+        isArray: prop?.isArray,
+    });
+}
 function extractNameFromAlias(alias) {
     const alias_ = Array.isArray(alias) ? alias[0] : alias;
     const names = Array.isArray(alias_?.name) ? alias_?.name : [alias_?.name];
@@ -79,92 +126,148 @@ function retrieveModuleAndAlias(entityName, moduleJoinerConfigs) {
     return { relatedModule, alias };
 }
 // TODO: rename util
-function retrieveLinkModuleAndAlias({ primaryEntity, primaryModuleConfig, foreignEntity, foreignModuleConfig, moduleJoinerConfigs, }) {
+function retrieveLinkModuleAndAlias({ primaryEntity, primaryModuleConfig, foreignEntity, foreignModuleConfig, moduleJoinerConfigs, servicesEntityMap, entitiesMap, }) {
     const linkModulesMetadata = [];
     for (const linkModuleJoinerConfig of moduleJoinerConfigs.filter((config) => config.isLink && !config.isReadOnlyLink)) {
         const linkPrimary = linkModuleJoinerConfig.relationships[0];
         const linkForeign = linkModuleJoinerConfig.relationships[1];
-        if (linkPrimary.serviceName === primaryModuleConfig.serviceName &&
-            linkForeign.serviceName === foreignModuleConfig.serviceName) {
-            const primaryEntityLinkableKey = linkPrimary.foreignKey;
-            const isTheForeignKeyEntityEqualPrimaryEntity = primaryModuleConfig.linkableKeys?.[primaryEntityLinkableKey] ===
-                primaryEntity;
-            const foreignEntityLinkableKey = linkForeign.foreignKey;
-            const isTheForeignKeyEntityEqualForeignEntity = foreignModuleConfig.linkableKeys?.[foreignEntityLinkableKey] ===
-                foreignEntity;
-            const linkName = linkModuleJoinerConfig.extends?.find((extend) => {
-                return (extend.serviceName === primaryModuleConfig.serviceName &&
-                    extend.relationship.primaryKey === primaryEntityLinkableKey);
-            })?.relationship.serviceName;
-            if (!linkName) {
-                throw new Error(`Index Module error, unable to retrieve the link module name for the services ${primaryModuleConfig.serviceName} - ${foreignModuleConfig.serviceName}. Please be sure that the extend relationship service name is set correctly`);
-            }
-            if (!linkModuleJoinerConfig.alias?.[0]?.entity) {
-                throw new Error(`Index Module error, unable to retrieve the link module entity name for the services ${primaryModuleConfig.serviceName} - ${foreignModuleConfig.serviceName}. Please be sure that the link module alias has an entity property in the args.`);
-            }
-            if (isTheForeignKeyEntityEqualPrimaryEntity &&
-                isTheForeignKeyEntityEqualForeignEntity) {
-                /**
-                 * The link will become the parent of the foreign entity, that is why the alias must be the one that correspond to the extended foreign module
-                 */
-                linkModulesMetadata.push({
-                    entityName: linkModuleJoinerConfig.alias[0].entity,
-                    alias: extractNameFromAlias(linkModuleJoinerConfig.alias),
-                    linkModuleConfig: linkModuleJoinerConfig,
-                    intermediateEntityNames: [],
-                });
+        const isDirectMatch = linkPrimary.serviceName === primaryModuleConfig.serviceName &&
+            linkForeign.serviceName === foreignModuleConfig.serviceName &&
+            linkPrimary.entity === primaryEntity;
+        const isInverseMatch = linkPrimary.serviceName === foreignModuleConfig.serviceName &&
+            linkForeign.serviceName === primaryModuleConfig.serviceName &&
+            linkPrimary.entity === foreignEntity;
+        if (!(isDirectMatch || isInverseMatch)) {
+            continue;
+        }
+        const primaryEntityLinkableKey = isDirectMatch
+            ? linkPrimary.foreignKey
+            : linkForeign.foreignKey;
+        const isTheForeignKeyEntityEqualPrimaryEntity = primaryModuleConfig.linkableKeys?.[primaryEntityLinkableKey] ===
+            primaryEntity;
+        const foreignEntityLinkableKey = isDirectMatch
+            ? linkForeign.foreignKey
+            : linkPrimary.foreignKey;
+        const isTheForeignKeyEntityEqualForeignEntity = foreignModuleConfig.linkableKeys?.[foreignEntityLinkableKey] ===
+            foreignEntity;
+        const relationshipsTypes = linkModuleJoinerConfig.relationships
+            ?.map((relationship) => relationship.entity)
+            .filter(Boolean) ?? [];
+        const filteredEntitiesMap = {
+            [linkModuleJoinerConfig.alias?.[0].entity]: entitiesMap[linkModuleJoinerConfig.alias?.[0].entity],
+        };
+        const filteredServicesEntityMap = {
+            [linkModuleJoinerConfig.alias?.[0].entity]: servicesEntityMap[linkModuleJoinerConfig.alias?.[0].entity],
+        };
+        for (const relationshipType of relationshipsTypes) {
+            filteredEntitiesMap[relationshipType] = entitiesMap[relationshipType];
+            filteredServicesEntityMap[relationshipType] =
+                servicesEntityMap[relationshipType];
+        }
+        const linkName = linkModuleJoinerConfig.extends?.find((extend) => {
+            return ((extend.serviceName === primaryModuleConfig.serviceName ||
+                extend.relationship.serviceName ===
+                    foreignModuleConfig.serviceName) &&
+                (extend.relationship.primaryKey === primaryEntityLinkableKey ||
+                    extend.relationship.primaryKey === foreignEntityLinkableKey));
+        })?.relationship.serviceName;
+        if (!linkName) {
+            throw new Error(`Index Module error, unable to retrieve the link module name for the services ${primaryModuleConfig.serviceName} - ${foreignModuleConfig.serviceName}. Please be sure that the extend relationship service name is set correctly`);
+        }
+        if (!linkModuleJoinerConfig.alias?.[0]?.entity) {
+            throw new Error(`Index Module error, unable to retrieve the link module entity name for the services ${primaryModuleConfig.serviceName} - ${foreignModuleConfig.serviceName}. Please be sure that the link module alias has an entity property in the args.`);
+        }
+        if (isTheForeignKeyEntityEqualPrimaryEntity &&
+            isTheForeignKeyEntityEqualForeignEntity) {
+            /**
+             * The link will become the parent of the foreign entity, that is why the alias must be the one that correspond to the extended foreign module
+             */
+            const inverseSideProp = retrieveEntityPropByType({
+                targetEntityName: primaryEntity,
+                sourceEntityName: linkModuleJoinerConfig.alias[0].entity,
+                servicesEntityMap: filteredServicesEntityMap,
+                entitiesMap: filteredEntitiesMap,
+            });
+            linkModulesMetadata.push({
+                entityName: linkModuleJoinerConfig.alias[0].entity,
+                alias: extractNameFromAlias(linkModuleJoinerConfig.alias),
+                linkModuleConfig: linkModuleJoinerConfig,
+                intermediateEntityNames: [],
+                isInverse: isInverseMatch,
+                isList: inverseSideProp?.isArray,
+                inverseSideProp: inverseSideProp?.name,
+            });
+        }
+        else {
+            const intermediateEntityName = foreignModuleConfig.linkableKeys[foreignEntityLinkableKey];
+            const moduleSchema = isDirectMatch
+                ? foreignModuleConfig.schema
+                : primaryModuleConfig.schema;
+            if (!moduleSchema) {
+                throw new Error(`Index Module error, unable to retrieve the intermediate entity name for the services ${primaryModuleConfig.serviceName} - ${foreignModuleConfig.serviceName}. Please be sure that the foreign module ${foreignModuleConfig.serviceName} has a schema.`);
             }
-            else {
-                const intermediateEntityName = foreignModuleConfig.linkableKeys[foreignEntityLinkableKey];
-                if (!foreignModuleConfig.schema) {
-                    throw new Error(`Index Module error, unable to retrieve the intermediate entity name for the services ${primaryModuleConfig.serviceName} - ${foreignModuleConfig.serviceName}. Please be sure that the foreign module ${foreignModuleConfig.serviceName} has a schema.`);
-                }
-                const executableSchema = makeSchemaExecutable(foreignModuleConfig.schema);
-                if (!executableSchema) {
-                    continue;
+            const entitiesMap = servicesEntityMap;
+            let intermediateEntities = [];
+            let foundCount = 0;
+            let foundName = null;
+            const isForeignEntityChildOfIntermediateEntity = (entityName, visited = new Set()) => {
+                if (visited.has(entityName)) {
+                    return false;
                 }
-                const entitiesMap = executableSchema.getTypeMap();
-                let intermediateEntities = [];
-                let foundCount = 0;
-                const isForeignEntityChildOfIntermediateEntity = (entityName) => {
-                    for (const entityType of Object.values(entitiesMap)) {
-                        if (entityType.astNode?.kind === "ObjectTypeDefinition" &&
-                            entityType.astNode?.fields?.some((field) => {
-                                return field.type?.type?.name?.value === entityName;
-                            })) {
-                            if (entityType.name === intermediateEntityName) {
-                                ++foundCount;
+                visited.add(entityName);
+                for (const entityType of Object.values(entitiesMap)) {
+                    const inverseSideProp = retrieveEntityPropByType({
+                        node: entityType,
+                        targetEntityName: entityName,
+                    });
+                    if (entityType.astNode?.kind === "ObjectTypeDefinition" &&
+                        inverseSideProp) {
+                        if (entityType.name === intermediateEntityName) {
+                            foundName = entityType.name;
+                            ++foundCount;
+                            return true;
+                        }
+                        else {
+                            const inverseSideProp = isForeignEntityChildOfIntermediateEntity(entityType.name, visited);
+                            if (inverseSideProp) {
+                                intermediateEntities.push(entityType.name);
                                 return true;
                             }
-                            else {
-                                const test = isForeignEntityChildOfIntermediateEntity(entityType.name);
-                                if (test) {
-                                    intermediateEntities.push(entityType.name);
-                                }
-                            }
                         }
                     }
-                    return false;
-                };
-                isForeignEntityChildOfIntermediateEntity(foreignEntity);
-                if (foundCount !== 1) {
-                    throw new Error(`Index Module error, unable to retrieve the intermediate entities for the services ${primaryModuleConfig.serviceName} - ${foreignModuleConfig.serviceName} between ${foreignEntity} and ${intermediateEntityName}. Multiple paths or no path found. Please check your schema in ${foreignModuleConfig.serviceName}`);
                 }
-                intermediateEntities.push(intermediateEntityName);
-                /**
-                 * The link will become the parent of the foreign entity, that is why the alias must be the one that correspond to the extended foreign module
-                 */
-                linkModulesMetadata.push({
-                    entityName: linkModuleJoinerConfig.alias[0].entity,
-                    alias: extractNameFromAlias(linkModuleJoinerConfig.alias),
-                    linkModuleConfig: linkModuleJoinerConfig,
-                    intermediateEntityNames: intermediateEntities,
-                });
+                return false;
+            };
+            isForeignEntityChildOfIntermediateEntity(isDirectMatch ? foreignEntity : primaryEntity);
+            if (foundCount !== 1) {
+                throw new Error(`Index Module error, unable to retrieve the intermediate entities for the services ${primaryModuleConfig.serviceName} - ${foreignModuleConfig.serviceName} between ${isDirectMatch ? foreignEntity : primaryEntity} and ${intermediateEntityName}. Multiple paths or no path found. Please check your schema in ${foreignModuleConfig.serviceName}`);
             }
+            intermediateEntities.push(foundName);
+            /**
+             * The link will become the parent of the foreign entity, that is why the alias must be the one that correspond to the extended foreign module
+             */
+            const directInverseSideProp = retrieveEntityPropByType({
+                targetEntityName: isDirectMatch
+                    ? primaryEntity
+                    : linkModuleJoinerConfig.alias[0].entity,
+                sourceEntityName: isDirectMatch
+                    ? linkModuleJoinerConfig.alias[0].entity
+                    : primaryEntity,
+                servicesEntityMap: filteredServicesEntityMap,
+                entitiesMap: filteredEntitiesMap,
+            });
+            linkModulesMetadata.push({
+                entityName: linkModuleJoinerConfig.alias[0].entity,
+                alias: extractNameFromAlias(linkModuleJoinerConfig.alias),
+                linkModuleConfig: linkModuleJoinerConfig,
+                intermediateEntityNames: intermediateEntities,
+                inverseSideProp: directInverseSideProp?.name,
+                isList: directInverseSideProp?.isArray,
+                isInverse: isInverseMatch,
+            });
         }
     }
     if (!linkModulesMetadata.length) {
-        // TODO: change to use the logger
         console.warn(`Index Module warning, unable to retrieve the link module that correspond to the entities ${primaryEntity} - ${foreignEntity}.`);
     }
     return linkModulesMetadata;
@@ -189,7 +292,7 @@ function setCustomDirectives(currentObjectRepresentationRef, directives) {
         currentObjectRepresentationRef[customDirectiveConfiguration.configurationPropertyName] = (directive.arguments[0].value?.values ?? []).map((v) => v.value);
     }
 }
-function processEntity(entityName, { entitiesMap, moduleJoinerConfigs, objectRepresentationRef, }) {
+function processEntity(entityName, { entitiesMap, servicesEntityMap, moduleJoinerConfigs, objectRepresentationRef, }) {
     /**
      * Get the reference to the object representation for the current entity.
      */
@@ -200,8 +303,11 @@ function processEntity(entityName, { entitiesMap, moduleJoinerConfigs, objectRep
      * Retrieve and set the custom directives for the current entity.
      */
     setCustomDirectives(currentObjectRepresentationRef, entitiesMap[entityName].astNode?.directives ?? []);
+    // Merge and deduplicate the fields
+    currentObjectRepresentationRef.fields ??= [];
     currentObjectRepresentationRef.fields =
-        utils_1.GraphQLUtils.gqlGetFieldsAndRelations(entitiesMap, entityName) ?? [];
+        currentObjectRepresentationRef.fields.concat(...(utils_1.GraphQLUtils.gqlGetFieldsAndRelations(entitiesMap, entityName) ?? []));
+    currentObjectRepresentationRef.fields = Array.from(new Set(currentObjectRepresentationRef.fields));
     /**
      * Retrieve the module and alias for the current entity.
      */
@@ -249,44 +355,84 @@ function processEntity(entityName, { entitiesMap, moduleJoinerConfigs, objectRep
         /**
          * Retrieve the parent entity field in the schema
          */
-        const entityFieldInParent = entitiesMap[parent].astNode?.fields?.find((field) => {
-            let currentType = field.type;
-            while (currentType.type) {
-                currentType = currentType.type;
-            }
-            return currentType.name?.value === entityName;
+        const entityFieldInParent = retrieveEntityPropByType({
+            sourceEntityName: parent,
+            targetEntityName: entityName,
+            entitiesMap,
+            servicesEntityMap,
         });
-        const isEntityListInParent = entityFieldInParent.type.kind === utils_1.GraphQLUtils.Kind.LIST_TYPE;
-        const entityTargetPropertyNameInParent = entityFieldInParent.name.value;
+        const entityTargetPropertyNameInParent = entityFieldInParent.name;
+        const entityTargetPropertyIsListInParent = entityFieldInParent.isArray;
         /**
          * Retrieve the parent entity object representation reference.
          */
+        if (!objectRepresentationRef[parent]) {
+            processEntity(parent, {
+                entitiesMap,
+                servicesEntityMap,
+                moduleJoinerConfigs,
+                objectRepresentationRef,
+            });
+        }
         const parentObjectRepresentationRef = getObjectRepresentationRef(parent, {
             objectRepresentationRef,
         });
         const parentModuleConfig = parentObjectRepresentationRef.moduleConfig;
         // If the entity is not part of any module, just set the parent and continue
         if (!currentObjectRepresentationRef.moduleConfig) {
-            currentObjectRepresentationRef.parents.push({
-                ref: parentObjectRepresentationRef,
-                targetProp: entityTargetPropertyNameInParent,
-                isList: isEntityListInParent,
+            const parentAlreadyExists = currentObjectRepresentationRef.parents.some((existingParent) => existingParent.ref?.entity === parentObjectRepresentationRef.entity &&
+                existingParent.targetProp === entityTargetPropertyNameInParent);
+            const parentPropertyNameWithinCurrentEntity = retrieveEntityPropByType({
+                sourceEntityName: entityName,
+                targetEntityName: parent,
+                entitiesMap,
+                servicesEntityMap,
             });
+            if (!parentAlreadyExists) {
+                currentObjectRepresentationRef.parents.push({
+                    ref: parentObjectRepresentationRef,
+                    targetProp: entityTargetPropertyNameInParent,
+                    inverseSideProp: parentPropertyNameWithinCurrentEntity?.name,
+                    isList: entityTargetPropertyIsListInParent,
+                });
+            }
+            else {
+                return;
+            }
             continue;
         }
         /**
-         * If the parent entity and the current entity are part of the same servive then configure the parent and
+         * If the parent entity and the current entity are part of the same service then configure the parent and
          * add the parent id as a field to the current entity.
          */
         if (currentObjectRepresentationRef.moduleConfig.serviceName ===
             parentModuleConfig.serviceName ||
-            parentModuleConfig.isLink) {
-            currentObjectRepresentationRef.parents.push({
-                ref: parentObjectRepresentationRef,
-                targetProp: entityTargetPropertyNameInParent,
-                isList: isEntityListInParent,
+            parentModuleConfig.isLink ||
+            currentObjectRepresentationRef.moduleConfig.isLink) {
+            const parentPropertyNameWithinCurrentEntity = retrieveEntityPropByType({
+                sourceEntityName: entityName,
+                targetEntityName: parent,
+                entitiesMap,
+                servicesEntityMap,
             });
-            currentObjectRepresentationRef.fields.push(parentObjectRepresentationRef.alias + ".id");
+            const parentAlreadyExists = currentObjectRepresentationRef.parents.some((existingParent) => existingParent.ref?.entity === parentObjectRepresentationRef.entity &&
+                existingParent.targetProp === entityTargetPropertyNameInParent);
+            if (!parentAlreadyExists) {
+                currentObjectRepresentationRef.parents.push({
+                    ref: parentObjectRepresentationRef,
+                    targetProp: entityTargetPropertyNameInParent,
+                    inverseSideProp: parentPropertyNameWithinCurrentEntity?.name,
+                    isList: entityTargetPropertyIsListInParent,
+                });
+            }
+            const propertyToAdd = parentPropertyNameWithinCurrentEntity?.name + ".id";
+            if (parentPropertyNameWithinCurrentEntity &&
+                !currentObjectRepresentationRef.fields.includes(propertyToAdd)) {
+                currentObjectRepresentationRef.fields.push(propertyToAdd);
+            }
+            if (parentAlreadyExists) {
+                return;
+            }
         }
         else {
             /**
@@ -299,20 +445,26 @@ function processEntity(entityName, { entitiesMap, moduleJoinerConfigs, objectRep
                 foreignEntity: currentObjectRepresentationRef.entity,
                 foreignModuleConfig: currentEntityModule,
                 moduleJoinerConfigs,
+                servicesEntityMap,
+                entitiesMap,
             });
             for (const linkModuleMetadata of linkModuleMetadatas) {
                 const linkObjectRepresentationRef = getObjectRepresentationRef(linkModuleMetadata.entityName, { objectRepresentationRef });
                 objectRepresentationRef._serviceNameModuleConfigMap[linkModuleMetadata.linkModuleConfig.serviceName ||
-                    linkModuleMetadata.entityName] = currentEntityModule;
+                    linkModuleMetadata.entityName] = linkModuleMetadata.linkModuleConfig;
                 /**
                  * Add the schema parent entity as a parent to the link module and configure it.
                  */
-                linkObjectRepresentationRef.parents = [
-                    {
+                linkObjectRepresentationRef.parents ??= [];
+                if (!linkObjectRepresentationRef.parents.some((parent) => parent.ref.entity === parentObjectRepresentationRef.entity)) {
+                    linkObjectRepresentationRef.parents.push({
                         ref: parentObjectRepresentationRef,
                         targetProp: linkModuleMetadata.alias,
-                    },
-                ];
+                        inverseSideProp: linkModuleMetadata.inverseSideProp ?? "",
+                        isList: linkModuleMetadata.isList,
+                        isInverse: linkModuleMetadata.isInverse,
+                    });
+                }
                 linkObjectRepresentationRef.alias = linkModuleMetadata.alias;
                 linkObjectRepresentationRef.listeners = [
                     `${linkModuleMetadata.entityName}.${utils_1.CommonEvents.ATTACHED}`,
@@ -345,38 +497,64 @@ function processEntity(entityName, { entitiesMap, moduleJoinerConfigs, objectRep
                         objectRepresentationRef,
                     });
                     objectRepresentationRef._serviceNameModuleConfigMap[intermediateEntityModule.serviceName] = intermediateEntityModule;
-                    intermediateEntityObjectRepresentationRef.parents.push({
+                    const parentPropertyNameWithinIntermediateEntity = retrieveEntityPropByType({
+                        sourceEntityName: intermediateEntityName,
+                        targetEntityName: parentIntermediateEntityRef.entity,
+                        entitiesMap: entitiesMap,
+                        servicesEntityMap: servicesEntityMap,
+                    });
+                    const intermediateEntityTargetPropertyIsListInParent = retrieveEntityPropByType({
+                        sourceEntityName: parentIntermediateEntityRef.entity,
+                        targetEntityName: intermediateEntityName,
+                        entitiesMap: entitiesMap,
+                        servicesEntityMap: servicesEntityMap,
+                    })?.isArray;
+                    const parentRef = {
                         ref: parentIntermediateEntityRef,
                         targetProp: intermediateEntityAlias,
-                        isList: true, // TODO: check if it is a list in retrieveLinkModuleAndAlias and return the intermediate entity names + isList for each
-                    });
+                        inverseSideProp: parentPropertyNameWithinIntermediateEntity?.name,
+                        isList: intermediateEntityTargetPropertyIsListInParent,
+                    };
+                    const parentAlreadyExists = intermediateEntityObjectRepresentationRef.parents.some((existingParent) => existingParent.ref?.entity ===
+                        parentIntermediateEntityRef.entity &&
+                        existingParent.targetProp === intermediateEntityAlias);
+                    if (!parentAlreadyExists) {
+                        intermediateEntityObjectRepresentationRef.parents.push(parentRef);
+                    }
                     intermediateEntityObjectRepresentationRef.alias =
                         intermediateEntityAlias;
+                    const kebabCasedServiceName = (0, utils_1.lowerCaseFirst)((0, utils_1.kebabCase)(intermediateEntityModule.serviceName));
                     intermediateEntityObjectRepresentationRef.listeners = [
                         (0, utils_1.buildModuleResourceEventName)({
                             action: utils_1.CommonEvents.CREATED,
                             objectName: intermediateEntityName,
-                            prefix: intermediateEntityModule.serviceName,
+                            prefix: kebabCasedServiceName,
                         }),
                         (0, utils_1.buildModuleResourceEventName)({
                             action: utils_1.CommonEvents.UPDATED,
                             objectName: intermediateEntityName,
-                            prefix: intermediateEntityModule.serviceName,
+                            prefix: kebabCasedServiceName,
                         }),
                         (0, utils_1.buildModuleResourceEventName)({
                             action: utils_1.CommonEvents.DELETED,
                             objectName: intermediateEntityName,
-                            prefix: intermediateEntityModule.serviceName,
+                            prefix: kebabCasedServiceName,
                         }),
                     ];
                     intermediateEntityObjectRepresentationRef.moduleConfig =
                         intermediateEntityModule;
-                    intermediateEntityObjectRepresentationRef.fields = ["id"];
+                    if (!intermediateEntityObjectRepresentationRef.fields.includes("id")) {
+                        intermediateEntityObjectRepresentationRef.fields.push("id");
+                    }
                     /**
                      * We push the parent id only between intermediate entities but not between intermediate and link
                      */
                     if (!isLastIntermediateEntity) {
-                        intermediateEntityObjectRepresentationRef.fields.push(parentIntermediateEntityRef.alias + ".id");
+                        const propertyToAdd = parentPropertyNameWithinIntermediateEntity?.name + ".id";
+                        if (parentPropertyNameWithinIntermediateEntity &&
+                            !intermediateEntityObjectRepresentationRef.fields.includes(propertyToAdd)) {
+                            intermediateEntityObjectRepresentationRef.fields.push(propertyToAdd);
+                        }
                     }
                 }
                 /**
@@ -387,18 +565,53 @@ function processEntity(entityName, { entitiesMap, moduleJoinerConfigs, objectRep
                 if (linkModuleMetadata.intermediateEntityNames.length) {
                     currentParentIntermediateRef =
                         objectRepresentationRef[linkModuleMetadata.intermediateEntityNames[0]];
-                    currentObjectRepresentationRef.fields.push(currentParentIntermediateRef.alias + ".id");
+                    const parentPropertyNameWithinCurrentEntity = retrieveEntityPropByType({
+                        sourceEntityName: currentObjectRepresentationRef.entity,
+                        targetEntityName: currentParentIntermediateRef.entity,
+                        entitiesMap: servicesEntityMap,
+                    });
+                    const propertyToAdd = parentPropertyNameWithinCurrentEntity?.name + ".id";
+                    if (parentPropertyNameWithinCurrentEntity &&
+                        !currentObjectRepresentationRef.fields.includes(propertyToAdd)) {
+                        currentObjectRepresentationRef.fields.push(propertyToAdd);
+                    }
                 }
-                currentObjectRepresentationRef.parents.push({
-                    ref: currentParentIntermediateRef,
-                    inSchemaRef: parentObjectRepresentationRef,
-                    targetProp: entityTargetPropertyNameInParent,
-                    isList: isEntityListInParent,
+                const parentPropertyNameWithinCurrentEntity = retrieveEntityPropByType({
+                    sourceEntityName: currentObjectRepresentationRef.entity,
+                    targetEntityName: currentParentIntermediateRef.entity,
+                    entitiesMap: servicesEntityMap,
                 });
+                const entityTargetPropertyIsListInParent = retrieveEntityPropByType({
+                    sourceEntityName: currentParentIntermediateRef.entity,
+                    targetEntityName: currentObjectRepresentationRef.entity,
+                    entitiesMap: entitiesMap,
+                    servicesEntityMap: servicesEntityMap,
+                })?.isArray;
+                const parentAlreadyExists = currentObjectRepresentationRef.parents.some((existingParent) => existingParent.ref?.entity ===
+                    currentParentIntermediateRef.entity &&
+                    existingParent.targetProp === entityTargetPropertyNameInParent);
+                if (!parentAlreadyExists) {
+                    currentObjectRepresentationRef.parents.push({
+                        ref: currentParentIntermediateRef,
+                        inSchemaRef: parentObjectRepresentationRef,
+                        targetProp: entityTargetPropertyNameInParent,
+                        inverseSideProp: parentPropertyNameWithinCurrentEntity?.name,
+                        isList: entityTargetPropertyIsListInParent,
+                    });
+                }
             }
         }
     }
 }
+function getServicesEntityMap(moduleJoinerConfigs, addtionalSchema = "") {
+    return makeSchemaExecutable(base_graphql_schema_1.baseGraphqlSchema +
+        "\n" +
+        moduleJoinerConfigs
+            .map((joinerConfig) => joinerConfig?.schema ?? "")
+            .join("\n") +
+        "\n" +
+        addtionalSchema).getTypeMap();
+}
 /**
  * Build a special object which will be used to retrieve the correct
  * object representation using path tree
@@ -413,51 +626,172 @@ function processEntity(entityName, { entitiesMap, moduleJoinerConfigs, objectRep
  */
 function buildAliasMap(objectRepresentation) {
     const aliasMap = {};
-    function recursivelyBuildAliasPath(current, alias = "", aliases = []) {
-        if (current.parents?.length) {
-            for (const parentEntity of current.parents) {
-                /**
-                 * Here we build the alias from child to parent to get it as parent to child
-                 */
-                const _aliases = recursivelyBuildAliasPath(parentEntity.ref, `${parentEntity.targetProp}${alias ? "." + alias : ""}`).map((alias) => ({ alias: alias.alias }));
-                aliases.push(..._aliases);
-                /**
-                 * Now if there is a inSchemaRef it means that we had inferred a link module
-                 * and we want to get the alias path as it would be in the schema provided
-                 * and it become the short cut path of the full path above
-                 */
-                if (parentEntity.inSchemaRef) {
-                    const shortCutOf = _aliases.map((a) => a.alias)[0];
-                    const _aliasesShortCut = recursivelyBuildAliasPath(parentEntity.inSchemaRef, `${parentEntity.targetProp}${alias ? "." + alias : ""}`).map((alias_) => {
-                        return {
-                            alias: alias_.alias,
-                            // It has to be the same entry point
-                            shortCutOf: shortCutOf.split(".")[0] === alias_.alias.split(".")[0]
-                                ? shortCutOf
-                                : undefined,
-                        };
+    function recursivelyBuildAliasPath(current, parentPath = "", aliases = [], visited = new Set(), pathStack = []) {
+        const pathIdentifier = `${current.entity}:${parentPath}`;
+        if (pathStack.includes(pathIdentifier)) {
+            return [];
+        }
+        pathStack.push(pathIdentifier);
+        if (visited.has(current.entity)) {
+            pathStack.pop();
+            return [];
+        }
+        visited.add(current.entity);
+        for (const parentEntity of current.parents) {
+            const newParentPath = parentPath
+                ? `${parentEntity.targetProp}.${parentPath}`
+                : parentEntity.targetProp;
+            const newVisited = new Set(visited);
+            const newPathStack = [...pathStack];
+            const parentAliases = recursivelyBuildAliasPath(parentEntity.ref, newParentPath, [], newVisited, newPathStack).map((aliasObj) => ({
+                alias: aliasObj.alias,
+                isInverse: parentEntity.isInverse,
+                isList: parentEntity.isList,
+            }));
+            aliases.push(...parentAliases);
+            // Handle shortcut paths via inSchemaRef
+            if (parentEntity.inSchemaRef) {
+                const shortCutOf = parentAliases[0];
+                if (!shortCutOf) {
+                    continue;
+                }
+                const shortcutAliases_ = recursivelyBuildAliasPath(parentEntity.inSchemaRef, newParentPath, [], new Set(visited), [...pathStack]);
+                // Assign all shortcut aliases to the parent aliases
+                const shortcutAliases = [];
+                shortcutAliases_.forEach((shortcutAlias) => {
+                    parentAliases.forEach((aliasObj) => {
+                        let isSamePath = aliasObj.alias.split(".")[0] === shortcutAlias.alias.split(".")[0];
+                        if (!isSamePath) {
+                            return;
+                        }
+                        shortcutAliases.push({
+                            alias: shortcutAlias.alias,
+                            shortCutOf: aliasObj.alias,
+                            isList: parentEntity.isList ?? true,
+                            isInverse: shortcutAlias.isInverse,
+                        });
                     });
-                    aliases.push(..._aliasesShortCut);
+                });
+                // Only add shortcut aliases if they don’t duplicate existing paths
+                for (const shortcut of shortcutAliases) {
+                    if (!aliases.some((a) => a.alias === shortcut?.alias)) {
+                        aliases.push(shortcut);
+                    }
                 }
             }
         }
-        aliases.push({ alias: current.alias + (alias ? "." + alias : "") });
+        // Add the current entity's alias, avoiding duplication
+        const pathSegments = parentPath ? parentPath.split(".") : [];
+        const baseAlias = pathSegments.length && pathSegments[0] === current.alias
+            ? parentPath // If parentPath already starts with this alias, use it as-is
+            : `${current.alias}${parentPath ? `.${parentPath}` : ""}`;
+        if (!aliases.some((a) => a.alias === baseAlias)) {
+            aliases.push({
+                alias: baseAlias,
+                isInverse: false,
+            });
+        }
+        pathStack.pop();
+        visited.delete(current.entity);
         return aliases;
     }
     for (const objectRepresentationKey of Object.keys(objectRepresentation).filter((key) => !_types_1.schemaObjectRepresentationPropertiesToOmit.includes(key))) {
         const entityRepresentationRef = objectRepresentation[objectRepresentationKey];
         const aliases = recursivelyBuildAliasPath(entityRepresentationRef);
         for (const alias of aliases) {
+            if (aliasMap[alias.alias] && !alias.shortCutOf) {
+                continue;
+            }
             aliasMap[alias.alias] = {
                 ref: entityRepresentationRef,
+                shortCutOf: alias.shortCutOf,
+                isList: alias.isList,
+                isInverse: alias.isInverse,
             };
-            if (alias.shortCutOf) {
-                aliasMap[alias.alias]["shortCutOf"] = alias.shortCutOf;
-            }
         }
     }
     return aliasMap;
 }
+function buildSchemaFromFilterableLinks(moduleJoinerConfigs, servicesEntityMap) {
+    const allFilterable = moduleJoinerConfigs.flatMap((config) => {
+        const entities = [];
+        const schema = config.schema;
+        if (config.isLink) {
+            if (!config.relationships?.some((r) => r.filterable?.length)) {
+                return [];
+            }
+            for (const relationship of config.relationships) {
+                relationship.filterable ??= [];
+                if (!relationship.filterable?.length ||
+                    !relationship.filterable?.includes("id")) {
+                    relationship.filterable.push("id");
+                }
+                const fieldAliasMap = {};
+                for (const extend of config.extends ?? []) {
+                    fieldAliasMap[extend.serviceName] = Object.keys(extend.fieldAlias ?? {});
+                    fieldAliasMap[extend.serviceName].push(extend.relationship.alias);
+                }
+                const serviceName = relationship.serviceName;
+                entities.push({
+                    serviceName,
+                    entity: relationship.entity,
+                    fields: Array.from(new Set(relationship.filterable.concat(fieldAliasMap[serviceName] ?? []))),
+                    schema,
+                });
+            }
+            return entities;
+        }
+        let aliases = config.alias ?? [];
+        aliases = (Array.isArray(aliases) ? aliases : [aliases]).filter((a) => a.filterable?.length && a.entity);
+        for (const alias of aliases) {
+            entities.push({
+                serviceName: config.serviceName,
+                entity: alias.entity,
+                fields: Array.from(new Set(alias.filterable)),
+                schema,
+            });
+        }
+        return entities;
+    });
+    const getGqlType = (entity, field) => {
+        const fieldRef = servicesEntityMap[entity]?._fields?.[field];
+        if (!fieldRef) {
+            return;
+        }
+        const fieldType = fieldRef.type.toString();
+        const isArray = fieldType.startsWith("[");
+        let currentType = fieldType.replace(/\[|\]|\!/g, "");
+        const isEnum = currentType.endsWith("Enum");
+        if (isEnum) {
+            currentType = "String";
+        }
+        return isArray ? `[${currentType}]` : currentType;
+    };
+    const schema = allFilterable
+        .map(({ serviceName, entity, fields, schema }) => {
+        if (!schema) {
+            return;
+        }
+        const normalizedEntity = (0, utils_1.lowerCaseFirst)((0, utils_1.kebabCase)(entity));
+        const events = `@Listeners(values: ["${serviceName}.${normalizedEntity}.created", "${serviceName}.${normalizedEntity}.updated", "${serviceName}.${normalizedEntity}.deleted"])`;
+        const fieldDefinitions = fields
+            .map((field) => {
+            const type = getGqlType(entity, field) ?? "String";
+            return `    ${field}: ${type}`;
+        })
+            .join("\n");
+        return `
+      type ${entity} ${events} {
+        id: ID!
+      }
+        
+      extend type ${entity} {
+${fieldDefinitions}
+}`;
+    })
+        .join("\n\n");
+    return schema;
+}
 /**
  * This util build an internal representation object from the provided schema.
  * It will resolve all modules, fields, link module representation to build
@@ -470,24 +804,36 @@ function buildAliasMap(objectRepresentation) {
  */
 function buildSchemaObjectRepresentation(schema) {
     const moduleJoinerConfigs = modules_sdk_1.MedusaModule.getAllJoinerConfigs();
-    const augmentedSchema = exports.CustomDirectives.Listeners.definition + schema;
+    const servicesEntityMap = getServicesEntityMap(moduleJoinerConfigs);
+    const filterableEntities = buildSchemaFromFilterableLinks(moduleJoinerConfigs, servicesEntityMap);
+    const augmentedSchema = exports.CustomDirectives.Listeners.definition +
+        "\n" +
+        schema +
+        "\n" +
+        filterableEntities;
     const executableSchema = makeSchemaExecutable(augmentedSchema);
     const entitiesMap = executableSchema.getTypeMap();
     const objectRepresentation = {
         _serviceNameModuleConfigMap: {},
     };
     Object.entries(entitiesMap).forEach(([entityName, entityMapValue]) => {
-        if (!entityMapValue.astNode) {
+        if (!entityMapValue.astNode ||
+            entityMapValue.astNode.kind === utils_1.GraphQLUtils.Kind.SCALAR_TYPE_DEFINITION) {
             return;
         }
         processEntity(entityName, {
             entitiesMap,
+            servicesEntityMap,
             moduleJoinerConfigs,
             objectRepresentationRef: objectRepresentation,
         });
     });
     objectRepresentation._schemaPropertiesMap =
         buildAliasMap(objectRepresentation);
-    return [objectRepresentation, entitiesMap];
+    return {
+        objectRepresentation,
+        entitiesMap,
+        executableSchema,
+    };
 }
 //# sourceMappingURL=build-config.js.map