@timardex/cluemart-shared 1.2.28 → 1.2.29

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CategorySchema: () => CategorySchema,
   EnumActivity: () => EnumActivity,
   EnumAdShowOn: () => EnumAdShowOn,
   EnumAdStatus: () => EnumAdStatus,
@@ -52,20 +53,28 @@ __export(index_exports, {
   EnumUserRole: () => EnumUserRole,
   EnumVendorType: () => EnumVendorType,
   ImageTypeEnum: () => ImageTypeEnum,
+  ParticipantSchema: () => ParticipantSchema,
+  RelationTypeSchema: () => RelationTypeSchema,
+  ResourceImageTypeSchema: () => ResourceImageTypeSchema,
   SAVED_EMAIL_KEY: () => SAVED_EMAIL_KEY,
   SAVED_PASSWORD_KEY: () => SAVED_PASSWORD_KEY,
   SAVED_REFRESH_TOKEN_KEY: () => SAVED_REFRESH_TOKEN_KEY,
   SAVED_TOKEN_KEY: () => SAVED_TOKEN_KEY,
+  SocialMediaTypeSchema: () => SocialMediaTypeSchema,
+  StallTypeSchema: () => StallTypeSchema,
   USER_STORAGE_KEY: () => USER_STORAGE_KEY,
   availableCategories: () => availableCategories,
   availableCityOptions: () => availableCityOptions,
   availableRegionOptions: () => availableRegionOptions,
   availableRegionTypes: () => availableRegionTypes,
   availableTagTypes: () => availableTagTypes,
+  baseResourceFields: () => baseResourceFields,
   capitalizeFirstLetter: () => capitalizeFirstLetter,
   categoryColors: () => categoryColors,
   companyContactFields: () => companyContactFields,
+  connectToDatabase: () => connectToDatabase,
   contactUsFields: () => contactUsFields,
+  createNotifications: () => createNotifications,
   darkColors: () => darkColors,
   dateFormat: () => dateFormat,
   defaultEventFormValues: () => defaultEventFormValues,
@@ -92,20 +101,25 @@ __export(index_exports, {
   mapBaseResourceTypeToFormData: () => mapBaseResourceTypeToFormData,
   normalizeUrl: () => normalizeUrl,
   packagingOptions: () => packagingOptions,
+  partnersSchema: () => partnersSchema,
   paymentMethodOptions: () => paymentMethodOptions,
   producedIngOptions: () => producedIngOptions,
   productLabelGroups: () => productLabelGroups,
   profileFields: () => profileFields,
+  publishNotificationEvents: () => publishNotificationEvents,
   registerFields: () => registerFields,
+  relationDatesSchema: () => relationDatesSchema,
   removeTypename: () => removeTypename,
   requestPasswordResetFields: () => requestPasswordResetFields,
   requirementsOptions: () => requirementsOptions,
   resetPasswordFields: () => resetPasswordFields,
+  sendPushNotification: () => sendPushNotification,
   socialMediaFields: () => socialMediaFields,
   sortDatesChronologically: () => sortDatesChronologically,
   stallTypeOptions: () => stallTypeOptions,
   statusOptions: () => statusOptions,
   tagOptions: () => tagOptions,
+  termsAgreementSchema: () => termsAgreementSchema,
   testersFields: () => testersFields,
   timeFormat: () => timeFormat,
   truncateText: () => truncateText,
@@ -4930,7 +4944,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({
@@ -5003,21 +5017,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({
@@ -5196,7 +5210,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) {
@@ -6166,6 +6180,1101 @@ function useAdForm(data) {
   };
 }
 
+// src/mongoose/Ad.ts
+var import_mongoose4 = __toESM(require("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
+var import_mongoose3 = __toESM(require("mongoose"));
+
+// src/mongoose/Relation.ts
+var import_mongoose2 = __toESM(require("mongoose"));
+
+// src/mongoose/event/EventInfo.ts
+var import_mongoose = __toESM(require("mongoose"));
+var MongooseSchema = import_mongoose.default.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: import_mongoose.default.Schema.Types.ObjectId
+    },
+    packInTime: { required: true, type: Number },
+    paymentDueHours: { required: true, type: Number },
+    paymentInfo: [paymentInfoSchema2],
+    requirements: [requirementsSchema]
+  },
+  { timestamps: true }
+);
+var EventInfoModel = import_mongoose.default.model("EventInfo", schema);
+
+// src/mongoose/Relation.ts
+var MongooseSchema2 = import_mongoose2.default.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: import_mongoose2.default.Schema.Types.ObjectId
+    },
+    deletedAt: { default: null, required: false, type: Date },
+    eventId: {
+      ref: "Event",
+      required: true,
+      type: import_mongoose2.default.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: import_mongoose2.default.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+RelationTypeSchema.index({
+  "relationDates.startDate": 1,
+  "relationDates.startTime": 1,
+  "relationDates.status": 1
+});
+var RelationModel = import_mongoose2.default.model(
+  "Relation",
+  RelationTypeSchema
+);
+
+// src/mongoose/global.ts
+var MongooseSchema3 = import_mongoose3.default.Schema;
+var OwnerTypeSchema = new MongooseSchema3(
+  {
+    email: { required: true, type: String },
+    userId: {
+      ref: "User",
+      required: true,
+      type: import_mongoose3.default.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: import_mongoose3.default.Schema.Types.ObjectId
+    }
+  },
+  { _id: false }
+);
+var baseResourceFields = {
+  active: { default: false, required: true, type: Boolean },
+  adIds: {
+    ref: "Ad",
+    required: false,
+    type: [import_mongoose3.default.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 = import_mongoose4.default.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 = import_mongoose4.default.model("Ad", schema2);
+
+// src/mongoose/Chat.ts
+var import_mongoose5 = __toESM(require("mongoose"));
+var MongooseSchema5 = import_mongoose5.default.Schema;
+var MessageSchema = new MongooseSchema5(
+  {
+    content: { required: true, type: String },
+    senderAvatar: { required: false, type: String },
+    senderId: {
+      ref: "User",
+      required: true,
+      type: import_mongoose5.default.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: import_mongoose5.default.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: import_mongoose5.default.Schema.Types.ObjectId
+      },
+      vendorId: {
+        ref: "Vendor",
+        required: false,
+        type: import_mongoose5.default.Schema.Types.ObjectId
+      }
+    }
+  },
+  {
+    timestamps: true
+  }
+);
+var ChatModel = import_mongoose5.default.model("Chat", ChatSchema);
+
+// src/mongoose/Notification.ts
+var import_mongoose6 = __toESM(require("mongoose"));
+var MongooseSchema6 = import_mongoose6.default.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: import_mongoose6.default.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+schema3.index({ isRead: 1, userId: 1 });
+schema3.index({ createdAt: -1, userId: 1 });
+var NotificationModel = import_mongoose6.default.model(
+  "Notification",
+  schema3
+);
+var Notification_default = NotificationModel;
+
+// src/mongoose/PushToken.ts
+var import_mongoose7 = __toESM(require("mongoose"));
+var MongooseSchema7 = import_mongoose7.default.Schema;
+var schema4 = new MongooseSchema7(
+  {
+    platform: {
+      enum: Object.values(EnumOSPlatform),
+      required: true,
+      type: String
+    },
+    token: { required: true, type: String },
+    userId: { required: true, type: import_mongoose7.default.Schema.Types.ObjectId }
+  },
+  { timestamps: true }
+);
+var PushTokenModel = import_mongoose7.default.model("PushToken", schema4);
+var PushToken_default = PushTokenModel;
+
+// src/mongoose/ResourceActivity.ts
+var import_mongoose8 = __toESM(require("mongoose"));
+var MongooseSchema8 = import_mongoose8.default.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 = import_mongoose8.default.model("ResourceActivity", schema5);
+
+// src/mongoose/Testers.ts
+var import_mongoose9 = __toESM(require("mongoose"));
+var MongooseSchema9 = import_mongoose9.default.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 = import_mongoose9.default.model("Tester", TesterSchema);
+
+// src/mongoose/User.ts
+var import_mongoose10 = __toESM(require("mongoose"));
+var MongooseSchema10 = import_mongoose10.default.Schema;
+var userActivityEventSchema = new MongooseSchema10(
+  {
+    resourceId: {
+      ref: "Event",
+      required: false,
+      type: import_mongoose10.default.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: [import_mongoose10.default.Schema.Types.ObjectId]
+    },
+    vendors: {
+      ref: "Vendor",
+      required: false,
+      type: [import_mongoose10.default.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: [import_mongoose10.default.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: import_mongoose10.default.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+schema6.index({ "partners.email": 1 });
+var UserModel = import_mongoose10.default.model("User", schema6);
+
+// src/mongoose/VerificationToken.ts
+var import_mongoose11 = __toESM(require("mongoose"));
+var MongooseSchema11 = import_mongoose11.default.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 = import_mongoose11.default.model(
+  "VerificationToken",
+  schema7
+);
+
+// src/mongoose/vendor/Vendor.ts
+var import_mongoose12 = __toESM(require("mongoose"));
+var MongooseSchema12 = import_mongoose12.default.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: import_mongoose12.default.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 = import_mongoose12.default.model("Vendor", schema8);
+
+// src/mongoose/vendor/VendorInfo.ts
+var import_mongoose13 = __toESM(require("mongoose"));
+var MongooseSchema13 = import_mongoose13.default.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: import_mongoose13.default.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+var VendorInfoModel = import_mongoose13.default.model(
+  "VendorInfo",
+  schema9
+);
+
+// src/mongoose/event/Event.ts
+var import_mongoose14 = __toESM(require("mongoose"));
+var MongooseSchema14 = import_mongoose14.default.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: import_mongoose14.default.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 = import_mongoose14.default.model("Event", schema10);
+
+// src/service/database.ts
+var import_mongoose15 = __toESM(require("mongoose"));
+
+// src/service/timezonePlugin.ts
+var import_dayjs3 = __toESM(require("dayjs"));
+var import_timezone2 = __toESM(require("dayjs/plugin/timezone"));
+var import_utc2 = __toESM(require("dayjs/plugin/utc"));
+import_dayjs3.default.extend(import_utc2.default);
+import_dayjs3.default.extend(import_timezone2.default);
+function timezonePlugin(schema11) {
+  if (!schema11.get("timestamps")) return;
+  const transform = (_doc, ret) => {
+    if (ret.createdAt)
+      ret.createdAt = (0, import_dayjs3.default)(ret.createdAt).tz("Pacific/Auckland").format();
+    if (ret.updatedAt)
+      ret.updatedAt = (0, import_dayjs3.default)(ret.updatedAt).tz("Pacific/Auckland").format();
+    return ret;
+  };
+  schema11.set("toJSON", { transform });
+  schema11.set("toObject", { transform });
+}
+
+// src/service/database.ts
+import_mongoose15.default.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 import_mongoose15.default.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
+var import_expo_server_sdk = require("expo-server-sdk");
+var expo = new import_expo_server_sdk.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 (!import_expo_server_sdk.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";
@@ -6210,27 +7319,9 @@ var fonts = {
     fontWeight: "400"
   }
 };
-
-// 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 || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CategorySchema,
   EnumActivity,
   EnumAdShowOn,
   EnumAdStatus,
@@ -6253,20 +7344,28 @@ var EnumActivity = /* @__PURE__ */ ((EnumActivity2) => {
   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,
@@ -6293,20 +7392,25 @@ var EnumActivity = /* @__PURE__ */ ((EnumActivity2) => {
   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,