@microsoft/typespec-msgraph 0.0.1-Preview.8 → 1.0.0-Preview.2

package/dist/src/utils.js

@@ -1,5 +1,19 @@
-import { getNamespaceFullName, isArrayModelType, } from "@typespec/compiler";
-import { getEntity, getGraphRoutePath, isEntity } from "./decorators/index.js";
+import { getLocationContext, getNamespaceFullName, isArrayModelType, navigateTypesInNamespace, walkPropertiesInherited, } from "@typespec/compiler";
+import { getEntity, getExpand, getFilter, getGraphRoutePaths, getPublicNamespaceName, getWorkloadNamespaceName, hasGraphRoute, hasPublicNamespace, hasWorkloadNamespace, isComplex, isContains, isDelta, isEntity, isExpand, isFilter, isPartial, isReferences, isSharedEntity } from "./decorators/index.js";
+import { getOperationVerb } from "@typespec/http";
+import { DEFAULT_MSGRAPH_NAMESPACE, GetDeclaredNamespaces, usedLibraryTypesKey } from "./entities/namespace.js";
+import { PathTree } from "./path-tree.js";
+// schema namespace is workloadNamespace if its defined or publicNamespace if its defined
+export function hasSchemaNamespace(program, namespace) {
+    return hasWorkloadNamespace(program, namespace) || hasPublicNamespace(program, namespace);
+}
+// schema namespace is workloadNamespace if its defined, publicNamespace if its defined or the defined namespace name
+export function getSchemaNamespaceName(program, namespace) {
+    if (hasWorkloadNamespace(program, namespace)) {
+        return getWorkloadNamespaceName(program, namespace);
+    }
+    return getPublicNamespaceName(program, namespace);
+}
 export function getNameForType(program, type) {
     switch (type.kind) {
         case "Union":
@@ -25,6 +39,9 @@ export function getNameForType(program, type) {
 export function getNameForModelType(program, type) {
     switch (type.name) {
         case "string":
+        case "url":
+        case "graphUrl":
+        case "webUrl":
             return "Edm.String";
         case "bytes":
             return "Collection(Edm.Byte)";
@@ -46,6 +63,10 @@ export function getNameForModelType(program, type) {
             return "Edm.TimeOfDay";
         case "zonedDateTime":
             return "Edm.DateTimeOffset";
+        case "offsetDateTime":
+            return "Edm.DateTimeOffset";
+        case "utcDateTime":
+            return "Edm.DateTimeOffset";
         case "duration":
             return "Edm.Duration";
         case "boolean":
@@ -54,6 +75,10 @@ export function getNameForModelType(program, type) {
             return "Edm.Stream";
         case "guid":
             return "Edm.Guid";
+        case "binary":
+            return "Edm.Binary";
+        case "unknown":
+            return "microsoft.graph.Json";
         default:
             break;
     }
@@ -62,15 +87,83 @@ export function getNameForModelType(program, type) {
     }
     return `Collection(${getPropertyTypeName(program, type.indexer.value)})`;
 }
+export function getCSDLPrimitiveType(typespecType) {
+    switch (typespecType) {
+        case "string":
+            return "String";
+        case "int8":
+            return "Byte";
+        case "int16":
+            return "Int16";
+        case "int32":
+            return "Int32";
+        case "int64":
+            return "Int64";
+        case "integer":
+            return "Int64";
+        case "float32":
+            return "Single";
+        case "float64":
+            return "Double";
+        case "decimal":
+            return "Decimal";
+        case "guid":
+            return "Guid";
+        case "plainDate":
+            return "Date";
+        case "plainTime":
+            return "TimeOfDay";
+        case "zonedDateTime":
+            return "DateTimeOffset";
+        case "duration":
+            return "Duration";
+        case "boolean":
+            return "Bool";
+        case "stream":
+            return "Stream";
+        default:
+            return typespecType;
+    }
+}
+export function isDictionaryType(program, type) {
+    var _a;
+    if (type.kind === "Model" && isTypeDefinedInLocalProject(program, type)) {
+        const indexer = (_a = type.indexer) === null || _a === void 0 ? void 0 : _a.value;
+        if (indexer) {
+            return true;
+        }
+        if (isComplex(program, type) && type.name === "Dictionary") {
+            return true;
+        }
+    }
+    return false;
+}
+export function generateDictionaryBaseType(program, model) {
+    if (getLocationContext(program, model).type === "library") {
+        return undefined;
+    }
+    if (isDictionaryType(program, model)) {
+        return "microsoft.graph.Dictionary";
+    }
+    return undefined;
+}
 export function getIdForType(program, type) {
     switch (type.kind) {
         case "Namespace":
-            return getNamespaceFullName(type);
+            if (hasWorkloadNamespace(program, type)) {
+                return getWorkloadNamespaceName(program, type);
+            }
+            else if (hasPublicNamespace(program, type)) {
+                return getPublicNamespaceName(program, type);
+            }
+            else {
+                return getNamespaceFullName(type);
+            }
         case "Model":
         case "Enum":
         case "Operation":
         case "Interface":
-            return `${getNamespaceFullName(type.namespace)}.${type.name}`;
+            return `${getIdForType(program, type.namespace)}.${type.name}`;
         case "String":
         case "Number":
         case "Boolean":
@@ -78,90 +171,131 @@ export function getIdForType(program, type) {
         case "Union":
             return getIdForUnion(program, type);
         case "Scalar":
+        case "Intrinsic":
             return getNameForModelType(program, type);
+        case "EnumMember":
+            return `${type.name}`;
         default:
             return type.kind;
     }
 }
 export function getNavigationTypeId(program, getOperation) {
-    var _a;
+    var _a, _b;
     const returnType = getOperation.returnType;
-    if (returnType.kind !== "Model" || !((_a = returnType.templateArguments) === null || _a === void 0 ? void 0 : _a.length)) {
+    if (returnType.kind !== "Model" || !((_a = returnType.templateMapper) === null || _a === void 0 ? void 0 : _a.args.length)) {
         return getIdForType(program, returnType);
     }
-    return getIdForType(program, returnType.templateArguments[0]);
+    return getIdForType(program, (_b = returnType === null || returnType === void 0 ? void 0 : returnType.templateMapper) === null || _b === void 0 ? void 0 : _b.args[0]);
 }
 export function getInterfacesOfKinds(program, navigationSources, kinds) {
     const interfaces = new Map();
     navigationSources.forEach((theInterface) => {
-        if (!theInterface.sourceInterfaces.some((s) => kinds.includes(s.name))) {
+        if (!getSourceInterfaces(theInterface).some((s) => kinds.includes(s.name))) {
             // if source interfaces DO NOT have the kinds.
             return;
         }
-        const graphRoutePath = getGraphRoutePath(program, theInterface);
-        let graphRoutes = [];
-        if (!graphRoutePath) {
-            return;
-        }
-        else if (Array.isArray(graphRoutePath)) {
-            graphRoutes = graphRoutePath;
+        const navigationSourceType = getInterfaceNavigationSourceType(program, theInterface);
+        if (navigationSourceType && isTypeDefinedInExternalLibrary(program, navigationSourceType)) {
+            program.stateSet(usedLibraryTypesKey).add(navigationSourceType);
         }
-        else {
-            graphRoutes = [graphRoutePath];
-        }
-        if (!graphRoutes.length) {
+        const graphRoutePaths = getGraphRoutePaths(program, theInterface);
+        if (!graphRoutePaths || !graphRoutePaths.length) {
             return;
         }
-        graphRoutes.forEach((graphRoute) => {
-            const path = removeRoutePathParams(graphRoute);
-            if (!path) {
+        graphRoutePaths.forEach((graphRoute) => {
+            // skip two-segment resources as they are collections
+            if (isRouteIndexOfACollection(theInterface, graphRoute)) {
                 return;
             }
-            let operations = [...theInterface.operations.values()];
-            if (interfaces.has(path)) {
-                const existing = interfaces.get(path);
-                operations = [...operations, ...existing.operations];
+            processGraphRoute(program, graphRoute, interfaces, theInterface);
+        });
+    });
+    return interfaces;
+}
+export function isRouteIndexOfACollection(theInterface, graphRoute) {
+    if (theInterface === undefined) {
+        return false;
+    }
+    const pathSegments = graphRoute.split("/");
+    const lastSegment = pathSegments[pathSegments.length - 1].replace(/\{[\w-]+\}/g, "");
+    if (lastSegment === "" && getSourceInterfaces(theInterface).some((s) => s.name === "Resource")) {
+        return true;
+    }
+    return false;
+}
+export function getComposableFunctionSegmentFromGraphRoute(graphRoutePath) {
+    const pattern = /\/([^\/]+\(.*\))$/;
+    const matches = graphRoutePath.match(pattern);
+    return matches != null ? matches[1] : undefined;
+}
+// Generate an interface for a resource that has a root path and an index like /users/{id}. Note that this is a collection.
+// Resources with two-segment paths like /users/{id} are essentially collections
+// This applies to deeply nested resources as well e.g. /cars/{carId}/wheels/{wheelId}
+export function getCollectionIndexInterfaces(program, navigationSources) {
+    const interfaces = new Map();
+    navigationSources.forEach((theInterface) => {
+        const graphRoutePaths = getGraphRoutePaths(program, theInterface);
+        if (!graphRoutePaths || !graphRoutePaths.length) {
+            return;
+        }
+        graphRoutePaths.forEach((graphRoute) => {
+            if (isRouteIndexOfACollection(theInterface, graphRoute)) {
+                processGraphRoute(program, graphRoute, interfaces, theInterface);
             }
-            interfaces.set(path, {
-                theInterface: theInterface,
-                operations: operations,
-                path: graphRoute
-            });
         });
     });
     return interfaces;
 }
+function processGraphRoute(program, graphRoute, interfaces, theInterface) {
+    const path = removeRoutePathParams(graphRoute);
+    if (!path) {
+        return;
+    }
+    let operations = [...theInterface.operations.values()].map((operation) => ({ theOperation: operation, verb: getOperationVerb(program, operation), graphRoute: graphRoute }));
+    if (interfaces.has(path)) {
+        const existing = interfaces.get(path);
+        operations = [...operations, ...existing.operations];
+    }
+    interfaces.set(path, {
+        theInterface: theInterface,
+        operations: operations,
+        path: graphRoute
+    });
+}
 export function getPropertyTypeName(program, type) {
     var _a;
     if (type.kind === "Union") {
         const unionTypes = extractTypesFromUnion(type);
-        const nonNullTypes = unionTypes.filter((t) => !isNullType(program, t));
+        const nonNullTypes = unionTypes.filter((t) => !isNullType(t));
         if (!nonNullTypes.length) {
             return "undefined.";
         }
-        return getPropertyTypeName(program, nonNullTypes[0]);
+        return removeReferencePrefixFromType(getPropertyTypeName(program, nonNullTypes[0]));
     }
     if ((type.kind === "Model" || type.kind === "Scalar") && ((_a = type.namespace) === null || _a === void 0 ? void 0 : _a.name) === "TypeSpec") {
-        return getNameForType(program, type);
+        return removeReferencePrefixFromType(getNameForType(program, type));
     }
-    return getIdForType(program, type);
+    return removeReferencePrefixFromType(getIdForType(program, type));
+}
+export function removeReferencePrefixFromType(typeName) {
+    return typeName.replace(/^reference\./, "");
 }
 export function isTypeNullable(program, type) {
     if (type.kind !== "Union") {
         return false;
     }
     const unionTypes = extractTypesFromUnion(type);
-    return unionTypes.some((t) => isNullType(program, t));
+    return unionTypes.some((t) => isNullType(t));
 }
 function getIdForUnion(program, unionType) {
     const unionTypes = extractTypesFromUnion(unionType);
-    const nonNullTypes = unionTypes.filter((t) => !isNullType(program, t));
+    const nonNullTypes = unionTypes.filter((t) => !isNullType(t));
     if (!nonNullTypes.length) {
         return "undefined.";
     }
     return getIdForType(program, nonNullTypes[0]);
 }
-function isNullType(program, type) {
+export function isNullType(type) {
     return type.kind === "Intrinsic" && type.name === "null";
 }
 export function extractTypesFromUnion(type) {
@@ -217,7 +351,8 @@ export function getNamespaceName(program, type) {
     if (type === undefined) {
         return "";
     }
-    return getNamespaceFullName(type);
+    const fullNamespaceName = getNamespaceFullName(type);
+    return fullNamespaceName;
 }
 /**
  * Imported from typespec-azure
@@ -231,54 +366,28 @@ export function isExcludedCoreType(program, type) {
     // https://github.com/Azure/typespec-azure/issues/801#issuecomment-1194454247
     //
     const nsName = getNamespaceName(program, type);
-    const excludedNamespaces = ["TypeSpec"];
-    return excludedNamespaces.find((ns) => nsName.startsWith(ns)) !== undefined;
+    const excludedNamespaces = ["TypeSpec", "MsGraph"];
+    const isExcluded = excludedNamespaces.find((ns) => nsName.startsWith(ns)) !== undefined;
+    return isExcluded;
 }
 export function isExcludedLibraryType(program, type) {
     const nsName = getNamespaceName(program, type);
-    const excludedNamespaces = ["TypeSpec", "MicrosoftGraph"];
+    const excludedNamespaces = ["TypeSpec", "MsGraph"];
     return excludedNamespaces.find((ns) => nsName.startsWith(ns)) !== undefined;
 }
 export function isNavigationProperty(program, property) {
-    let propertyType = property.type;
-    if (propertyType.kind === "Union") {
-        const unionTypes = extractTypesFromUnion(propertyType);
-        const nonNullTypes = unionTypes.filter((t) => !isNullType(program, t));
-        if (!nonNullTypes.length) {
-            return false;
-        }
-        propertyType = nonNullTypes[0];
-    }
-    if (propertyType.kind !== "Model") {
+    const model = getTypeModel(program, property.type);
+    if (!model) {
         return false;
     }
-    if (isArrayModelType(program, propertyType)) {
-        propertyType = propertyType.indexer.value;
-        if (propertyType.kind !== "Model") {
-            return false;
-        }
-    }
-    return isEntity(program, propertyType);
+    return isEntity(program, model) && (isContains(program, property) || isReferences(program, property));
 }
 export function isNavigationSource(theInterface) {
     return findNavigationSource(theInterface) !== undefined;
 }
-export function isTopLevelNavigationSource(program, theInterface) {
+export function isTopLevelNavigationSource(theInterface) {
     return removeRoutePathParams(theInterface.path).split("/").length === 1;
 }
-/**
- * Check if a @graphRoute returns a single resource of a collection.
- *
- * `Example`
- *
- * @graphRoute("users/{id}")
- * interface UsersById extends Resource<user> {
- *  get is GraphOps.GetResource;
- * }
- */
-export function isCollectionResource(program, theInterface) {
-    return (isTopLevelNavigationSource(program, theInterface) && theInterface.path.split("/").length === 2);
-}
 // Get the type returned by all operations in an interface representing a navigation source.
 // This is the 'T' in Collection<T> and friends.
 export function getInterfaceNavigationSourceType(program, theInterface) {
@@ -296,7 +405,7 @@ export function getNavigationSourceType(program, operation) {
     return getInterfaceNavigationSourceType(program, operation.interface);
 }
 function findNavigationSource(theInterface) {
-    for (const baseInterface of theInterface.sourceInterfaces) {
+    for (const baseInterface of getSourceInterfaces(theInterface)) {
         if (baseInterface.name === "Resource" || baseInterface.name === "Collection") {
             return baseInterface;
         }
@@ -315,8 +424,474 @@ function findNavigationSource(theInterface) {
  * Examples:
  *  - user/{id}/manager -> user/manager
  *  - user/{id}/friends/{friendId}/hobbies -> user/friends/hobbies
+ *  - user/{user-id}/friends/{friend-id}/hobbies -> user/friends/hobbies
+ */
+export function removeRoutePathParams(routePath) {
+    return routePath.replace(/\/\{[\w-]+\}/g, "");
+}
+export function isSameNamespace(program, model, baseModel) {
+    if (!baseModel) {
+        return false;
+    }
+    return getNamespaceName(program, model) === getNamespaceName(program, baseModel);
+}
+export function isTypeDefinedInExternalLibrary(program, type) {
+    const locationContext = getLocationContext(program, type);
+    return locationContext.type === "library";
+}
+export function isTypeDefinedInLocalProject(program, type) {
+    const locationContext = getLocationContext(program, type);
+    return locationContext.type === "project";
+}
+/**
+ * Recursively get all source interfaces of an interface
+ * @param theInterface
+ * @returns an array of all source interfaces
+ */
+export function getSourceInterfaces(theInterface) {
+    return [...theInterface.sourceInterfaces, ...[...theInterface.sourceInterfaces.values()].flatMap(getSourceInterfaces)];
+}
+export function getModelStructuralPropertyNames(program, model) {
+    return getModelPropertyNames(program, model, true);
+}
+export function getAllModelPropertyNames(program, model) {
+    return getModelPropertyNames(program, model, false);
+}
+function getModelPropertyNames(program, model, structuralPropertiesOnly) {
+    const propertyNames = getModelProperties(program, model, structuralPropertiesOnly).map(p => p.name.trim());
+    const propertiesOfTypeModel = getPropertiesOfTypeModel(program, model, structuralPropertiesOnly);
+    const nestedPropertyNames = getNestedPropertyNames(program, propertiesOfTypeModel, structuralPropertiesOnly);
+    return [...new Set([...propertyNames, ...nestedPropertyNames])].filter(p => p !== model.name);
+}
+export function getModelProperties(program, model, structuralPropertiesOnly = false) {
+    const allProperties = walkPropertiesInherited(model);
+    // structural properties are the ones that are not navigation properties
+    if (structuralPropertiesOnly) {
+        return [...allProperties].filter(p => !isNavigationProperty(program, p));
+    }
+    return [...allProperties];
+}
+function getPropertiesOfTypeModel(program, model, structuralPropertiesOnly = false) {
+    const properties = getModelProperties(program, model, structuralPropertiesOnly);
+    const propertiesOfTypeModel = [];
+    for (const property of properties) {
+        const model = getTypeModel(program, property.type, structuralPropertiesOnly);
+        if (model) {
+            propertiesOfTypeModel.push({
+                name: property.name,
+                type: model
+            });
+        }
+    }
+    return propertiesOfTypeModel;
+}
+function getNestedPropertyNames(program, propertyTypes, structuralPropertiesOnly = false, prefix = "") {
+    const names = [];
+    if (prefix && hasRepeatedItem(prefix)) {
+        return names;
+    }
+    for (const propertyType of propertyTypes) {
+        const propertyTypePrefix = prefix + propertyType.name + "/";
+        const nestedPropertyTypes = getNestedPropertyTypes(program, propertyType, structuralPropertiesOnly);
+        nestedPropertyTypes.forEach(m => {
+            const name = propertyTypePrefix + m.name;
+            if (!hasRepeatedItem(name)) {
+                names.push(name);
+            }
+        });
+        names.push(...getNestedPropertyNames(program, nestedPropertyTypes, structuralPropertiesOnly, propertyTypePrefix));
+    }
+    return names;
+}
+function getNestedPropertyTypes(program, propertyType, structuralPropertiesOnly = false) {
+    const propertyTypes = [];
+    const theType = propertyType.type;
+    if (theType.kind === "Scalar" || theType.kind === "Enum") {
+        return propertyTypes;
+    }
+    theType.properties.forEach((property, name) => {
+        const type = getPropertyType(program, property, structuralPropertiesOnly);
+        if (type !== undefined) {
+            propertyTypes.push({ name: name, type: type });
+        }
+    });
+    return propertyTypes;
+}
+function getPropertyType(program, property, structuralPropertiesOnly = false) {
+    if (structuralPropertiesOnly && isNavigationProperty(program, property)) {
+        return undefined;
+    }
+    const type = getActualType(program, property.type);
+    if (!type || !(type.kind === "Model" || type.kind === "Scalar" || type.kind === "Enum")) {
+        return undefined;
+    }
+    return type;
+}
+/**
+ * This function checks if a path is repeating.
+ * For example, if we have a tsp with this structure:
+    * @complex model inner {
+        innerName: string;
+        otherInnerName: string;
+        circularReferenceProp: outer;
+      }
+
+      @complex model outer {
+        inner: inner | null;
+      }
+
+  If our root (interface navigation type) is outer, some of the possible paths would be
+    - outer/inner/innerName
+    - outer/inner/otherInnerName
+  For circularReferenceProp property, we run the risk of having a path like the one below which would cause an infinite loop:
+  - outer/inner/circularReferenceProp/inner/circularReferenceProp
+ * @param slashSeparatedString
+ * @returns
  */
-function removeRoutePathParams(routePath) {
-    return routePath.replace(/\/\{\w+\}/g, "");
+function hasRepeatedItem(slashSeparatedString) {
+    const items = slashSeparatedString.split('/');
+    const uniqueItems = new Set(items);
+    return items.length !== uniqueItems.size;
+}
+export function isInterfaceBindingTypeOwned(program, $interface) {
+    const interfaceBindingType = getInterfaceBindingType(program, $interface);
+    if (interfaceBindingType) {
+        if (isPartial(program, interfaceBindingType)) {
+            return false;
+        }
+        if (isTypeDefinedInExternalLibrary(program, interfaceBindingType)) {
+            return false;
+        }
+    }
+    return true;
+}
+function getInterfaceBindingType(program, $interface) {
+    const navigationSourceType = getInterfaceNavigationSourceType(program, $interface);
+    if (navigationSourceType) {
+        return getModelFromTemplateMapper(program, navigationSourceType);
+    }
+    return undefined;
+}
+export function getNestedComplexTypes(program, model, nestedModels = new Set()) {
+    nestedModels.add(model);
+    const modelProperties = model.properties;
+    if (modelProperties.size === 0) {
+        return nestedModels;
+    }
+    for (const property of modelProperties.values()) {
+        const model = getTypeModel(program, property.type);
+        if (model && !nestedModels.has(model)) {
+            getNestedComplexTypes(program, model, nestedModels);
+        }
+    }
+    return nestedModels;
+}
+export function generateDeltaPropertiesForNavigationProperties(program, navigationProperty) {
+    const navigationPropertyModel = getTypeModel(program, navigationProperty.type);
+    if (navigationPropertyModel) {
+        const interfacesTargetingParentModel = getInterfacesTargetingModel(program, navigationPropertyModel);
+        for (const theInterface of interfacesTargetingParentModel) {
+            const graphRoutes = getGraphRoutePaths(program, theInterface);
+            if (graphRoutes) {
+                for (const graphRoute of graphRoutes) {
+                    const routeParts = graphRoute.split("/");
+                    const navPropAtEndOfRoute = routeParts[routeParts.length - 1];
+                    if (navPropAtEndOfRoute === navigationProperty.name) {
+                        return getDeltaProperties(program, theInterface);
+                    }
+                }
+            }
+        }
+    }
+    return undefined;
+}
+export function getInterfacesTargetingModel(program, type) {
+    const interfacesTargettingModel = [];
+    let model = getTypeModel(program, type);
+    if (model) {
+        const namespace = model.namespace;
+        const theInterfaces = namespace === null || namespace === void 0 ? void 0 : namespace.interfaces;
+        if (theInterfaces) {
+            for (const [_, theInterface] of theInterfaces.entries()) {
+                const navigationBindingType = getInterfaceNavigationSourceType(program, theInterface);
+                if (navigationBindingType && navigationBindingType.name === model.name) {
+                    interfacesTargettingModel.push(theInterface);
+                }
+            }
+        }
+    }
+    return interfacesTargettingModel;
+}
+// This function gets filterable and expandable properties
+export function getDeltaProperties(program, entity) {
+    const operations = entity.operations;
+    let hasDelta = false;
+    let filterProps;
+    let expandProps;
+    for (const [_, operation] of operations) {
+        // Get filterable and expandable properties as defined by @filter and @expand on the @delta operation
+        if (isDelta(program, operation)) {
+            hasDelta = true;
+            filterProps = getFilterableProperties(program, operation);
+            expandProps = getExpandableProperties(program, operation);
+            break;
+        }
+    }
+    // If the delta operation exists and the filter properties are not set, get the filter properties from the get operation
+    if (hasDelta && !filterProps) {
+        filterProps = [...getFilterablePropertiesFromGetOperation(program, operations)];
+    }
+    // If the delta operation exists and the expand properties are not set, get the expand properties from the get operation
+    if (hasDelta && !expandProps) {
+        expandProps = [...getExpandablePropertiesFromGetOperation(program, operations)];
+    }
+    if (hasDelta) {
+        return {
+            FilterProperties: filterProps,
+            ExpandProperties: expandProps,
+        };
+    }
+    return undefined;
+}
+function getFilterableProperties(program, operation) {
+    if (isFilter(program, operation)) {
+        const filterProps = getFilter(program, operation);
+        if (filterProps.includes("*")) {
+            // Return all structural properties (nested and inherited) as filterable
+            return getModelStructuralPropertyNamesFromOperation(program, operation);
+        }
+        return filterProps;
+    }
+    return undefined;
+}
+function getExpandableProperties(program, operation) {
+    if (isExpand(program, operation)) {
+        return getExpand(program, operation);
+    }
+    return undefined;
+}
+function getFilterablePropertiesFromGetOperation(program, operationsMap) {
+    const operations = [...operationsMap.values()];
+    if (operations.some(theOperation => isFilter(program, theOperation))) {
+        for (const operation of operations) {
+            if (operation.name === "get") {
+                if (isFilter(program, operation)) {
+                    const filterProps = getFilter(program, operation);
+                    if (filterProps.includes("*")) {
+                        // Return all structural properties (nested and inherited) as filterable
+                        return getModelStructuralPropertyNamesFromOperation(program, operation);
+                    }
+                    return filterProps;
+                }
+            }
+        }
+    }
+    return [];
+}
+function getModelStructuralPropertyNamesFromOperation(program, operation) {
+    const returnType = getNavigationSourceType(program, operation);
+    if (!returnType) {
+        return [];
+    }
+    const model = returnType.indexer ? returnType.indexer.value : returnType;
+    return getModelStructuralPropertyNames(program, model);
+}
+function getExpandablePropertiesFromGetOperation(program, operationsMap) {
+    const operations = [...operationsMap.values()];
+    if (operations.some(theOperation => isExpand(program, theOperation))) {
+        for (const operation of operations) {
+            if (operation.name === "get") {
+                if (isExpand(program, operation)) {
+                    return getExpand(program, operation);
+                }
+            }
+        }
+    }
+    return [];
+}
+export function isCollection(theInterfaces) {
+    return theInterfaces.some(theInterface => theInterface.name === "Collection");
+}
+export function isUnion(type) {
+    return type.kind === "Union";
+}
+export function filterMapByIdenticalValues(inputMap) {
+    var _a;
+    const resultMap = new Map();
+    const valueToKeys = new Map();
+    // Iterate over the input map
+    for (const [key, value] of inputMap.entries()) {
+        if (!valueToKeys.has(value)) {
+            valueToKeys.set(value, [key]);
+        }
+        else {
+            (_a = valueToKeys.get(value)) === null || _a === void 0 ? void 0 : _a.push(key);
+        }
+    }
+    // Add keys with identical values to the result map
+    for (const [value, keys] of valueToKeys.entries()) {
+        if (keys.length > 1) {
+            keys.forEach((key) => resultMap.set(key, value));
+        }
+    }
+    return resultMap;
+}
+// This gets nested navigation paths for all contained and non-contained models and root paths for primitive types. 
+export function getAllNestedNavigationPaths(program, model) {
+    const structuralProperties = getModelProperties(program, model, false).map(property => property.name);
+    const rootPropertyNames = structuralProperties.map(property => model.name + "/" + property);
+    let nestedPropertyNames = getAllModelPropertyNames(program, model);
+    nestedPropertyNames = nestedPropertyNames.map(propertyName => model.name + "/" + propertyName);
+    return [...new Set([...structuralProperties, ...nestedPropertyNames, ...rootPropertyNames])].filter(path => path !== model.name);
+}
+export function removeTrailingSlash(path) {
+    return path.replace(/\/$/, "");
+}
+/**
+ *
+ * @param obj1 Function that checks for equality of two objects
+ * @param obj2
+ * @returns
+ */
+export function isEqual(obj1, obj2) {
+    // Check if both are null or undefined
+    if (obj1 === obj2)
+        return true;
+    // Check if both are not objects or one is null
+    if (typeof obj1 !== 'object' || typeof obj2 !== 'object' || obj1 === null || obj2 === null) {
+        return false;
+    }
+    // Check if they have the same number of properties
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    // Check if values are the same for each property
+    for (let key of keys1) {
+        if (!keys2.includes(key) || !isEqual(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function checkFunctionOverloadsWithReturnType(operation1, operation2) {
+    return functionOperationsAreOverloads(operation1, operation2, true);
+}
+export function checkFunctionOverloads(operation1, operation2) {
+    return functionOperationsAreOverloads(operation1, operation2);
+}
+function functionOperationsAreOverloads(operation1, operation2, checkReturnType = false) {
+    if (operation1.Name === operation2.Name && operation1.BindingTypeName === operation2.BindingTypeName) {
+        if (!checkReturnType || operation1.ReturnTypeName === operation2.ReturnTypeName) {
+            const properties1 = operation1.Properties.filter((property) => property.Name !== "bindingParameter").sort((a, b) => a.Name.localeCompare(b.Name));
+            const properties2 = operation2.Properties.filter((property) => property.Name !== "bindingParameter").sort((a, b) => a.Name.localeCompare(b.Name));
+            return isEqual(properties1, properties2);
+        }
+    }
+    return false;
+}
+/**
+ * @returns a Model type if the underlying type is a model, undefined otherwise
+ */
+export function getTypeModel(program, type, structuralPropertiesOnly = false) {
+    // Use getActualType to handle cases where the type is a union type or an array type
+    const actualType = getActualType(program, type, structuralPropertiesOnly);
+    // if the actual type is not a Model type, return undefined
+    if ((actualType === null || actualType === void 0 ? void 0 : actualType.kind) !== "Model") {
+        return undefined;
+    }
+    return actualType;
+}
+function getActualType(program, type, structuralPropertiesOnly = false) {
+    var _a;
+    if (type.kind === "Union") {
+        const nonNullTypes = extractTypesFromUnion(type).filter(t => !isNullType(t));
+        if (!nonNullTypes.length) {
+            return undefined;
+        }
+        type = nonNullTypes[0];
+    }
+    if (type.kind === "Model" && isArrayModelType(program, type)) {
+        // Skip array-typed properties when looking for structural properties
+        if (structuralPropertiesOnly) {
+            return undefined;
+        }
+        type = (_a = type.indexer) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    return type;
+}
+/**
+ *
+ * @param model Handles case where model is wrapped in an EntityRef template
+ * @returns
+ */
+function getModelFromTemplateMapper(program, model) {
+    var _a;
+    const templateArguments = (_a = model.templateMapper) === null || _a === void 0 ? void 0 : _a.args;
+    if (templateArguments && templateArguments.length > 0) {
+        return getTypeModel(program, templateArguments[0]);
+    }
+    return getTypeModel(program, model);
+}
+function removeTrailingRef(path) {
+    if (path.endsWith("/$ref")) {
+        return path.slice(0, -5);
+    }
+    return path;
+}
+/**
+ * This function removes the composable function pattern from the path
+ * accessReviews/{reviewId}/instances/{instanceId}/decisions/filterByCurrentUser(string) -> accessReviews/{reviewId}/instances/{instanceId}/decisions
+ * @param path
+ * @returns
+ */
+const removeComposableFunctionPattern = (path) => {
+    const pattern = /\/[^/]+\(.*?\)(?=\/|$)/g;
+    if (pattern.test(path)) {
+        return path.replace(pattern, '');
+    }
+    return path;
+};
+export function cleanGraphRoutePath(path) {
+    path = removeRoutePathParams(path);
+    path = removeTrailingRef(path);
+    path = removeComposableFunctionPattern(path);
+    return path;
+}
+export function buildPathTree(program) {
+    const tree = new PathTree();
+    for (const namespace of GetDeclaredNamespaces(program)) {
+        navigateTypesInNamespace(namespace, {
+            interface: ($interface) => {
+                if (!hasGraphRoute(program, $interface)) {
+                    return;
+                }
+                const entityType = getInterfaceNavigationSourceType(program, $interface);
+                getGraphRoutePaths(program, $interface).forEach(graphRoutePath => {
+                    const path = removeRoutePathParams(graphRoutePath);
+                    tree.addNode(path, entityType);
+                });
+            }
+        });
+    }
+    return tree;
+}
+export function getParentModelForPropertyFromGraphRoute(pathTree, graphRoutePath) {
+    var _a;
+    const path = cleanGraphRoutePath(graphRoutePath);
+    const pathSegments = path.split("/");
+    if (pathSegments.length < 2) {
+        return;
+    }
+    const entityType = (_a = pathTree.getNodeByPath(pathSegments[pathSegments.length - 2])) === null || _a === void 0 ? void 0 : _a.entityType;
+    return entityType;
+}
+export function isParentSharedEntity(program, model) {
+    var _a;
+    if (!isSharedEntity(program, model)) {
+        return false;
+    }
+    return ((_a = model.namespace) === null || _a === void 0 ? void 0 : _a.name) === DEFAULT_MSGRAPH_NAMESPACE;
 }
 //# sourceMappingURL=utils.js.map