@timardex/cluemart-server-shared 1.0.163 → 1.0.165

package/dist/index.mjs

@@ -4677,10 +4677,10 @@ var Condition = class _Condition {
       otherwise
     } = config;
     let check = typeof is === "function" ? is : (...values) => values.every((value) => value === is);
-    return new _Condition(refs, (values, schema16) => {
+    return new _Condition(refs, (values, schema17) => {
       var _branch;
       let branch = check(...values) ? then : otherwise;
-      return (_branch = branch == null ? void 0 : branch(schema16)) != null ? _branch : schema16;
+      return (_branch = branch == null ? void 0 : branch(schema17)) != null ? _branch : schema17;
     });
   }
   constructor(refs, builder) {
@@ -4694,13 +4694,13 @@ var Condition = class _Condition {
       // TODO: ? operator here?
       ref.getValue(options == null ? void 0 : options.value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context)
     ));
-    let schema16 = this.fn(values, base, options);
-    if (schema16 === void 0 || // @ts-ignore this can be base
-    schema16 === base) {
+    let schema17 = this.fn(values, base, options);
+    if (schema17 === void 0 || // @ts-ignore this can be base
+    schema17 === base) {
       return base;
     }
-    if (!isSchema(schema16)) throw new TypeError("conditions must return a schema object");
-    return schema16.resolve(options);
+    if (!isSchema(schema17)) throw new TypeError("conditions must return a schema object");
+    return schema17.resolve(options);
   }
 };
 var prefixes = {
@@ -4770,7 +4770,7 @@ function createValidation(config) {
     path = "",
     options,
     originalValue,
-    schema: schema16
+    schema: schema17
   }, panic, next) {
     const {
       name,
@@ -4782,8 +4782,8 @@ function createValidation(config) {
     let {
       parent,
       context,
-      abortEarly = schema16.spec.abortEarly,
-      disableStackTrace = schema16.spec.disableStackTrace
+      abortEarly = schema17.spec.abortEarly,
+      disableStackTrace = schema17.spec.disableStackTrace
     } = options;
     function resolve(item) {
       return Reference.isRef(item) ? item.getValue(value, parent, context) : item;
@@ -4792,9 +4792,9 @@ function createValidation(config) {
       const nextParams = Object.assign({
         value,
         originalValue,
-        label: schema16.spec.label,
+        label: schema17.spec.label,
         path: overrides.path || path,
-        spec: schema16.spec,
+        spec: schema17.spec,
         disableStackTrace: overrides.disableStackTrace || disableStackTrace
       }, params, overrides.params);
       for (const key of Object.keys(nextParams)) nextParams[key] = resolve(nextParams[key]);
@@ -4812,7 +4812,7 @@ function createValidation(config) {
       resolve,
       options,
       originalValue,
-      schema: schema16
+      schema: schema17
     };
     const handleResult = (validOrError) => {
       if (ValidationError.isError(validOrError)) invalid(validOrError);
@@ -4846,42 +4846,42 @@ function createValidation(config) {
   validate.OPTIONS = config;
   return validate;
 }
-function getIn(schema16, path, value, context = value) {
+function getIn(schema17, path, value, context = value) {
   let parent, lastPart, lastPartDebug;
   if (!path) return {
     parent,
     parentPath: path,
-    schema: schema16
+    schema: schema17
   };
   (0, import_property_expr.forEach)(path, (_part, isBracket, isArray) => {
     let part = isBracket ? _part.slice(1, _part.length - 1) : _part;
-    schema16 = schema16.resolve({
+    schema17 = schema17.resolve({
       context,
       parent,
       value
     });
-    let isTuple = schema16.type === "tuple";
+    let isTuple = schema17.type === "tuple";
     let idx = isArray ? parseInt(part, 10) : 0;
-    if (schema16.innerType || isTuple) {
+    if (schema17.innerType || isTuple) {
       if (isTuple && !isArray) throw new Error(`Yup.reach cannot implicitly index into a tuple type. the path part "${lastPartDebug}" must contain an index to the tuple element, e.g. "${lastPartDebug}[0]"`);
       if (value && idx >= value.length) {
         throw new Error(`Yup.reach cannot resolve an array item at index: ${_part}, in the path: ${path}. because there is no value at that index. `);
       }
       parent = value;
       value = value && value[idx];
-      schema16 = isTuple ? schema16.spec.types[idx] : schema16.innerType;
+      schema17 = isTuple ? schema17.spec.types[idx] : schema17.innerType;
     }
     if (!isArray) {
-      if (!schema16.fields || !schema16.fields[part]) throw new Error(`The schema does not contain the path: ${path}. (failed at: ${lastPartDebug} which is a type: "${schema16.type}")`);
+      if (!schema17.fields || !schema17.fields[part]) throw new Error(`The schema does not contain the path: ${path}. (failed at: ${lastPartDebug} which is a type: "${schema17.type}")`);
       parent = value;
       value = value && value[part];
-      schema16 = schema16.fields[part];
+      schema17 = schema17.fields[part];
     }
     lastPart = part;
     lastPartDebug = isBracket ? "[" + _part + "]" : "." + _part;
   });
   return {
-    schema: schema16,
+    schema: schema17,
     parent,
     parentPath: lastPart
   };
@@ -5018,20 +5018,20 @@ var Schema = class {
     this._mutate = before;
     return result;
   }
-  concat(schema16) {
-    if (!schema16 || schema16 === this) return this;
-    if (schema16.type !== this.type && this.type !== "mixed") throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${schema16.type}`);
+  concat(schema17) {
+    if (!schema17 || schema17 === this) return this;
+    if (schema17.type !== this.type && this.type !== "mixed") throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${schema17.type}`);
     let base = this;
-    let combined = schema16.clone();
+    let combined = schema17.clone();
     const mergedSpec = Object.assign({}, base.spec, combined.spec);
     combined.spec = mergedSpec;
     combined.internalTests = Object.assign({}, base.internalTests, combined.internalTests);
-    combined._whitelist = base._whitelist.merge(schema16._whitelist, schema16._blacklist);
-    combined._blacklist = base._blacklist.merge(schema16._blacklist, schema16._whitelist);
+    combined._whitelist = base._whitelist.merge(schema17._whitelist, schema17._blacklist);
+    combined._blacklist = base._blacklist.merge(schema17._blacklist, schema17._whitelist);
     combined.tests = base.tests;
     combined.exclusiveTests = base.exclusiveTests;
     combined.withMutation((next) => {
-      schema16.tests.forEach((fn) => {
+      schema17.tests.forEach((fn) => {
         next.test(fn.OPTIONS);
       });
     });
@@ -5047,15 +5047,15 @@ var Schema = class {
     return this._typeCheck(v);
   }
   resolve(options) {
-    let schema16 = this;
-    if (schema16.conditions.length) {
-      let conditions = schema16.conditions;
-      schema16 = schema16.clone();
-      schema16.conditions = [];
-      schema16 = conditions.reduce((prevSchema, condition) => condition.resolve(prevSchema, options), schema16);
-      schema16 = schema16.resolve(options);
+    let schema17 = this;
+    if (schema17.conditions.length) {
+      let conditions = schema17.conditions;
+      schema17 = schema17.clone();
+      schema17.conditions = [];
+      schema17 = conditions.reduce((prevSchema, condition) => condition.resolve(prevSchema, options), schema17);
+      schema17 = schema17.resolve(options);
     }
-    return schema16;
+    return schema17;
   }
   resolveOptions(options) {
     var _options$strict, _options$abortEarly, _options$recursive, _options$disableStack;
@@ -5209,11 +5209,11 @@ attempted value: ${formattedValue}
   }
   validate(value, options) {
     var _options$disableStack2;
-    let schema16 = this.resolve(Object.assign({}, options, {
+    let schema17 = this.resolve(Object.assign({}, options, {
       value
     }));
-    let disableStackTrace = (_options$disableStack2 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack2 : schema16.spec.disableStackTrace;
-    return new Promise((resolve, reject) => schema16._validate(value, options, (error, parsed) => {
+    let disableStackTrace = (_options$disableStack2 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack2 : schema17.spec.disableStackTrace;
+    return new Promise((resolve, reject) => schema17._validate(value, options, (error, parsed) => {
       if (ValidationError.isError(error)) error.value = parsed;
       reject(error);
     }, (errors, validated) => {
@@ -5223,12 +5223,12 @@ attempted value: ${formattedValue}
   }
   validateSync(value, options) {
     var _options$disableStack3;
-    let schema16 = this.resolve(Object.assign({}, options, {
+    let schema17 = this.resolve(Object.assign({}, options, {
       value
     }));
     let result;
-    let disableStackTrace = (_options$disableStack3 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack3 : schema16.spec.disableStackTrace;
-    schema16._validate(value, Object.assign({}, options, {
+    let disableStackTrace = (_options$disableStack3 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack3 : schema17.spec.disableStackTrace;
+    schema17._validate(value, Object.assign({}, options, {
       sync: true
     }), (error, parsed) => {
       if (ValidationError.isError(error)) error.value = parsed;
@@ -5262,8 +5262,8 @@ attempted value: ${formattedValue}
     return typeof defaultValue === "function" ? defaultValue.call(this, options) : clone(defaultValue);
   }
   getDefault(options) {
-    let schema16 = this.resolve(options || {});
-    return schema16._getDefault(options);
+    let schema17 = this.resolve(options || {});
+    return schema17._getDefault(options);
   }
   default(def) {
     if (arguments.length === 0) {
@@ -5498,9 +5498,9 @@ for (const method of ["validate", "validateSync"]) Schema.prototype[`${method}At
   const {
     parent,
     parentPath,
-    schema: schema16
+    schema: schema17
   } = getIn(this, path, value, options.context);
-  return schema16[method](parent && parent[parentPath], Object.assign({}, options, {
+  return schema17[method](parent && parent[parentPath], Object.assign({}, options, {
     parent,
     path
   }));
@@ -5674,7 +5674,7 @@ var StringSchema = class extends Schema {
     });
   }
   required(message) {
-    return super.required(message).withMutation((schema16) => schema16.test({
+    return super.required(message).withMutation((schema17) => schema17.test({
       message: message || mixed.required,
       name: "required",
       skipAbsent: true,
@@ -5682,9 +5682,9 @@ var StringSchema = class extends Schema {
     }));
   }
   notRequired() {
-    return super.notRequired().withMutation((schema16) => {
-      schema16.tests = schema16.tests.filter((t) => t.OPTIONS.name !== "required");
-      return schema16;
+    return super.notRequired().withMutation((schema17) => {
+      schema17.tests = schema17.tests.filter((t) => t.OPTIONS.name !== "required");
+      return schema17;
     });
   }
   length(length, message = string.length) {
@@ -6073,28 +6073,28 @@ var parseJson = (value, _, ctx) => {
   }
   return ctx.isType(parsed) ? parsed : value;
 };
-function deepPartial(schema16) {
-  if ("fields" in schema16) {
+function deepPartial(schema17) {
+  if ("fields" in schema17) {
     const partial = {};
-    for (const [key, fieldSchema] of Object.entries(schema16.fields)) {
+    for (const [key, fieldSchema] of Object.entries(schema17.fields)) {
       partial[key] = deepPartial(fieldSchema);
     }
-    return schema16.setFields(partial);
+    return schema17.setFields(partial);
   }
-  if (schema16.type === "array") {
-    const nextArray = schema16.optional();
+  if (schema17.type === "array") {
+    const nextArray = schema17.optional();
     if (nextArray.innerType) nextArray.innerType = deepPartial(nextArray.innerType);
     return nextArray;
   }
-  if (schema16.type === "tuple") {
-    return schema16.optional().clone({
-      types: schema16.spec.types.map(deepPartial)
+  if (schema17.type === "tuple") {
+    return schema17.optional().clone({
+      types: schema17.spec.types.map(deepPartial)
     });
   }
-  if ("optional" in schema16) {
-    return schema16.optional();
+  if ("optional" in schema17) {
+    return schema17.optional();
   }
-  return schema16;
+  return schema17;
 }
 var deepHas = (obj, p) => {
   const path = [...(0, import_property_expr.normalizePath)(p)];
@@ -6228,8 +6228,8 @@ var ObjectSchema = class extends Schema {
     next._sortErrors = this._sortErrors;
     return next;
   }
-  concat(schema16) {
-    let next = super.concat(schema16);
+  concat(schema17) {
+    let next = super.concat(schema17);
     let nextFields = next.fields;
     for (let [field, schemaOrRef] of Object.entries(this.fields)) {
       const target = nextFields[field];
@@ -6237,7 +6237,7 @@ var ObjectSchema = class extends Schema {
     }
     return next.withMutation((s) => (
       // XXX: excludes here is wrong
-      s.setFields(nextFields, [...this._excludedEdges, ...schema16._excludedEdges])
+      s.setFields(nextFields, [...this._excludedEdges, ...schema17._excludedEdges])
     ));
   }
   _getDefault(options) {
@@ -6282,8 +6282,8 @@ var ObjectSchema = class extends Schema {
   }
   partial() {
     const partial = {};
-    for (const [key, schema16] of Object.entries(this.fields)) {
-      partial[key] = "optional" in schema16 && schema16.optional instanceof Function ? schema16.optional() : schema16;
+    for (const [key, schema17] of Object.entries(this.fields)) {
+      partial[key] = "optional" in schema17 && schema17.optional instanceof Function ? schema17.optional() : schema17;
     }
     return this.setFields(partial);
   }
@@ -6481,22 +6481,22 @@ var ArraySchema = class extends Schema {
   json() {
     return this.transform(parseJson);
   }
-  concat(schema16) {
-    let next = super.concat(schema16);
+  concat(schema17) {
+    let next = super.concat(schema17);
     next.innerType = this.innerType;
-    if (schema16.innerType)
+    if (schema17.innerType)
       next.innerType = next.innerType ? (
         // @ts-expect-error Lazy doesn't have concat and will break
-        next.innerType.concat(schema16.innerType)
-      ) : schema16.innerType;
+        next.innerType.concat(schema17.innerType)
+      ) : schema17.innerType;
     return next;
   }
-  of(schema16) {
+  of(schema17) {
     let next = this.clone();
-    if (!isSchema(schema16)) throw new TypeError("`array.of()` sub-schema must be a valid yup schema not: " + printValue(schema16));
-    next.innerType = schema16;
+    if (!isSchema(schema17)) throw new TypeError("`array.of()` sub-schema must be a valid yup schema not: " + printValue(schema17));
+    next.innerType = schema17;
     next.spec = Object.assign({}, next.spec, {
-      types: schema16
+      types: schema17
     });
     return next;
   }
@@ -6640,7 +6640,7 @@ var TupleSchema = class extends Schema {
   describe(options) {
     const next = (options ? this.resolve(options) : this).clone();
     const base = super.describe(options);
-    base.innerType = next.spec.types.map((schema16, index) => {
+    base.innerType = next.spec.types.map((schema17, index) => {
       var _innerOptions;
       let innerOptions = options;
       if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
@@ -6649,7 +6649,7 @@ var TupleSchema = class extends Schema {
           value: innerOptions.value[index]
         });
       }
-      return schema16.describe(innerOptions);
+      return schema17.describe(innerOptions);
     });
     return base;
   }
@@ -10542,7 +10542,7 @@ var stallTypesSchema = create$3({
     "",
     noLeadingZeros("Stall price", { allowDecimal: true })
   ),
-  stallCapacity: create$5().label("Stall Capacity").typeError("Stall capacity must be a number").min(1, "Stall capacity must be at least 1").integer("Stall capacity must be a whole number").required("Stall capacity is required").test("no-leading-zeros", "", noLeadingZeros("Stall capacity"))
+  stallCapacity: create$5().label("Stall Capacity").typeError("Stall capacity must be a number").min(0, "Stall capacity cannot be negative").integer("Stall capacity must be a whole number").required("Stall capacity is required").test("no-leading-zeros", "", noLeadingZeros("Stall capacity"))
 });
 var dateTimeWithPriceSchema = dateTimeSchema.shape({
   stallTypes: create$2().of(stallTypesSchema).min(1, "At least one stall type is required").required("Stall types are required")
@@ -10569,7 +10569,7 @@ var socialMediaSchema = create$3({
     is: (name) => !!name,
     // If name has a value
     then: () => normalizedUrlTransform().required("Link is required when name is set").url("Link must be a valid URL").label("Social Media Link"),
-    otherwise: (schema16) => schema16.notRequired()
+    otherwise: (schema17) => schema17.notRequired()
   })
 });
 var globalResourceSchema = create$3().shape({
@@ -10645,21 +10645,21 @@ var paymentInfoSchema = create$3({
   ).required("Please select a Payment method"),
   accountHolderName: create$6().when("paymentMethod", {
     is: "bank_transfer",
-    then: (schema16) => schema16.required("Account holder name is required for bank transfer").trim(),
-    otherwise: (schema16) => schema16.notRequired()
+    then: (schema17) => schema17.required("Account holder name is required for bank transfer").trim(),
+    otherwise: (schema17) => schema17.notRequired()
   }),
   accountNumber: create$6().when("paymentMethod", {
     is: "bank_transfer",
-    then: (schema16) => schema16.required("Account number is required for bank transfer").matches(
+    then: (schema17) => schema17.required("Account number is required for bank transfer").matches(
       nzBankAccountRegex,
       "Account number must be in format: XX-XXXX-XXXXXXX-XX"
     ).trim(),
-    otherwise: (schema16) => schema16.notRequired()
+    otherwise: (schema17) => schema17.notRequired()
   }),
   link: create$6().when("paymentMethod", {
     is: (val) => val === "paypal" || val === "stripe",
     then: () => normalizedUrlTransform().url("Link must be a valid URL").required("Link is required for PayPal/Stripe"),
-    otherwise: (schema16) => schema16.notRequired()
+    otherwise: (schema17) => schema17.notRequired()
   })
 });
 var eventInfoSchema = create$3().shape({
@@ -10809,8 +10809,8 @@ var userSchema = create$3().shape({
   confirmPassword: create$6().nullable().trim().label("Confirm Password").when("password", {
     is: (val) => !!val,
     // only necessary if password typed
-    then: (schema16) => schema16.required("Confirm Password is required").oneOf([create$9("password")], "Passwords must match"),
-    otherwise: (schema16) => schema16.notRequired()
+    then: (schema17) => schema17.required("Confirm Password is required").oneOf([create$9("password")], "Passwords must match"),
+    otherwise: (schema17) => schema17.notRequired()
   }),
   role: create$8().oneOf(Object.values(EnumUserRole)).required("Role is required")
 });
@@ -10881,7 +10881,7 @@ var adSchema = create$3().shape({
     return endDate > now;
   }).when("start", {
     is: (val) => val && val.length > 0,
-    then: (schema16) => schema16.test(
+    then: (schema17) => schema17.test(
       "is-after-start",
       "End date must be after start date",
       function(value) {
@@ -12157,7 +12157,7 @@ var schema9 = new MongooseSchema13(
       required: false,
       type: calendarWrapperSchema
     },
-    categories: [CategorySchema],
+    categories: { required: true, type: [CategorySchema] },
     foodTruck: { required: true, type: Boolean },
     products: { required: false, type: productWrapperSchema },
     relations: {
@@ -12236,19 +12236,47 @@ var schema10 = new MongooseSchema14(
 );
 var VendorInfoModel = mongoose14.models.VendorInfo || mongoose14.model("VendorInfo", schema10);
 
-// src/mongoose/event/Event.ts
+// src/mongoose/vendor/UnregisteredVendor.ts
 import mongoose15 from "mongoose";
 var MongooseSchema15 = mongoose15.Schema;
+var invitationSchema = new MongooseSchema15(
+  {
+    dateTime: { required: true, type: [dateTimeSchema3] },
+    eventId: {
+      ref: "Event",
+      required: true,
+      type: String
+    }
+  },
+  { _id: false }
+);
 var schema11 = new MongooseSchema15(
+  {
+    categoryIds: { required: true, type: [String] },
+    deletedAt: { default: null, required: false, type: Date },
+    email: { required: true, type: String },
+    invitations: { required: true, type: [invitationSchema] },
+    name: { required: true, type: String }
+  },
+  { timestamps: true }
+);
+schema11.index({ email: 1 }, { unique: true });
+schema11.index({ name: 1 });
+var UnregisteredVendorModel = mongoose15.models.UnregisteredVendor || mongoose15.model("UnregisteredVendor", schema11);
+
+// src/mongoose/event/Event.ts
+import mongoose16 from "mongoose";
+var MongooseSchema16 = mongoose16.Schema;
+var schema12 = new MongooseSchema16(
   {
     ...baseResourceFields,
     // Importing base resource fields from global.ts
     claimed: { default: true, required: false, type: Boolean },
-    dateTime: [dateTimeSchema3],
+    dateTime: { required: true, type: [dateTimeSchema3] },
     eventInfoId: {
       ref: "EventInfo",
       required: false,
-      type: mongoose15.Schema.Types.ObjectId
+      type: mongoose16.Schema.Types.ObjectId
     },
     eventType: {
       enum: Object.values(EnumEventType),
@@ -12277,18 +12305,18 @@ var schema11 = new MongooseSchema15(
   },
   { timestamps: true }
 );
-schema11.index({ name: 1 });
-schema11.index({ description: 1 });
-schema11.index({ region: 1 });
-schema11.index({ "location.geo": "2dsphere" });
-schema11.index({ tags: 1 });
-schema11.index({ "associates.email": 1 });
-var EventModel = mongoose15.models.Event || mongoose15.model("Event", schema11);
+schema12.index({ name: 1 });
+schema12.index({ description: 1 });
+schema12.index({ region: 1 });
+schema12.index({ "location.geo": "2dsphere" });
+schema12.index({ tags: 1 });
+schema12.index({ "associates.email": 1 });
+var EventModel = mongoose16.models.Event || mongoose16.model("Event", schema12);
 
 // src/mongoose/Partner.ts
-import mongoose16 from "mongoose";
-var MongooseSchema16 = mongoose16.Schema;
-var schema12 = new MongooseSchema16(
+import mongoose17 from "mongoose";
+var MongooseSchema17 = mongoose17.Schema;
+var schema13 = new MongooseSchema17(
   {
     ...baseResourceFields,
     location: {
@@ -12304,17 +12332,17 @@ var schema12 = new MongooseSchema16(
   },
   { timestamps: true }
 );
-schema12.index({ name: 1 });
-schema12.index({ description: 1 });
-schema12.index({ region: 1 });
-schema12.index({ "location.geo": "2dsphere" });
-schema12.index({ "associates.email": 1 });
-var PartnerModel = mongoose16.models.Partner || mongoose16.model("Partner", schema12);
+schema13.index({ name: 1 });
+schema13.index({ description: 1 });
+schema13.index({ region: 1 });
+schema13.index({ "location.geo": "2dsphere" });
+schema13.index({ "associates.email": 1 });
+var PartnerModel = mongoose17.models.Partner || mongoose17.model("Partner", schema13);
 
 // src/mongoose/Post.ts
-import mongoose17, { Schema as Schema2 } from "mongoose";
-var MongooseSchema17 = mongoose17.Schema;
-var contentSchema = new MongooseSchema17(
+import mongoose18, { Schema as Schema2 } from "mongoose";
+var MongooseSchema18 = mongoose18.Schema;
+var contentSchema = new MongooseSchema18(
   {
     contentData: Schema2.Types.Mixed,
     contentOrder: { required: true, type: Number },
@@ -12326,7 +12354,7 @@ var contentSchema = new MongooseSchema17(
   },
   { _id: false }
 );
-var schema13 = new MongooseSchema17(
+var schema14 = new MongooseSchema18(
   {
     active: { default: true, required: true, type: Boolean },
     caption: { required: true, type: String },
@@ -12362,15 +12390,15 @@ var schema13 = new MongooseSchema17(
   },
   { timestamps: true }
 );
-schema13.index({ title: 1 });
-schema13.index({ tags: 1 });
-var PostModel = mongoose17.models.Post || mongoose17.model("Post", schema13);
+schema14.index({ title: 1 });
+schema14.index({ tags: 1 });
+var PostModel = mongoose18.models.Post || mongoose18.model("Post", schema14);
 
 // src/mongoose/AppSetting.ts
-import mongoose18 from "mongoose";
-var MongooseSchema18 = mongoose18.Schema;
+import mongoose19 from "mongoose";
+var MongooseSchema19 = mongoose19.Schema;
 var APP_SETTINGS_ID = "APP_SETTINGS_DOCUMENT_ID";
-var AppSettingSchema = new MongooseSchema18(
+var AppSettingSchema = new MongooseSchema19(
   {
     activeSchoolsStudentCountTotal: {
       default: 0,
@@ -12396,18 +12424,18 @@ var AppSettingSchema = new MongooseSchema18(
   },
   { timestamps: true }
 );
-var AppSettingModel = mongoose18.models.AppSetting || mongoose18.model("AppSetting", AppSettingSchema);
+var AppSettingModel = mongoose19.models.AppSetting || mongoose19.model("AppSetting", AppSettingSchema);
 
 // src/mongoose/game/Game.ts
-import mongoose22 from "mongoose";
+import mongoose23 from "mongoose";
 
 // src/mongoose/game/DailyClue.ts
-import mongoose20 from "mongoose";
+import mongoose21 from "mongoose";
 
 // src/mongoose/game/utils.ts
-import mongoose19 from "mongoose";
-var MongooseSchema19 = mongoose19.Schema;
-var schemaGameDate = new MongooseSchema19(
+import mongoose20 from "mongoose";
+var MongooseSchema20 = mongoose20.Schema;
+var schemaGameDate = new MongooseSchema20(
   {
     endDate: { required: true, type: Date },
     startDate: { required: true, type: Date }
@@ -12416,8 +12444,8 @@ var schemaGameDate = new MongooseSchema19(
 );
 
 // src/mongoose/game/DailyClue.ts
-var MongooseSchema20 = mongoose20.Schema;
-var schemaLetters = new MongooseSchema20(
+var MongooseSchema21 = mongoose21.Schema;
+var schemaLetters = new MongooseSchema21(
   {
     collected: { required: false, type: [String] },
     solutionShuffled: { required: true, type: [String] }
@@ -12425,14 +12453,14 @@ var schemaLetters = new MongooseSchema20(
   },
   { _id: false }
 );
-var schemaDailyClueBaseGame = new MongooseSchema20(
+var schemaDailyClueBaseGame = new MongooseSchema21(
   {
     gameDate: { required: true, type: schemaGameDate },
     gameSolution: { required: true, type: String }
   },
   { _id: false }
 );
-var schemaDailyClueGameData = new MongooseSchema20(
+var schemaDailyClueGameData = new MongooseSchema21(
   {
     gameFields: { required: true, type: schemaDailyClueBaseGame },
     lastFoundDate: { default: null, required: false, type: Date },
@@ -12447,9 +12475,9 @@ var schemaDailyClueGameData = new MongooseSchema20(
 );
 
 // src/mongoose/game/MiniQuiz.ts
-import mongoose21 from "mongoose";
-var MongooseSchema21 = mongoose21.Schema;
-var schemaMiniQuizAnswer = new MongooseSchema21(
+import mongoose22 from "mongoose";
+var MongooseSchema22 = mongoose22.Schema;
+var schemaMiniQuizAnswer = new MongooseSchema22(
   {
     answer: { required: true, type: String },
     answerId: { required: true, type: String },
@@ -12457,7 +12485,7 @@ var schemaMiniQuizAnswer = new MongooseSchema21(
   },
   { _id: false }
 );
-var schemaMiniQuizQuestion = new MongooseSchema21(
+var schemaMiniQuizQuestion = new MongooseSchema22(
   {
     answers: { required: true, type: [schemaMiniQuizAnswer] },
     question: { required: true, type: String },
@@ -12465,20 +12493,20 @@ var schemaMiniQuizQuestion = new MongooseSchema21(
   },
   { _id: false }
 );
-var schemaMiniQuizBaseGame = new MongooseSchema21(
+var schemaMiniQuizBaseGame = new MongooseSchema22(
   {
     questions: { required: true, type: [schemaMiniQuizQuestion] }
   },
   { _id: false }
 );
-var schemaMiniQuizAnsweredQuestion = new MongooseSchema21(
+var schemaMiniQuizAnsweredQuestion = new MongooseSchema22(
   {
     questionId: { required: true, type: String },
     selectedAnswerId: { required: true, type: String }
   },
   { _id: false }
 );
-var schemaMiniQuizGameData = new MongooseSchema21(
+var schemaMiniQuizGameData = new MongooseSchema22(
   {
     answeredQuestions: {
       default: null,
@@ -12493,18 +12521,18 @@ var schemaMiniQuizGameData = new MongooseSchema21(
 );
 
 // src/mongoose/game/Game.ts
-var MongooseSchema22 = mongoose22.Schema;
+var MongooseSchema23 = mongoose23.Schema;
 var gameDataSchemas = {
   [EnumGameType.DAILY_CLUE]: schemaDailyClueGameData,
   [EnumGameType.MINI_QUIZ]: schemaMiniQuizGameData
 };
 var gameDataDefinition = Object.fromEntries(
-  Object.entries(gameDataSchemas).map(([key, schema16]) => [
+  Object.entries(gameDataSchemas).map(([key, schema17]) => [
     key,
-    { default: null, required: false, type: schema16 }
+    { default: null, required: false, type: schema17 }
   ])
 );
-var gameHistorySchema = new MongooseSchema22(
+var gameHistorySchema = new MongooseSchema23(
   {
     createdAt: { required: true, type: Date },
     gameDate: { required: true, type: schemaGameDate },
@@ -12522,7 +12550,7 @@ var gameHistorySchema = new MongooseSchema22(
   },
   { _id: false }
 );
-var gameTypeSchema = new MongooseSchema22(
+var gameTypeSchema = new MongooseSchema23(
   {
     active: { default: true, required: true, type: Boolean },
     gameData: gameDataDefinition,
@@ -12536,7 +12564,7 @@ var gameTypeSchema = new MongooseSchema22(
   },
   { timestamps: true }
 );
-var schema14 = new MongooseSchema22(
+var schema15 = new MongooseSchema23(
   {
     active: { default: false, required: true, type: Boolean },
     deletedAt: { default: null, required: false, type: Date },
@@ -12549,12 +12577,12 @@ var schema14 = new MongooseSchema22(
   },
   { timestamps: true }
 );
-var GameModel = mongoose22.models.Game || mongoose22.model("Game", schema14);
+var GameModel = mongoose23.models.Game || mongoose23.model("Game", schema15);
 
 // src/mongoose/School.ts
-import mongoose23 from "mongoose";
-var MongooseSchema23 = mongoose23.Schema;
-var campaignsSchema = new MongooseSchema23(
+import mongoose24 from "mongoose";
+var MongooseSchema24 = mongoose24.Schema;
+var campaignsSchema = new MongooseSchema24(
   {
     endDate: { required: true, type: Date },
     name: { required: true, type: String },
@@ -12562,7 +12590,7 @@ var campaignsSchema = new MongooseSchema23(
   },
   { _id: false }
 );
-var schema15 = new MongooseSchema23(
+var schema16 = new MongooseSchema24(
   {
     // New schools are active by default
     active: { default: true, required: true, type: Boolean },
@@ -12588,10 +12616,10 @@ var schema15 = new MongooseSchema23(
   },
   { timestamps: true }
 );
-var SchoolModel = mongoose23.models.School || mongoose23.model("School", schema15);
+var SchoolModel = mongoose24.models.School || mongoose24.model("School", schema16);
 
 // src/service/database.ts
-import mongoose24 from "mongoose";
+import mongoose25 from "mongoose";
 var connectToDatabase = async ({
   appName,
   dbName,
@@ -12604,7 +12632,7 @@ var connectToDatabase = async ({
       // Fallback to MongoDB Atlas connection string
       `mongodb+srv://${dbUser}:${dbPassword}@${dbName}.mongodb.net/?retryWrites=true&w=majority&appName=${appName}`
     );
-    await mongoose24.connect(mongoUri);
+    await mongoose25.connect(mongoUri);
     const connectionType = mongodbUri ? "Local MongoDB" : "MongoDB Atlas";
     console.log(
       `${connectionType} connected from server/src/service/database.ts`
@@ -12783,84 +12811,102 @@ async function updateAdStatuses() {
 }
 
 // src/service/associate.ts
-import mongoose25 from "mongoose";
-async function removeAssociateFromResource({
-  resourceId,
-  resourceOwnerId,
+import mongoose26 from "mongoose";
+function normalizeObjectId(id) {
+  return typeof id === "string" ? new mongoose26.Types.ObjectId(id) : id;
+}
+async function getAssociateEmailsForResource({
+  normalizedResourceId,
   resourceType
 }) {
-  try {
-    const normalizedResourceId = resourceId.toString();
-    const normalizedOwnerId = typeof resourceOwnerId === "string" ? new mongoose25.Types.ObjectId(resourceOwnerId) : resourceOwnerId;
-    const usersWithAssociates = await UserModel.find(
-      {
-        associates: {
-          $elemMatch: {
-            resourceId: normalizedResourceId,
-            resourceType
-          }
+  const usersWithAssociates = await UserModel.find(
+    {
+      associates: {
+        $elemMatch: {
+          resourceId: normalizedResourceId,
+          resourceType
         }
-      },
-      {
-        associates: 1
-      }
-    ).lean();
-    const associateEmails = [
-      ...new Set(
-        usersWithAssociates.flatMap(
-          (user) => (user.associates ?? []).filter(
-            (associate) => associate.resourceId === normalizedResourceId && associate.resourceType === resourceType
-          ).map((associate) => associate.email)
-        )
+      }
+    },
+    {
+      associates: 1
+    }
+  ).lean();
+  return [
+    ...new Set(
+      usersWithAssociates.flatMap(
+        (user) => (user.associates ?? []).filter(
+          (associate) => associate.resourceId === normalizedResourceId && associate.resourceType === resourceType
+        ).map((associate) => associate.email)
       )
-    ];
-    if (associateEmails.length === 0) {
-      return;
-    }
-    await UserModel.updateMany(
-      {
+    )
+  ];
+}
+async function pullAssociatesFromUsers({
+  normalizedResourceId,
+  resourceType
+}) {
+  await UserModel.updateMany(
+    {
+      associates: {
+        $elemMatch: {
+          resourceId: normalizedResourceId,
+          resourceType
+        }
+      }
+    },
+    {
+      $pull: {
         associates: {
-          $elemMatch: {
-            resourceId: normalizedResourceId,
-            resourceType
-          }
+          resourceId: normalizedResourceId,
+          resourceType
         }
-      },
-      {
-        $pull: {
-          associates: {
-            resourceId: normalizedResourceId,
-            resourceType
-          }
+      }
+    }
+  );
+}
+async function pullAssociateParticipantsFromChats(resourceOwnerId, associateEmails) {
+  await ChatModel.updateMany(
+    {
+      active: true,
+      chatType: EnumChatType.RELATION,
+      deletedAt: null,
+      participants: {
+        $elemMatch: {
+          userId: resourceOwnerId
         }
       }
-    );
-    await ChatModel.updateMany(
-      {
-        active: true,
-        chatType: EnumChatType.RELATION,
-        deletedAt: null,
+    },
+    {
+      $pull: {
         participants: {
-          $elemMatch: {
-            userId: normalizedOwnerId
+          isAssociate: true,
+          userEmail: {
+            $in: associateEmails
           }
         }
-      },
-      {
-        $set: {
-          "participants.$[associate].active": false
-        }
-      },
-      {
-        arrayFilters: [
-          {
-            "associate.isAssociate": true,
-            "associate.userEmail": {
-              $in: associateEmails
-            }
-          }
-        ]
       }
+    }
+  );
+}
+async function removeAssociateFromResource({
+  resourceId,
+  resourceOwnerId,
+  resourceType
+}) {
+  try {
+    const scope = {
+      normalizedResourceId: resourceId.toString(),
+      resourceType
+    };
+    const associateEmails = await getAssociateEmailsForResource(scope);
+    if (associateEmails.length === 0) {
+      return;
+    }
+    await pullAssociatesFromUsers(scope);
+    await pullAssociateParticipantsFromChats(
+      normalizeObjectId(resourceOwnerId),
+      associateEmails
     );
   } catch (error) {
     console.error(
@@ -12919,12 +12965,12 @@ async function updateVendorBasedOnUserLicense(userId, licenceType) {
 }
 
 // src/service/objectIdToString.ts
-import mongoose26 from "mongoose";
+import mongoose27 from "mongoose";
 function convertObjectIdsToStrings(obj) {
   if (obj === null || obj === void 0) {
     return obj;
   }
-  if (obj instanceof mongoose26.Types.ObjectId) {
+  if (obj instanceof mongoose27.Types.ObjectId) {
     return obj.toString();
   }
   if (Array.isArray(obj)) {
@@ -12968,7 +13014,7 @@ function updateRelationDatesToUnavailable(relationDates, eventDateTime) {
 
 // src/types/index.ts
 import express from "express";
-import mongoose27 from "mongoose";
+import mongoose28 from "mongoose";
 var EnumPubSubEvents = /* @__PURE__ */ ((EnumPubSubEvents2) => {
   EnumPubSubEvents2["GET_CHAT_MESSAGE"] = "GET_CHAT_MESSAGE";
   EnumPubSubEvents2["GET_NOTIFICATIONS"] = "GET_NOTIFICATIONS";
@@ -13001,6 +13047,7 @@ export {
   SchoolModel,
   SocialMediaTypeSchema,
   StallTypeSchema,
+  UnregisteredVendorModel,
   UserModel,
   VendorInfoModel,
   VendorModel,
@@ -13014,7 +13061,7 @@ export {
   findEventOrImportedMarketById,
   locationGeoSchema,
   locationsSchema,
-  mongoose27 as mongoose,
+  mongoose28 as mongoose,
   refundPolicySchema,
   relationDatesSchema,
   resourceRelationsSchema,