fix: remove double dto mapping from save calls

Author: ascott18

src/coalesce-vue/src/api-client.ts

@@ -19,6 +19,7 @@ import type {
   CollectionValue,
   ItemMethod,
   ListMethod,
+  MethodParameter,
   TypeDiscriminatorToType,
   PropNames,
 } from "./metadata.js";
@@ -1326,20 +1327,28 @@ export class ModelApiClient<TModel extends Model<ModelType>> extends ApiClient<
   ): ItemResultPromise<TModel> {
     const { fields, ...params } = parameters ?? new SaveParameters<TModel>();
 
-    const paramsMeta = Object.fromEntries([
-      [
-        "$type",
-        {
-          type: "string",
-          name: "$type",
-          displayName: "$type",
+    // The item is fully serialized to a DTO here (respecting `fields` for
+    // surgical saves). Declare the resulting fields as passthrough `unknown`
+    // params so that `getRequestBody` does not serialize them a *second* time.
+    // A double serialization is not idempotent for polymorphic child objects
+    // (their type discriminator is a `$type` string once serialized, not a
+    // `$metadata` reference), which would downgrade them to their base type.
+    const dto = mapToDtoFiltered(item, fields)!;
+
+    // Order the params by `$type` (if present) followed by metadata declaration
+    // order so that the serialized request body's field order is stable and
+    // matches what it was when each field was individually re-serialized.
+    const paramsMeta: { [name: string]: MethodParameter } = {};
+    for (const name of ["$type", ...Object.keys(this.$metadata.props)]) {
+      if (name in dto) {
+        paramsMeta[name] = {
+          type: "unknown",
+          name,
+          displayName: name,
           role: "value",
-        },
-      ],
-      ...Object.entries(this.$metadata.props).filter(
-        (p) => !p[1].dontSerialize,
-      ),
-    ]);
+        };
+      }
+    }
 
     return this.$invoke(
       {
@@ -1350,7 +1359,7 @@ export class ModelApiClient<TModel extends Model<ModelType>> extends ApiClient<
         params: paramsMeta,
         return: this.$itemValueMeta,
       },
-      mapToDtoFiltered(item, fields)!,
+      dto,
       config,
       params,
     );

src/coalesce-vue/src/model.ts

@@ -595,10 +595,10 @@ class MapToDtoVisitor extends Visitor<
 
     if ("derivedTypes" in meta || "baseTypes" in meta) {
       meta =
-        value.$metadata ??
+        value.$metadata ||
         // Fall back to checking the object's $type, in case its getting double-mapped.
         ("derivedTypes" in meta &&
-          meta.derivedTypes?.find((t) => t.name == value.$type)) ??
+          meta.derivedTypes?.find((t) => t.name == value.$type)) ||
         meta;
       output.$type = meta.name;
     }

src/coalesce-vue/test/model.toDto.spec.ts

@@ -246,4 +246,32 @@ describe("mapToDto", () => {
       impl1OnlyField: "hello",
     });
   });
+
+  test("is idempotent for a leaf type mapped against its own (concrete) metadata", () => {
+    // The concrete leaf metadata has `baseTypes` but no `derivedTypes`. The type
+    // resolution fallback must handle this without corrupting `meta` when the
+    // value has no `$metadata` reference (i.e. it's already a DTO).
+    const implValue = {
+      name: "model",
+      displayName: "Model",
+      type: "model",
+      role: "value",
+      typeDef: $metadata.AbstractImpl1,
+    } as any;
+
+    const once = model.mapToDto(
+      new AbstractImpl1({ id: 1, impl1OnlyField: "hello" }),
+      implValue,
+    ) as any;
+    expect(once).toMatchObject({
+      $type: "AbstractImpl1",
+      impl1OnlyField: "hello",
+    });
+
+    const twice = model.mapToDto(once, implValue) as any;
+    expect(twice).toMatchObject({
+      $type: "AbstractImpl1",
+      impl1OnlyField: "hello",
+    });
+  });
 });

src/coalesce-vue/test/viewmodel.inheritance.spec.ts

@@ -114,6 +114,28 @@ describe("ViewModel", () => {
 
     echoEndpoint.destroy();
   });
+
+  test("$save of a derived type sends its discriminator and derived props", async () => {
+    // The save pipeline serializes the model to a DTO once (mapToDtoFiltered) and
+    // must not serialize it a second time in getRequestBody, which would downgrade
+    // a polymorphic model to its base type and drop derived-only props.
+    const saveEndpoint = mockEndpoint(
+      "/AbstractImpl1/save",
+      vitest.fn((req) => ({ wasSuccessful: true, object: null })),
+    );
+
+    const vm = new AbstractImpl1ViewModel({ id: 1, impl1OnlyField: "hello" });
+    vm.$setPropDirty("impl1OnlyField");
+    await vm.$save();
+
+    expect(JSON.parse(saveEndpoint.mock.calls[0][0].data)).toMatchObject({
+      $type: "AbstractImpl1",
+      id: 1,
+      impl1OnlyField: "hello",
+    });
+
+    saveEndpoint.destroy();
+  });
 });
 
 describe("abstract loader", () => {