Feature/update nuget 1 156 0 (#26)

* Regenerated with new version 1.156.0 and bumped .NET to 8.0

* Removed para tags from generated documentation

* Removed c tags from generated documentation

* Removed example tags from generated documentation

* Bumped dotnet-version from 7.0.x to 8.0.x

* Handle three generic params and add overwritten constructor for ProductDataRelenvanceModifier

* Replaced chained Replace() calls with regex that captures all cases

* Removed types that were no longer part of the API.

* Updated to be able to generate creator method that sets properties not owned directly by the type.

* Removed unrelated change in test.

* Fixed breaking change for `ProductRecentlyPurchasedByCompanyFilter.php`.

* Fixed breaking change for `ProductRecentlyPurchasedByUserCompanyFilter.php`.

* Fixed breaking change for `ProductRecentlyPurchasedByUserFilter.php`.

* Fixed breaking change for `ProductRecentlyPurchasedByUserRelevanceModifier.php`.

* Fixed breaking change for `ProductRecentlyViewedByCompanyFilter.php`.

* Fixed breaking change in `ProductRecentlyViewedByUserFilter.php`.

* Fixed breaking change for `ProductRecentlyViewedByUserRelevanceModifier.php`.

* Fixed breaking change for `VariantDataRelevanceModifier.php`.

* Added support for see-tag langword de-referencing.

* Added remarks for nullable value type flag.

---------

Co-authored-by: KSGRelewise <119578211+KSGRelewise@users.noreply.github.com>

Author: soe-relewise

.github/workflows/ci.yml

@@ -12,10 +12,10 @@ jobs:
 
       - uses: php-actions/composer@v6
 
-      - name: Setup .NET 7 preview
+      - name: Setup .NET 8 preview
         uses: actions/setup-dotnet@v1
         with:
-          dotnet-version: '7.0.x'
+          dotnet-version: '8.0.x'
 
       - name: Generate PHP classes
         run: ./generate.sh

.github/workflows/publish.yml

@@ -13,10 +13,10 @@ jobs:
 
       - uses: php-actions/composer@v5
 
-      - name: Setup .NET 7 preview
+      - name: Setup .NET 8 preview
         uses: actions/setup-dotnet@v1
         with:
-          dotnet-version: '7.0.x'
+          dotnet-version: '8.0.x'
 
       - name: Generate PHP classes
         run: ./generate.sh

Generator/Generator.csproj

@@ -2,14 +2,14 @@
 
 	<PropertyGroup>
 		<OutputType>Exe</OutputType>
-		<TargetFramework>net7.0</TargetFramework>
+		<TargetFramework>net8.0</TargetFramework>
 		<ImplicitUsings>enable</ImplicitUsings>
 		<Nullable>enable</Nullable>
 	</PropertyGroup>
 
 	<ItemGroup>
 		<PackageReference Include="AngleSharp.Xml" Version="1.0.0" />
-		<PackageReference Include="Relewise.Client" Version="1.130.0" />
+		<PackageReference Include="Relewise.Client" Version="1.156.0" />
 	</ItemGroup>
 
 </Project>

Generator/PhpMemberWriters/PhpCreatorMethodWriter.cs

@@ -3,14 +3,45 @@
 using System.Globalization;
 using System.Reflection;
 using Relewise.Client.Requests;
+using Relewise.Client.Requests.RelevanceModifiers;
+using Relewise.Client.Requests.Conditions;
+using Relewise.Client.Requests.ValueSelectors;
+using Relewise.Client.Requests.Filters;
 
 namespace Generator.PhpMemberWriters;
 
 public class PhpCreatorMethodWriter
 {
     private readonly Dictionary<Type, ConstructorInfo> overrideDefaultConstructors = new()
     {
-        [typeof(Channel)] = typeof(Channel).GetConstructor(new[] { typeof(string) })! // We override any matching logic and choose the constructor with one string parameter.
+        // We override any matching logic and choose the constructor with one string parameter.
+        [typeof(Channel)] = typeof(Channel).GetConstructor(new[] { typeof(string) })!,
+        // For backwards compatibility remove in next major release.
+        [typeof(ProductDataRelevanceModifier)] = typeof(ProductDataRelevanceModifier).GetConstructor(new[] { typeof(string), typeof(List<ValueCondition>), typeof(ValueSelector), typeof(bool), typeof(bool) })!,
+        // For backwards compatibility remove in next major release.
+        [typeof(ProductRecentlyViewedByUserFilter)] = typeof(ProductRecentlyViewedByUserFilter).GetConstructor(new[] { typeof(DateTimeOffset), typeof(bool) })!,
+        // For backwards compatibility remove in next major release.
+        [typeof(ProductRecentlyViewedByUserRelevanceModifier)] = typeof(ProductRecentlyViewedByUserRelevanceModifier).GetConstructor(new[] { typeof(DateTimeOffset), typeof(double), typeof(double) })!,
+        // For backwards compatibility remove in next major release.
+        [typeof(VariantDataRelevanceModifier)] = typeof(VariantDataRelevanceModifier).GetConstructor(new[] { typeof(string), typeof(List<ValueCondition>), typeof(ValueSelector), typeof(bool), typeof(bool) })!,
+    };
+
+    /// <summary>
+    /// We sometimes change the types that own specific properties so that the optimistic parameter matcher can no longer find the properties in the same way as previously.
+    /// In this case we can define manual mappings that select which parameters should be mapped to keep the generated code from breaking.
+    /// </summary>
+    private readonly Dictionary<Type, (ConstructorInfo constructor, string[] parameters)> overrideDefaultConstructorsWithSelectedParameters = new()
+    {
+        // For backwards compatibility remove in next major release.
+        [typeof(ProductRecentlyPurchasedByCompanyFilter)] = (typeof(ProductRecentlyPurchasedByCompanyFilter).GetConstructor(new[] { typeof(DateTimeOffset), typeof(string), typeof(bool) })!, new []{ "sinceUtc", "negated" }),
+        // For backwards compatibility remove in next major release.
+        [typeof(ProductRecentlyPurchasedByUserCompanyFilter)] = (typeof(ProductRecentlyPurchasedByUserCompanyFilter).GetConstructor(new[] { typeof(DateTimeOffset), typeof(bool) })!, new[] { "sinceUtc", "negated" }),
+        // For backwards compatibility remove in next major release.
+        [typeof(ProductRecentlyPurchasedByUserFilter)] = (typeof(ProductRecentlyPurchasedByUserFilter).GetConstructor(new[] { typeof(DateTimeOffset), typeof(bool) })!, new[] { "sinceUtc", "negated" }),
+        // For backwards compatibility remove in next major release.
+        [typeof(ProductRecentlyPurchasedByUserRelevanceModifier)] = (typeof(ProductRecentlyPurchasedByUserRelevanceModifier).GetConstructor(new[] { typeof(DateTimeOffset), typeof(double), typeof(double) })!, new[] { "sinceUtc", "ifPreviouslyPurchasedByUserMultiplyWeightBy", "ifNotPreviouslyPurchasedByUserMultiplyWeightBy" }),
+        // For backwards compatibility remove in next major release.
+        [typeof(ProductRecentlyViewedByCompanyFilter)] = (typeof(ProductRecentlyViewedByCompanyFilter).GetConstructor(new[] { typeof(DateTimeOffset), typeof(string), typeof(bool) })!, new[] { "sinceUtc", "negated" }),
     };
 
     private readonly PhpWriter phpWriter;
@@ -20,7 +51,9 @@ public PhpCreatorMethodWriter(PhpWriter phpWriter)
         this.phpWriter = phpWriter;
     }
 
-    public void Write(IndentedTextWriter writer, Type type, string typeName, (PropertyInfo info, string propertyTypeName, string propertyName, string lowerCaseName)[] propertyInformations)
+    public void Write(IndentedTextWriter writer, Type type, string typeName,
+        (PropertyInfo info, string propertyTypeName, string propertyName, string lowerCaseName)[] settablePropertyInformations,
+        (PropertyInfo info, string propertyTypeName, string propertyName, string lowerCaseName)[] ownedPropertyInformations)
     {
         if (type.IsAbstract || type.IsInterface) return;
 
@@ -31,9 +64,9 @@ public void Write(IndentedTextWriter writer, Type type, string typeName, (Proper
 
         var coveringUniqueTypeMappableConstructorParameters = allConstructors
             .FirstOrDefault(c => c.GetParameters().Length == c.GetParameters().DistinctBy(parameter => parameter.ParameterType).Count() // There are no parameters with the same type.
-                                 && c.GetParameters().Length == propertyInformations.Length // There are as many parameters as there are properties.
+                                 && c.GetParameters().Length == ownedPropertyInformations.Length // There are as many parameters as there are properties.
                                  && c.GetParameters()
-                                     .All(parameter => propertyInformations
+                                     .All(parameter => ownedPropertyInformations
                                          .Any(property => ParameterIsPersuadableIntoPropertyType(property.info, parameter))
                                      ) // There is a property type that matches each parameter type.
             )
@@ -42,7 +75,7 @@ public void Write(IndentedTextWriter writer, Type type, string typeName, (Proper
 
         var coveringTypeAndNameMappableConstructorParameters = allConstructors
             .Where(c => c.GetParameters()
-                                     .All(parameter => propertyInformations
+                                     .All(parameter => ownedPropertyInformations
                                          .Count(property =>
                                              ContainedWithinEitherOne(property.propertyName, parameter.Name)
                                              && ParameterIsPersuadableIntoPropertyType(property.info, parameter)) == 1
@@ -85,8 +118,34 @@ public void Write(IndentedTextWriter writer, Type type, string typeName, (Proper
 
             foreach (var parameter in parameters)
             {
-                var propertyName = propertyInformations
-                    .Single(property => ContainedWithinEitherOne(property.propertyName, parameter.Name) && ParameterIsPersuadableIntoPropertyType(property.info, parameter))
+                // We use settablePropertyInformations here as the only place as it was an error originally that we didn't use it, but it would create too many breaking changes if we corrected in all places.
+                var propertyName = settablePropertyInformations
+                    .Single(property => ContainedWithinEitherOne(property.propertyName, parameter.Name) && ParameterIsPersuadableIntoPropertyType(property.info, parameter, supportNullableValueTypes: true))
+                    .lowerCaseName;
+
+                writer.WriteLine($"$result->{propertyName} = ${parameter.Name};");
+            }
+        }
+        else if (overrideDefaultConstructorsWithSelectedParameters.TryGetValue(type, out (ConstructorInfo defaultConstructor, string[] parameters) overriden))
+        {
+            var parameters = overriden.defaultConstructor.GetParameters().Where(p => overriden.parameters.Contains(p.Name)).ToArray();
+
+            writer.WriteCommentBlock(
+                parameters.Select(p => phpWriter.XmlDocumentation.GetConstructorParam(typeName, parameters, p))
+                    .Prepend(phpWriter.XmlDocumentation.GetConstructorSummary(typeName, parameters))
+                    .ToArray()
+            );
+
+            writer.WriteLine($"public static function create({ParameterList(parameters)}) : {typeName}");
+            writer.WriteLine("{");
+            writer.Indent++;
+            writer.WriteLine($"$result = new {typeName}();");
+
+            foreach (var parameter in parameters)
+            {
+                // We use settablePropertyInformations here as the only place as it was an error originally that we didn't use it, but it would create too many breaking changes if we corrected in all places.
+                var propertyName = settablePropertyInformations
+                    .Single(property => ContainedWithinEitherOne(property.propertyName, parameter.Name) && ParameterIsPersuadableIntoPropertyType(property.info, parameter, supportNullableValueTypes: true))
                     .lowerCaseName;
 
                 writer.WriteLine($"$result->{propertyName} = ${parameter.Name};");
@@ -107,7 +166,7 @@ public void Write(IndentedTextWriter writer, Type type, string typeName, (Proper
 
             foreach (var parameter in coveringUniqueTypeMappableConstructorParameters)
             {
-                var propertyName = propertyInformations
+                var propertyName = ownedPropertyInformations
                     .Single(property => ParameterIsPersuadableIntoPropertyType(property.info, parameter))
                     .lowerCaseName;
 
@@ -129,7 +188,7 @@ public void Write(IndentedTextWriter writer, Type type, string typeName, (Proper
 
             foreach (var parameter in coveringTypeAndNameMappableConstructorParameters)
             {
-                var propertyName = propertyInformations
+                var propertyName = ownedPropertyInformations
                     .Single(property => ContainedWithinEitherOne(property.propertyName, parameter.Name) && ParameterIsPersuadableIntoPropertyType(property.info, parameter))
                     .lowerCaseName;
 
@@ -254,28 +313,37 @@ private static bool EqualCollectionElementType(Type type1, Type type2)
             || EnumerableTypeArgumentMatchesSecondEnumerableType(type1, type2);
     }
 
-    private static bool ParameterIsPersuadableIntoPropertyType(PropertyInfo property, ParameterInfo parameter)
+    /// <remarks>
+    /// On next major release <paramref name="supportNullableValueTypes"/> should be removed and this should be rewritten to have it always apply.
+    /// </remarks>
+    /// <param name="supportNullableValueTypes">This is introduced as we previously did not support matching on nullable value types. So setting this to <see langword="true"/> would be breaking for most places.</param>
+    private static bool ParameterIsPersuadableIntoPropertyType(PropertyInfo property, ParameterInfo parameter, bool supportNullableValueTypes = false)
     {
         if (EqualCollectionElementType(property.PropertyType, parameter.ParameterType))
         {
             return true;
         }
 
-        if (property.PropertyType != parameter.ParameterType)
-        {
-            return false;
-        }
+        Type propertyType = supportNullableValueTypes && property.PropertyType.IsConstructedGenericType && property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>) ? property.PropertyType.GetGenericArguments()[0] : property.PropertyType;
+        Type parameterType = supportNullableValueTypes && parameter.ParameterType.IsConstructedGenericType && parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable<>) ? parameter.ParameterType.GetGenericArguments()[0] : parameter.ParameterType;
 
         var propertyNullabilityContext = new NullabilityInfoContext().Create(property);
         var parameterNullabilityContext = new NullabilityInfoContext().Create(parameter);
 
-        if (propertyNullabilityContext.WriteState is NullabilityState.Nullable)
+        bool propertyIsNullable = property.PropertyType != propertyType || propertyNullabilityContext.WriteState is NullabilityState.Nullable;
+        bool parameterIsNullable = parameter.ParameterType != parameterType || parameterNullabilityContext.WriteState is NullabilityState.Nullable;
+        
+        if (propertyType != parameterType)
+        {
+            return false;
+        }
+
+        if (propertyIsNullable)
         {
             return true;
         }
 
-        if (propertyNullabilityContext.WriteState is NullabilityState.Nullable
-            == parameterNullabilityContext.WriteState is NullabilityState.Nullable)
+        if (!propertyIsNullable && !parameterIsNullable)
         {
             return true;
         }

Generator/PhpTypeResolver.cs

@@ -1,4 +1,5 @@
 using System.Reflection;
+using System.Text.RegularExpressions;
 
 namespace Generator;
 
@@ -48,12 +49,14 @@ private string GetOrAddTypeDefinition(Type type)
 
     private static string GetTypeName(Type type)
     {
+        var name = Regex.Replace(type.Name, @"`\d+", "");
+
         if (type.IsNested)
         {
-            return type.DeclaringType!.Name + type.Name.Replace("`1", "").Replace("`2", "");
+            return type.DeclaringType!.Name + name;
         }
 
-        return type.Name.Replace("`1", "").Replace("`2", "");
+        return name;
     }
 
     private string AddCollectionTypeDefinition(Type type)

Generator/PhpTypeWriters/PhpClassWriter.cs

@@ -82,7 +82,7 @@ namespace {Constants.Namespace};
         phpWriter.PhpSettablePropertiesWriter.Write(writer, type, ownedProperties);
         phpWriter.PhpStaticReadonlyPropertiesWriter.Write(writer, staticGetterProperties);
 
-        phpWriter.PhpCreatorMethodWriter.Write(writer, type, typeName, ownedProperties);
+        phpWriter.PhpCreatorMethodWriter.Write(writer, type, typeName, settableProperties, ownedProperties);
         phpWriter.PhpHydrationMethodsWriter.Write(writer, type, typeName, ownedProperties);
         phpWriter.PhpPropertySetterMethodsWriter.Write(writer, type, settableProperties);
 

Generator/Program.cs

@@ -18,7 +18,7 @@
 
 var assembly = Assembly.GetAssembly(typeof(ClientBase)) ?? throw new ArgumentException("Could not load Relewise Client assembly.");
 
-var xmlDocumentation = await XMLDocsFetcher.Get("Relewise.Client", "1.130.0");
+var xmlDocumentation = await XMLDocsFetcher.Get("Relewise.Client", "1.156.0");
 
 Console.WriteLine($"Loaded {xmlDocumentation.Summaries.Count} documentation summaries.");
 Console.WriteLine($"Loaded {xmlDocumentation.Params.Count} documentation params.");

Generator/XMLDocsFetcher.cs

@@ -30,7 +30,7 @@ public static async Task<XmlDocumentation> Get(string package, string version)
         var document = await context.OpenAsync(req => req.Content(content.Replace("/>", "></SEE>")));
         foreach (var seeReference in document.QuerySelectorAll("see"))
         {
-            seeReference.OuterHtml = seeReference.GetAttribute("cref")?.Split(".").Last() ?? string.Empty;
+            seeReference.OuterHtml = seeReference.GetAttribute("cref")?.Split(".").Last() ?? seeReference.GetAttribute("langword")?.Split(".").Last() ?? string.Empty;
         }
 
         foreach (var member in document.GetElementsByTagName("doc")[0].Children[1].Children)
@@ -43,11 +43,19 @@ public static async Task<XmlDocumentation> Get(string package, string version)
                     {
                         summaryWrapper.OuterHtml = summaryWrapper.InnerHtml.Trim();
                     }
-                    foreach (var seeReference in child.Children.Where(c => c.TagName == "SEE"))
+                    foreach (var paraWrapper in child.Children.Where(c => c.TagName == "PARA"))
                     {
-                        seeReference.OuterHtml = seeReference.GetAttribute("cref")?.Split(".").Last() ?? string.Empty;
+                        paraWrapper.OuterHtml = paraWrapper.InnerHtml.Trim();
                     }
-                    
+                    foreach (var cWrapper in child.Children.Where(c => c.TagName == "C"))
+                    {
+                        cWrapper.OuterHtml = cWrapper.InnerHtml.Trim();
+                    }
+                    foreach (var exampleWrapper in child.Children.Where(c => c.TagName == "EXAMPLE"))
+                    {
+                        exampleWrapper.OuterHtml = exampleWrapper.InnerHtml.Trim();
+                    }
+
                     result.Summaries.TryAdd(member.GetAttribute("name")!, HttpUtility.HtmlDecode(JoinInOneLine(child.InnerHtml)));
                 }
                 else if (child.TagName is "PARAM" && child.NextSibling?.TextContent is { Length: > 0 } text)

src/Models/AbandonedCartTriggerResultTriggerConfiguration.php

@@ -6,7 +6,7 @@
 
 abstract class AbandonedCartTriggerResultTriggerConfiguration extends TriggerConfiguration
 {
-    public string $typeDefinition = "Relewise.Client.DataTypes.Triggers.Configurations.TriggerConfiguration`1[[Relewise.Client.Responses.Triggers.Results.AbandonedCartTriggerResult, Relewise.Client, Version=1.130.0.0, Culture=neutral, PublicKeyToken=null]], Relewise.Client";
+    public string $typeDefinition = "Relewise.Client.DataTypes.Triggers.Configurations.TriggerConfiguration`1[[Relewise.Client.Responses.Triggers.Results.AbandonedCartTriggerResult, Relewise.Client, Version=1.156.0.0, Culture=neutral, PublicKeyToken=null]], Relewise.Client";
     public static function hydrate(array $arr)
     {
         $type = $arr["\$type"];

src/Models/AbandonedSearchTriggerResultTriggerConfiguration.php

@@ -6,7 +6,7 @@
 
 abstract class AbandonedSearchTriggerResultTriggerConfiguration extends TriggerConfiguration
 {
-    public string $typeDefinition = "Relewise.Client.DataTypes.Triggers.Configurations.TriggerConfiguration`1[[Relewise.Client.Responses.Triggers.Results.AbandonedSearchTriggerResult, Relewise.Client, Version=1.130.0.0, Culture=neutral, PublicKeyToken=null]], Relewise.Client";
+    public string $typeDefinition = "Relewise.Client.DataTypes.Triggers.Configurations.TriggerConfiguration`1[[Relewise.Client.Responses.Triggers.Results.AbandonedSearchTriggerResult, Relewise.Client, Version=1.156.0.0, Culture=neutral, PublicKeyToken=null]], Relewise.Client";
     public static function hydrate(array $arr)
     {
         $type = $arr["\$type"];