vimcord 1.0.47 → 1.0.49

package/dist/index.cjs

@@ -1787,7 +1787,7 @@ var VimcordErrorHandler = class {
 var import_chalk2 = __toESM(require("chalk"));
 
 // package.json
-var version = "1.0.47";
+var version = "1.0.48";
 
 // src/client/vimcord.logger.ts
 var clientLoggerFactory = (client) => new Logger({ prefixEmoji: "\u26A1", prefix: `vimcord (i${client.clientId})` }).extend({
@@ -3072,7 +3072,6 @@ var MongoDatabase = class _MongoDatabase {
 
 // src/db/mongo/mongoSchema.builder.ts
 var import_mongoose2 = require("mongoose");
-var import_node_crypto4 = require("crypto");
 var import_qznt6 = require("qznt");
 try {
   import("mongoose");
@@ -3159,7 +3158,7 @@ var MongoSchemaBuilder = class _MongoSchemaBuilder {
    * @param maxRetries [default: 3]
    */
   async execute(fn, maxRetries = 3) {
-    return await import_qznt6.$.async.retry(
+    return (0, import_qznt6.retry)(
       async () => {
         const model = await this.getModel();
         return await fn(model);
@@ -3168,82 +3167,81 @@ var MongoSchemaBuilder = class _MongoSchemaBuilder {
     );
   }
   async startSession(options) {
-    return await this.execute(async () => {
+    return this.execute(async () => {
       if (!this.db) throw new Error("No database instance found");
       return await this.db.startSession(options);
     });
   }
   async useTransaction(fn) {
-    return await this.execute(async (model) => {
+    return this.execute(async (model) => {
       if (!this.db) throw new Error("No database instance found");
       return await this.db.useTransaction((session) => fn(session, model));
     });
   }
-  async createHexId(bytes, path2, maxRetries = 10) {
-    return await this.execute(async (model) => {
-      const createHex = () => (0, import_node_crypto4.randomBytes)(bytes).toString("hex");
-      let id = createHex();
+  async createUniqueId(collisionPath, fn, maxRetries = 10) {
+    return this.execute(async (model) => {
+      let id;
       let tries = 0;
-      while (await model.exists({ [path2]: id })) {
-        if (tries >= maxRetries) throw Error(`Failed to generate a unique hex ID after ${tries} attempt(s)`);
-        id = createHex();
+      do {
+        if (tries >= maxRetries) throw new Error(`Failed to generate a unique ID after ${tries} attempt(s)`);
+        id = fn();
         tries++;
-      }
+      } while (await model.exists({ [collisionPath]: id }));
       return id;
     });
   }
   async count(filter, options) {
-    return await this.execute(async (model) => model.countDocuments(filter, options));
+    return this.execute(async (model) => model.countDocuments(filter, options));
   }
   async exists(filter) {
-    return await this.execute(async (model) => !!await model.exists(filter));
+    return this.execute(async (model) => !!await model.exists(filter));
   }
   async create(query, options) {
-    return await this.execute(async (model) => model.create(query, options));
+    return this.execute(async (model) => model.create(query, options));
   }
   async upsert(filter, query, options) {
-    return await this.execute(
-      async (model) => model.findOneAndUpdate(filter, query, { ...options, upsert: true, new: true })
+    return this.execute(
+      async (model) => model.findOneAndUpdate(filter, query, { returnDocument: "after", ...options, upsert: true })
     );
   }
   async delete(filter, options) {
-    return await this.execute(async (model) => model.deleteOne(filter, options));
+    return this.execute(async (model) => model.deleteOne(filter, options));
   }
   async deleteAll(filter, options) {
-    return await this.execute(async (model) => model.deleteMany(filter, options));
+    return this.execute(async (model) => model.deleteMany(filter, options));
   }
   async distinct(key, filter, options) {
-    return await this.execute(async (model) => model.distinct(key, filter, options));
+    return this.execute(async (model) => model.distinct(key, filter, options));
   }
   async fetch(filter, projection, options) {
-    return await this.execute(
+    const result = await this.execute(
       async (model) => model.findOne(filter, projection, { ...options, lean: options?.lean ?? true })
     );
+    if (options?.required && !result) throw new Error("Document not found");
+    return result;
   }
   async fetchAll(filter = {}, projection, options) {
-    return await this.execute(
-      async (model) => model.find(filter, projection, { ...options, lean: options?.lean ?? true })
-    );
+    return this.execute(async (model) => model.find(filter, projection, { ...options, lean: options?.lean ?? true }));
   }
   async update(filter, update, options) {
-    return await this.execute(
+    return this.execute(
       async (model) => model.findOneAndUpdate(filter, update, { ...options, lean: options?.lean ?? true })
     );
   }
   async updateAll(filter, update, options) {
-    return await this.execute(async (model) => model.updateMany(filter, update, options));
+    return this.execute(async (model) => model.updateMany(filter, update, options));
   }
   async aggregate(pipeline, options) {
-    return await this.execute(async (model) => {
+    return this.execute(async (model) => {
       const result = await model.aggregate(pipeline, options);
       return result?.length ? result : [];
     });
   }
   async bulkWrite(ops, options) {
-    return await this.execute(async (model) => model.bulkWrite(ops, options));
+    return this.execute(async (model) => model.bulkWrite(ops, options));
   }
   async bulkSave(docs, options) {
-    return await this.execute(async (model) => model.bulkSave(docs, options));
+    return this.execute(async (model) => model.bulkSave(docs, options));
   }
 };