+40 -14

model/core.ts

··· 17 17 UpdateResult, 18 18 WithId, 19 19 BulkWriteOptions, 20 20 + UpdateFilter, 20 21 } from "mongodb"; 21 22 import { ObjectId } from "mongodb"; 22 23 import type { Schema, Infer, Input } from "../types.ts"; 23 23 - import { parse, parsePartial, parseReplace } from "./validation.ts"; 24 24 + import { parse, parsePartial, parseReplace, applyDefaultsForUpsert } from "./validation.ts"; 24 25 25 26 /** 26 27 * Core CRUD operations for the Model class ··· 125 126 /** 126 127 * Update multiple documents matching the query 127 128 * 129 129 + * Case handling: 130 130 + * - If upsert: false (or undefined) → Normal update, no defaults applied 131 131 + * - If upsert: true → Defaults added to $setOnInsert for new document creation 132 132 + * 128 133 * @param collection - MongoDB collection 129 134 * @param schema - Zod schema for validation 130 135 * @param query - MongoDB query filter 131 136 * @param data - Partial data to update 132 132 - * @param options - Update options (including session for transactions) 137 137 + * @param options - Update options (including session for transactions and upsert flag) 133 138 * @returns Update result 134 139 */ 135 140 export async function update<T extends Schema>( ··· 140 145 options?: UpdateOptions 141 146 ): Promise<UpdateResult<Infer<T>>> { 142 147 const validatedData = parsePartial(schema, data); 143 143 - return await collection.updateMany( 144 144 - query, 145 145 - { $set: validatedData as Partial<Infer<T>> }, 146 146 - options 147 147 - ); 148 148 + let updateDoc: UpdateFilter<Infer<T>> = { $set: validatedData as Partial<Infer<T>> }; 149 149 + 150 150 + // If this is an upsert, apply defaults using $setOnInsert 151 151 + if (options?.upsert) { 152 152 + updateDoc = applyDefaultsForUpsert(schema, query, updateDoc); 153 153 + } 154 154 + 155 155 + return await collection.updateMany(query, updateDoc, options); 148 156 } 149 157 150 158 /** 151 159 * Update a single document matching the query 152 160 * 161 161 + * Case handling: 162 162 + * - If upsert: false (or undefined) → Normal update, no defaults applied 163 163 + * - If upsert: true → Defaults added to $setOnInsert for new document creation 164 164 + * 153 165 * @param collection - MongoDB collection 154 166 * @param schema - Zod schema for validation 155 167 * @param query - MongoDB query filter 156 168 * @param data - Partial data to update 157 157 - * @param options - Update options (including session for transactions) 169 169 + * @param options - Update options (including session for transactions and upsert flag) 158 170 * @returns Update result 159 171 */ 160 172 export async function updateOne<T extends Schema>( ··· 165 177 options?: UpdateOptions 166 178 ): Promise<UpdateResult<Infer<T>>> { 167 179 const validatedData = parsePartial(schema, data); 168 168 - return await collection.updateOne( 169 169 - query, 170 170 - { $set: validatedData as Partial<Infer<T>> }, 171 171 - options 172 172 - ); 180 180 + let updateDoc: UpdateFilter<Infer<T>> = { $set: validatedData as Partial<Infer<T>> }; 181 181 + 182 182 + // If this is an upsert, apply defaults using $setOnInsert 183 183 + if (options?.upsert) { 184 184 + updateDoc = applyDefaultsForUpsert(schema, query, updateDoc); 185 185 + } 186 186 + 187 187 + return await collection.updateOne(query, updateDoc, options); 173 188 } 174 189 175 190 /** 176 191 * Replace a single document matching the query 177 192 * 193 193 + * Case handling: 194 194 + * - If upsert: false (or undefined) → Normal replace on existing doc, no additional defaults 195 195 + * - If upsert: true → Defaults applied via parse() since we're passing a full document 196 196 + * 197 197 + * Note: For replace operations, defaults are automatically applied by the schema's 198 198 + * parse() function which treats missing fields as candidates for defaults. This works 199 199 + * for both regular replaces and upsert-creates since we're providing a full document. 200 200 + * 178 201 * @param collection - MongoDB collection 179 202 * @param schema - Zod schema for validation 180 203 * @param query - MongoDB query filter 181 204 * @param data - Complete document data for replacement 182 182 - * @param options - Replace options (including session for transactions) 205 205 + * @param options - Replace options (including session for transactions and upsert flag) 183 206 * @returns Update result 184 207 */ 185 208 export async function replaceOne<T extends Schema>( ··· 189 212 data: Input<T>, 190 213 options?: ReplaceOptions 191 214 ): Promise<UpdateResult<Infer<T>>> { 215 215 + // parseReplace will apply all schema defaults to missing fields 216 216 + // This works correctly for both regular replaces and upsert-created documents 192 217 const validatedData = parseReplace(schema, data); 218 218 + 193 219 // Remove _id from validatedData for replaceOne (it will use the query's _id) 194 220 const { _id, ...withoutId } = validatedData as Infer<T> & { _id?: unknown }; 195 221 return await collection.replaceOne(

+192 -2

model/validation.ts

··· 1 1 import type { z } from "@zod/zod"; 2 2 import type { Schema, Infer, Input } from "../types.ts"; 3 3 import { ValidationError, AsyncValidationError } from "../errors.ts"; 4 4 + import type { Document, UpdateFilter, Filter } from "mongodb"; 4 5 5 6 /** 6 7 * Validate data for insert operations using Zod schema ··· 28 29 /** 29 30 * Validate partial data for update operations using Zod schema 30 31 * 32 32 + * Important: This function only validates the fields that are provided in the data object. 33 33 + * Unlike parse(), this function does NOT apply defaults for missing fields because 34 34 + * in an update context, missing fields should remain unchanged in the database. 35 35 + * 31 36 * @param schema - Zod schema to validate against 32 37 * @param data - Partial data to validate 33 33 - * @returns Validated and typed partial data 38 38 + * @returns Validated and typed partial data (only fields present in input) 34 39 * @throws {ValidationError} If validation fails 35 40 * @throws {AsyncValidationError} If async validation is detected 36 41 */ ··· 38 43 schema: T, 39 44 data: Partial<z.infer<T>>, 40 45 ): Partial<z.infer<T>> { 46 46 + // Get the list of fields actually provided in the input 47 47 + const inputKeys = Object.keys(data); 48 48 + 41 49 const result = schema.partial().safeParse(data); 42 50 43 51 // Check for async validation ··· 48 56 if (!result.success) { 49 57 throw new ValidationError(result.error.issues, "update"); 50 58 } 51 51 - return result.data as Partial<z.infer<T>>; 59 59 + 60 60 + // Filter the result to only include fields that were in the input 61 61 + // This prevents defaults from being applied to fields that weren't provided 62 62 + const filtered: Record<string, unknown> = {}; 63 63 + for (const key of inputKeys) { 64 64 + if (key in result.data) { 65 65 + filtered[key] = (result.data as Record<string, unknown>)[key]; 66 66 + } 67 67 + } 68 68 + 69 69 + return filtered as Partial<z.infer<T>>; 52 70 } 53 71 54 72 /** ··· 73 91 } 74 92 return result.data as Infer<T>; 75 93 } 94 94 + 95 95 + /** 96 96 + * Extract default values from a Zod schema 97 97 + * This parses an empty object through the schema to get all defaults applied 98 98 + * 99 99 + * @param schema - Zod schema to extract defaults from 100 100 + * @returns Object containing all default values from the schema 101 101 + */ 102 102 + export function extractDefaults<T extends Schema>(schema: T): Partial<Infer<T>> { 103 103 + try { 104 104 + // Make all fields optional, then parse empty object to trigger defaults 105 105 + // This allows us to see which fields get default values 106 106 + const partialSchema = schema.partial(); 107 107 + const result = partialSchema.safeParse({}); 108 108 + 109 109 + if (result instanceof Promise) { 110 110 + // Cannot extract defaults from async schemas 111 111 + return {}; 112 112 + } 113 113 + 114 114 + // If successful, the result contains all fields that have defaults 115 115 + // Only include fields that were actually added (have values) 116 116 + if (!result.success) { 117 117 + return {}; 118 118 + } 119 119 + 120 120 + // Filter to only include fields that got values from defaults 121 121 + // (not undefined, which indicates no default) 122 122 + const defaults: Record<string, unknown> = {}; 123 123 + const data = result.data as Record<string, unknown>; 124 124 + 125 125 + for (const [key, value] of Object.entries(data)) { 126 126 + if (value !== undefined) { 127 127 + defaults[key] = value; 128 128 + } 129 129 + } 130 130 + 131 131 + return defaults as Partial<Infer<T>>; 132 132 + } catch { 133 133 + return {}; 134 134 + } 135 135 + } 136 136 + 137 137 + /** 138 138 + * Get all field paths mentioned in an update filter object 139 139 + * This includes fields in $set, $unset, $inc, $push, etc. 140 140 + * 141 141 + * @param update - MongoDB update filter 142 142 + * @returns Set of field paths that are being modified 143 143 + */ 144 144 + function getModifiedFields(update: UpdateFilter<Document>): Set<string> { 145 145 + const fields = new Set<string>(); 146 146 + 147 147 + // Operators that modify fields 148 148 + const operators = [ 149 149 + '$set', '$unset', '$inc', '$mul', '$rename', '$min', '$max', 150 150 + '$currentDate', '$push', '$pull', '$addToSet', '$pop', '$bit', 151 151 + '$setOnInsert', 152 152 + ]; 153 153 + 154 154 + for (const op of operators) { 155 155 + if (update[op] && typeof update[op] === 'object') { 156 156 + // Add all field names from this operator 157 157 + for (const field of Object.keys(update[op] as Document)) { 158 158 + fields.add(field); 159 159 + } 160 160 + } 161 161 + } 162 162 + 163 163 + return fields; 164 164 + } 165 165 + 166 166 + /** 167 167 + * Get field paths that are fixed by equality clauses in a query filter. 168 168 + * Only equality-style predicates become part of the inserted document during upsert. 169 169 + */ 170 170 + function getEqualityFields(filter: Filter<Document>): Set<string> { 171 171 + const fields = new Set<string>(); 172 172 + 173 173 + const collect = (node: Record<string, unknown>) => { 174 174 + for (const [key, value] of Object.entries(node)) { 175 175 + if (key.startsWith("$")) { 176 176 + if (Array.isArray(value)) { 177 177 + for (const item of value) { 178 178 + if (item && typeof item === "object" && !Array.isArray(item)) { 179 179 + collect(item as Record<string, unknown>); 180 180 + } 181 181 + } 182 182 + } else if (value && typeof value === "object") { 183 183 + collect(value as Record<string, unknown>); 184 184 + } 185 185 + continue; 186 186 + } 187 187 + 188 188 + if (value && typeof value === "object" && !Array.isArray(value)) { 189 189 + const objectValue = value as Record<string, unknown>; 190 190 + const keys = Object.keys(objectValue); 191 191 + const hasOperator = keys.some((k) => k.startsWith("$")); 192 192 + 193 193 + if (hasOperator) { 194 194 + if (Object.prototype.hasOwnProperty.call(objectValue, "$eq")) { 195 195 + fields.add(key); 196 196 + } 197 197 + } else { 198 198 + fields.add(key); 199 199 + } 200 200 + } else { 201 201 + fields.add(key); 202 202 + } 203 203 + } 204 204 + }; 205 205 + 206 206 + collect(filter as Record<string, unknown>); 207 207 + return fields; 208 208 + } 209 209 + 210 210 + /** 211 211 + * Apply schema defaults to an update operation using $setOnInsert 212 212 + * 213 213 + * This is used for upsert operations to ensure defaults are applied when 214 214 + * a new document is created, but not when updating an existing document. 215 215 + * 216 216 + * For each default field: 217 217 + * - If the field is NOT mentioned in any update operator ($set, $inc, etc.) 218 218 + * - If the field is NOT fixed by an equality clause in the query filter 219 219 + * - Add it to $setOnInsert so it's only applied on insert 220 220 + * 221 221 + * @param schema - Zod schema with defaults 222 222 + * @param query - MongoDB query filter 223 223 + * @param update - MongoDB update filter 224 224 + * @returns Modified update filter with defaults in $setOnInsert 225 225 + */ 226 226 + export function applyDefaultsForUpsert<T extends Schema>( 227 227 + schema: T, 228 228 + query: Filter<Infer<T>>, 229 229 + update: UpdateFilter<Infer<T>> 230 230 + ): UpdateFilter<Infer<T>> { 231 231 + // Extract defaults from schema 232 232 + const defaults = extractDefaults(schema); 233 233 + 234 234 + // If no defaults, return update unchanged 235 235 + if (Object.keys(defaults).length === 0) { 236 236 + return update; 237 237 + } 238 238 + 239 239 + // Get fields that are already being modified 240 240 + const modifiedFields = getModifiedFields(update as UpdateFilter<Document>); 241 241 + const filterEqualityFields = getEqualityFields(query as Filter<Document>); 242 242 + 243 243 + // Build $setOnInsert with defaults for unmodified fields 244 244 + const setOnInsert: Partial<Infer<T>> = {}; 245 245 + 246 246 + for (const [field, value] of Object.entries(defaults)) { 247 247 + // Only add default if field is not already being modified or fixed by filter equality 248 248 + if (!modifiedFields.has(field) && !filterEqualityFields.has(field)) { 249 249 + setOnInsert[field as keyof Infer<T>] = value as Infer<T>[keyof Infer<T>]; 250 250 + } 251 251 + } 252 252 + 253 253 + // If there are defaults to add, merge them into $setOnInsert 254 254 + if (Object.keys(setOnInsert).length > 0) { 255 255 + return { 256 256 + ...update, 257 257 + $setOnInsert: { 258 258 + ...(update.$setOnInsert || {}), 259 259 + ...setOnInsert 260 260 + } as Partial<Infer<T>> 261 261 + }; 262 262 + } 263 263 + 264 264 + return update; 265 265 + }

+352

tests/defaults_test.ts

··· 1 1 + import { assertEquals, assertExists } from "@std/assert"; 2 2 + import { z } from "@zod/zod"; 3 3 + import { connect, disconnect, Model, type Input } from "../mod.ts"; 4 4 + import { applyDefaultsForUpsert } from "../model/validation.ts"; 5 5 + import { MongoMemoryServer } from "mongodb-memory-server-core"; 6 6 + 7 7 + /** 8 8 + * Test suite for default value handling in different operation types 9 9 + * 10 10 + * This tests the three main cases: 11 11 + * 1. Plain inserts - defaults applied directly 12 12 + * 2. Updates without upsert - defaults NOT applied 13 13 + * 3. Upserts that create - defaults applied via $setOnInsert 14 14 + * 4. Upserts that match - $setOnInsert ignored (correct behavior) 15 15 + * 5. Replace with upsert - defaults applied on creation 16 16 + */ 17 17 + 18 18 + // Schema with defaults for testing 19 19 + const productSchema = z.object({ 20 20 + name: z.string(), 21 21 + price: z.number().min(0), 22 22 + category: z.string().default("general"), 23 23 + inStock: z.boolean().default(true), 24 24 + createdAt: z.date().default(() => new Date("2024-01-01T00:00:00Z")), 25 25 + tags: z.array(z.string()).default([]), 26 26 + }); 27 27 + 28 28 + type Product = z.infer<typeof productSchema>; 29 29 + type ProductInsert = Input<typeof productSchema>; 30 30 + 31 31 + let ProductModel: Model<typeof productSchema>; 32 32 + let mongoServer: MongoMemoryServer; 33 33 + 34 34 + Deno.test.beforeAll(async () => { 35 35 + mongoServer = await MongoMemoryServer.create(); 36 36 + const uri = mongoServer.getUri(); 37 37 + await connect(uri, "test_defaults_db"); 38 38 + ProductModel = new Model("test_products_defaults", productSchema); 39 39 + }); 40 40 + 41 41 + Deno.test.beforeEach(async () => { 42 42 + await ProductModel.delete({}); 43 43 + }); 44 44 + 45 45 + Deno.test.afterAll(async () => { 46 46 + await ProductModel.delete({}); 47 47 + await disconnect(); 48 48 + await mongoServer.stop(); 49 49 + }); 50 50 + 51 51 + Deno.test({ 52 52 + name: "Defaults: Case 1 - Plain insert applies defaults", 53 53 + async fn() { 54 54 + // Insert without providing optional fields with defaults 55 55 + const result = await ProductModel.insertOne({ 56 56 + name: "Widget", 57 57 + price: 29.99, 58 58 + // category, inStock, createdAt, tags not provided - should use defaults 59 59 + }); 60 60 + 61 61 + assertExists(result.insertedId); 62 62 + 63 63 + // Verify defaults were applied 64 64 + const product = await ProductModel.findById(result.insertedId); 65 65 + assertExists(product); 66 66 + 67 67 + assertEquals(product.name, "Widget"); 68 68 + assertEquals(product.price, 29.99); 69 69 + assertEquals(product.category, "general"); // default 70 70 + assertEquals(product.inStock, true); // default 71 71 + assertExists(product.createdAt); // default function called 72 72 + assertEquals(product.tags, []); // default empty array 73 73 + }, 74 74 + sanitizeResources: false, 75 75 + sanitizeOps: false, 76 76 + }); 77 77 + 78 78 + Deno.test({ 79 79 + name: "Defaults: Case 2 - Update without upsert does NOT apply defaults", 80 80 + async fn() { 81 81 + // First create a document without defaults (simulate old data) 82 82 + const insertResult = await ProductModel.insertOne({ 83 83 + name: "Gadget", 84 84 + price: 19.99, 85 85 + category: "electronics", 86 86 + inStock: false, 87 87 + createdAt: new Date("2023-01-01"), 88 88 + tags: ["test"], 89 89 + }); 90 90 + 91 91 + assertExists(insertResult.insertedId); 92 92 + 93 93 + // Now update it - defaults should NOT be applied 94 94 + await ProductModel.updateOne( 95 95 + { _id: insertResult.insertedId }, 96 96 + { price: 24.99 } 97 97 + // No upsert flag 98 98 + ); 99 99 + 100 100 + const updated = await ProductModel.findById(insertResult.insertedId); 101 101 + assertExists(updated); 102 102 + 103 103 + assertEquals(updated.price, 24.99); // updated 104 104 + assertEquals(updated.category, "electronics"); // unchanged 105 105 + assertEquals(updated.inStock, false); // unchanged 106 106 + assertEquals(updated.tags, ["test"]); // unchanged 107 107 + }, 108 108 + sanitizeResources: false, 109 109 + sanitizeOps: false, 110 110 + }); 111 111 + 112 112 + Deno.test({ 113 113 + name: "Defaults: Case 3 - Upsert that creates applies defaults via $setOnInsert", 114 114 + async fn() { 115 115 + // Upsert with a query that won't match - will create new document 116 116 + const result = await ProductModel.updateOne( 117 117 + { name: "NonExistent" }, 118 118 + { price: 39.99 }, 119 119 + { upsert: true } 120 120 + ); 121 121 + 122 122 + assertEquals(result.upsertedCount, 1); 123 123 + assertExists(result.upsertedId); 124 124 + 125 125 + // Verify the created document has defaults applied 126 126 + const product = await ProductModel.findOne({ name: "NonExistent" }); 127 127 + assertExists(product); 128 128 + 129 129 + assertEquals(product.price, 39.99); // from $set 130 130 + assertEquals(product.name, "NonExistent"); // from query 131 131 + assertEquals(product.category, "general"); // default via $setOnInsert 132 132 + assertEquals(product.inStock, true); // default via $setOnInsert 133 133 + assertExists(product.createdAt); // default via $setOnInsert 134 134 + assertEquals(product.tags, []); // default via $setOnInsert 135 135 + }, 136 136 + sanitizeResources: false, 137 137 + sanitizeOps: false, 138 138 + }); 139 139 + 140 140 + Deno.test({ 141 141 + name: "Defaults: Case 4 - Upsert that matches does NOT apply defaults", 142 142 + async fn() { 143 143 + // Create a document first with explicit non-default values 144 144 + const insertResult = await ProductModel.insertOne({ 145 145 + name: "ExistingProduct", 146 146 + price: 49.99, 147 147 + category: "premium", 148 148 + inStock: false, 149 149 + createdAt: new Date("2023-06-01"), 150 150 + tags: ["premium", "featured"], 151 151 + }); 152 152 + 153 153 + assertExists(insertResult.insertedId); 154 154 + 155 155 + // Upsert with matching query - should update, not insert 156 156 + const result = await ProductModel.updateOne( 157 157 + { name: "ExistingProduct" }, 158 158 + { price: 44.99 }, 159 159 + { upsert: true } 160 160 + ); 161 161 + 162 162 + assertEquals(result.matchedCount, 1); 163 163 + assertEquals(result.modifiedCount, 1); 164 164 + assertEquals(result.upsertedCount, 0); // No insert happened 165 165 + 166 166 + // Verify defaults were NOT applied (existing values preserved) 167 167 + const product = await ProductModel.findOne({ name: "ExistingProduct" }); 168 168 + assertExists(product); 169 169 + 170 170 + assertEquals(product.price, 44.99); // updated via $set 171 171 + assertEquals(product.category, "premium"); // preserved (not overwritten with default) 172 172 + assertEquals(product.inStock, false); // preserved 173 173 + assertEquals(product.tags, ["premium", "featured"]); // preserved 174 174 + }, 175 175 + sanitizeResources: false, 176 176 + sanitizeOps: false, 177 177 + }); 178 178 + 179 179 + Deno.test({ 180 180 + name: "Defaults: Case 5 - Replace without upsert uses defaults from parse", 181 181 + async fn() { 182 182 + // Create initial document 183 183 + const insertResult = await ProductModel.insertOne({ 184 184 + name: "ReplaceMe", 185 185 + price: 10.0, 186 186 + category: "old", 187 187 + inStock: true, 188 188 + createdAt: new Date("2020-01-01"), 189 189 + tags: ["old"], 190 190 + }); 191 191 + 192 192 + assertExists(insertResult.insertedId); 193 193 + 194 194 + // Replace with partial data - defaults should fill in missing fields 195 195 + await ProductModel.replaceOne( 196 196 + { _id: insertResult.insertedId }, 197 197 + { 198 198 + name: "Replaced", 199 199 + price: 15.0, 200 200 + // category, inStock, createdAt, tags not provided - defaults should apply 201 201 + } 202 202 + ); 203 203 + 204 204 + const product = await ProductModel.findById(insertResult.insertedId); 205 205 + assertExists(product); 206 206 + 207 207 + assertEquals(product.name, "Replaced"); 208 208 + assertEquals(product.price, 15.0); 209 209 + assertEquals(product.category, "general"); // default applied 210 210 + assertEquals(product.inStock, true); // default applied 211 211 + assertExists(product.createdAt); // default applied 212 212 + assertEquals(product.tags, []); // default applied 213 213 + }, 214 214 + sanitizeResources: false, 215 215 + sanitizeOps: false, 216 216 + }); 217 217 + 218 218 + Deno.test({ 219 219 + name: "Defaults: Case 6 - Replace with upsert (creates) applies defaults", 220 220 + async fn() { 221 221 + // Replace with upsert on non-existent document 222 222 + const result = await ProductModel.replaceOne( 223 223 + { name: "NewViaReplace" }, 224 224 + { 225 225 + name: "NewViaReplace", 226 226 + price: 99.99, 227 227 + // Missing optional fields - defaults should apply 228 228 + }, 229 229 + { upsert: true } 230 230 + ); 231 231 + 232 232 + assertEquals(result.upsertedCount, 1); 233 233 + assertExists(result.upsertedId); 234 234 + 235 235 + const product = await ProductModel.findOne({ name: "NewViaReplace" }); 236 236 + assertExists(product); 237 237 + 238 238 + assertEquals(product.name, "NewViaReplace"); 239 239 + assertEquals(product.price, 99.99); 240 240 + assertEquals(product.category, "general"); // default 241 241 + assertEquals(product.inStock, true); // default 242 242 + assertExists(product.createdAt); // default 243 243 + assertEquals(product.tags, []); // default 244 244 + }, 245 245 + sanitizeResources: false, 246 246 + sanitizeOps: false, 247 247 + }); 248 248 + 249 249 + Deno.test({ 250 250 + name: "Defaults: Upsert only applies defaults to unmodified fields", 251 251 + async fn() { 252 252 + // Upsert where we explicitly set some fields that have defaults 253 253 + const result = await ProductModel.updateOne( 254 254 + { name: "CustomDefaults" }, 255 255 + { 256 256 + price: 25.0, 257 257 + category: "custom", // Explicitly setting a field that has a default 258 258 + // inStock not set - should get default 259 259 + }, 260 260 + { upsert: true } 261 261 + ); 262 262 + 263 263 + assertEquals(result.upsertedCount, 1); 264 264 + 265 265 + const product = await ProductModel.findOne({ name: "CustomDefaults" }); 266 266 + assertExists(product); 267 267 + 268 268 + assertEquals(product.name, "CustomDefaults"); // from query 269 269 + assertEquals(product.price, 25.0); // from $set 270 270 + assertEquals(product.category, "custom"); // from $set (NOT default) 271 271 + assertEquals(product.inStock, true); // default via $setOnInsert 272 272 + assertExists(product.createdAt); // default via $setOnInsert 273 273 + assertEquals(product.tags, []); // default via $setOnInsert 274 274 + }, 275 275 + sanitizeResources: false, 276 276 + sanitizeOps: false, 277 277 + }); 278 278 + 279 279 + Deno.test({ 280 280 + name: "Defaults: insertMany applies defaults to all documents", 281 281 + async fn() { 282 282 + const result = await ProductModel.insertMany([ 283 283 + { name: "Bulk1", price: 10 }, 284 284 + { name: "Bulk2", price: 20, category: "special" }, 285 285 + { name: "Bulk3", price: 30 }, 286 286 + ]); 287 287 + 288 288 + assertEquals(Object.keys(result.insertedIds).length, 3); 289 289 + 290 290 + const products = await ProductModel.find({}); 291 291 + assertEquals(products.length, 3); 292 292 + 293 293 + // All should have defaults where not provided 294 294 + for (const product of products) { 295 295 + assertExists(product.createdAt); 296 296 + assertEquals(product.inStock, true); 297 297 + assertEquals(product.tags, []); 298 298 + 299 299 + if (product.name === "Bulk2") { 300 300 + assertEquals(product.category, "special"); 301 301 + } else { 302 302 + assertEquals(product.category, "general"); 303 303 + } 304 304 + } 305 305 + }, 306 306 + sanitizeResources: false, 307 307 + sanitizeOps: false, 308 308 + }); 309 309 + 310 310 + Deno.test({ 311 311 + name: "Defaults: applyDefaultsForUpsert preserves existing $setOnInsert values", 312 312 + fn() { 313 313 + const schema = z.object({ 314 314 + name: z.string(), 315 315 + flag: z.boolean().default(true), 316 316 + count: z.number().default(0), 317 317 + }); 318 318 + 319 319 + const update = { 320 320 + $set: { name: "test" }, 321 321 + $setOnInsert: { flag: false }, 322 322 + }; 323 323 + 324 324 + const result = applyDefaultsForUpsert(schema, {}, update); 325 325 + 326 326 + assertEquals(result.$setOnInsert?.flag, false); 327 327 + assertEquals(result.$setOnInsert?.count, 0); 328 328 + }, 329 329 + sanitizeResources: false, 330 330 + sanitizeOps: false, 331 331 + }); 332 332 + 333 333 + Deno.test({ 334 334 + name: "Defaults: applyDefaultsForUpsert keeps query equality fields untouched", 335 335 + fn() { 336 336 + const schema = z.object({ 337 337 + status: z.string().default("pending"), 338 338 + flag: z.boolean().default(true), 339 339 + name: z.string(), 340 340 + }); 341 341 + 342 342 + const query = { status: "queued" }; 343 343 + const update = { $set: { name: "upsert-test" } }; 344 344 + 345 345 + const result = applyDefaultsForUpsert(schema, query, update); 346 346 + 347 347 + assertEquals(result.$setOnInsert?.status, undefined); 348 348 + assertEquals(result.$setOnInsert?.flag, true); 349 349 + }, 350 350 + sanitizeResources: false, 351 351 + sanitizeOps: false, 352 352 + });