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

package/dist/index.js

@@ -153,15 +153,215 @@ function typedId(prefix) {
 // src/service/index.ts
 import { Service } from "@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
-import isPlainObject from "lodash/isPlainObject";
 function getSelector(args) {
   if (args.length === 0) return {};
   const selector = args[0];
   if (typeof selector === "string") {
     return { _id: selector };
   }
-  if (isPlainObject(selector)) {
+  if (type(selector) === "Object") {
     return selector;
   }
   return {
@@ -261,11 +461,14 @@ async function validateInc_default({ schema, operationDoc }) {
 
 // src/createCollection/getMethods/validateModifier/validateSet.ts
 import { validate as validate2 } from "@orion-js/schema";
-import mapKeys from "lodash/mapKeys";
 async function validateSet_default({ schema, operationDoc }) {
   let cleaned = toDot_default(operationDoc);
-  cleaned = mapKeys(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 validate2(schema, cleaned, { omitRequired: true });
 }
 
@@ -302,8 +505,7 @@ async function validateModifier(schema, modifier) {
 
 // src/createCollection/getMethods/validateModifier/validateUpsert.ts
 import { validate as validate3 } from "@orion-js/schema";
-import omit from "lodash/omit";
-var getPushSimulation = function($push) {
+var getPushSimulation = ($push) => {
   if (!$push) return {};
   const simulation = {};
   for (const key of Object.keys($push)) {
@@ -316,31 +518,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 validate3(schema, doc);
 };
 async function validateUpsert_default(schema, selector, modifier) {
   await validateNewDoc(schema, selector, modifier);
-  await validateModifier(schema, omit(modifier, "$setOnInsert"));
+  await validateModifier(schema, omit(["$setOnInsert"], modifier));
 }
 
 // src/createCollection/getMethods/cleanModifier.ts
 import { cleanKey, clean } from "@orion-js/schema";
-import isEmpty from "lodash/isEmpty";
-import isNil from "lodash/isNil";
-import isUndefined from "lodash/isUndefined";
-import isEqual from "lodash/isEqual";
 var shouldCheck2 = (key) => {
   if (key === "$pushAll") throw new Error("$pushAll is not supported; use $push + $each");
   return ["$pull", "$pullAll", "$pop", "$slice"].indexOf(key) === -1;
@@ -382,7 +578,7 @@ async function cleanModifier(schema, modifier, { isUpsert } = { isUpsert: false
         const isPresent = await cleanKey(schema, key, "anyvalue", cleanOptions);
         cleaned = !isNil(isPresent) ? "" : null;
       }
-      if (!isUndefined(cleaned)) {
+      if (cleaned !== void 0) {
         cleanedModifier[operation][key] = cleaned;
       }
     }
@@ -396,7 +592,7 @@ async function cleanModifier(schema, modifier, { isUpsert } = { isUpsert: false
       cleanedModifier.$setOnInsert = cleanedSetOnInsert;
     }
   }
-  if (isEqual(cleanedModifier, {})) {
+  if (equals(cleanedModifier, {})) {
     throw new Error("After cleaning your modifier is empty");
   }
   return cleanedModifier;
@@ -562,13 +758,12 @@ function deleteMany_default(collection) {
 }
 
 // src/createCollection/getMethods/insertOne.ts
-import isPlainObject2 from "lodash/isPlainObject";
 import { clean as clean2, validate as validate4 } from "@orion-js/schema";
 var insertOne_default = (collection) => {
   const insertOne = async (insertDoc, options = {}) => {
     await collection.connectionPromise;
     let doc = insertDoc;
-    if (!doc || !isPlainObject2(doc)) {
+    if (!doc || !isType("Object", doc)) {
       throw new Error("Insert must receive a document");
     }
     if (!doc._id) {
@@ -588,15 +783,14 @@ var insertOne_default = (collection) => {
 };
 
 // src/createCollection/getMethods/insertMany.ts
-import isPlainObject3 from "lodash/isPlainObject";
-import { cloneDeep, values } from "lodash";
+import { clone } from "@orion-js/helpers";
 import { clean as clean3, validate as validate5 } from "@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 = cloneDeep(docs[index]);
-      if (!doc || !isPlainObject3(doc)) {
+      let doc = clone(docs[index]);
+      if (!doc || type(doc) !== "Object") {
         throw new Error(`Item at index ${index} is not a document`);
       }
       if (!doc._id) {
@@ -612,7 +806,7 @@ var insertMany_default = (collection) => {
     const { insertedIds } = await wrapErrors(() => {
       return collection.rawCollection.insertMany(docs, options.mongoOptions);
     });
-    const ids = values(insertedIds);
+    const ids = Object.values(insertedIds);
     return ids.map((id) => id.toString());
   };
   return insertMany;
@@ -657,13 +851,12 @@ var estimatedDocumentCount_default = (collection) => {
 };
 
 // src/createCollection/getMethods/insertAndFind.ts
-import isPlainObject4 from "lodash/isPlainObject";
 import { clean as clean4, validate as validate6 } from "@orion-js/schema";
 var insertAndFind_default = (collection) => {
   const insertAndFind = async (insertDoc, options = {}) => {
     await collection.connectionPromise;
     let doc = insertDoc;
-    if (!doc || !isPlainObject4(doc)) {
+    if (!doc || type(doc) !== "Object") {
       throw new Error("Insert must receive a document");
     }
     if (!doc._id) {
@@ -713,8 +906,7 @@ function loadOne_default(collection) {
 }
 
 // src/createCollection/getMethods/dataLoader/loadData.ts
-import { createMapArray } from "@orion-js/helpers";
-import cloneDeep2 from "lodash/cloneDeep";
+import { createMapArray, clone as clone2 } from "@orion-js/helpers";
 
 // src/createCollection/getMethods/dataLoader/dataLoad/getDataLoader.ts
 import DataLoader from "dataloader";
@@ -736,7 +928,6 @@ var getDataLoader = (params) => {
 };
 
 // src/createCollection/getMethods/dataLoader/dataLoad/index.ts
-import flatten from "lodash/flatten";
 import { hashObject } from "@orion-js/helpers";
 var dataLoad = async (options) => {
   const dataLoader = getDataLoader({
@@ -767,10 +958,10 @@ function loadData_default(collection) {
       id: options.value,
       ids: options.values,
       timeout: options.timeout,
-      load: async (values2) => {
+      load: async (values) => {
         const query = {
-          ...cloneDeep2(options.match),
-          [options.key]: { $in: values2 }
+          ...clone2(options.match),
+          [options.key]: { $in: values }
         };
         const cursor = collection.find(query);
         if (options.sort) {
@@ -784,7 +975,7 @@ function loadData_default(collection) {
         }
         const items = await cursor.toArray();
         const itemsMap = createMapArray(items, options.key);
-        return values2.map((value) => {
+        return values.map((value) => {
           return itemsMap[value] || [];
         });
       }
@@ -890,7 +1081,7 @@ async function loadIndexes(collection) {
 }
 
 // src/createCollection/getSchemaAndModel.ts
-import { cloneDeep as cloneDeep3, isPlainObject as isPlainObject5 } from "lodash";
+import { clone as clone3 } from "@orion-js/helpers";
 Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
 function prepareShema(schema) {
   if (!schema._id) {
@@ -912,10 +1103,10 @@ function getSchema(options) {
   }
   if (options.schema.getModel) {
     const model = options.schema.getModel();
-    const schema = model ? cloneDeep3(model.getSchema()) : {};
+    const schema = model ? clone3(model.getSchema()) : {};
     return prepareShema(schema);
   }
-  if (isPlainObject5(options.schema)) {
+  if (type(options.schema) === "Object") {
     return prepareShema(options.schema);
   }
 }