feat: enhance compatibility handling for legacy UserDefinedType formatting during comparison

Author: zacateras

CHANGELOG.md

@@ -17,6 +17,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 - Treat equivalent `TableData` scripts as compatible during comparison when the normalized `INSERT` statements differ only by row ordering within the same contiguous data block.
 - Treat equivalent `Table` scripts as compatible during comparison when post-create statement packages differ only by ordering after the base `CREATE TABLE` block.
 - Treat equivalent legacy `Table` statement formatting as compatible during comparison when normalized table definitions, post-create table statements, and persisted option values are otherwise identical.
+- Treat equivalent legacy `UserDefinedType` `CREATE TYPE` formatting as compatible during comparison when the normalized type definition is otherwise identical.
 - Treat omitted `TEXTIMAGE_ON` on `Table` scripts as compatible during comparison only when DB metadata shows the table LOB data space matches the current default data space.
 - Treat equivalent extended-property blocks as compatible during comparison when the normalized `sp_addextendedproperty` statements differ only by ordering, argument spacing, or named-vs-positional argument forms within the same contiguous block.
 - Treat leading SSMS-generated banner comments on programmable objects as compatible during comparison.

specs/01-cli.md

@@ -207,6 +207,7 @@ Behavior:
 - Equivalent `TableData` `INSERT` statement ordering within the same contiguous data block compares as compatible when the inserted row set is otherwise identical.
 - Equivalent `Table` post-create statement package ordering compares as compatible when the normalized package set after the base `CREATE TABLE` block is otherwise identical.
 - Equivalent legacy `Table` statement formatting for `CREATE TABLE`, `ALTER TABLE`, and `CREATE ... INDEX` statements compares as compatible when normalized identifiers, type tokens, default expressions, semicolons, and persisted option values are otherwise identical.
+- Equivalent legacy `UserDefinedType` `CREATE TYPE` statement formatting compares as compatible when normalized identifiers, type tokens, default expressions, semicolons, and inline table-valued type bodies are otherwise identical.
 - For `Table`, omitted `TEXTIMAGE_ON [name]` compares as compatible with an explicit clause only when DB metadata shows that the table LOB data space equals the current default data space represented by `[name]`.
 - Equivalent extended-property statement ordering within the same contiguous extended-property block compares as compatible when the normalized property statement set is otherwise identical. Equivalent named-vs-positional `sp_addextendedproperty` argument forms, including omitted trailing `NULL` levels, compare as compatible.
 - Equivalent `Queue` option spacing, line wrapping, explicit default `ON [PRIMARY]`, and disabled default activation compare as compatible.
@@ -239,6 +240,7 @@ Behavior:
 - Equivalent `TableData` `INSERT` statement ordering within the same contiguous data block compares as compatible when the inserted row set is otherwise identical.
 - Equivalent `Table` post-create statement package ordering compares as compatible when the normalized package set after the base `CREATE TABLE` block is otherwise identical.
 - Equivalent legacy `Table` statement formatting for `CREATE TABLE`, `ALTER TABLE`, and `CREATE ... INDEX` statements compares as compatible when normalized identifiers, type tokens, default expressions, semicolons, and persisted option values are otherwise identical.
+- Equivalent legacy `UserDefinedType` `CREATE TYPE` statement formatting compares as compatible when normalized identifiers, type tokens, default expressions, semicolons, and inline table-valued type bodies are otherwise identical.
 - For `Table`, omitted `TEXTIMAGE_ON [name]` compares as compatible with an explicit clause only when DB metadata shows that the table LOB data space equals the current default data space represented by `[name]`.
 - Equivalent extended-property statement ordering within the same contiguous extended-property block compares as compatible when the normalized property statement set is otherwise identical. Equivalent named-vs-positional `sp_addextendedproperty` argument forms, including omitted trailing `NULL` levels, compare as compatible.
 - Equivalent `Queue` option spacing, line wrapping, explicit default `ON [PRIMARY]`, and disabled default activation compare as compatible.

specs/04-scripting.md

@@ -820,6 +820,7 @@ When compatibility reference files are available, `sqlct` MAY apply reconciliati
 - For `TableData`, comparison normalization MAY treat reordered `INSERT ... VALUES (...)` statements within the same contiguous data block as compatible when the normalized inserted-row set is otherwise identical.
 - For `Table`, comparison normalization MAY treat reordered post-create statement packages as compatible when the normalized package set after the base table `CREATE` block is otherwise identical. Table-scoped trigger packages MUST include the trigger body together with any immediately preceding programmable-object `SET` blocks.
 - For `Table`, comparison normalization MAY treat equivalent legacy formatting for `CREATE TABLE`, `ALTER TABLE`, and `CREATE ... INDEX` statement blocks as compatible when normalized identifiers, type tokens, default expressions, semicolons, and persisted option values are otherwise identical.
+- For `UserDefinedType`, comparison normalization MAY treat equivalent legacy `CREATE TYPE` statement formatting as compatible when normalized identifiers, type tokens, default expressions, semicolons, and inline table-valued type bodies are otherwise identical.
 - For `Table`, comparison normalization MAY treat omitted `TEXTIMAGE_ON [name]` as compatible with an explicit clause only when DB metadata shows that the table `lob_data_space_id` resolves to the current default data space named `[name]`; otherwise omission remains a semantic difference.
 - For extended-property blocks, comparison normalization MAY treat reordered `EXEC sp_addextendedproperty ...` statements as compatible within the same contiguous extended-property block when the normalized property statement set is otherwise identical, MAY ignore equivalent spacing around commas and arguments in those statements, and MAY treat equivalent named-vs-positional argument forms with omitted trailing `NULL` levels as compatible.
 - For programmable `StoredProcedure`, `View`, `Function`, and `Trigger` scripts, comparison normalization MAY ignore leading SSMS-generated `/*** Object: ... Script Date: ... ***/` banner comments.

src/SqlChangeTracker/Sync/SyncCommandService.cs

@@ -2110,6 +2110,10 @@ internal static string NormalizeForComparison(
                 compatibleOmittedTextImageOnDataSpaceName);
             joined = NormalizeTableScriptForComparison(joined);
         }
+        else if (string.Equals(objectType, "UserDefinedType", StringComparison.OrdinalIgnoreCase))
+        {
+            joined = NormalizeUserDefinedTypeScriptForComparison(joined);
+        }
 
         if (!joined.Contains("INSERT ", StringComparison.OrdinalIgnoreCase))
         {
@@ -2693,6 +2697,24 @@ private static string NormalizeTablePostCreatePackageForComparison(string packag
         return NormalizeTableBlockForComparison(blocks[0]);
     }
 
+    private static string NormalizeUserDefinedTypeScriptForComparison(string script)
+    {
+        var blocks = SplitGoDelimitedBlocks(script);
+        for (var i = 0; i < blocks.Count; i++)
+        {
+            var firstLine = GetFirstMeaningfulLine(blocks[i]);
+            if (firstLine is null ||
+                !firstLine.StartsWith("CREATE TYPE", StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            blocks[i] = [NormalizeLegacyTableStatementBlockForComparison(blocks[i])];
+        }
+
+        return string.Join("\n", blocks.SelectMany(block => block));
+    }
+
     private static string NormalizeLegacyTableStatementBlockForComparison(IEnumerable<string> block)
     {
         var statement = string.Join(

tests/SqlChangeTracker.Tests/Sync/SyncCommandServiceTests.cs

@@ -1615,6 +1615,31 @@ public void BuildUnifiedDiff_Table_SuppressesEquivalentLegacyTableFormattingDiff
         Assert.Empty(diff);
     }
 
+    [Fact]
+    public void BuildUnifiedDiff_UserDefinedType_SuppressesEquivalentLegacyTableValuedTypeFormattingDifferences()
+    {
+        var source =
+            "CREATE TYPE [Accounting].[RateWindow] AS TABLE\n" +
+            "(\n" +
+            "[EffectiveDate] [date] NOT NULL,\n" +
+            "[RateValue] [decimal] (15, 8) NOT NULL,\n" +
+            "[YearFraction] [decimal] (15, 12) NOT NULL\n" +
+            ")\n" +
+            "GO";
+        var target =
+            "CREATE TYPE Accounting.RateWindow AS TABLE\n" +
+            "(\n" +
+            "       [EffectiveDate] DATE NOT NULL,\n" +
+            "       RateValue DECIMAL(15,8) NOT NULL,\n" +
+            "       YearFraction Decimal(15,12) NOT NULL\n" +
+            ");\n" +
+            "GO";
+
+        var diff = SyncCommandService.BuildUnifiedDiff("UserDefinedType", "db", "folder", source, target);
+
+        Assert.Empty(diff);
+    }
+
     [Fact]
     public void BuildUnifiedDiff_Table_PreservesPostCreatePackageContentDifferencesWhenOrderAlsoDiffers()
     {