@microsoft/typespec-msgraph 0.0.1-Preview.2 → 0.0.1-Preview.20

package/dist/src/utils.js

@@ -1,5 +1,17 @@
-import { getNamespaceFullName, isArrayModelType, } from "@typespec/compiler";
-import { getEntity, isEntity } from "./decorators/index.js";
+import { getLocationContext, getNamespaceFullName, isArrayModelType, walkPropertiesInherited, } from "@typespec/compiler";
+import { getEntity, getExpand, getFilter, getGraphRoutePaths, getPublicNamespaceName, getWorkloadNamespaceName, hasPublicNamespace, hasWorkloadNamespace, isComplex, isContains, isDelta, isEntity, isExpand, isFilter, isPartial, isReferences } from "./decorators/index.js";
+import { getOperationVerb } from "@typespec/http";
+// 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 +37,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,12 +61,20 @@ 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":
             return "Edm.Boolean";
         case "stream":
             return "Edm.Stream";
+        case "guid":
+            return "Edm.Guid";
+        case "unknown":
+            return "Edm.Untyped";
         default:
             break;
     }
@@ -60,21 +83,89 @@ 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" && getLocationContext(program, type).type === "project") {
+        const indexer = (_a = type.indexer) === null || _a === void 0 ? void 0 : _a.value;
+        if (indexer) {
+            return true;
+        }
+    }
+    return false;
+}
+export function generateDictionaryBaseType(program, model) {
+    if (getLocationContext(program, model).type === "library") {
+        return undefined;
+    }
+    if (isDictionaryType(program, model)) {
+        return "Org.OData.Core.V1.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":
             return `${type.value}`;
         case "Union":
             return getIdForUnion(program, type);
+        case "Scalar":
+        case "Intrinsic":
+            return getNameForModelType(program, type);
         default:
             return type.kind;
     }
@@ -87,37 +178,106 @@ export function getNavigationTypeId(program, getOperation) {
     }
     return getIdForType(program, returnType.templateArguments[0]);
 }
+export function getInterfacesOfKinds(program, navigationSources, kinds) {
+    const interfaces = new Map();
+    navigationSources.forEach((theInterface) => {
+        if (!getSourceInterfaces(theInterface).some((s) => kinds.includes(s.name))) {
+            // if source interfaces DO NOT have the kinds.
+            return;
+        }
+        const graphRoutePaths = getGraphRoutePaths(program, theInterface);
+        if (!graphRoutePaths || !graphRoutePaths.length) {
+            return;
+        }
+        graphRoutePaths.forEach((graphRoute) => {
+            // skip two-segment resources as they are collections
+            if (isRouteIndexOfACollection(theInterface, graphRoute)) {
+                return;
+            }
+            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;
+}
+// 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);
+            }
+        });
+    });
+    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) {
@@ -130,6 +290,26 @@ export function getSingletonTypeId(program, singletonType, getOperation) {
     }
     return getOperation && getNavigationTypeId(program, getOperation);
 }
+/**
+ * Returns whether a type matches Graph's  definition of a collection
+ * @param program
+ * @param type
+ */
+export function isTypeCollection(Program, type) {
+    let modelTypes = [];
+    if (type.kind === "Union") {
+        const extracted = (extractTypesFromUnion(type).filter((t) => t.kind === "Model"));
+        modelTypes = modelTypes.concat(extracted);
+    }
+    else if (type.kind === "Model") {
+        modelTypes.push(type);
+    }
+    if (modelTypes.length === 0) {
+        return false;
+    }
+    return modelTypes.some((t) => t.kind === "Model" &&
+        (t.name === "Array" || t.name.includes("Collection")));
+}
 /**
  * Imported from typespec-azure
  * Returns the full namespace name for the given type, if available.
@@ -167,11 +347,24 @@ export function isExcludedCoreType(program, type) {
     // https://github.com/Azure/typespec-azure/issues/801#issuecomment-1194454247
     //
     const nsName = getNamespaceName(program, type);
-    const excludedNamespaces = ["TypeSpec", "TypeSpec"];
+    const excludedNamespaces = ["TypeSpec", "MsGraph"];
+    return excludedNamespaces.find((ns) => nsName.startsWith(ns)) !== undefined;
+}
+export function isExcludedLibraryType(program, type) {
+    const nsName = getNamespaceName(program, type);
+    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(t));
+        if (!nonNullTypes.length) {
+            return false;
+        }
+        propertyType = nonNullTypes[0];
+    }
     if (propertyType.kind !== "Model") {
         return false;
     }
@@ -183,4 +376,334 @@ export function isNavigationProperty(program, property) {
     }
     return isEntity(program, propertyType);
 }
+export function isNavigationSource(theInterface) {
+    return findNavigationSource(theInterface) !== undefined;
+}
+export function isTopLevelNavigationSource(program, theInterface) {
+    return removeRoutePathParams(theInterface.path).split("/").length === 1;
+}
+// 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) {
+    var _a;
+    const navSource = findNavigationSource(theInterface);
+    if (navSource === undefined) {
+        return undefined;
+    }
+    else {
+        return (_a = navSource.templateMapper) === null || _a === void 0 ? void 0 : _a.args[0];
+    }
+}
+// Get the type returned by all operations in an interface representing a navigation source.
+export function getNavigationSourceType(program, operation) {
+    return getInterfaceNavigationSourceType(program, operation.interface);
+}
+function findNavigationSource(theInterface) {
+    for (const baseInterface of getSourceInterfaces(theInterface)) {
+        if (baseInterface.name === "Resource" || baseInterface.name === "Collection") {
+            return baseInterface;
+        }
+        else {
+            const baseBase = findNavigationSource(baseInterface);
+            if (baseBase !== undefined) {
+                return baseBase;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Removes route path params from a route path
+ *
+ * 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";
+}
+/**
+ * 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 getStructuralProperties(program, model) {
+    const structuralProperties = getStructuralPropertyNames(program, model);
+    const propertiesOfTypeModel = getPropertiesOfTypeModel(program, model);
+    const nestedPropertyNames = getNestedPropertyNames(program, propertiesOfTypeModel);
+    return [...new Set([...structuralProperties, ...nestedPropertyNames])].filter(path => path !== model.name);
+}
+function getStructuralPropertyNames(program, model) {
+    const allProperties = walkPropertiesInherited(model);
+    const structuralPropertyNames = [...allProperties] // gets only reachable ones per the function
+        .filter((property) => !isContains(program, property) && !isReferences(program, property))
+        .map(property => property.name.trim());
+    return structuralPropertyNames;
+}
+function getPropertiesOfTypeModel(program, model) {
+    const allProperties = walkPropertiesInherited(model);
+    const propertiesOfTypeModel = [];
+    for (const property of allProperties) {
+        const type = getModelStructuredTypeFromProperty(program, property);
+        if (type) {
+            propertiesOfTypeModel.push(type);
+        }
+    }
+    return propertiesOfTypeModel;
+}
+function getModelStructuredTypeFromProperty(program, property) {
+    // Skip navigation properties
+    if (isContains(program, property) || isReferences(program, property)) {
+        return null;
+    }
+    const type = property.type;
+    if (type.kind === "Model") {
+        // Skip array-typed properties
+        if (type.name === "Array") {
+            return null;
+        }
+        return {
+            name: property.name,
+            model: type
+        };
+    }
+    if (type.kind === "Union") {
+        const nonNullUnionTypes = extractTypesFromUnion(type).filter(t => !isNullType(t));
+        if (nonNullUnionTypes[0].kind === "Model") {
+            return {
+                name: property.name,
+                model: nonNullUnionTypes[0]
+            };
+        }
+    }
+    return null;
+}
+function getNestedPropertyNames(program, propertyModels, prefix = "") {
+    const names = [];
+    if (prefix && hasRepeatedItem(prefix)) {
+        return names;
+    }
+    for (const propertyModel of propertyModels) {
+        const propertyModelPrefix = prefix + propertyModel.name + "/";
+        const nestedPropertyModels = getNestedPropertyModels(program, propertyModel);
+        nestedPropertyModels.forEach(m => {
+            const name = propertyModelPrefix + m.name;
+            if (!hasRepeatedItem(name)) {
+                names.push(name);
+            }
+        });
+        names.push(...getNestedPropertyNames(program, nestedPropertyModels, propertyModelPrefix));
+    }
+    return names;
+}
+function getNestedPropertyModels(program, propertyModel) {
+    const propertyModels = [];
+    if (!propertyModel.model.properties) {
+        return propertyModels;
+    }
+    propertyModel.model.properties.forEach((property, name) => {
+        const model = getPropertyModel(program, property);
+        if (model !== null) {
+            propertyModels.push({ name: name, model: model });
+        }
+    });
+    return propertyModels;
+}
+function getPropertyModel(program, property) {
+    if (isContains(program, property) || isReferences(program, property)) {
+        return null;
+    }
+    let type = property.type;
+    if (type.kind === "Union") {
+        const nonNullUnionTypes = extractTypesFromUnion(type).filter(t => !isNullType(t));
+        type = nonNullUnionTypes[0];
+    }
+    if (type.kind === "Model") {
+        if (type.name === "Array") {
+            if (type.indexer.value.kind !== "Model") {
+                return null;
+            }
+            type = type.indexer.value;
+        }
+    }
+    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 hasRepeatedItem(slashSeparatedString) {
+    const items = slashSeparatedString.split('/');
+    const uniqueItems = new Set(items);
+    return items.length !== uniqueItems.size;
+}
+export function isInterfaceBindingTypeOwned(program, $interface) {
+    const interfaceBindingType = getInterfaceNavigationSourceType(program, $interface);
+    if (interfaceBindingType) {
+        if (isPartial(program, interfaceBindingType)) {
+            return false;
+        }
+    }
+    return true;
+}
+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()) {
+        if (property.type.kind === "Model" && isComplex(program, property.type)) {
+            if (!nestedModels.has(property.type)) {
+                getNestedComplexTypes(program, property.type, nestedModels);
+            }
+        }
+        if (property.type.kind === "Union") {
+            const nonNullTypes = extractTypesFromUnion(property.type).filter((t) => !isNullType(t));
+            if (nonNullTypes.length > 0 && nonNullTypes[0].kind === "Model" && isComplex(program, nonNullTypes[0])) {
+                if (!nestedModels.has(nonNullTypes[0])) {
+                    getNestedComplexTypes(program, nonNullTypes[0], nestedModels);
+                }
+            }
+        }
+        if (property.type.kind === "Model" && isArrayModelType(program, property.type)) {
+            const indexer = property.type.indexer.value;
+            if (indexer.kind === "Model" && isComplex(program, indexer)) {
+                if (!nestedModels.has(indexer)) {
+                    getNestedComplexTypes(program, indexer, nestedModels);
+                }
+            }
+        }
+    }
+    return nestedModels;
+}
+// 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);
+        return filterProps;
+    }
+    return undefined;
+}
+function getExpandableProperties(program, operation) {
+    if (isExpand(program, operation)) {
+        return getExpand(program, operation);
+    }
+    return undefined;
+}
+// check this
+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)) {
+                    return getFilter(program, operation);
+                }
+            }
+        }
+    }
+    return [];
+}
+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;
+}
 //# sourceMappingURL=utils.js.map