feat: #622 add ability to generate arbitrary metadata into metadata.g.ts

Author: ascott18

CHANGELOG.md

@@ -1,6 +1,7 @@
-# 6.3.1
+# 6.4.0
 - Added `app.UseAppVersionHeader()` middleware and `<CAppUpdateAlert>` component for detecting and notifying users when a new version of the application has been deployed.
 - Assorted template improvements
+- Added `[attribute: CoalesceMetadata<TAttribute>]`, an assembly-level attribute that causes any occurrences of the target attribute and its value to be generated into the TypeScript metadata.
 
 # 6.3.0
 - Added Vuetify 4 compatibility to coalesce-vue-vuetify3.

docs/modeling/model-components/attributes/coalesce-metadata.md

@@ -0,0 +1,60 @@
+
+# [CoalesceMetadata]
+
+`IntelliTect.Coalesce.DataAnnotations.CoalesceMetadataAttribute`
+
+Placed on an assembly, specifies an attribute type whose values should be extracted from any Coalesce-generated types, properties, methods, and parameters, and emitted into the generated TypeScript metadata.
+
+The extracted attribute values are available in the `attributes` property of the corresponding metadata object in `metadata.g.ts`.
+
+## Example Usage
+
+Register the attribute type at the assembly level in your data project (e.g. in any `.cs` file):
+
+```c#
+[assembly: CoalesceMetadata<System.ComponentModel.CategoryAttribute>]
+```
+
+Then use the attribute on your models:
+
+```c#
+[Category("people")]
+public class Person
+{
+    [Category("contact")]
+    public string? Email { get; set; }
+
+    [Category("contact")]
+    public string? Phone { get; set; }
+
+    [return: Category("action")]
+    public ItemResult ChangeSpaces(string newSpaces) { ... }
+}
+```
+
+## Properties
+
+<Prop def="Type AttributeType" />
+
+The attribute type whose values should be extracted and emitted into metadata. All constructor arguments and explicitly-set named properties on the attribute will be included.
+
+<Prop def="string? Key" />
+
+The key name to use in the generated metadata. If not specified, the attribute type name is used with the `Attribute` suffix removed and camelCased (e.g. `FeatureFlagAttribute` → `featureFlag`).
+
+## Output Format
+
+- **Parameterless attributes**: Emitted as an empty object `{}`.
+- **All other attributes**: Emitted as an object with camelCased property names.
+
+Supported value types include strings, numbers, booleans, enums (emitted as their string representation), and arrays of these types.
+
+## TypeScript Type
+
+The `attributes` property is available on all metadata interfaces:
+
+```ts
+readonly attributes?: {
+  readonly [key: string]: { readonly [key: string]: unknown }
+}
+```

playground/Coalesce.Domain/AppDbContext.cs

@@ -1,11 +1,13 @@
 using IntelliTect.Coalesce;
 using IntelliTect.Coalesce.AuditLogging;
+using IntelliTect.Coalesce.DataAnnotations;
 using Microsoft.EntityFrameworkCore;
 using System;
 using System.Linq;
 using System.Security.Cryptography;
 
 // [assembly: CoalesceConfiguration(NoAutoInclude = true)]
+[assembly: CoalesceMetadata<Coalesce.Domain.FeatureFlagAttribute>]
 
 namespace Coalesce.Domain;
 

playground/Coalesce.Domain/FeatureFlagAttribute.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace Coalesce.Domain;
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Method)]
+public class FeatureFlagAttribute : Attribute
+{
+    public string Flag { get; }
+
+    public FeatureFlagAttribute(string flag)
+    {
+        Flag = flag;
+    }
+}

playground/Coalesce.Domain/Person.cs

@@ -70,6 +70,7 @@ public enum Titles
     /// <summary>
     /// Email address of the person
     /// </summary>
+    [FeatureFlag("new-email-validation")]
     [ClientValidation(IsEmail = true)]
     [DataType(DataType.EmailAddress)]
     [EmailAddress]

playground/Coalesce.Web.Vue3/src/metadata.g.ts

@@ -137,6 +137,7 @@ private void WriteCommonClassMetadata(TypeScriptCodeBuilder b, ClassViewModel mo
             }
             b.Line("]},");
         }
+        WriteCustomMetadata(b, model);
     }
 
     private void WriteExternalTypeMetadata(TypeScriptCodeBuilder b, ClassViewModel model)
@@ -198,6 +199,8 @@ private void WriteEnumMetadata(TypeScriptCodeBuilder b, TypeViewModel model)
                 }
             }
             b.Line("]),");
+
+            WriteCustomMetadata(b, model);
         }
     }
 
@@ -548,6 +551,8 @@ private void WriteClassMethodMetadata(TypeScriptCodeBuilder b, ClassViewModel mo
             b.StringProp("transportType", method.TransportType.ToString().Replace("Result", "").ToLower());
             b.StringProp("httpMethod", method.ApiActionHttpMethod.ToString().ToUpperInvariant());
 
+            WriteCustomMetadata(b, method);
+
 
             int hiddenAreaFlags = (int)method.HiddenAreas;
             if (hiddenAreaFlags != 0)
@@ -666,6 +671,7 @@ private void WriteValueCommonMetadata(TypeScriptCodeBuilder b, ValueViewModel va
         }
 
         WriteTypeCommonMetadata(b, value.Type, value);
+        WriteCustomMetadata(b, value);
     }
 
     /// <summary>
@@ -788,4 +794,39 @@ private void WriteTypeCommonMetadata(TypeScriptCodeBuilder b, TypeViewModel type
                 break;
         }
     }
+
+    private void WriteCustomMetadata(TypeScriptCodeBuilder b, IAttributeProvider provider)
+    {
+        var entries = provider.GetCustomMetadata();
+        if (!entries.Any()) return;
+
+        using (b.Block("attributes:", ','))
+        {
+            foreach (var entry in entries)
+            {
+                using (b.Block($"{entry.Key}:", ','))
+                {
+                    foreach (var (propName, propValue) in entry.Properties)
+                    {
+                        b.Prop(propName.ToCamelCase(), ValueToJsLiteral(propValue));
+                    }
+                }
+            }
+        }
+    }
+
+    private static string ValueToJsLiteral(object value) => value switch
+    {
+        null => "null",
+        true => "true",
+        false => "false",
+        string s => $"\"{s.EscapeStringLiteralForTypeScript()}\"",
+        int or long or short or byte or sbyte or uint or ulong or ushort => value.ToString(),
+        float f => f.ToString(System.Globalization.CultureInfo.InvariantCulture),
+        double d => d.ToString(System.Globalization.CultureInfo.InvariantCulture),
+        decimal m => m.ToString(System.Globalization.CultureInfo.InvariantCulture),
+        TypeViewModel tv => $"\"{tv.FullyQualifiedName.EscapeStringLiteralForTypeScript()}\"",
+        object[] arr => $"[{string.Join(", ", arr.Select(ValueToJsLiteral))}]",
+        _ => $"\"{value.ToString().EscapeStringLiteralForTypeScript()}\""
+    };
 }

src/IntelliTect.Coalesce.CodeGeneration.Vue/Generators/Scripts/TsMetadata.cs

@@ -0,0 +1,23 @@
+using IntelliTect.Coalesce.DataAnnotations;
+using System;
+using System.ComponentModel.DataAnnotations;
+
+[assembly: CoalesceMetadata<IntelliTect.Coalesce.Testing.TargetClasses.CustomMetadataTargetAttribute>]
+[assembly: CoalesceMetadata<IntelliTect.Coalesce.Testing.TargetClasses.CustomMetadataMarkerAttribute>]
+
+namespace IntelliTect.Coalesce.Testing.TargetClasses;
+
+[AttributeUsage(AttributeTargets.All)]
+public class CustomMetadataTargetAttribute : Attribute
+{
+    public string Name { get; }
+    public int Value { get; set; }
+
+    public CustomMetadataTargetAttribute(string name)
+    {
+        Name = name;
+    }
+}
+
+[AttributeUsage(AttributeTargets.All)]
+public class CustomMetadataMarkerAttribute : Attribute { }

src/IntelliTect.Coalesce.Testing/TargetClasses/CustomMetadataAttributes.cs

@@ -16,6 +16,7 @@
 namespace IntelliTect.Coalesce.Testing.TargetClasses.TestDbContext;
 
 [SemanticKernel("ComplexModel", DeleteEnabled = true, SaveEnabled = true)]
+[CustomMetadataTarget("ClassLevel", Value = 42)]
 public class ComplexModel
 {
     [Coalesce]
@@ -54,6 +55,8 @@ public class ComplexModel
     public EnumPk EnumPk { get; set; }
 
     [Search]
+    [CustomMetadataTarget("PropLevel")]
+    [CustomMetadataMarker]
     public DateTimeOffset DateTimeOffset { get; set; }
 
     public DateTimeOffset? DateTimeOffsetNullable { get; set; }
@@ -190,11 +193,12 @@ This is a second line in the string.
     // Add other kinds of properties, relationships, etc... as needed.
 
     [Coalesce, Execute]
+    [CustomMetadataTarget("MethodLevel", Value = 99)]
     public ExternalParent MethodWithManyParams(
         ExternalParent singleExternal,
         ICollection<ExternalParent> collectionExternal,
         IFile file,
-        string strParam,
+        [CustomMetadataTarget("ParamLevel")] string strParam,
         string[] stringsParam,
         DateTime dateTime,
         int integer,

src/IntelliTect.Coalesce.Testing/TargetClasses/TestDbContext/ComplexModel.cs

@@ -0,0 +1,78 @@
+using IntelliTect.Coalesce.Testing.TargetClasses.TestDbContext;
+using IntelliTect.Coalesce.Testing.Util;
+using IntelliTect.Coalesce.TypeDefinition;
+
+namespace IntelliTect.Coalesce.Tests.TypeDefinition;
+
+public class CustomMetadataProviderTests
+{
+    [Test]
+    [ClassViewModelData(typeof(ComplexModel))]
+    public async Task ClassLevel_ExtractsConstructorAndNamedArgs(ClassViewModelData data)
+    {
+        ClassViewModel vm = data;
+        var results = vm.GetCustomMetadata().ToList();
+
+        await Assert.That(results).Count().IsEqualTo(1);
+        await Assert.That(results[0].Key).IsEqualTo("customMetadataTarget");
+        await Assert.That(results[0].Properties.Any(kv =>
+            string.Equals(kv.Key, "name", StringComparison.OrdinalIgnoreCase)
+            && (string)kv.Value! == "ClassLevel")).IsTrue();
+        await Assert.That(results[0].Properties.Any(kv =>
+            string.Equals(kv.Key, "value", StringComparison.OrdinalIgnoreCase)
+            && kv.Value is int and 42)).IsTrue();
+    }
+
+    [Test]
+    [ClassViewModelData(typeof(ComplexModel))]
+    public async Task PropertyLevel_ExtractsMultipleAttributes(ClassViewModelData data)
+    {
+        ClassViewModel vm = data;
+        var results = vm.PropertyByName(nameof(ComplexModel.DateTimeOffset))!
+            .GetCustomMetadata().ToList();
+
+        await Assert.That(results).Count().IsEqualTo(2);
+
+        var target = results.Single(r => r.Key == "customMetadataTarget");
+        await Assert.That(target.Properties.Any(kv =>
+            string.Equals(kv.Key, "name", StringComparison.OrdinalIgnoreCase)
+            && (string)kv.Value! == "PropLevel")).IsTrue();
+
+        var marker = results.Single(r => r.Key == "customMetadataMarker");
+        await Assert.That(marker.Properties).IsEmpty();
+    }
+
+    [Test]
+    [ClassViewModelData(typeof(ComplexModel))]
+    public async Task MethodLevel_ExtractsAttributes(ClassViewModelData data)
+    {
+        ClassViewModel vm = data;
+        var results = vm.MethodByName(nameof(ComplexModel.MethodWithManyParams))!
+            .GetCustomMetadata().ToList();
+
+        await Assert.That(results).Count().IsEqualTo(1);
+        await Assert.That(results[0].Key).IsEqualTo("customMetadataTarget");
+        await Assert.That(results[0].Properties.Any(kv =>
+            string.Equals(kv.Key, "name", StringComparison.OrdinalIgnoreCase)
+            && (string)kv.Value! == "MethodLevel")).IsTrue();
+        await Assert.That(results[0].Properties.Any(kv =>
+            string.Equals(kv.Key, "value", StringComparison.OrdinalIgnoreCase)
+            && kv.Value is int and 99)).IsTrue();
+    }
+
+    [Test]
+    [ClassViewModelData(typeof(ComplexModel))]
+    public async Task ParameterLevel_ExtractsAttributes(ClassViewModelData data)
+    {
+        ClassViewModel vm = data;
+        var results = vm.MethodByName(nameof(ComplexModel.MethodWithManyParams))!
+            .Parameters.Single(p => p.Name == "strParam")
+            .GetCustomMetadata().ToList();
+
+        await Assert.That(results).Count().IsEqualTo(1);
+        await Assert.That(results[0].Key).IsEqualTo("customMetadataTarget");
+        await Assert.That(results[0].Properties.Any(kv =>
+            string.Equals(kv.Key, "name", StringComparison.OrdinalIgnoreCase)
+            && (string)kv.Value! == "ParamLevel")).IsTrue();
+    }
+}