vimcord 1.0.46 → 1.0.48

package/dist/index.cjs

@@ -1787,7 +1787,7 @@ var VimcordErrorHandler = class {
 var import_chalk2 = __toESM(require("chalk"));
 
 // package.json
-var version = "1.0.45";
+var version = "1.0.48";
 
 // src/client/vimcord.logger.ts
 var clientLoggerFactory = (client) => new Logger({ prefixEmoji: "\u26A1", prefix: `vimcord (i${client.clientId})` }).extend({
@@ -3104,10 +3104,10 @@ var MongoSchemaBuilder = class _MongoSchemaBuilder {
     this.globalPlugins.push(plugin);
   }
   constructor(collection, definition, options = {}) {
-    const { instanceId = 0 } = options;
+    const { instanceId = 0, ...schemaOptions } = options;
     this.instanceId = instanceId;
     this.collection = collection;
-    this.schema = new import_mongoose2.Schema(definition, { versionKey: false });
+    this.schema = new import_mongoose2.Schema(definition, { versionKey: false, ...schemaOptions });
     this.logger = new Logger({
       prefixEmoji: "\u{1F96D}",
       prefix: `MongoSchema (i${instanceId}) [${collection}]`,
@@ -3159,7 +3159,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,19 +3168,19 @@ 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) => {
+    return this.execute(async (model) => {
       const createHex = () => (0, import_node_crypto4.randomBytes)(bytes).toString("hex");
       let id = createHex();
       let tries = 0;
@@ -3193,57 +3193,57 @@ var MongoSchemaBuilder = class _MongoSchemaBuilder {
     });
   }
   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));
   }
 };