monsqlize 3.0.0 → 3.1.0

package/dist/cjs/index.cjs

@@ -769,31 +769,51 @@ async function runModelV1Hook(hooksFactory, model, operation, phase, context, ..
   }
   return hook(context, ...args);
 }
+function mapModelSchemaValidationErrors(errors = []) {
+  return errors.map((error) => ({
+    field: error.path ?? "",
+    message: error.message ?? ""
+  }));
+}
 function validateModelSchemaPayload(context, document, options, metadata = {}) {
   const shouldValidate = context.validateEnabled || options?.validate === true;
   if (!shouldValidate) {
-    return;
+    return document;
   }
   if (options?.skipValidation) {
-    return;
+    return document;
   }
   if (!context.schemaCache || !context.schemaValidateFn) {
-    return;
+    return document;
   }
   const result = context.schemaValidateFn(context.schemaCache, document);
-  if (result.valid) {
-    return;
+  if (!result.valid) {
+    const errors = mapModelSchemaValidationErrors(result.errors);
+    const fields = [...new Set(errors.map((item) => item.field).filter(Boolean))];
+    const summary = fields.length > 0 ? ` (${fields.join(", ")})` : "";
+    throw withModelErrorMetadata(
+      createError(ErrorCodes.VALIDATION_ERROR, `Schema validation failed${summary}`),
+      {
+        errors,
+        ...metadata
+      }
+    );
   }
-  const errors = result.errors ?? [];
-  const fields = [...new Set(errors.map((item) => item.path ?? item.field).filter(Boolean))];
-  const summary = fields.length > 0 ? ` (${fields.join(", ")})` : "";
-  throw withModelErrorMetadata(
-    createError(ErrorCodes.VALIDATION_ERROR, `Schema validation failed${summary}`),
-    {
-      errors,
-      ...metadata
-    }
-  );
+  const normalized = result.data === void 0 ? document : result.data;
+  if (normalized === null || typeof normalized !== "object" || Array.isArray(normalized)) {
+    const errors = [{
+      field: "_schema",
+      message: "Schema validation returned non-object data for a complete-document write."
+    }];
+    throw withModelErrorMetadata(
+      createError(ErrorCodes.VALIDATION_ERROR, errors[0].message),
+      {
+        errors,
+        ...metadata
+      }
+    );
+  }
+  return normalized;
 }
 function applyModelSoftDeleteFilter(query, options, softDeleteConfig) {
   if (!softDeleteConfig?.enabled) {
@@ -999,6 +1019,19 @@ function applyModelReplaceTimestamps(replacement, timestampsConfig, nowFactory)
     [timestampsConfig.updatedAt]: nowFactory()
   };
 }
+function preserveModelReplaceCreatedAt(original, normalized, timestampsConfig) {
+  if (!timestampsConfig || timestampsConfig.createdAt === false) {
+    return normalized;
+  }
+  const field = timestampsConfig.createdAt;
+  if (normalized[field] !== void 0 || original[field] === void 0) {
+    return normalized;
+  }
+  return {
+    ...normalized,
+    [field]: original[field]
+  };
+}
 
 // src/capabilities/model/model-instance-helpers.ts
 var DEFAULT_POPULATE_MAX_DEPTH = 5;
@@ -1219,11 +1252,8 @@ function validateModelDocument(runtime, document) {
     const result = runtime.schemaValidateFn(runtime.schemaCache, document ?? {});
     return {
       valid: result.valid,
-      errors: (result.errors ?? []).map((error) => ({
-        field: error.field ?? error.path ?? "",
-        message: error.message ?? ""
-      })),
-      data: result.data ?? document
+      errors: mapModelSchemaValidationErrors(result.errors),
+      data: result.data === void 0 ? document : result.data
     };
   } catch (error) {
     return {
@@ -1243,44 +1273,87 @@ function applyModelDefaults(definition, document) {
   }
   return payload;
 }
+function serializeModelWriteDocument(document) {
+  const payload = serializeDocument(document);
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(document))) {
+    if (descriptor.get || descriptor.set) {
+      delete payload[key];
+    }
+  }
+  return payload;
+}
+function replaceModelDocumentData(document, payload) {
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(document))) {
+    if (!descriptor.enumerable || descriptor.get || descriptor.set || typeof descriptor.value === "function") {
+      continue;
+    }
+    if (!Object.prototype.hasOwnProperty.call(payload, key) && descriptor.configurable !== false) {
+      delete document[key];
+    }
+  }
+  for (const [key, value] of Object.entries(payload)) {
+    const descriptor = Object.getOwnPropertyDescriptor(document, key);
+    if (descriptor?.get || descriptor?.set || descriptor?.writable === false) {
+      continue;
+    }
+    document[key] = value;
+  }
+}
 async function saveModelDocument(collection, document, options = {}) {
   const nowFactory = options.nowFactory ?? (() => /* @__PURE__ */ new Date());
-  let payload = serializeDocument(document);
+  let payload = serializeModelWriteDocument(document);
   if (payload._id !== void 0) {
+    const documentId = payload._id;
     if (options.versionConfig?.enabled) {
       const expectedVersion = assertNumericExpectedVersion(payload[options.versionConfig.field], "save");
-      const replacement = applyModelReplaceVersion(
+      if (options.schemaValidationContext) {
+        payload = preserveModelReplaceCreatedAt(
+          serializeModelWriteDocument(document),
+          validateModelSchemaPayload(options.schemaValidationContext, payload),
+          options.timestampsConfig ?? null
+        );
+      }
+      const replacement2 = applyModelReplaceVersion(
         applyModelReplaceTimestamps(payload, options.timestampsConfig ?? null, nowFactory),
         options.versionConfig,
         expectedVersion
       );
-      if (options.schemaValidationContext) {
-        validateModelSchemaPayload(options.schemaValidationContext, replacement);
-      }
       const result2 = await collection.replaceOne(
-        { _id: payload._id, [options.versionConfig.field]: expectedVersion },
-        replacement,
+        { _id: documentId, [options.versionConfig.field]: expectedVersion },
+        replacement2,
         { upsert: false }
       );
       assertModelOptimisticLockMatched(result2, options.versionConfig);
-      Object.assign(document, replacement);
+      replaceModelDocumentData(document, replacement2);
+      document._id = documentId;
       return document;
     }
     if (options.schemaValidationContext) {
-      validateModelSchemaPayload(options.schemaValidationContext, payload);
+      payload = preserveModelReplaceCreatedAt(
+        serializeModelWriteDocument(document),
+        validateModelSchemaPayload(options.schemaValidationContext, payload),
+        options.timestampsConfig ?? null
+      );
     }
-    await collection.replaceOne({ _id: payload._id }, payload, { upsert: true });
+    const replacement = applyModelReplaceTimestamps(
+      payload,
+      options.timestampsConfig ?? null,
+      nowFactory
+    );
+    await collection.replaceOne({ _id: documentId }, replacement, { upsert: true });
+    replaceModelDocumentData(document, replacement);
+    document._id = documentId;
     return document;
   }
+  if (options.schemaValidationContext) {
+    payload = validateModelSchemaPayload(options.schemaValidationContext, payload);
+  }
   payload = applyModelInsertVersion(
     applyModelInsertTimestamps(payload, options.timestampsConfig ?? null, nowFactory),
     options.versionConfig ?? null
   );
-  if (options.schemaValidationContext) {
-    validateModelSchemaPayload(options.schemaValidationContext, payload);
-  }
   const result = await collection.insertOne(payload);
-  Object.assign(document, payload);
+  replaceModelDocumentData(document, payload);
   document._id = result.insertedId;
   return document;
 }
@@ -5078,7 +5151,7 @@ async function orchestrateModelInsertOne(context, document, options) {
   } else {
     await invokeStandardOperationHook(context, "insert", "before", { operation: "insertOne", collection: context.collectionName, data: payload });
   }
-  validateModelSchemaPayload({
+  payload = validateModelSchemaPayload({
     validateEnabled: context.validateEnabled,
     schemaCache: context.schemaCache,
     schemaValidateFn: context.schemaValidateFn
@@ -5103,23 +5176,23 @@ async function orchestrateModelInsertOne(context, document, options) {
 }
 async function orchestrateModelInsertMany(context, documents, options) {
   const hookContext = {};
+  const docs = (documents ?? []).map((document) => context.applyDefaults(document));
   if (context.hooksFactory) {
-    await invokeV1Hook(context, "insert", "before", hookContext, documents);
+    await invokeV1Hook(context, "insert", "before", hookContext, docs);
   } else {
-    await invokeStandardOperationHook(context, "insert", "before", { operation: "insertMany", collection: context.collectionName, data: documents });
+    await invokeStandardOperationHook(context, "insert", "before", { operation: "insertMany", collection: context.collectionName, data: docs });
   }
   const resolvedOptions = options ?? {};
-  const docs = [];
-  for (let index = 0; index < (documents ?? []).length; index++) {
-    let doc = context.applyDefaults((documents ?? [])[index]);
-    validateModelSchemaPayload({
+  for (let index = 0; index < docs.length; index++) {
+    let doc = docs[index];
+    doc = validateModelSchemaPayload({
       validateEnabled: context.validateEnabled,
       schemaCache: context.schemaCache,
       schemaValidateFn: context.schemaValidateFn
     }, doc, resolvedOptions, { index });
     doc = applyModelInsertTimestamps(doc, context.timestampsConfig, () => context.nowDate());
     doc = applyModelInsertVersion(doc, context.versionConfig);
-    docs.push(doc);
+    docs[index] = doc;
   }
   const result = await context.collection.insertMany(docs, options);
   if (context.hooksFactory) {
@@ -5197,17 +5270,22 @@ async function orchestrateModelReplaceOne(context, filter, replacement, options)
   } else {
     await invokeStandardOperationHook(context, "update", "before", { operation: "replaceOne", collection: context.collectionName, filter, update: replacement });
   }
+  let nextReplacement = validateModelSchemaPayload({
+    validateEnabled: context.validateEnabled,
+    schemaCache: context.schemaCache,
+    schemaValidateFn: context.schemaValidateFn
+  }, replacement, options);
+  nextReplacement = preserveModelReplaceCreatedAt(
+    replacement,
+    nextReplacement,
+    context.timestampsConfig
+  );
   const lock = await resolveModelOptimisticLockAsync(context.collection, filter, options, context.versionConfig, "replaceOne");
-  const nextReplacement = applyModelReplaceVersion(
-    applyModelReplaceTimestamps(replacement, context.timestampsConfig, () => context.nowDate()),
+  nextReplacement = applyModelReplaceVersion(
+    applyModelReplaceTimestamps(nextReplacement, context.timestampsConfig, () => context.nowDate()),
     context.versionConfig,
     lock.expectedVersion
   );
-  validateModelSchemaPayload({
-    validateEnabled: context.validateEnabled,
-    schemaCache: context.schemaCache,
-    schemaValidateFn: context.schemaValidateFn
-  }, nextReplacement, lock.driverOptions);
   const result = await context.collection.replaceOne(lock.filter, nextReplacement, lock.driverOptions);
   assertModelOptimisticLockMatched(result, context.versionConfig);
   if (context.hooksFactory) {
@@ -5251,17 +5329,22 @@ async function orchestrateModelFindOneAndReplace(context, filter, replacement, o
   } else {
     await invokeStandardOperationHook(context, "update", "before", { operation: "findOneAndReplace", collection: context.collectionName, filter, update: replacement });
   }
+  let nextReplacement = validateModelSchemaPayload({
+    validateEnabled: context.validateEnabled,
+    schemaCache: context.schemaCache,
+    schemaValidateFn: context.schemaValidateFn
+  }, replacement, options);
+  nextReplacement = preserveModelReplaceCreatedAt(
+    replacement,
+    nextReplacement,
+    context.timestampsConfig
+  );
   const lock = await resolveModelOptimisticLockAsync(context.collection, filter, options, context.versionConfig, "findOneAndReplace");
-  const nextReplacement = applyModelReplaceVersion(
-    applyModelReplaceTimestamps(replacement, context.timestampsConfig, () => context.nowDate()),
+  nextReplacement = applyModelReplaceVersion(
+    applyModelReplaceTimestamps(nextReplacement, context.timestampsConfig, () => context.nowDate()),
     context.versionConfig,
     lock.expectedVersion
   );
-  validateModelSchemaPayload({
-    validateEnabled: context.validateEnabled,
-    schemaCache: context.schemaCache,
-    schemaValidateFn: context.schemaValidateFn
-  }, nextReplacement, lock.driverOptions);
   const result = await context.extendedCollection().findOneAndReplace(lock.filter, nextReplacement, lock.driverOptions);
   assertModelOptimisticLockDocument(result, context.versionConfig);
   if (context.hooksFactory) {
@@ -5349,23 +5432,24 @@ async function orchestrateModelIncrementOne(context, filter, field, increment, o
 }
 async function orchestrateModelInsertBatch(context, docs, options) {
   const hookContext = {};
+  const docsToInsert = docs.map((doc) => context.applyDefaults(doc));
   if (context.hooksFactory) {
-    await invokeV1Hook(context, "insert", "before", hookContext, docs);
+    await invokeV1Hook(context, "insert", "before", hookContext, docsToInsert);
   } else {
-    await invokeStandardOperationHook(context, "insert", "before", { operation: "insertBatch", collection: context.collectionName, data: docs });
+    await invokeStandardOperationHook(context, "insert", "before", { operation: "insertBatch", collection: context.collectionName, data: docsToInsert });
   }
   const resolvedOptions = options ?? {};
-  const docsToInsert = docs.map((doc, index) => {
-    let record = context.applyDefaults(doc);
-    validateModelSchemaPayload({
+  for (let index = 0; index < docsToInsert.length; index++) {
+    let record = docsToInsert[index];
+    record = validateModelSchemaPayload({
       validateEnabled: context.validateEnabled,
       schemaCache: context.schemaCache,
       schemaValidateFn: context.schemaValidateFn
     }, record, resolvedOptions, { index });
     record = applyModelInsertTimestamps(record, context.timestampsConfig, () => context.nowDate());
     record = applyModelInsertVersion(record, context.versionConfig);
-    return record;
-  });
+    docsToInsert[index] = record;
+  }
   const result = await context.extendedCollection().insertBatch(docsToInsert, options);
   if (context.hooksFactory) {
     try {
@@ -6482,9 +6566,28 @@ async function sleep(ms) {
 var import_node_fs = require("node:fs");
 var import_node_path = __toESM(require("node:path"));
 var import_mongodb3 = require("mongodb");
-var DEFAULT_MEMORY_SERVER_VERSION = "7.0.14";
+
+// config/mongodb-memory-server.json
+var mongodb_memory_server_default = {
+  defaultVersion: "7.0.37",
+  requiredVersions: [
+    { label: "MongoDB 7.0", version: "7.0.37" },
+    { label: "MongoDB 8.0", version: "8.0.26" }
+  ],
+  managedDbPathKinds: [
+    "single",
+    "replset",
+    "examples-single",
+    "examples-replset",
+    "probe-single",
+    "probe-replset"
+  ]
+};
+
+// src/adapters/mongodb/common/connect.ts
+var DEFAULT_MEMORY_SERVER_VERSION = mongodb_memory_server_default.defaultVersion;
 var DEFAULT_MEMORY_SERVER_LAUNCH_TIMEOUT_MS = 3e4;
-var MANAGED_DB_PATH_PREFIXES = ["single-", "replset-", "examples-single-", "examples-replset-", "probe-single-", "probe-replset-"];
+var MANAGED_DB_PATH_PREFIXES = mongodb_memory_server_default.managedDbPathKinds.map((kind) => `${kind}-`);
 var _memoryServerInstance = null;
 var _memoryServerStartPromise = null;
 var _memoryServerCleanupOptions = { doCleanup: true, force: true };