@orion-js/mongodb 4.3.1 → 4.4.0

package/dist/index.cjs

@@ -541,7 +541,7 @@ function findOne_default(collection) {
   return findOne;
 }
 
-// src/createCollection/getMethods/validateModifier/validatePush.ts
+// src/createCollection/getMethods/cleanModifier.ts
 var import_schema2 = require("@orion-js/schema");
 
 // src/helpers/fromDot.ts
@@ -560,7 +560,70 @@ function fromDot(doc) {
   return import_dot_object2.default.object(doc);
 }
 
+// src/createCollection/getMethods/cleanModifier.ts
+var shouldCheck = (key) => {
+  if (key === "$pushAll") throw new Error("$pushAll is not supported; use $push + $each");
+  return ["$pull", "$pullAll", "$pop", "$slice"].indexOf(key) === -1;
+};
+async function cleanModifier(schema, modifier, { isUpsert } = { isUpsert: false }) {
+  const cleanedModifier = {};
+  for (const operation of Object.keys(modifier)) {
+    const operationDoc = modifier[operation];
+    cleanedModifier[operation] = {};
+    if (operation.slice(0, 1) !== "$") {
+      throw new Error(`Expected '${operation}' to be a modifier operator like '$set'`);
+    }
+    if (!shouldCheck(operation)) {
+      cleanedModifier[operation] = operationDoc;
+      continue;
+    }
+    for (const key of Object.keys(operationDoc)) {
+      const value = operationDoc[key];
+      const cleanOptions = { forceDoc: operationDoc };
+      let cleaned = null;
+      if (operation === "$push" || operation === "$addToSet") {
+        if (typeof value === "object" && "$each" in value) {
+          const $each = await (0, import_schema2.cleanKey)(schema, key, value.$each, cleanOptions);
+          cleaned = { ...value, $each };
+        } else {
+          cleaned = await (0, import_schema2.cleanKey)(schema, `${key}.0`, value, cleanOptions);
+        }
+      }
+      if (operation === "$set") {
+        cleaned = await (0, import_schema2.cleanKey)(schema, key, value, cleanOptions);
+      }
+      if (operation === "$setOnInsert") {
+        cleaned = await (0, import_schema2.cleanKey)(schema, key, value, cleanOptions);
+      }
+      if (operation === "$inc") {
+        cleaned = await (0, import_schema2.cleanKey)(schema, key, value, cleanOptions);
+      }
+      if (operation === "$unset") {
+        const isPresent = await (0, import_schema2.cleanKey)(schema, key, "anyvalue", cleanOptions);
+        cleaned = !isNil(isPresent) ? "" : null;
+      }
+      if (cleaned !== void 0) {
+        cleanedModifier[operation][key] = cleaned;
+      }
+    }
+    if (isEmpty(cleanedModifier[operation])) {
+      delete cleanedModifier[operation];
+    }
+  }
+  if (isUpsert) {
+    const cleanedSetOnInsert = await (0, import_schema2.clean)(schema, fromDot(cleanedModifier.$setOnInsert || {}));
+    if (!isEmpty(cleanedSetOnInsert)) {
+      cleanedModifier.$setOnInsert = cleanedSetOnInsert;
+    }
+  }
+  if (equals(cleanedModifier, {})) {
+    throw new Error("After cleaning your modifier is empty");
+  }
+  return cleanedModifier;
+}
+
 // src/createCollection/getMethods/validateModifier/validatePush.ts
+var import_schema3 = require("@orion-js/schema");
 async function validatePush_default({ schema, operationDoc, operation }) {
   for (const key of Object.keys(operationDoc)) {
     const value = operationDoc[key];
@@ -573,43 +636,43 @@ async function validatePush_default({ schema, operationDoc, operation }) {
       }
     }
     const validationObject = fromDot({ [key]: toValidate });
-    await (0, import_schema2.validate)(schema, validationObject, { omitRequired: true });
+    await (0, import_schema3.validate)(schema, validationObject, { omitRequired: true });
   }
 }
 
 // src/createCollection/getMethods/validateModifier/validateUnset.ts
-var import_schema3 = require("@orion-js/schema");
+var import_schema4 = require("@orion-js/schema");
 async function validateUnset_default({ schema, operationDoc }) {
   const errors = {};
   for (const key of Object.keys(operationDoc)) {
-    const error = await (0, import_schema3.validateKey)(schema, key, null);
+    const error = await (0, import_schema4.validateKey)(schema, key, null);
     if (error) {
       errors[key] = error;
     }
   }
   if (Object.keys(errors).length) {
-    throw new import_schema3.ValidationError(errors);
+    throw new import_schema4.ValidationError(errors);
   }
 }
 
 // src/createCollection/getMethods/validateModifier/validateInc.ts
-var import_schema4 = require("@orion-js/schema");
+var import_schema5 = require("@orion-js/schema");
 async function validateInc_default({ schema, operationDoc }) {
   const errors = {};
   for (const key of Object.keys(operationDoc)) {
     const value = operationDoc[key];
-    const error = await (0, import_schema4.validateKey)(schema, key, value);
+    const error = await (0, import_schema5.validateKey)(schema, key, value);
     if (error) {
       errors[key] = error;
     }
   }
   if (Object.keys(errors).length) {
-    throw new import_schema4.ValidationError(errors);
+    throw new import_schema5.ValidationError(errors);
   }
 }
 
 // src/createCollection/getMethods/validateModifier/validateSet.ts
-var import_schema5 = require("@orion-js/schema");
+var import_schema6 = require("@orion-js/schema");
 async function validateSet_default({ schema, operationDoc }) {
   let cleaned = toDot_default(operationDoc);
   const transformedObj = {};
@@ -618,16 +681,16 @@ async function validateSet_default({ schema, operationDoc }) {
     transformedObj[newKey] = cleaned[key];
   });
   cleaned = fromDot(transformedObj);
-  await (0, import_schema5.validate)(schema, cleaned, { omitRequired: true });
+  await (0, import_schema6.validate)(schema, cleaned, { omitRequired: true });
 }
 
 // src/createCollection/getMethods/validateModifier/validateOperator.ts
-var shouldCheck = function(key) {
+var shouldCheck2 = function(key) {
   if (key === "$pushAll") throw new Error("$pushAll is not supported, use $push + $each");
   return ["$pull", "$pullAll", "$pop", "$slice"].indexOf(key) === -1;
 };
 async function validateOperator_default({ schema, operationDoc, operation }) {
-  if (!shouldCheck(operation)) return;
+  if (!shouldCheck2(operation)) return;
   if (operation === "$set") {
     await validateSet_default({ schema, operationDoc });
   } else if (operation === "$unset") {
@@ -653,7 +716,7 @@ async function validateModifier(schema, modifier) {
 }
 
 // src/createCollection/getMethods/validateModifier/validateUpsert.ts
-var import_schema6 = require("@orion-js/schema");
+var import_schema7 = require("@orion-js/schema");
 var getPushSimulation = ($push) => {
   if (!$push) return {};
   const simulation = {};
@@ -677,76 +740,13 @@ var simulateNewDoc = (selector, modifier) => fromDot({
 });
 var validateNewDoc = async (schema, selector, modifier) => {
   const doc = simulateNewDoc(selector, modifier);
-  await (0, import_schema6.validate)(schema, doc);
+  await (0, import_schema7.validate)(schema, doc);
 };
 async function validateUpsert_default(schema, selector, modifier) {
   await validateNewDoc(schema, selector, modifier);
   await validateModifier(schema, omit(["$setOnInsert"], modifier));
 }
 
-// src/createCollection/getMethods/cleanModifier.ts
-var import_schema7 = require("@orion-js/schema");
-var shouldCheck2 = (key) => {
-  if (key === "$pushAll") throw new Error("$pushAll is not supported; use $push + $each");
-  return ["$pull", "$pullAll", "$pop", "$slice"].indexOf(key) === -1;
-};
-async function cleanModifier(schema, modifier, { isUpsert } = { isUpsert: false }) {
-  const cleanedModifier = {};
-  for (const operation of Object.keys(modifier)) {
-    const operationDoc = modifier[operation];
-    cleanedModifier[operation] = {};
-    if (operation.slice(0, 1) !== "$") {
-      throw new Error(`Expected '${operation}' to be a modifier operator like '$set'`);
-    }
-    if (!shouldCheck2(operation)) {
-      cleanedModifier[operation] = operationDoc;
-      continue;
-    }
-    for (const key of Object.keys(operationDoc)) {
-      const value = operationDoc[key];
-      const cleanOptions = { forceDoc: operationDoc };
-      let cleaned = null;
-      if (operation === "$push" || operation === "$addToSet") {
-        if (typeof value === "object" && "$each" in value) {
-          const $each = await (0, import_schema7.cleanKey)(schema, key, value.$each, cleanOptions);
-          cleaned = { ...value, $each };
-        } else {
-          cleaned = await (0, import_schema7.cleanKey)(schema, `${key}.0`, value, cleanOptions);
-        }
-      }
-      if (operation === "$set") {
-        cleaned = await (0, import_schema7.cleanKey)(schema, key, value, cleanOptions);
-      }
-      if (operation === "$setOnInsert") {
-        cleaned = await (0, import_schema7.cleanKey)(schema, key, value, cleanOptions);
-      }
-      if (operation === "$inc") {
-        cleaned = await (0, import_schema7.cleanKey)(schema, key, value, cleanOptions);
-      }
-      if (operation === "$unset") {
-        const isPresent = await (0, import_schema7.cleanKey)(schema, key, "anyvalue", cleanOptions);
-        cleaned = !isNil(isPresent) ? "" : null;
-      }
-      if (cleaned !== void 0) {
-        cleanedModifier[operation][key] = cleaned;
-      }
-    }
-    if (isEmpty(cleanedModifier[operation])) {
-      delete cleanedModifier[operation];
-    }
-  }
-  if (isUpsert) {
-    const cleanedSetOnInsert = await (0, import_schema7.clean)(schema, fromDot(cleanedModifier.$setOnInsert || {}));
-    if (!isEmpty(cleanedSetOnInsert)) {
-      cleanedModifier.$setOnInsert = cleanedSetOnInsert;
-    }
-  }
-  if (equals(cleanedModifier, {})) {
-    throw new Error("After cleaning your modifier is empty");
-  }
-  return cleanedModifier;
-}
-
 // src/createCollection/getMethods/wrapErrors.ts
 var import_schema8 = require("@orion-js/schema");
 var wrapErrors = async (operation) => {
@@ -775,10 +775,10 @@ var wrapErrors = async (operation) => {
 
 // src/createCollection/getMethods/upsert.ts
 var upsert_default = (collection) => {
-  const upsert = async function(selectorArg, modifierArg, options = {}) {
+  const upsert = async (selectorArg, modifierArg, options = {}) => {
     await collection.connectionPromise;
     let modifier = modifierArg;
-    let selector = getSelector(arguments);
+    let selector = getSelector([selectorArg]);
     modifier.$setOnInsert = { ...modifier.$setOnInsert, _id: collection.generateId() };
     if (collection.schema) {
       const schema = collection.getSchema();
@@ -869,16 +869,17 @@ var updateMany_default = (collection) => {
 
 // src/createCollection/getMethods/updateAndFind.ts
 var updateAndFind_default = (collection) => {
-  const updateAndFind = async function(selector, modifier, options = {}) {
+  const updateAndFind = async (selector, modifier, options = {}) => {
     await collection.connectionPromise;
     return await wrapErrors(async () => {
-      return await collection.findOneAndUpdate(selector, modifier, {
+      const result = await collection.findOneAndUpdate(selector, modifier, {
         ...options,
         mongoOptions: {
           ...options.mongoOptions,
           returnDocument: "after"
         }
       });
+      return result;
     });
   };
   return updateAndFind;
@@ -963,10 +964,14 @@ var insertMany_default = (collection) => {
 
 // src/createCollection/getMethods/updateItem.ts
 function updateItem_default(collection) {
-  const updateItem = async function(item, modifier, options = {}) {
+  const updateItem = async (item, modifier, options = {}) => {
     await collection.connectionPromise;
     const updated = await wrapErrors(async () => {
-      return await collection.updateAndFind(item._id, modifier, options);
+      return await collection.updateAndFind(
+        item._id,
+        modifier,
+        options
+      );
     });
     for (const key in item) {
       delete item[key];
@@ -1162,10 +1167,11 @@ function loadData_default(collection) {
 var import_helpers6 = require("@orion-js/helpers");
 var import_bson = require("bson");
 var getIdGenerator = (options) => {
-  var _a, _b;
-  if (!options.idPrefix && ((_a = options == null ? void 0 : options.schema) == null ? void 0 : _a._id)) {
-    const idField = options.schema._id.type;
-    if ((_b = idField.name) == null ? void 0 : _b.startsWith("typedId:")) {
+  var _a;
+  const schema = options.schema;
+  if (!options.idPrefix && (schema == null ? void 0 : schema._id)) {
+    const idField = schema._id.type;
+    if ((_a = idField.name) == null ? void 0 : _a.startsWith("typedId:")) {
       return () => {
         return idField.generateId();
       };
@@ -1436,20 +1442,21 @@ function prepareShema(schema) {
 function getSchema(options) {
   var _a;
   if (!options.schema) return;
-  if ((_a = options.schema[Symbol.metadata]) == null ? void 0 : _a._getModel) {
-    return options.schema[Symbol.metadata]._getModel().getSchema();
+  const schemaOption = options.schema;
+  if ((_a = schemaOption[Symbol.metadata]) == null ? void 0 : _a._getModel) {
+    return schemaOption[Symbol.metadata]._getModel().getSchema();
   }
-  if (options.schema.getSchema) {
-    const schema = options.schema.getSchema();
+  if (schemaOption.getSchema) {
+    const schema = schemaOption.getSchema();
     return prepareShema(schema);
   }
-  if (options.schema.getModel) {
-    const model = options.schema.getModel();
+  if (schemaOption.getModel) {
+    const model = schemaOption.getModel();
     const schema = model ? (0, import_helpers7.clone)(model.getSchema()) : {};
     return prepareShema(schema);
   }
-  if (type(options.schema) === "Object") {
-    return prepareShema(options.schema);
+  if (type(schemaOption) === "Object") {
+    return prepareShema(schemaOption);
   }
 }