@timardex/cluemart-shared 1.2.27 → 1.2.29

package/dist/index.mjs

@@ -4698,7 +4698,7 @@ var socialMediaSchema = yup.object({
     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: (schema) => schema.notRequired()
+    otherwise: (schema11) => schema11.notRequired()
   })
 });
 var globalResourceSchema = yup.object().shape({
@@ -4771,21 +4771,21 @@ var paymentInfoSchema = yup2.object({
   paymentMethod: yup2.mixed().oneOf(Object.values(EnumPaymentMethod)).required("Please select a Payment method"),
   accountHolderName: yup2.string().when("paymentMethod", {
     is: "bank_transfer" /* BANK_TRANSFER */,
-    then: (schema) => schema.required("Account holder name is required for bank transfer").trim(),
-    otherwise: (schema) => schema.notRequired()
+    then: (schema11) => schema11.required("Account holder name is required for bank transfer").trim(),
+    otherwise: (schema11) => schema11.notRequired()
   }),
   accountNumber: yup2.string().when("paymentMethod", {
     is: "bank_transfer" /* BANK_TRANSFER */,
-    then: (schema) => schema.required("Account number is required for bank transfer").matches(
+    then: (schema11) => schema11.required("Account number is required for bank transfer").matches(
       nzBankAccountRegex,
       "Account number must be in format: XX-XXXX-XXXXXXX-XX"
     ).trim(),
-    otherwise: (schema) => schema.notRequired()
+    otherwise: (schema11) => schema11.notRequired()
   }),
   link: yup2.string().when("paymentMethod", {
     is: (val) => val !== "bank_transfer" /* BANK_TRANSFER */,
     then: () => normalizedUrlTransform().url("Link must be a valid URL").required("Link is required for PayPal/Stripe"),
-    otherwise: (schema) => schema.notRequired()
+    otherwise: (schema11) => schema11.notRequired()
   })
 });
 var eventInfoSchema = yup2.object().shape({
@@ -4964,7 +4964,7 @@ var adSchema = yup7.object().shape({
     return endDate > now;
   }).when("start", {
     is: (val) => val && val.length > 0,
-    then: (schema) => schema.test(
+    then: (schema11) => schema11.test(
       "is-after-start",
       "End date must be after start date",
       function(value) {
@@ -5934,6 +5934,1101 @@ function useAdForm(data) {
   };
 }
 
+// src/mongoose/Ad.ts
+import mongoose4 from "mongoose";
+
+// src/types/global.ts
+var EnumPubSubEvents = /* @__PURE__ */ ((EnumPubSubEvents2) => {
+  EnumPubSubEvents2["GET_CHAT_MESSAGE"] = "GET_CHAT_MESSAGE";
+  EnumPubSubEvents2["GET_NOTIFICATIONS"] = "GET_NOTIFICATIONS";
+  EnumPubSubEvents2["GET_NOTIFICATIONS_COUNT"] = "GET_NOTIFICATIONS_COUNT";
+  EnumPubSubEvents2["USER_TYPING"] = "USER_TYPING";
+  return EnumPubSubEvents2;
+})(EnumPubSubEvents || {});
+
+// src/types/resourceActivities.ts
+var EnumActivity = /* @__PURE__ */ ((EnumActivity2) => {
+  EnumActivity2["FAVORITE"] = "FAVORITE";
+  EnumActivity2["GOING"] = "GOING";
+  EnumActivity2["INTERESTED"] = "INTERESTED";
+  EnumActivity2["PRESENT"] = "PRESENT";
+  EnumActivity2["VIEW"] = "VIEW";
+  return EnumActivity2;
+})(EnumActivity || {});
+
+// src/mongoose/global.ts
+import mongoose3 from "mongoose";
+
+// src/mongoose/Relation.ts
+import mongoose2 from "mongoose";
+
+// src/mongoose/event/EventInfo.ts
+import mongoose from "mongoose";
+var MongooseSchema = mongoose.Schema;
+var StallTypeSchema = new MongooseSchema(
+  {
+    electricity: {
+      price: { required: false, type: Number },
+      selected: { required: false, type: Boolean }
+    },
+    label: { required: false, type: String },
+    price: { required: false, type: Number },
+    stallCapacity: { required: false, type: Number }
+  },
+  {
+    _id: false
+    // Prevents Mongoose from creating an additional _id field for subdocuments
+  }
+);
+var dateTimeSchema2 = new MongooseSchema(
+  {
+    endDate: { required: true, type: String },
+    endTime: { required: true, type: String },
+    stallTypes: [StallTypeSchema],
+    startDate: { required: true, type: String },
+    startTime: { required: true, type: String }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var paymentInfoSchema2 = new MongooseSchema(
+  {
+    accountHolderName: { required: false, type: String },
+    accountNumber: { required: false, type: String },
+    link: { required: false, type: String },
+    paymentMethod: {
+      enum: Object.values(EnumPaymentMethod),
+      required: true,
+      type: String
+    }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field
+);
+var requirementsSchema = new MongooseSchema(
+  {
+    category: { required: true, type: String },
+    label: { required: true, type: String },
+    value: { required: true, type: Boolean }
+  },
+  {
+    _id: false
+    // Prevents Mongoose from creating an additional _id field for
+  }
+);
+var schema = new MongooseSchema(
+  {
+    applicationDeadlineHours: { required: true, type: Number },
+    dateTime: [dateTimeSchema2],
+    eventId: {
+      ref: "Event",
+      required: false,
+      type: mongoose.Schema.Types.ObjectId
+    },
+    packInTime: { required: true, type: Number },
+    paymentDueHours: { required: true, type: Number },
+    paymentInfo: [paymentInfoSchema2],
+    requirements: [requirementsSchema]
+  },
+  { timestamps: true }
+);
+var EventInfoModel = mongoose.model("EventInfo", schema);
+
+// src/mongoose/Relation.ts
+var MongooseSchema2 = mongoose2.Schema;
+var relationDatesSchema = new MongooseSchema2(
+  {
+    lastUpdateBy: {
+      resourceId: { required: false, type: String },
+      userEmail: { required: false, type: String }
+    },
+    paymentReference: { required: false, type: String },
+    stallType: StallTypeSchema,
+    startDate: { required: false, type: String },
+    startTime: { required: false, type: String },
+    status: {
+      enum: Object.values(EnumInviteStatus),
+      required: false,
+      type: String
+    }
+  },
+  { _id: false }
+);
+var RelationTypeSchema = new MongooseSchema2(
+  {
+    active: { default: true, required: true, type: Boolean },
+    chatId: {
+      ref: "Chat",
+      required: true,
+      type: mongoose2.Schema.Types.ObjectId
+    },
+    deletedAt: { default: null, required: false, type: Date },
+    eventId: {
+      ref: "Event",
+      required: true,
+      type: mongoose2.Schema.Types.ObjectId
+    },
+    lastUpdateBy: {
+      enum: Object.values(EnumResourceType),
+      required: true,
+      type: String
+    },
+    relationDates: [relationDatesSchema],
+    relationType: {
+      enum: Object.values(EnumRelationResource),
+      required: true,
+      type: String
+    },
+    vendorId: {
+      ref: "Vendor",
+      required: true,
+      type: mongoose2.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+RelationTypeSchema.index({
+  "relationDates.startDate": 1,
+  "relationDates.startTime": 1,
+  "relationDates.status": 1
+});
+var RelationModel = mongoose2.model(
+  "Relation",
+  RelationTypeSchema
+);
+
+// src/mongoose/global.ts
+var MongooseSchema3 = mongoose3.Schema;
+var OwnerTypeSchema = new MongooseSchema3(
+  {
+    email: { required: true, type: String },
+    userId: {
+      ref: "User",
+      required: true,
+      type: mongoose3.Schema.Types.ObjectId
+    }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var SocialMediaTypeSchema = new MongooseSchema3(
+  {
+    link: { required: true, type: String },
+    name: { required: true, type: String }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field
+);
+var ResourceImageTypeSchema = new MongooseSchema3(
+  {
+    source: { required: false, type: String },
+    title: { required: false, type: String }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var SubCategorySchema = new MongooseSchema3(
+  {
+    id: { required: false, type: String },
+    items: [
+      {
+        id: { required: false, type: String },
+        name: { required: false, type: String }
+      }
+    ],
+    name: { required: false, type: String }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var CategorySchema = new MongooseSchema3(
+  {
+    id: { required: true, type: String },
+    name: { required: true, type: String },
+    subcategories: [SubCategorySchema]
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var PosterUsageTypeSchema = new MongooseSchema3(
+  {
+    count: { default: 0, required: false, type: Number },
+    month: { required: false, type: String }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var partnersSchema = new MongooseSchema3(
+  {
+    email: { required: false, type: String },
+    licence: {
+      enum: Object.values(EnumUserLicence),
+      required: false,
+      type: String
+    },
+    resourceId: {
+      required: false,
+      type: String
+    },
+    resourceType: {
+      enum: Object.values(EnumResourceType),
+      required: false,
+      type: String
+    }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var ContactDetailsSchema = new MongooseSchema3(
+  {
+    email: { required: false, type: String },
+    landlinePhone: { required: false, type: String },
+    mobilePhone: { required: false, type: String }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var termsAgreementSchema = new MongooseSchema3(
+  {
+    appBuildNumber: { required: true, type: String },
+    appId: { required: true, type: String },
+    appVersion: { required: true, type: String },
+    brand: { required: true, type: String },
+    deviceName: { required: true, type: String },
+    installationId: { required: true, type: String },
+    manufacturer: { required: true, type: String },
+    modelName: { required: true, type: String },
+    osName: { required: true, type: String },
+    osVersion: { required: true, type: String },
+    termVersion: { required: true, type: String },
+    timestamp: { required: true, type: String }
+  },
+  { _id: false }
+);
+var resourceRelationsSchema = new MongooseSchema3(
+  {
+    relationDates: {
+      default: [],
+      required: false,
+      type: [relationDatesSchema]
+    },
+    relationId: {
+      ref: "Relation",
+      required: false,
+      type: mongoose3.Schema.Types.ObjectId
+    }
+  },
+  { _id: false }
+);
+var baseResourceFields = {
+  active: { default: false, required: true, type: Boolean },
+  adIds: {
+    ref: "Ad",
+    required: false,
+    type: [mongoose3.Schema.Types.ObjectId]
+  },
+  contactDetails: ContactDetailsSchema,
+  cover: ResourceImageTypeSchema,
+  deletedAt: { default: null, required: false, type: Date },
+  description: { required: true, type: String },
+  images: [ResourceImageTypeSchema],
+  logo: ResourceImageTypeSchema,
+  name: { required: true, type: String },
+  owner: OwnerTypeSchema,
+  partners: {
+    required: false,
+    type: [partnersSchema]
+  },
+  posterUsage: PosterUsageTypeSchema,
+  promoCodes: { required: false, type: [String] },
+  region: { required: true, type: String },
+  relations: {
+    default: [],
+    required: false,
+    type: [resourceRelationsSchema]
+  },
+  socialMedia: [SocialMediaTypeSchema],
+  termsAgreement: termsAgreementSchema
+};
+
+// src/mongoose/Ad.ts
+var MongooseSchema4 = mongoose4.Schema;
+var schema2 = new MongooseSchema4(
+  {
+    active: { default: true, type: Boolean },
+    adStyle: {
+      default: "Bloom" /* BLOOM */,
+      enum: Object.values(EnumAdStyle),
+      required: true,
+      type: String
+    },
+    adType: {
+      default: "Sponsored" /* SPONSORED */,
+      enum: Object.values(EnumAdType),
+      required: true,
+      type: String
+    },
+    // TODO: similar to  ViewSchema
+    clicks: { default: 0, required: true, type: Number },
+    clui: { required: false, type: String },
+    end: { required: true, type: Date },
+    // TODO: similar to  ViewSchema
+    impressions: { default: 0, required: true, type: Number },
+    resourceCover: { required: true, type: String },
+    resourceDescription: { required: true, type: String },
+    resourceId: { required: true, type: String },
+    resourceLogo: { required: false, type: String },
+    resourceName: { required: true, type: String },
+    resourceRegion: { required: true, type: String },
+    resourceType: {
+      enum: Object.values(EnumResourceType),
+      required: true,
+      type: String
+    },
+    showOn: {
+      default: "Front_page" /* FRONT_PAGE */,
+      enum: Object.values(EnumAdShowOn),
+      required: true,
+      type: String
+    },
+    socialMedia: [SocialMediaTypeSchema],
+    start: { required: true, type: Date },
+    status: {
+      default: "Active" /* ACTIVE */,
+      enum: Object.values(EnumAdStatus),
+      required: true,
+      type: String
+    },
+    targetRegion: { required: false, type: String }
+  },
+  {
+    timestamps: true
+  }
+);
+schema2.index({
+  end: 1,
+  start: 1,
+  status: 1
+});
+var AdModel = mongoose4.model("Ad", schema2);
+
+// src/mongoose/Chat.ts
+import mongoose5 from "mongoose";
+var MongooseSchema5 = mongoose5.Schema;
+var MessageSchema = new MongooseSchema5(
+  {
+    content: { required: true, type: String },
+    senderAvatar: { required: false, type: String },
+    senderId: {
+      ref: "User",
+      required: true,
+      type: mongoose5.Schema.Types.ObjectId
+    },
+    senderName: { required: true, type: String }
+  },
+  { timestamps: true }
+);
+var ParticipantSchema = new MongooseSchema5(
+  {
+    active: { default: true, required: true, type: Boolean },
+    email: { required: true, type: String },
+    userId: {
+      ref: "User",
+      required: true,
+      type: mongoose5.Schema.Types.ObjectId
+    }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var ChatSchema = new MongooseSchema5(
+  {
+    active: { default: true, required: true, type: Boolean },
+    chatName: { required: true, type: String },
+    chatType: {
+      enum: Object.values(EnumChatType),
+      required: true,
+      type: String
+    },
+    deletedAt: { default: null, required: false, type: Date },
+    messages: [MessageSchema],
+    participants: [ParticipantSchema],
+    resourceInfo: {
+      eventId: {
+        ref: "Event",
+        required: false,
+        type: mongoose5.Schema.Types.ObjectId
+      },
+      vendorId: {
+        ref: "Vendor",
+        required: false,
+        type: mongoose5.Schema.Types.ObjectId
+      }
+    }
+  },
+  {
+    timestamps: true
+  }
+);
+var ChatModel = mongoose5.model("Chat", ChatSchema);
+
+// src/mongoose/Notification.ts
+import mongoose6 from "mongoose";
+var MongooseSchema6 = mongoose6.Schema;
+var schema3 = new MongooseSchema6(
+  {
+    data: {
+      resourceId: { required: true, type: String },
+      resourceName: { required: true, type: String },
+      resourceType: {
+        enum: Object.values(EnumNotificationResourceType),
+        required: true,
+        type: String
+      }
+    },
+    isRead: { default: false, index: true, required: true, type: Boolean },
+    message: { required: true, type: String },
+    title: { required: true, type: String },
+    type: {
+      default: "system" /* SYSTEM */,
+      enum: Object.values(EnumNotificationType),
+      required: true,
+      type: String
+    },
+    userId: {
+      ref: "User",
+      required: true,
+      type: mongoose6.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+schema3.index({ isRead: 1, userId: 1 });
+schema3.index({ createdAt: -1, userId: 1 });
+var NotificationModel = mongoose6.model(
+  "Notification",
+  schema3
+);
+var Notification_default = NotificationModel;
+
+// src/mongoose/PushToken.ts
+import mongoose7 from "mongoose";
+var MongooseSchema7 = mongoose7.Schema;
+var schema4 = new MongooseSchema7(
+  {
+    platform: {
+      enum: Object.values(EnumOSPlatform),
+      required: true,
+      type: String
+    },
+    token: { required: true, type: String },
+    userId: { required: true, type: mongoose7.Schema.Types.ObjectId }
+  },
+  { timestamps: true }
+);
+var PushTokenModel = mongoose7.model("PushToken", schema4);
+var PushToken_default = PushTokenModel;
+
+// src/mongoose/ResourceActivity.ts
+import mongoose8 from "mongoose";
+var MongooseSchema8 = mongoose8.Schema;
+var ActivitySchema = new MongooseSchema8(
+  {
+    activityType: {
+      enum: Object.values(EnumActivity),
+      required: true,
+      type: String
+    },
+    location: {
+      coordinates: {
+        required: false,
+        type: [Number]
+      },
+      type: {
+        default: "Point",
+        enum: ["Point"],
+        required: false,
+        type: String
+      }
+    },
+    startDate: { required: false, type: String },
+    startTime: { required: false, type: String },
+    timestamp: { default: Date.now, type: Date },
+    userAgent: {
+      enum: Object.values(EnumOSPlatform),
+      required: true,
+      type: String
+    },
+    userId: { required: false, type: String }
+  },
+  { _id: false }
+);
+var schema5 = new MongooseSchema8(
+  {
+    activity: { default: [], type: [ActivitySchema] },
+    resourceId: { required: true, type: String },
+    resourceType: {
+      enum: Object.values(EnumResourceType),
+      required: true,
+      type: String
+    }
+  },
+  { timestamps: true }
+);
+schema5.index({ resourceId: 1, resourceType: 1 }, { unique: true });
+schema5.index({ "views.location": "2dsphere" });
+var ResourceActivityModel = mongoose8.model("ResourceActivity", schema5);
+
+// src/mongoose/Testers.ts
+import mongoose9 from "mongoose";
+var MongooseSchema9 = mongoose9.Schema;
+var TesterSchema = new MongooseSchema9(
+  {
+    active: { default: false, required: true, type: Boolean },
+    categories: [CategorySchema],
+    companyName: { required: true, type: String },
+    email: { required: true, type: String },
+    firstName: { required: true, type: String },
+    lastName: { required: true, type: String },
+    osType: {
+      enum: Object.values(EnumOSPlatform),
+      required: true,
+      type: String
+    },
+    region: { required: true, type: String },
+    resourceType: {
+      enum: Object.values(EnumResourceType),
+      required: true,
+      type: String
+    }
+  },
+  {
+    timestamps: true
+  }
+);
+var TesterModel = mongoose9.model("Tester", TesterSchema);
+
+// src/mongoose/User.ts
+import mongoose10 from "mongoose";
+var MongooseSchema10 = mongoose10.Schema;
+var userActivityEventSchema = new MongooseSchema10(
+  {
+    resourceId: {
+      ref: "Event",
+      required: false,
+      type: mongoose10.Schema.Types.ObjectId
+    },
+    startDate: { required: false, type: String },
+    startTime: { required: false, type: String }
+  },
+  { _id: false }
+);
+var userActivityFavouritesSchema = new MongooseSchema10(
+  {
+    events: {
+      ref: "Event",
+      required: false,
+      type: [mongoose10.Schema.Types.ObjectId]
+    },
+    vendors: {
+      ref: "Vendor",
+      required: false,
+      type: [mongoose10.Schema.Types.ObjectId]
+    }
+  },
+  { _id: false }
+);
+var schema6 = new MongooseSchema10(
+  {
+    active: { default: false, required: true, type: Boolean },
+    avatar: ResourceImageTypeSchema,
+    deletedAt: { default: null, required: false, type: Date },
+    email: { required: true, type: String },
+    events: {
+      ref: "Event",
+      required: false,
+      type: [mongoose10.Schema.Types.ObjectId]
+    },
+    firstName: { required: true, type: String },
+    isTester: { default: false, required: false, type: Boolean },
+    lastName: { required: true, type: String },
+    licences: {
+      enum: Object.values(EnumUserLicence),
+      required: false,
+      type: [String]
+    },
+    partners: {
+      required: false,
+      type: [partnersSchema]
+    },
+    password: { required: true, type: String },
+    platform: {
+      enum: Object.values(EnumOSPlatform),
+      required: false,
+      type: String
+    },
+    preferredRegion: {
+      required: true,
+      type: String
+    },
+    refreshToken: {
+      required: false,
+      type: String
+    },
+    role: {
+      default: "customer" /* CUSTOMER */,
+      enum: Object.values(EnumUserRole),
+      required: true,
+      type: String
+    },
+    termsAgreement: termsAgreementSchema,
+    userActivity: {
+      favourites: {
+        default: () => ({ events: [], vendors: [] }),
+        type: userActivityFavouritesSchema
+      },
+      going: {
+        events: [userActivityEventSchema]
+      },
+      interested: {
+        events: [userActivityEventSchema]
+      },
+      present: {
+        events: [userActivityEventSchema]
+      }
+    },
+    vendor: {
+      ref: "Vendor",
+      required: false,
+      type: mongoose10.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+schema6.index({ "partners.email": 1 });
+var UserModel = mongoose10.model("User", schema6);
+
+// src/mongoose/VerificationToken.ts
+import mongoose11 from "mongoose";
+var MongooseSchema11 = mongoose11.Schema;
+var schema7 = new MongooseSchema11(
+  {
+    createdAt: {
+      default: Date.now,
+      expires: 24 * 60 * 60,
+      // 24 hours in seconds (MongoDB TTL expects seconds)
+      required: true,
+      type: Date
+    },
+    // Token expires after 1 day
+    email: { required: true, type: String },
+    verificationToken: { required: true, type: String }
+  },
+  { timestamps: true }
+);
+var VerificationTokenModel = mongoose11.model(
+  "VerificationToken",
+  schema7
+);
+
+// src/mongoose/vendor/Vendor.ts
+import mongoose12 from "mongoose";
+var MongooseSchema12 = mongoose12.Schema;
+var MenuTypeSchema = new MongooseSchema12(
+  {
+    description: { required: false, type: String },
+    name: { required: false, type: String },
+    price: { required: false, type: Number },
+    productGroups: { required: false, type: [String] }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var LocationsSchema = new MongooseSchema12(
+  {
+    dateTime: {
+      endDate: { required: false, type: String },
+      endTime: { required: false, type: String },
+      startDate: { required: false, type: String },
+      startTime: { required: false, type: String }
+    },
+    description: { required: false, type: String },
+    location: {
+      city: { required: false, type: String },
+      coordinates: {
+        required: false,
+        type: [Number]
+        // [longitude, latitude]
+      },
+      country: { required: false, type: String },
+      fullAddress: { required: false, type: String },
+      latitude: { required: false, type: Number },
+      longitude: { required: false, type: Number },
+      region: { required: false, type: String },
+      type: { required: false, type: String }
+      // Mongoose GeoJSON type
+    }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var schema8 = new MongooseSchema12(
+  {
+    ...baseResourceFields,
+    // Importing base resource fields from global.ts
+    availability: {
+      corporate: { default: false, required: false, type: Boolean },
+      private: { default: false, required: false, type: Boolean },
+      school: { default: false, required: false, type: Boolean }
+    },
+    categories: [CategorySchema],
+    locations: [LocationsSchema],
+    multiLocation: { required: true, type: Boolean },
+    products: [MenuTypeSchema],
+    vendorInfoId: {
+      ref: "VendorInfo",
+      required: false,
+      type: mongoose12.Schema.Types.ObjectId
+    },
+    vendorType: {
+      enum: Object.values(EnumVendorType),
+      required: true,
+      type: String
+    }
+  },
+  { timestamps: true }
+);
+schema8.index({ name: 1 });
+schema8.index({ description: 1 });
+schema8.index({ region: 1 });
+schema8.index({ "categories.name": 1 });
+schema8.index({ "partners.email": 1 });
+var VendorModel = mongoose12.model("Vendor", schema8);
+
+// src/mongoose/vendor/VendorInfo.ts
+import mongoose13 from "mongoose";
+var MongooseSchema13 = mongoose13.Schema;
+var AttributesSchema = new MongooseSchema13(
+  {
+    details: { required: false, type: String },
+    isRequired: { default: false, required: true, type: Boolean }
+  },
+  { _id: false }
+);
+var schema9 = new MongooseSchema13(
+  {
+    compliance: {
+      foodBeverageLicense: { default: false, required: false, type: Boolean },
+      liabilityInsurance: { default: false, required: false, type: Boolean }
+    },
+    documents: [ResourceImageTypeSchema],
+    product: {
+      foodFlavors: {
+        enum: Object.values(EnumFoodFlavor),
+        required: true,
+        type: [String]
+      },
+      packaging: { required: true, type: [String] },
+      priceRange: {
+        max: { required: true, type: Number },
+        min: { required: true, type: Number }
+      },
+      producedIn: { required: true, type: [String] }
+    },
+    requirements: {
+      electricity: AttributesSchema,
+      gazebo: AttributesSchema,
+      table: AttributesSchema
+    },
+    stallInfo: {
+      size: {
+        depth: { required: true, type: Number },
+        width: { required: true, type: Number }
+      }
+    },
+    vendorId: {
+      ref: "Vendor",
+      required: true,
+      type: mongoose13.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+var VendorInfoModel = mongoose13.model(
+  "VendorInfo",
+  schema9
+);
+
+// src/mongoose/event/Event.ts
+import mongoose14 from "mongoose";
+var MongooseSchema14 = mongoose14.Schema;
+var locationsSchema = new MongooseSchema14(
+  {
+    city: { required: true, type: String },
+    coordinates: {
+      required: true,
+      type: [Number]
+      // [longitude, latitude]
+    },
+    country: { required: true, type: String },
+    fullAddress: { required: true, type: String },
+    latitude: { required: true, type: Number },
+    longitude: { required: true, type: Number },
+    region: { required: true, type: String },
+    type: {
+      default: "Point",
+      enum: ["Point"],
+      required: true,
+      type: String
+    }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var dateTimeSchema3 = new MongooseSchema14(
+  {
+    endDate: { required: true, type: String },
+    endTime: { required: true, type: String },
+    startDate: { required: true, type: String },
+    startTime: { required: true, type: String }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var schema10 = new MongooseSchema14(
+  {
+    ...baseResourceFields,
+    // Importing base resource fields from global.ts
+    dateTime: [dateTimeSchema3],
+    eventInfoId: {
+      ref: "EventInfo",
+      required: false,
+      type: mongoose14.Schema.Types.ObjectId
+    },
+    eventType: {
+      enum: Object.values(EnumEventType),
+      required: true,
+      type: String
+    },
+    location: {
+      required: true,
+      type: locationsSchema
+    },
+    nzbn: { required: true, type: String },
+    provider: { required: false, type: String },
+    rainOrShine: { required: true, type: Boolean },
+    tags: { required: true, type: [String] }
+  },
+  { timestamps: true }
+);
+schema10.index({ name: 1 });
+schema10.index({ description: 1 });
+schema10.index({ region: 1 });
+schema10.index({ location: "2dsphere" });
+schema10.index({ tags: 1 });
+schema10.index({ "partners.email": 1 });
+var EventModel = mongoose14.model("Event", schema10);
+
+// src/service/database.ts
+import mongoose15 from "mongoose";
+
+// src/service/timezonePlugin.ts
+import dayjs3 from "dayjs";
+import timezone2 from "dayjs/plugin/timezone";
+import utc2 from "dayjs/plugin/utc";
+dayjs3.extend(utc2);
+dayjs3.extend(timezone2);
+function timezonePlugin(schema11) {
+  if (!schema11.get("timestamps")) return;
+  const transform = (_doc, ret) => {
+    if (ret.createdAt)
+      ret.createdAt = dayjs3(ret.createdAt).tz("Pacific/Auckland").format();
+    if (ret.updatedAt)
+      ret.updatedAt = dayjs3(ret.updatedAt).tz("Pacific/Auckland").format();
+    return ret;
+  };
+  schema11.set("toJSON", { transform });
+  schema11.set("toObject", { transform });
+}
+
+// src/service/database.ts
+mongoose15.plugin(timezonePlugin);
+var connectToDatabase = async () => {
+  try {
+    const mongoUri = process.env.MONGODB_URI ? process.env.MONGODB_URI : (
+      // Fallback to MongoDB Atlas connection string
+      `mongodb+srv://${process.env.DB_USER}:${process.env.DB_PASSWORD}@${process.env.DB_NAME}.mongodb.net/?retryWrites=true&w=majority&appName=${process.env.APP_NAME}`
+    );
+    await mongoose15.connect(mongoUri);
+    const connectionType = process.env.MONGODB_URI ? "Local MongoDB" : "MongoDB Atlas";
+    console.log(
+      `${connectionType} connected from server/src/service/database.ts`
+    );
+  } catch (err) {
+    console.error("Error connecting to MongoDB:", err);
+    throw err;
+  }
+};
+
+// src/service/notificationService.ts
+async function publishNotificationEvents(userId, context) {
+  try {
+    const userNotifications = await Notification_default.find({
+      userId
+    }).sort({ createdAt: -1 });
+    const [total, unread] = await Promise.all([
+      Notification_default.countDocuments({ userId }),
+      Notification_default.countDocuments({ isRead: false, userId })
+    ]);
+    context.pubsub.publish("GET_NOTIFICATIONS" /* GET_NOTIFICATIONS */, {
+      getNotifications: userNotifications,
+      getNotificationsUserId: userId
+    });
+    context.pubsub.publish("GET_NOTIFICATIONS_COUNT" /* GET_NOTIFICATIONS_COUNT */, {
+      getNotificationsCount: { total, unread, userId }
+    });
+    console.log(`Published notification events for user: ${String(userId)}`);
+  } catch (error) {
+    console.error(
+      `Failed to publish notification events for user ${String(userId)}:`,
+      error
+    );
+  }
+}
+async function createNotifications(payload, context) {
+  const { data, message, title, type, userIds } = payload;
+  try {
+    const notifications = userIds.map((userId) => ({
+      data,
+      isRead: false,
+      message,
+      title,
+      type,
+      userId
+    }));
+    const savedNotifications = await Notification_default.insertMany(notifications);
+    console.log(
+      `Created ${savedNotifications.length} notifications for ${userIds.length} users`
+    );
+    const uniqueUserIds = [...new Set(userIds)];
+    for (const userId of uniqueUserIds) {
+      await publishNotificationEvents(userId, context);
+    }
+    return savedNotifications;
+  } catch (error) {
+    console.error("Failed to create notifications:", error);
+    return [];
+  }
+}
+
+// src/service/sendPushNotification.ts
+import { Expo } from "expo-server-sdk";
+var expo = new Expo();
+function extractTokensFromMessage(message) {
+  return Array.isArray(message.to) ? message.to : [message.to];
+}
+function createPushMessages({
+  tokens,
+  message,
+  title,
+  data
+}) {
+  const messages = [];
+  const invalidTokens = [];
+  for (const token of tokens) {
+    if (!Expo.isExpoPushToken(token)) {
+      invalidTokens.push(token);
+      continue;
+    }
+    messages.push({
+      body: message,
+      data: { ...data },
+      sound: "default",
+      title,
+      to: token
+    });
+  }
+  return { invalidTokens, messages };
+}
+function processChunkResults(tickets, chunk) {
+  let successCount = 0;
+  const failedTokens = [];
+  for (const [ticketIndex, ticket] of tickets.entries()) {
+    if (ticket.status === "error") {
+      const message = chunk[ticketIndex];
+      if (message) {
+        const tokens = extractTokensFromMessage(message);
+        if (ticket.details?.error === "DeviceNotRegistered") {
+          failedTokens.push(...tokens);
+        }
+        console.log("Push notification error", {
+          error: ticket.details?.error,
+          tokens
+        });
+      }
+    } else {
+      successCount++;
+    }
+  }
+  return { failedTokens, successCount };
+}
+async function sendChunk(chunk, chunkIndex) {
+  try {
+    const tickets = await expo.sendPushNotificationsAsync(chunk);
+    const { successCount, failedTokens } = processChunkResults(tickets, chunk);
+    console.log(
+      `Chunk ${chunkIndex + 1}: Sent ${successCount}/${chunk.length} notifications successfully`
+    );
+    return { failedTokens, successCount };
+  } catch (error) {
+    console.log("Error sending Expo push notification chunk", {
+      chunkIndex,
+      chunkSize: chunk.length,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { failedTokens: [], successCount: 0 };
+  }
+}
+async function sendPushNotification({
+  data,
+  message,
+  title,
+  userIds
+}) {
+  const pushTokens = await PushToken_default.find({ userId: { $in: userIds } });
+  const expoTokens = pushTokens.map((token) => token.token);
+  const { messages, invalidTokens } = createPushMessages({
+    data,
+    message,
+    title,
+    tokens: expoTokens
+  });
+  if (invalidTokens.length > 0) {
+    console.log(`Found ${invalidTokens.length} invalid push tokens`);
+  }
+  if (messages.length === 0) {
+    console.log("No valid messages to send after filtering tokens");
+    return;
+  }
+  const chunks = expo.chunkPushNotifications(messages);
+  let totalSuccessCount = 0;
+  const allFailedTokens = [];
+  for (const [chunkIndex, chunk] of chunks.entries()) {
+    const { successCount, failedTokens } = await sendChunk(
+      chunk,
+      chunkIndex + 1
+    );
+    totalSuccessCount += successCount;
+    allFailedTokens.push(...failedTokens);
+  }
+  console.log(
+    `Sent push notification to ${totalSuccessCount}/${messages.length} tokens across ${chunks.length} chunks`
+  );
+  if (allFailedTokens.length > 0) {
+    console.log(`Found ${allFailedTokens.length} failed push tokens`);
+  }
+}
+
 // src/storage/index.ts
 var SAVED_PASSWORD_KEY = "savedPassword";
 var SAVED_EMAIL_KEY = "savedEmail";
@@ -5978,17 +7073,8 @@ var fonts = {
     fontWeight: "400"
   }
 };
-
-// src/types/resourceActivities.ts
-var EnumActivity = /* @__PURE__ */ ((EnumActivity2) => {
-  EnumActivity2["FAVORITE"] = "FAVORITE";
-  EnumActivity2["GOING"] = "GOING";
-  EnumActivity2["INTERESTED"] = "INTERESTED";
-  EnumActivity2["PRESENT"] = "PRESENT";
-  EnumActivity2["VIEW"] = "VIEW";
-  return EnumActivity2;
-})(EnumActivity || {});
 export {
+  CategorySchema,
   EnumActivity,
   EnumAdShowOn,
   EnumAdStatus,
@@ -6002,6 +7088,7 @@ export {
   EnumNotificationType,
   EnumOSPlatform,
   EnumPaymentMethod,
+  EnumPubSubEvents,
   EnumRegions,
   EnumRelationResource,
   EnumResourceType,
@@ -6010,20 +7097,28 @@ export {
   EnumUserRole,
   EnumVendorType,
   ImageTypeEnum,
+  ParticipantSchema,
+  RelationTypeSchema,
+  ResourceImageTypeSchema,
   SAVED_EMAIL_KEY,
   SAVED_PASSWORD_KEY,
   SAVED_REFRESH_TOKEN_KEY,
   SAVED_TOKEN_KEY,
+  SocialMediaTypeSchema,
+  StallTypeSchema,
   USER_STORAGE_KEY,
   availableCategories,
   availableCityOptions,
   availableRegionOptions,
   availableRegionTypes,
   availableTagTypes,
+  baseResourceFields,
   capitalizeFirstLetter,
   categoryColors,
   companyContactFields,
+  connectToDatabase,
   contactUsFields,
+  createNotifications,
   darkColors,
   dateFormat,
   defaultEventFormValues,
@@ -6050,20 +7145,25 @@ export {
   mapBaseResourceTypeToFormData,
   normalizeUrl,
   packagingOptions,
+  partnersSchema,
   paymentMethodOptions,
   producedIngOptions,
   productLabelGroups,
   profileFields,
+  publishNotificationEvents,
   registerFields,
+  relationDatesSchema,
   removeTypename,
   requestPasswordResetFields,
   requirementsOptions,
   resetPasswordFields,
+  sendPushNotification,
   socialMediaFields,
   sortDatesChronologically,
   stallTypeOptions,
   statusOptions,
   tagOptions,
+  termsAgreementSchema,
   testersFields,
   timeFormat,
   truncateText,