vimcord 1.0.47 → 1.0.49

package/dist/index.d.mts

@@ -2460,7 +2460,7 @@ declare class MongoSchemaBuilder<Definition extends object = any> {
     execute<T extends (model: Model<Definition>) => any>(fn: T, maxRetries?: number): Promise<ExtractReturn<T>>;
     startSession(options?: ClientSessionOptions): Promise<mongo.ClientSession>;
     useTransaction(fn: (session: ClientSession, model: Model<Definition>) => any): Promise<void>;
-    createHexId(bytes: number, path: keyof Require_id<Definition>, maxRetries?: number): Promise<string>;
+    createUniqueId(collisionPath: keyof Require_id<Definition>, fn: () => string, maxRetries?: number): Promise<string>;
     count(filter?: RootFilterQuery<Definition>, options?: mongo.CountOptions & MongooseBaseQueryOptions<Definition> & mongo.Abortable): Promise<number>;
     exists(filter: RootFilterQuery<Definition>): Promise<boolean>;
     create(query: Partial<Require_id<Definition>>[], options?: CreateOptions): Promise<(Document<unknown, {}, Definition, {}, {}> & (Require_id<Definition> extends infer T ? T extends Require_id<Definition> ? T extends {
@@ -2468,15 +2468,20 @@ declare class MongoSchemaBuilder<Definition extends object = any> {
     } ? T : T & {
         __v: number;
     } : never : never))[]>;
-    upsert(filter: RootFilterQuery<Definition>, query: Partial<Require_id<Definition>>, options?: QueryOptions<Definition>): Promise<Document<unknown, {}, Definition, {}, {}> & (Require_id<Definition> extends infer T ? T extends Require_id<Definition> ? T extends {
+    upsert(filter: RootFilterQuery<Definition>, query: Partial<Require_id<Definition>>, options?: Exclude<QueryOptions<Definition>, "upsert">): Promise<(Document<unknown, {}, Definition, {}, {}> & (Require_id<Definition> extends infer T ? T extends Require_id<Definition> ? T extends {
         __v?: infer U;
     } ? T : T & {
         __v: number;
-    } : never : never)>;
+    } : never : never)) | null>;
     delete(filter: RootFilterQuery<Definition>, options?: mongo.DeleteOptions & MongooseBaseQueryOptions<Definition>): Promise<mongo.DeleteResult>;
     deleteAll(filter: RootFilterQuery<Definition>, options?: mongo.DeleteOptions & MongooseBaseQueryOptions<Definition>): Promise<mongo.DeleteResult>;
     distinct<K extends keyof Require_id<Definition> & string>(key: K, filter?: RootFilterQuery<Definition>, options?: QueryOptions<Definition>): Promise<(K extends keyof Definition | mongoose.NestedPaths<Required<Definition>, keyof Definition> ? mongoose.WithoutUndefined<mongoose.Unpacked<mongoose.WithLevel1NestedPaths<Definition, keyof Definition>[K]>> : unknown)[]>;
-    fetch<Options extends QueryOptions<Definition>>(filter?: RootFilterQuery<Definition>, projection?: ProjectionType<Definition>, options?: Options): Promise<LeanOrHydratedDocument<Definition, Options> | null | undefined>;
+    fetch<Options extends QueryOptions<Definition>>(filter?: RootFilterQuery<Definition>, projection?: ProjectionType<Definition>, options?: Options & {
+        required?: boolean;
+    }): Promise<LeanOrHydratedDocument<Definition, Options> | null | undefined>;
+    fetch<Options extends QueryOptions<Definition>>(filter?: RootFilterQuery<Definition>, projection?: ProjectionType<Definition>, options?: Options & {
+        required: true;
+    }): Promise<LeanOrHydratedDocument<Definition, Options>>;
     fetchAll<Options extends QueryOptions<Definition>>(filter?: RootFilterQuery<Definition>, projection?: ProjectionType<Definition>, options?: Options): Promise<LeanOrHydratedDocument<Definition, Options>[]>;
     update<Options extends QueryOptions<Definition>>(filter: RootFilterQuery<Definition>, update: UpdateQuery<Definition>, options?: Options): Promise<LeanOrHydratedDocument<Definition, Options> | null | undefined>;
     updateAll(filter: RootFilterQuery<Definition>, update: UpdateQuery<Definition>, options?: mongo.UpdateOptions & MongooseUpdateQueryOptions<Definition>): Promise<mongoose.UpdateWriteOpResult>;

package/dist/index.d.ts

@@ -2460,7 +2460,7 @@ declare class MongoSchemaBuilder<Definition extends object = any> {
     execute<T extends (model: Model<Definition>) => any>(fn: T, maxRetries?: number): Promise<ExtractReturn<T>>;
     startSession(options?: ClientSessionOptions): Promise<mongo.ClientSession>;
     useTransaction(fn: (session: ClientSession, model: Model<Definition>) => any): Promise<void>;
-    createHexId(bytes: number, path: keyof Require_id<Definition>, maxRetries?: number): Promise<string>;
+    createUniqueId(collisionPath: keyof Require_id<Definition>, fn: () => string, maxRetries?: number): Promise<string>;
     count(filter?: RootFilterQuery<Definition>, options?: mongo.CountOptions & MongooseBaseQueryOptions<Definition> & mongo.Abortable): Promise<number>;
     exists(filter: RootFilterQuery<Definition>): Promise<boolean>;
     create(query: Partial<Require_id<Definition>>[], options?: CreateOptions): Promise<(Document<unknown, {}, Definition, {}, {}> & (Require_id<Definition> extends infer T ? T extends Require_id<Definition> ? T extends {
@@ -2468,15 +2468,20 @@ declare class MongoSchemaBuilder<Definition extends object = any> {
     } ? T : T & {
         __v: number;
     } : never : never))[]>;
-    upsert(filter: RootFilterQuery<Definition>, query: Partial<Require_id<Definition>>, options?: QueryOptions<Definition>): Promise<Document<unknown, {}, Definition, {}, {}> & (Require_id<Definition> extends infer T ? T extends Require_id<Definition> ? T extends {
+    upsert(filter: RootFilterQuery<Definition>, query: Partial<Require_id<Definition>>, options?: Exclude<QueryOptions<Definition>, "upsert">): Promise<(Document<unknown, {}, Definition, {}, {}> & (Require_id<Definition> extends infer T ? T extends Require_id<Definition> ? T extends {
         __v?: infer U;
     } ? T : T & {
         __v: number;
-    } : never : never)>;
+    } : never : never)) | null>;
     delete(filter: RootFilterQuery<Definition>, options?: mongo.DeleteOptions & MongooseBaseQueryOptions<Definition>): Promise<mongo.DeleteResult>;
     deleteAll(filter: RootFilterQuery<Definition>, options?: mongo.DeleteOptions & MongooseBaseQueryOptions<Definition>): Promise<mongo.DeleteResult>;
     distinct<K extends keyof Require_id<Definition> & string>(key: K, filter?: RootFilterQuery<Definition>, options?: QueryOptions<Definition>): Promise<(K extends keyof Definition | mongoose.NestedPaths<Required<Definition>, keyof Definition> ? mongoose.WithoutUndefined<mongoose.Unpacked<mongoose.WithLevel1NestedPaths<Definition, keyof Definition>[K]>> : unknown)[]>;
-    fetch<Options extends QueryOptions<Definition>>(filter?: RootFilterQuery<Definition>, projection?: ProjectionType<Definition>, options?: Options): Promise<LeanOrHydratedDocument<Definition, Options> | null | undefined>;
+    fetch<Options extends QueryOptions<Definition>>(filter?: RootFilterQuery<Definition>, projection?: ProjectionType<Definition>, options?: Options & {
+        required?: boolean;
+    }): Promise<LeanOrHydratedDocument<Definition, Options> | null | undefined>;
+    fetch<Options extends QueryOptions<Definition>>(filter?: RootFilterQuery<Definition>, projection?: ProjectionType<Definition>, options?: Options & {
+        required: true;
+    }): Promise<LeanOrHydratedDocument<Definition, Options>>;
     fetchAll<Options extends QueryOptions<Definition>>(filter?: RootFilterQuery<Definition>, projection?: ProjectionType<Definition>, options?: Options): Promise<LeanOrHydratedDocument<Definition, Options>[]>;
     update<Options extends QueryOptions<Definition>>(filter: RootFilterQuery<Definition>, update: UpdateQuery<Definition>, options?: Options): Promise<LeanOrHydratedDocument<Definition, Options> | null | undefined>;
     updateAll(filter: RootFilterQuery<Definition>, update: UpdateQuery<Definition>, options?: mongo.UpdateOptions & MongooseUpdateQueryOptions<Definition>): Promise<mongoose.UpdateWriteOpResult>;

package/dist/index.js

@@ -1693,7 +1693,7 @@ var VimcordErrorHandler = class {
 import chalk2 from "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({
@@ -2980,8 +2980,7 @@ var MongoDatabase = class _MongoDatabase {
 import {
   Schema
 } from "mongoose";
-import { randomBytes } from "crypto";
-import { $ as $6 } from "qznt";
+import { retry } from "qznt";
 try {
   import("mongoose");
 } catch {
@@ -3067,7 +3066,7 @@ var MongoSchemaBuilder = class _MongoSchemaBuilder {
    * @param maxRetries [default: 3]
    */
   async execute(fn, maxRetries = 3) {
-    return await $6.async.retry(
+    return retry(
       async () => {
         const model = await this.getModel();
         return await fn(model);
@@ -3076,82 +3075,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 = () => 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));
   }
 };
 
@@ -3484,7 +3482,7 @@ import {
   TextInputStyle,
   UserSelectMenuBuilder
 } from "discord.js";
-import { $ as $7 } from "qznt";
+import { $ as $6 } from "qznt";
 var BetterModal = class {
   id;
   options;
@@ -3504,10 +3502,10 @@ var BetterModal = class {
     }
   }
   createModalId() {
-    return `modal:${$7.rnd.str(10, "alpha", { casing: "mixed" })}-${Date.now()}`;
+    return `modal:${$6.rnd.str(10, "alpha", { casing: "mixed" })}-${Date.now()}`;
   }
   createComponentId() {
-    return `modal-component:${this.id}-${$7.rnd.str(4, "alpha", { casing: "mixed" })}-${Date.now().toString().slice(-4)}`;
+    return `modal-component:${this.id}-${$6.rnd.str(4, "alpha", { casing: "mixed" })}-${Date.now().toString().slice(-4)}`;
   }
   validateComponentLength() {
     if (this.components.size >= 5) throw new Error("Modal can only have 5 components");