fix: update operator $setOnInsert not working

Author: princecodes247

src/schema/type-helpers.ts

@@ -214,7 +214,7 @@ type UpdateOperators<TSchema extends AnySchema, T extends KV<any, any>> = {
   $mul?: PrettyNonEmpty<MapKVUpdateEnhanced<T, NumericType>>;
   $rename?: PrettyNonEmpty<MapKVUpdateRename<T>>;
   $set?: PrettyNonEmpty<MapKVUpdate<T>>;
-  $setOnInsert?: InferSchemaInput<TSchema>;
+  $setOnInsert?: PrettyNonEmpty<MapKVUpdate<T>>;
   $unset?: PrettyNonEmpty<MapKVUpdateUnset<T>>;
   $addToSet?: PrettyNonEmpty<MapKVUpdateAddToSet<T>>;
   $pop?: PrettyNonEmpty<MapKVUpdateEnhanced<T, MonarchArray<any>, 1 | -1>>;

src/schema/update.ts

@@ -11,6 +11,7 @@ import {
   MonarchNullable,
   MonarchNumber,
   MonarchOptional,
+  MonarchObject,
   MonarchType,
   type AnyMonarchType,
 } from "../types";
@@ -83,7 +84,10 @@ export function updateParser<T extends AnyMonarchType>(
 
   // Upsert update: parse and flatten full document
   if (setOnInsertSkipSet) {
-    input.$setOnInsert = parseSetOnInsertOperator(schemaType, update.$setOnInsert ?? {}, setOnInsertSkipSet);
+    const setOnInsert = parseSetOnInsertOperator(schemaType, update.$setOnInsert ?? {}, setOnInsertSkipSet);
+    if (Object.keys(setOnInsert).length > 0) {
+      input.$setOnInsert = setOnInsert;
+    }
   }
 
   return input;
@@ -104,7 +108,7 @@ function unwrapTo<T extends new (...args: any) => AnyMonarchType>(
 }
 
 function parseFieldsOperator(
-  op: "$set" | "$min" | "$max",
+  op: "$set" | "$min" | "$max" | "$setOnInsert",
   schemaType: AnyMonarchType,
   fields: Record<string, unknown>,
   schemaUpdates?: Map<string, { op: string; value: any }>,
@@ -147,7 +151,7 @@ function parseArrayOperator(
       const elementType = MonarchArray.type(arrayType);
       const parser = MonarchType.parser(elementType, path);
       if (typeof value === "object" && value !== null && "$each" in value) {
-        const ops = value as { $each: unknown[]; [k: string]: unknown };
+        const ops = value as { $each: unknown[];[k: string]: unknown };
         parsed[path] = { ...ops, $each: ops.$each.map(parser) };
       } else {
         parsed[path] = parser(value);
@@ -390,8 +394,12 @@ function parseSetOnInsertOperator(
   setOnInsertSkipSet: Set<string>,
 ) {
   try {
-    const parser = MonarchType.parser(schemaType);
-    return flattenObject(parser(fields), setOnInsertSkipSet);
+    const flatFields = flattenObject(fields, setOnInsertSkipSet);
+    const defaults = schemaType.getDefaults();
+    const flatDefaults = defaults ? flattenObject(defaults, setOnInsertSkipSet) : {};
+
+    const combinedFields = { ...flatDefaults, ...flatFields };
+    return parseFieldsOperator("$setOnInsert", schemaType, combinedFields, undefined, setOnInsertSkipSet);
   } catch (error) {
     throw MonarchParseError.fromCause({ path: "$setOnInsert", cause: error });
   }

src/types/object.ts

@@ -42,6 +42,15 @@ export class MonarchObject<T extends Record<string, AnyMonarchType>> extends Mon
     return new MonarchObject(this.shape);
   }
 
+  public getDefaults(): any {
+    const obj: any = {};
+    for (const [key, type] of Object.entries(this.shape)) {
+      const def = (type as AnyMonarchType).getDefaults();
+      if (def !== undefined) obj[key] = def;
+    }
+    return Object.keys(obj).length > 0 ? obj : undefined;
+  }
+
   protected index(path: string[], depth: number): AnyMonarchType {
     if (depth === path.length - 1) return this;
     const key = path[depth + 1];

src/types/tuple.ts

@@ -49,6 +49,16 @@ export class MonarchTuple<T extends [AnyMonarchType, ...AnyMonarchType[]]> exten
     return new MonarchTuple(this.types);
   }
 
+  public getDefaults(): any {
+    const arr: any[] = [];
+    for (const type of this.types) {
+      const def = type.getDefaults();
+      if (def === undefined) return undefined;
+      arr.push(def);
+    }
+    return arr;
+  }
+
   protected index(path: string[], depth: number): AnyMonarchType {
     if (depth === path.length - 1) return this;
     const index = path[depth + 1];

src/types/type.ts

@@ -216,6 +216,15 @@ export abstract class MonarchType<TInput, TOutput extends TInput = TInput> {
     return defaulted(this, defaultInput as InferTypeInput<this> | (() => InferTypeInput<this>));
   }
 
+  /**
+   * Evaluates and returns the default values for this type.
+   * If the type is an object, it recursively evaluates all nested defaults.
+   * Returns undefined if the type has no defaults.
+   */
+  public getDefaults(): any {
+    return undefined;
+  }
+
   /**
    * Validate input.
    *
@@ -309,6 +318,10 @@ export class MonarchNullable<T extends AnyMonarchType> extends MonarchType<
     return this instanceof target || MonarchType.isInstanceOf(this.type, target);
   }
 
+  public getDefaults(): any {
+    return this.type.getDefaults();
+  }
+
   public static type<T extends AnyMonarchType>(nullable: MonarchNullable<T>): T {
     return nullable.type;
   }
@@ -354,6 +367,10 @@ export class MonarchOptional<T extends AnyMonarchType> extends MonarchType<
     return this instanceof target || MonarchType.isInstanceOf(this.type, target);
   }
 
+  public getDefaults(): any {
+    return this.type.getDefaults();
+  }
+
   public static type<T extends AnyMonarchType>(optional: MonarchOptional<T>): T {
     return optional.type;
   }
@@ -409,6 +426,10 @@ export class MonarchDefaulted<T extends AnyMonarchType> extends MonarchType<
     return this instanceof target || MonarchType.isInstanceOf(this.type, target);
   }
 
+  public getDefaults(): any {
+    return MonarchDefaulted.isDefaultFunction(this.defaultInput) ? this.defaultInput() : this.defaultInput;
+  }
+
   public static type<T extends AnyMonarchType>(defaulted: MonarchDefaulted<T>): T {
     return defaulted.type;
   }

tests/query/update.test.ts

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
 import { createDatabase, createSchema, defineSchemas } from "../../src";
-import { array, boolean, date, mixed, number, string } from "../../src/types";
+import { array, boolean, date, literal, mixed, number, object, string, tuple } from "../../src/types";
 import { createMockDatabase, mockUsers } from "../mock";
 
 describe("Update Operations", async () => {
@@ -799,6 +799,7 @@ describe("Update Operations", async () => {
       count: number(),
       tags: array(string()),
       alias: string().optional(),
+      pair: tuple([string().default("X"), number().default(99)]).optional(),
     });
 
     const db = createDatabase(client.db(), defineSchemas({ UpsertSchema }));
@@ -831,13 +832,22 @@ describe("Update Operations", async () => {
       expect(result?.count).toBe(0);
     });
 
-    it("$setOnInsert fields fails validation when upsert is true", async () => {
-      await expect(
-        db.collections.docs
-          // @ts-expect-error
-          .findOneAndUpdate({ name: "ghost" }, { $set: { name: "alice" }, $setOnInsert: { count: 1 } })
-          .options({ upsert: true }),
-      ).rejects.toThrow("$setOnInsert.name: expected 'string' received 'undefined'");
+    it("$setOnInsert allows partial fields and generates defaults when upsert is true", async () => {
+      const result = await db.collections.docs
+        .findOneAndUpdate({ name: "ghost" }, { $set: { name: "alice" }, $setOnInsert: { count: 1 } })
+        .options({ upsert: true, returnDocument: "after" });
+
+      expect(result?.name).toBe("alice");
+      expect(result?.count).toBe(1);
+    });
+
+    it("$setOnInsert safely generates default structures for tuples when upserting", async () => {
+      const result = await db.collections.docs
+        .findOneAndUpdate({ name: "ghost" }, { $set: { name: "alice" }, $setOnInsert: { count: 1 } })
+        .options({ upsert: true, returnDocument: "after" });
+
+      expect(result?.name).toBe("alice");
+      expect(result?.pair).toEqual(["X", 99]);
     });
   });
 });