RPC peers: emit empty arrays for descriptor collections, never omit them (#7546)

* RPC peers: emit empty arrays for descriptor collections, never omit them

`Recipe.getDescriptor()` on the Java side always returns a descriptor
whose collection-valued getters (`tags`, `options`, `preconditions`,
`recipeList`, `dataTables`, `maintainers`, `contributors`, `examples`)
are non-null. Callers across the ecosystem rely on that and iterate the
getters without null checks.

When a `RecipeDescriptor` is produced by a polyglot RPC peer, however,
the JSON those peers emit can omit empty collections — Jackson then
deserializes the corresponding fields as `null`, breaking every
downstream caller (e.g. `descriptor.getPreconditions().iterator()`).

Fix the Python and TypeScript peers to always emit every collection key,
even when empty. The C# peer was already correct: `RecipeDescriptorDto`
declares each list/set property with an `= []` initializer and
Newtonsoft serializes empty collections as `[]`, so the JSON it produces
already matches the contract.

Python (`rewrite/src/rewrite/rpc/server.py`):
  Add `preconditions`, `maintainers`, `contributors`, `examples` as
  empty lists in `_recipe_descriptor_to_dict`. (The Python `RecipeDescriptor`
  dataclass doesn't model these fields yet, so they're hardcoded.)

TypeScript (`rewrite/src/recipe.ts`):
  Extend the `RecipeDescriptor` interface with the four missing fields
  and have `Recipe.descriptor()` populate them. Updates the existing
  `recipe.test.ts` snapshot.

* Update recipe.ts

* Update server.py

* Update test_server.py

Author: jkschneider

rewrite-javascript/rewrite/src/recipe.ts

@@ -96,14 +96,18 @@ export abstract class Recipe {
             description: this.description,
             tags: this.tags,
             estimatedEffortPerOccurrence: this.estimatedEffortPerOccurrence,
-            recipeList: await mapAsync(await this.recipeList(), async r => r.descriptor()),
             options: Object.entries(optionsRecord).map(([key, descriptor]) => ({
                 name: key,
                 value: (this as any)[key],
                 required: descriptor.required ?? true,
                 ...descriptor
             })),
-            dataTables: this.dataTables
+            preconditions: [],
+            recipeList: await mapAsync(await this.recipeList(), async r => r.descriptor()),
+            dataTables: this.dataTables,
+            maintainers: [],
+            contributors: [],
+            examples: []
         }
     }
 
@@ -135,9 +139,13 @@ export interface RecipeDescriptor {
     readonly description: string
     readonly tags: string[]
     readonly estimatedEffortPerOccurrence: Minutes
-    readonly recipeList: RecipeDescriptor[]
     readonly options: ({ name: string, value?: any } & OptionDescriptor)[]
+    readonly preconditions: RecipeDescriptor[]
+    readonly recipeList: RecipeDescriptor[]
     readonly dataTables: DataTableDescriptor[]
+    readonly maintainers: any[]
+    readonly contributors: any[]
+    readonly examples: any[]
 }
 
 export interface OptionDescriptor {

rewrite-javascript/rewrite/test/recipe.test.ts

@@ -43,9 +43,13 @@ describe("recipes", () => {
                     value: undefined
                 }
             ],
+            preconditions: [],
             recipeList: [],
             tags: [],
-            dataTables: []
+            dataTables: [],
+            maintainers: [],
+            contributors: [],
+            examples: []
         });
     });
 });

rewrite-python/rewrite/src/rewrite/rpc/server.py

@@ -971,8 +971,12 @@ def _recipe_descriptor_to_dict(descriptor) -> dict:
             }
             for name, value, opt in descriptor.options
         ],
-        'dataTables': descriptor.data_tables,
+        'preconditions': [],
         'recipeList': [_recipe_descriptor_to_dict(r) for r in descriptor.recipe_list],
+        'dataTables': descriptor.data_tables,
+        'maintainers': [],
+        'contributors': [],
+        'examples': [],
     }
 
 

rewrite-python/rewrite/tests/rpc/test_server.py

@@ -24,3 +24,26 @@ def fake_parse_python_source(source, path="<unknown>", relative_to=None, ty_clie
     assert observed["source"] == ""
     assert observed["path"] == str(tmp_path / "pkg" / "__init__.py")
     assert (tmp_path / "pkg" / "__init__.py").read_text(encoding="utf-8") == ""
+
+
+def test_recipe_descriptor_to_dict_emits_all_collection_keys():
+    from rewrite.recipe import RecipeDescriptor
+    from rewrite.rpc.server import _recipe_descriptor_to_dict
+
+    descriptor = RecipeDescriptor(
+        name="org.example.Foo",
+        display_name="Foo",
+        description="A recipe.",
+        tags=[],
+        estimated_effort_per_occurrence=0,
+        options=[],
+        data_tables=[],
+        recipe_list=[],
+    )
+
+    result = _recipe_descriptor_to_dict(descriptor)
+
+    for key in ("tags", "options", "preconditions", "recipeList",
+                "dataTables", "maintainers", "contributors", "examples"):
+        assert key in result, f"missing key: {key}"
+        assert result[key] == [], f"{key} should be empty list, got {result[key]!r}"