@orion-js/mongodb 4.0.0-next.4 → 4.0.0-next.6

package/dist/index.cjs

@@ -197,15 +197,215 @@ function typedId(prefix) {
 // src/service/index.ts
 var import_services = require("@orion-js/services");
 
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/type.js
+function type(input) {
+  if (input === null) {
+    return "Null";
+  } else if (input === void 0) {
+    return "Undefined";
+  } else if (Number.isNaN(input)) {
+    return "NaN";
+  }
+  const typeResult = Object.prototype.toString.call(input).slice(8, -1);
+  return typeResult === "AsyncFunction" ? "Promise" : typeResult;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/isArray.js
+var { isArray } = Array;
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/isInteger.js
+function _isInteger(n) {
+  return n << 0 === n;
+}
+var isInteger = Number.isInteger || _isInteger;
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/createPath.js
+function createPath(path, delimiter = ".") {
+  return typeof path === "string" ? path.split(delimiter).map((x) => isInteger(x) ? Number(x) : x) : path;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/equals.js
+function _indexOf(valueToFind, list) {
+  if (!isArray(list))
+    throw new Error(`Cannot read property 'indexOf' of ${list}`);
+  const typeOfValue = type(valueToFind);
+  if (!["Array", "NaN", "Object", "RegExp"].includes(typeOfValue))
+    return list.indexOf(valueToFind);
+  let index = -1;
+  let foundIndex = -1;
+  const { length } = list;
+  while (++index < length && foundIndex === -1)
+    if (equals(list[index], valueToFind))
+      foundIndex = index;
+  return foundIndex;
+}
+function _arrayFromIterator(iter) {
+  const list = [];
+  let next;
+  while (!(next = iter.next()).done)
+    list.push(next.value);
+  return list;
+}
+function _compareSets(a, b) {
+  if (a.size !== b.size)
+    return false;
+  const aList = _arrayFromIterator(a.values());
+  const bList = _arrayFromIterator(b.values());
+  const filtered = aList.filter((aInstance) => _indexOf(aInstance, bList) === -1);
+  return filtered.length === 0;
+}
+function compareErrors(a, b) {
+  if (a.message !== b.message) return false;
+  if (a.toString !== b.toString) return false;
+  return a.toString() === b.toString();
+}
+function parseDate(maybeDate) {
+  if (!maybeDate.toDateString) return [false];
+  return [true, maybeDate.getTime()];
+}
+function parseRegex(maybeRegex) {
+  if (maybeRegex.constructor !== RegExp) return [false];
+  return [true, maybeRegex.toString()];
+}
+function equals(a, b) {
+  if (arguments.length === 1) return (_b) => equals(a, _b);
+  if (Object.is(a, b)) return true;
+  const aType = type(a);
+  if (aType !== type(b)) return false;
+  if (aType === "Function")
+    return a.name === void 0 ? false : a.name === b.name;
+  if (["NaN", "Null", "Undefined"].includes(aType)) return true;
+  if (["BigInt", "Number"].includes(aType)) {
+    if (Object.is(-0, a) !== Object.is(-0, b)) return false;
+    return a.toString() === b.toString();
+  }
+  if (["Boolean", "String"].includes(aType))
+    return a.toString() === b.toString();
+  if (aType === "Array") {
+    const aClone = Array.from(a);
+    const bClone = Array.from(b);
+    if (aClone.toString() !== bClone.toString())
+      return false;
+    let loopArrayFlag = true;
+    aClone.forEach((aCloneInstance, aCloneIndex) => {
+      if (loopArrayFlag) {
+        if (aCloneInstance !== bClone[aCloneIndex] && !equals(aCloneInstance, bClone[aCloneIndex]))
+          loopArrayFlag = false;
+      }
+    });
+    return loopArrayFlag;
+  }
+  const aRegex = parseRegex(a);
+  const bRegex = parseRegex(b);
+  if (aRegex[0])
+    return bRegex[0] ? aRegex[1] === bRegex[1] : false;
+  else if (bRegex[0]) return false;
+  const aDate = parseDate(a);
+  const bDate = parseDate(b);
+  if (aDate[0])
+    return bDate[0] ? aDate[1] === bDate[1] : false;
+  else if (bDate[0]) return false;
+  if (a instanceof Error) {
+    if (!(b instanceof Error)) return false;
+    return compareErrors(a, b);
+  }
+  if (aType === "Set")
+    return _compareSets(a, b);
+  if (aType === "Object") {
+    const aKeys = Object.keys(a);
+    if (aKeys.length !== Object.keys(b).length)
+      return false;
+    let loopObjectFlag = true;
+    aKeys.forEach((aKeyInstance) => {
+      if (loopObjectFlag) {
+        const aValue = a[aKeyInstance];
+        const bValue = b[aKeyInstance];
+        if (aValue !== bValue && !equals(aValue, bValue))
+          loopObjectFlag = false;
+      }
+    });
+    return loopObjectFlag;
+  }
+  return false;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/isType.js
+function isType(xType, x) {
+  if (arguments.length === 1) {
+    return (xHolder) => isType(xType, xHolder);
+  }
+  return type(x) === xType;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/compare.js
+function compare(a, b) {
+  return String(a) === String(b);
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/includes.js
+function includes(a, list) {
+  let index = -1;
+  const { length } = list;
+  while (++index < length)
+    if (compare(list[index], a))
+      return true;
+  return false;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/omit.js
+function omit(propsToOmit, obj) {
+  if (arguments.length === 1) return (_obj) => omit(propsToOmit, _obj);
+  if (obj === null || obj === void 0)
+    return void 0;
+  const propsToOmitValue = createPath(propsToOmit, ",");
+  const willReturn = {};
+  for (const key in obj)
+    if (!includes(key, propsToOmitValue))
+      willReturn[key] = obj[key];
+  return willReturn;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/flatten.js
+function flatten(list, input) {
+  const willReturn = input === void 0 ? [] : input;
+  for (let i = 0; i < list.length; i++) {
+    if (isArray(list[i])) {
+      flatten(list[i], willReturn);
+    } else {
+      willReturn.push(list[i]);
+    }
+  }
+  return willReturn;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/isEmpty.js
+function isEmpty(input) {
+  const inputType = type(input);
+  if (["Undefined", "NaN", "Number", "Null"].includes(inputType))
+    return false;
+  if (!input) return true;
+  if (inputType === "Object") {
+    return Object.keys(input).length === 0;
+  }
+  if (inputType === "Array") {
+    return input.length === 0;
+  }
+  return false;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/isNil.js
+function isNil(x) {
+  return x === void 0 || x === null;
+}
+
 // src/createCollection/getMethods/getSelector.ts
-var import_isPlainObject = __toESM(require("lodash/isPlainObject"), 1);
 function getSelector(args) {
   if (args.length === 0) return {};
   const selector = args[0];
   if (typeof selector === "string") {
     return { _id: selector };
   }
-  if ((0, import_isPlainObject.default)(selector)) {
+  if (type(selector) === "Object") {
     return selector;
   }
   return {
@@ -305,11 +505,14 @@ async function validateInc_default({ schema, operationDoc }) {
 
 // src/createCollection/getMethods/validateModifier/validateSet.ts
 var import_schema5 = require("@orion-js/schema");
-var import_mapKeys = __toESM(require("lodash/mapKeys"), 1);
 async function validateSet_default({ schema, operationDoc }) {
   let cleaned = toDot_default(operationDoc);
-  cleaned = (0, import_mapKeys.default)(cleaned, (value, key) => key.replace("$.", "0."));
-  cleaned = fromDot(cleaned);
+  const transformedObj = {};
+  Object.keys(cleaned).map((key) => {
+    const newKey = key.replace("$.", "0.");
+    transformedObj[newKey] = cleaned[key];
+  });
+  cleaned = fromDot(transformedObj);
   await (0, import_schema5.validate)(schema, cleaned, { omitRequired: true });
 }
 
@@ -346,8 +549,7 @@ async function validateModifier(schema, modifier) {
 
 // src/createCollection/getMethods/validateModifier/validateUpsert.ts
 var import_schema6 = require("@orion-js/schema");
-var import_omit = __toESM(require("lodash/omit"), 1);
-var getPushSimulation = function($push) {
+var getPushSimulation = ($push) => {
   if (!$push) return {};
   const simulation = {};
   for (const key of Object.keys($push)) {
@@ -360,31 +562,25 @@ var getPushSimulation = function($push) {
   }
   return simulation;
 };
-var simulateNewDoc = function(selector, modifier) {
-  return fromDot({
-    ...selector,
-    ...modifier.$set,
-    ...modifier.$inc,
-    ...getPushSimulation(modifier.$push),
-    ...getPushSimulation(modifier.$addToSet),
-    ...modifier.$setOnInsert
-  });
-};
-var validateNewDoc = async function(schema, selector, modifier) {
+var simulateNewDoc = (selector, modifier) => fromDot({
+  ...selector,
+  ...modifier.$set,
+  ...modifier.$inc,
+  ...getPushSimulation(modifier.$push),
+  ...getPushSimulation(modifier.$addToSet),
+  ...modifier.$setOnInsert
+});
+var validateNewDoc = async (schema, selector, modifier) => {
   const doc = simulateNewDoc(selector, modifier);
   await (0, import_schema6.validate)(schema, doc);
 };
 async function validateUpsert_default(schema, selector, modifier) {
   await validateNewDoc(schema, selector, modifier);
-  await validateModifier(schema, (0, import_omit.default)(modifier, "$setOnInsert"));
+  await validateModifier(schema, omit(["$setOnInsert"], modifier));
 }
 
 // src/createCollection/getMethods/cleanModifier.ts
 var import_schema7 = require("@orion-js/schema");
-var import_isEmpty = __toESM(require("lodash/isEmpty"), 1);
-var import_isNil = __toESM(require("lodash/isNil"), 1);
-var import_isUndefined = __toESM(require("lodash/isUndefined"), 1);
-var import_isEqual = __toESM(require("lodash/isEqual"), 1);
 var shouldCheck2 = (key) => {
   if (key === "$pushAll") throw new Error("$pushAll is not supported; use $push + $each");
   return ["$pull", "$pullAll", "$pop", "$slice"].indexOf(key) === -1;
@@ -424,23 +620,23 @@ async function cleanModifier(schema, modifier, { isUpsert } = { isUpsert: false
       }
       if (operation === "$unset") {
         const isPresent = await (0, import_schema7.cleanKey)(schema, key, "anyvalue", cleanOptions);
-        cleaned = !(0, import_isNil.default)(isPresent) ? "" : null;
+        cleaned = !isNil(isPresent) ? "" : null;
       }
-      if (!(0, import_isUndefined.default)(cleaned)) {
+      if (cleaned !== void 0) {
         cleanedModifier[operation][key] = cleaned;
       }
     }
-    if ((0, import_isEmpty.default)(cleanedModifier[operation])) {
+    if (isEmpty(cleanedModifier[operation])) {
       delete cleanedModifier[operation];
     }
   }
   if (isUpsert) {
     const cleanedSetOnInsert = await (0, import_schema7.clean)(schema, fromDot(cleanedModifier.$setOnInsert || {}));
-    if (!(0, import_isEmpty.default)(cleanedSetOnInsert)) {
+    if (!isEmpty(cleanedSetOnInsert)) {
       cleanedModifier.$setOnInsert = cleanedSetOnInsert;
     }
   }
-  if ((0, import_isEqual.default)(cleanedModifier, {})) {
+  if (equals(cleanedModifier, {})) {
     throw new Error("After cleaning your modifier is empty");
   }
   return cleanedModifier;
@@ -606,13 +802,12 @@ function deleteMany_default(collection) {
 }
 
 // src/createCollection/getMethods/insertOne.ts
-var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"), 1);
 var import_schema9 = require("@orion-js/schema");
 var insertOne_default = (collection) => {
   const insertOne = async (insertDoc, options = {}) => {
     await collection.connectionPromise;
     let doc = insertDoc;
-    if (!doc || !(0, import_isPlainObject2.default)(doc)) {
+    if (!doc || !isType("Object", doc)) {
       throw new Error("Insert must receive a document");
     }
     if (!doc._id) {
@@ -632,15 +827,14 @@ var insertOne_default = (collection) => {
 };
 
 // src/createCollection/getMethods/insertMany.ts
-var import_isPlainObject3 = __toESM(require("lodash/isPlainObject"), 1);
-var import_lodash = require("lodash");
+var import_helpers2 = require("@orion-js/helpers");
 var import_schema10 = require("@orion-js/schema");
 var insertMany_default = (collection) => {
   const insertMany = async (docs, options = {}) => {
     await collection.connectionPromise;
     for (let index = 0; index < docs.length; index++) {
-      let doc = (0, import_lodash.cloneDeep)(docs[index]);
-      if (!doc || !(0, import_isPlainObject3.default)(doc)) {
+      let doc = (0, import_helpers2.clone)(docs[index]);
+      if (!doc || type(doc) !== "Object") {
         throw new Error(`Item at index ${index} is not a document`);
       }
       if (!doc._id) {
@@ -656,7 +850,7 @@ var insertMany_default = (collection) => {
     const { insertedIds } = await wrapErrors(() => {
       return collection.rawCollection.insertMany(docs, options.mongoOptions);
     });
-    const ids = (0, import_lodash.values)(insertedIds);
+    const ids = Object.values(insertedIds);
     return ids.map((id) => id.toString());
   };
   return insertMany;
@@ -701,13 +895,12 @@ var estimatedDocumentCount_default = (collection) => {
 };
 
 // src/createCollection/getMethods/insertAndFind.ts
-var import_isPlainObject4 = __toESM(require("lodash/isPlainObject"), 1);
 var import_schema11 = require("@orion-js/schema");
 var insertAndFind_default = (collection) => {
   const insertAndFind = async (insertDoc, options = {}) => {
     await collection.connectionPromise;
     let doc = insertDoc;
-    if (!doc || !(0, import_isPlainObject4.default)(doc)) {
+    if (!doc || type(doc) !== "Object") {
       throw new Error("Insert must receive a document");
     }
     if (!doc._id) {
@@ -757,8 +950,7 @@ function loadOne_default(collection) {
 }
 
 // src/createCollection/getMethods/dataLoader/loadData.ts
-var import_helpers3 = require("@orion-js/helpers");
-var import_cloneDeep = __toESM(require("lodash/cloneDeep"), 1);
+var import_helpers4 = require("@orion-js/helpers");
 
 // src/createCollection/getMethods/dataLoader/dataLoad/getDataLoader.ts
 var import_dataloader = __toESM(require("dataloader"), 1);
@@ -780,17 +972,16 @@ var getDataLoader = (params) => {
 };
 
 // src/createCollection/getMethods/dataLoader/dataLoad/index.ts
-var import_flatten = __toESM(require("lodash/flatten"), 1);
-var import_helpers2 = require("@orion-js/helpers");
+var import_helpers3 = require("@orion-js/helpers");
 var dataLoad = async (options) => {
   const dataLoader = getDataLoader({
-    key: (0, import_helpers2.hashObject)(options.loaderKey),
+    key: (0, import_helpers3.hashObject)(options.loaderKey),
     func: options.load,
     timeout: options.timeout || 5
   });
   if (options.ids) {
     const resultArray = await dataLoader.loadMany(options.ids);
-    return (0, import_flatten.default)(resultArray);
+    return flatten(resultArray);
   }
   return await dataLoader.load(options.id);
 };
@@ -811,10 +1002,10 @@ function loadData_default(collection) {
       id: options.value,
       ids: options.values,
       timeout: options.timeout,
-      load: async (values2) => {
+      load: async (values) => {
         const query = {
-          ...(0, import_cloneDeep.default)(options.match),
-          [options.key]: { $in: values2 }
+          ...(0, import_helpers4.clone)(options.match),
+          [options.key]: { $in: values }
         };
         const cursor = collection.find(query);
         if (options.sort) {
@@ -827,8 +1018,8 @@ function loadData_default(collection) {
           console.info(`Will execute data loading query now on ${collection.name}: `, query);
         }
         const items = await cursor.toArray();
-        const itemsMap = (0, import_helpers3.createMapArray)(items, options.key);
-        return values2.map((value) => {
+        const itemsMap = (0, import_helpers4.createMapArray)(items, options.key);
+        return values.map((value) => {
           return itemsMap[value] || [];
         });
       }
@@ -839,7 +1030,7 @@ function loadData_default(collection) {
 }
 
 // src/createCollection/generateId.ts
-var import_helpers4 = require("@orion-js/helpers");
+var import_helpers5 = require("@orion-js/helpers");
 var import_bson = require("bson");
 var getIdGenerator = (options) => {
   var _a, _b;
@@ -848,7 +1039,7 @@ var getIdGenerator = (options) => {
     if ((_b = idField.name) == null ? void 0 : _b.startsWith("typedId:")) {
       return () => {
         const prefix = idField.name.split(":")[1];
-        const random = (0, import_helpers4.generateUUID)();
+        const random = (0, import_helpers5.generateUUID)();
         return `${prefix}-${random}`;
       };
     }
@@ -856,14 +1047,14 @@ var getIdGenerator = (options) => {
   if (options.idPrefix || options.idGeneration === "uuid") {
     return () => {
       const prefix = options.idPrefix || "";
-      const random = (0, import_helpers4.generateUUID)();
+      const random = (0, import_helpers5.generateUUID)();
       return `${prefix}${random}`;
     };
   }
   if (options.idGeneration === "random") {
     return () => {
       const prefix = options.idPrefix || "";
-      const random = (0, import_helpers4.generateId)();
+      const random = (0, import_helpers5.generateId)();
       return `${prefix}${random}`;
     };
   }
@@ -934,7 +1125,7 @@ async function loadIndexes(collection) {
 }
 
 // src/createCollection/getSchemaAndModel.ts
-var import_lodash2 = require("lodash");
+var import_helpers6 = require("@orion-js/helpers");
 Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
 function prepareShema(schema) {
   if (!schema._id) {
@@ -956,10 +1147,10 @@ function getSchema(options) {
   }
   if (options.schema.getModel) {
     const model = options.schema.getModel();
-    const schema = model ? (0, import_lodash2.cloneDeep)(model.getSchema()) : {};
+    const schema = model ? (0, import_helpers6.clone)(model.getSchema()) : {};
     return prepareShema(schema);
   }
-  if ((0, import_lodash2.isPlainObject)(options.schema)) {
+  if (type(options.schema) === "Object") {
     return prepareShema(options.schema);
   }
 }