Fixes #1817: support key alias

Introduce the IEdmPropertyRef interface
Use default interface method for IEdmEntityType avoid breaking changes
This change focus on Edm lib, if it's ready and will move to OData.Core.

src/Microsoft.OData.Edm/Csdl/Parsing/Ast/CsdlPropertyReference.cs

@@ -11,17 +11,14 @@ namespace Microsoft.OData.Edm.Csdl.Parsing.Ast
     /// </summary>
     internal class CsdlPropertyReference : CsdlElement
     {
-        private readonly string propertyName;
-
-        public CsdlPropertyReference(string propertyName, CsdlLocation location)
+        public CsdlPropertyReference(string propertyName, string propertyAlias, CsdlLocation location)
             : base(location)
         {
-            this.propertyName = propertyName;
+            PropertyName = propertyName;
+            PropertyAlias = propertyAlias;
         }
 
-        public string PropertyName
-        {
-            get { return this.propertyName; }
-        }
+        public string PropertyName { get; }
+        public string PropertyAlias { get; }
     }
 }

src/Microsoft.OData.Edm/Csdl/Parsing/CsdlDocumentParser.cs

@@ -364,7 +364,7 @@ private static CsdlKey OnEntityKeyElement(XmlElementInfo element, XmlElementValu
 
         private CsdlPropertyReference OnPropertyRefElement(XmlElementInfo element, XmlElementValueCollection childValues)
         {
-            return new CsdlPropertyReference(Required(CsdlConstants.Attribute_Name), element.Location);
+            return new CsdlPropertyReference(Required(CsdlConstants.Attribute_Name), Optional(CsdlConstants.Attribute_Alias), element.Location);
         }
 
         private CsdlEnumType OnEnumTypeElement(XmlElementInfo element, XmlElementValueCollection childValues)

src/Microsoft.OData.Edm/Csdl/Parsing/SchemaJsonParser.cs

@@ -650,21 +650,37 @@ internal static CsdlKey ParseCsdlKey(string name, JsonElement keyArray, JsonPars
             Debug.Assert(keyArray.ValueKind == JsonValueKind.Array);
             Debug.Assert(name == "$Key", "The name should be $Key.");
 
+            string alias = null;
+            string propertyName = null;
             IList<CsdlPropertyReference> properties = keyArray.ParseAsArray(context, (v, p) =>
             {
                 if (v.ValueKind == JsonValueKind.Object)
                 {
-                    // TODO: ODL doesn't support the key referencing a property of a complex type as below.
+                    // Key properties with a key alias are represented as objects with one member
+                    // whose name is the key alias and whose value is a string containing the path to the property. For example:
                     // "$Key": [
                     //    {
                     //      "EntityInfoID": "Info/ID"
                     //    }
                     //  ]
-                    p.ReportError(EdmErrorCode.InvalidKeyValue, "It doesn't support the key object.");
+                    var objectProperties = v.EnumerateObject();
+                    if (objectProperties.Count() != 1)
+                    {
+                        p.ReportError(EdmErrorCode.InvalidKeyValue, "Key properties with a key alias are represented as objects with only one member.");
+                    }
+                    else
+                    {
+                        var property = objectProperties.First();
+                        alias = property.Name;
+                        propertyName = property.Value.ParseAsString(context);
+                    }
+                }
+                else
+                {
+                    propertyName = v.ParseAsString(context);
                 }
 
-                string propertyName = v.ParseAsString(context);
-                return new CsdlPropertyReference(propertyName, context.Location());
+                return new CsdlPropertyReference(propertyName, alias, context.Location());
             });
 
             return new CsdlKey(properties, context.Location());

src/Microsoft.OData.Edm/Csdl/Semantics/BadElements/UnresolvedPropertyRef.cs

@@ -0,0 +1,30 @@
+//---------------------------------------------------------------------
+// <copyright file="UnresolvedProperty.cs" company="Microsoft">
+//      Copyright (C) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+// </copyright>
+//---------------------------------------------------------------------
+
+using Microsoft.OData.Edm.Validation;
+
+namespace Microsoft.OData.Edm.Csdl.CsdlSemantics
+{
+    internal class UnresolvedPropertyRef : BadElement, IUnresolvedElement, IEdmPropertyRef
+    {
+        public UnresolvedPropertyRef(IEdmStructuredType declaringType, string name, string alias, EdmLocation location)
+            : base(new EdmError[]
+            {
+                new EdmError(location, EdmErrorCode.BadUnresolvedPropertyRef,
+                    Edm.Strings.Bad_UnresolvedPropertyRef(declaringType.FullTypeName(), name, alias))
+            })
+        {
+        }
+
+        public IEdmStructuralProperty ReferencedProperty => null;
+
+        public string PropertyAlias { get; }
+
+        public string Name { get; }
+
+        public IEdmPathExpression Path { get; }
+    }
+}

src/Microsoft.OData.Edm/Csdl/Semantics/CsdlSemanticsEntityTypeDefinition.cs

@@ -8,6 +8,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.OData.Edm.Csdl.Parsing.Ast;
+using Microsoft.OData.Edm.Vocabularies;
 
 namespace Microsoft.OData.Edm.Csdl.CsdlSemantics
 {
@@ -23,8 +24,8 @@ internal class CsdlSemanticsEntityTypeDefinition : CsdlSemanticsStructuredTypeDe
         private static readonly Func<CsdlSemanticsEntityTypeDefinition, IEdmEntityType> ComputeBaseTypeFunc = (me) => me.ComputeBaseType();
         private static readonly Func<CsdlSemanticsEntityTypeDefinition, IEdmEntityType> OnCycleBaseTypeFunc = (me) => new CyclicEntityType(me.GetCyclicBaseTypeName(me.entity.BaseTypeName), me.Location);
 
-        private readonly Cache<CsdlSemanticsEntityTypeDefinition, IEnumerable<IEdmStructuralProperty>> declaredKeyCache = new Cache<CsdlSemanticsEntityTypeDefinition, IEnumerable<IEdmStructuralProperty>>();
-        private static readonly Func<CsdlSemanticsEntityTypeDefinition, IEnumerable<IEdmStructuralProperty>> ComputeDeclaredKeyFunc = (me) => me.ComputeDeclaredKey();
+        private readonly Cache<CsdlSemanticsEntityTypeDefinition, IEnumerable<IEdmPropertyRef>> declaredKeyCache = new Cache<CsdlSemanticsEntityTypeDefinition, IEnumerable<IEdmPropertyRef>>();
+        private static readonly Func<CsdlSemanticsEntityTypeDefinition, IEnumerable<IEdmPropertyRef>> ComputeDeclaredKeyFunc = (me) => me.ComputeDeclaredKey();
 
         public CsdlSemanticsEntityTypeDefinition(CsdlSemanticsSchema context, CsdlEntityType entity)
             : base(context, entity)
@@ -72,6 +73,14 @@ public bool HasStream
         }
 
         public IEnumerable<IEdmStructuralProperty> DeclaredKey
+        {
+            get
+            {
+                return this.DeclaredKeyRef?.Select(x => x.ReferencedProperty);
+            }
+        }
+
+        public IEnumerable<IEdmPropertyRef> DeclaredKeyRef
         {
             get
             {
@@ -105,17 +114,24 @@ private IEdmEntityType ComputeBaseType()
             return null;
         }
 
-        private IEnumerable<IEdmStructuralProperty> ComputeDeclaredKey()
+        private IEnumerable<IEdmPropertyRef> ComputeDeclaredKey()
         {
             if (this.entity.Key != null)
             {
-                List<IEdmStructuralProperty> key = new List<IEdmStructuralProperty>();
+                List<IEdmPropertyRef> key = new List<IEdmPropertyRef>();
                 foreach (CsdlPropertyReference keyProperty in this.entity.Key.Properties)
                 {
-                    IEdmStructuralProperty structuralProperty = this.FindProperty(keyProperty.PropertyName) as IEdmStructuralProperty;
+                    IEdmStructuralProperty structuralProperty = FindKeyProperty(keyProperty.PropertyName);
                     if (structuralProperty != null)
                     {
-                        key.Add(structuralProperty);
+                        if (keyProperty.PropertyAlias != null)
+                        {
+                            key.Add(new EdmPropertyRef(structuralProperty, new EdmPropertyPathExpression(keyProperty.PropertyName), keyProperty.PropertyAlias));
+                        }
+                        else
+                        {
+                            key.Add(new EdmPropertyRef(structuralProperty));
+                        }
                     }
                     else
                     {
@@ -125,11 +141,11 @@ private IEnumerable<IEdmStructuralProperty> ComputeDeclaredKey()
                         structuralProperty = this.DeclaredProperties.FirstOrDefault(p => p.Name == keyProperty.PropertyName) as IEdmStructuralProperty;
                         if (structuralProperty != null)
                         {
-                            key.Add(structuralProperty);
+                            key.Add(new EdmPropertyRef(structuralProperty));
                         }
                         else
                         {
-                            key.Add(new UnresolvedProperty(this, keyProperty.PropertyName, this.Location));
+                            key.Add(new UnresolvedPropertyRef(this, keyProperty.PropertyName, keyProperty.PropertyAlias, this.Location));
                         }
                     }
                 }
@@ -139,5 +155,71 @@ private IEnumerable<IEdmStructuralProperty> ComputeDeclaredKey()
 
             return null;
         }
+
+        private IEdmStructuralProperty FindKeyProperty(string nameOrPath)
+        {
+            if (string.IsNullOrWhiteSpace(nameOrPath))
+            {
+                return null;
+            }
+
+            string[] segments = nameOrPath.Split('/');
+            if (segments.Length == 1)
+            {
+                return FindPropertyOnType(this, nameOrPath) as IEdmStructuralProperty;
+            }
+            else
+            {
+                // OData spec says "The value of Name is a path expression leading to a primitive property."
+                // The segment in a path expression could be single value property name, collection value property name, type cast, ...
+                // However, for the key property reference path expression:
+                // 1) Collection value property name segment is invalid, right?
+                // 2) Type cast? reference a key on the sub type? it's valid but So far, let's skip it.
+                IEdmStructuredType edmStructuredType = this;
+                for (int i = 0; i < segments.Length; ++i)
+                {
+                    if (edmStructuredType == null)
+                    {
+                        return null;
+                    }
+
+                    string segment = segments[i];
+                    if (segment.Contains('.', StringComparison.Ordinal))
+                    {
+                        // a type cast, let's skip it for key reference now.
+                        continue;
+                    }
+
+                    IEdmProperty edmProperty = FindPropertyOnType(edmStructuredType, segment);
+                    if (i == segments.Length - 1)
+                    {
+                        return edmProperty as IEdmStructuralProperty;
+                    }
+                    else if (edmProperty != null)
+                    {
+                        // If the property is a collection value, let's move on using the element type of this collection
+                        edmStructuredType = edmProperty.Type.ToStructuredType();
+                    }
+                    else
+                    {
+                        return null;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private static IEdmProperty FindPropertyOnType(IEdmStructuredType structuredType, string name)
+        {
+            IEdmProperty property = structuredType.FindProperty(name);
+
+            if (property == null)
+            {
+                property = structuredType.DeclaredProperties.FirstOrDefault(p => p.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
+            }
+
+            return property;
+        }
     }
 }

src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaJsonWriter.cs

@@ -398,24 +398,33 @@ internal override Task WriteDeclaredKeyPropertiesElementHeaderAsync()
         /// Write the Key property
         /// </summary>
         /// <param name="property">The Edm Structural Property.</param>
-        internal override void WritePropertyRefElement(IEdmStructuralProperty property)
+        internal override void WritePropertyRefElement(IEdmPropertyRef propertyRef)
         {
-            // Key properties without a key alias are represented as strings containing the property name.
-            // Key properties with a key alias are represented as objects with one member whose name is the key alias and whose value is a string containing the path to the property.
-            // TODO: It seems the second one is not supported.
-            this.jsonWriter.WriteStringValue(property.Name);
+            if (propertyRef.PropertyAlias != null && propertyRef.PropertyAlias != propertyRef.Path.Path)
+            {
+                // Key properties with a key alias are represented as objects with one member
+                // whose name is the key alias and whose value is a string containing the path to the property.
+                this.jsonWriter.WriteStartObject();
+                this.jsonWriter.WriteRequiredProperty(propertyRef.PropertyAlias, propertyRef.Path.Path);
+                this.jsonWriter.WriteEndObject();
+            }
+            else
+            {
+                // Key properties without a key alias are represented as strings containing the property name.
+                this.jsonWriter.WriteStringValue(propertyRef.Path.Path);
+            }
         }
 
         /// <summary>
         /// Asynchronously Writes the Key property.
         /// </summary>
         /// <param name="property">The Edm Structural Property.</param>
         /// <returns>Task represents an asynchronous operation that may or may not return a result.</returns>
-        internal override Task WritePropertyRefElementAsync(IEdmStructuralProperty property)
+        internal override Task WritePropertyRefElementAsync(IEdmPropertyRef propertyRef)
         {
             // Key properties without a key alias are represented as strings containing the property name.
             // Key properties with a key alias are represented as objects with one member whose name is the key alias and whose value is a string containing the path to the property.
-            this.jsonWriter.WriteStringValue(property.Name);
+            WritePropertyRefElement(propertyRef);
 
             return Task.CompletedTask;
         }

src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaWriter.cs

@@ -84,8 +84,8 @@ internal EdmModelCsdlSchemaWriter(IEdmModel model, Version edmVersion)
         internal abstract void WriteDeclaredKeyPropertiesElementHeader();
         internal abstract Task WriteDeclaredKeyPropertiesElementHeaderAsync();
 
-        internal abstract void WritePropertyRefElement(IEdmStructuralProperty property);
-        internal abstract Task WritePropertyRefElementAsync(IEdmStructuralProperty property);
+        internal abstract void WritePropertyRefElement(IEdmPropertyRef propertyRef);
+        internal abstract Task WritePropertyRefElementAsync(IEdmPropertyRef propertyRef);
 
         internal abstract void WriteNavigationPropertyElementHeader(IEdmNavigationProperty property);
         internal abstract Task WriteNavigationPropertyElementHeaderAsync(IEdmNavigationProperty property);

src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaXmlWriter.cs

@@ -400,23 +400,35 @@ internal override Task WriteDeclaredKeyPropertiesElementHeaderAsync()
         /// <summary>
         /// Writes the PropertyRef element.
         /// </summary>
-        /// <param name="property">The Edm Structural Property.</param>
-        internal override void WritePropertyRefElement(IEdmStructuralProperty property)
+        /// <param name="propertyRef">The Edm property ref.</param>
+        internal override void WritePropertyRefElement(IEdmPropertyRef propertyRef)
         {
             this.xmlWriter.WriteStartElement(CsdlConstants.Element_PropertyRef);
-            this.WriteRequiredAttribute(CsdlConstants.Attribute_Name, property.Name, EdmValueWriter.StringAsXml);
+
+            this.WriteRequiredAttribute(CsdlConstants.Attribute_Name, propertyRef.Path.Path, EdmValueWriter.StringAsXml);
+
+            if (propertyRef.PropertyAlias != null && propertyRef.PropertyAlias != propertyRef.Path.Path)
+            {
+                this.WriteRequiredAttribute(CsdlConstants.Attribute_Alias, propertyRef.PropertyAlias, EdmValueWriter.StringAsXml);
+            }
+
             this.WriteEndElement();
         }
 
         /// <summary>
         /// Asynchronously writes the PropertyRef element.
         /// </summary>
-        /// <param name="property">The Edm Structural Property.</param>
+        /// <param name="propertyRef">The Edm property ref.</param>
         /// <returns>Task represents an asynchronous operation.</returns>
-        internal override async Task WritePropertyRefElementAsync(IEdmStructuralProperty property)
+        internal override async Task WritePropertyRefElementAsync(IEdmPropertyRef propertyRef)
         {
             await this.xmlWriter.WriteStartElementAsync(null, CsdlConstants.Element_PropertyRef, null).ConfigureAwait(false);
-            await this.WriteRequiredAttributeAsync(CsdlConstants.Attribute_Name, property.Name, EdmValueWriter.StringAsXml).ConfigureAwait(false);
+            await this.WriteRequiredAttributeAsync(CsdlConstants.Attribute_Name, propertyRef.Path.Path, EdmValueWriter.StringAsXml).ConfigureAwait(false);
+
+            if (propertyRef.PropertyAlias != null && propertyRef.PropertyAlias != propertyRef.Path.Path)
+            {
+                await this.WriteRequiredAttributeAsync(CsdlConstants.Attribute_Name, propertyRef.PropertyAlias, EdmValueWriter.StringAsXml).ConfigureAwait(false);
+            }
             await this.WriteEndElementAsync().ConfigureAwait(false);
         }