@timardex/cluemart-server-shared 1.0.3 → 1.0.4

package/dist/service/index.cjs

@@ -0,0 +1,1139 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/service/index.ts
+var service_exports = {};
+__export(service_exports, {
+  connectToDatabase: () => connectToDatabase,
+  saveNotificationsInDb: () => saveNotificationsInDb,
+  sendPushNotifications: () => sendPushNotifications,
+  updateAdStatuses: () => updateAdStatuses
+});
+module.exports = __toCommonJS(service_exports);
+
+// src/service/database.ts
+var import_mongoose = __toESM(require("mongoose"));
+
+// src/service/timezonePlugin.ts
+var import_dayjs = __toESM(require("dayjs"));
+var import_timezone = __toESM(require("dayjs/plugin/timezone"));
+var import_utc = __toESM(require("dayjs/plugin/utc"));
+import_dayjs.default.extend(import_utc.default);
+import_dayjs.default.extend(import_timezone.default);
+function timezonePlugin(schema11) {
+  if (!schema11.get("timestamps")) return;
+  const transform = (_doc, ret) => {
+    if (ret.createdAt)
+      ret.createdAt = (0, import_dayjs.default)(ret.createdAt).tz("Pacific/Auckland").format();
+    if (ret.updatedAt)
+      ret.updatedAt = (0, import_dayjs.default)(ret.updatedAt).tz("Pacific/Auckland").format();
+    return ret;
+  };
+  schema11.set("toJSON", { transform });
+  schema11.set("toObject", { transform });
+}
+
+// src/service/database.ts
+import_mongoose.default.plugin(timezonePlugin);
+var connectToDatabase = async ({
+  appName,
+  dbName,
+  dbPassword,
+  dbUser,
+  mongodbUri
+}) => {
+  try {
+    const mongoUri = mongodbUri ? mongodbUri : (
+      // Fallback to MongoDB Atlas connection string
+      `mongodb+srv://${dbUser}:${dbPassword}@${dbName}.mongodb.net/?retryWrites=true&w=majority&appName=${appName}`
+    );
+    await import_mongoose.default.connect(mongoUri);
+    const connectionType = mongodbUri ? "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/mongoose/Notification.ts
+var import_cluemart_shared = require("@timardex/cluemart-shared");
+var import_mongoose2 = __toESM(require("mongoose"));
+var MongooseSchema = import_mongoose2.default.Schema;
+var schema = new MongooseSchema(
+  {
+    data: {
+      resourceId: { required: true, type: String },
+      resourceName: { required: true, type: String },
+      resourceType: {
+        enum: Object.values(import_cluemart_shared.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: import_cluemart_shared.EnumNotificationType.SYSTEM,
+      enum: Object.values(import_cluemart_shared.EnumNotificationType),
+      required: true,
+      type: String
+    },
+    userId: {
+      ref: "User",
+      required: true,
+      type: import_mongoose2.default.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+schema.index({ isRead: 1, userId: 1 });
+schema.index({ createdAt: -1, userId: 1 });
+var NotificationModel = import_mongoose2.default.models.Notification || import_mongoose2.default.model("Notification", schema);
+
+// src/service/saveNotificationsInDb.ts
+async function saveNotificationsInDb(payload) {
+  const { data, message, title, type, userIds } = payload;
+  try {
+    const notifications = userIds.map((userId) => ({
+      data,
+      isRead: false,
+      message,
+      title,
+      type,
+      userId
+    }));
+    await NotificationModel.insertMany(notifications);
+    console.log(
+      `Created ${notifications.length} notifications for ${userIds.length} users`
+    );
+    return [...new Set(userIds)];
+  } catch (error) {
+    console.error("Failed to create notifications:", error);
+    return [];
+  }
+}
+
+// src/service/sendPushNotifications.ts
+var import_expo_server_sdk = require("expo-server-sdk");
+
+// src/mongoose/PushToken.ts
+var import_enums = require("@timardex/cluemart-shared/enums");
+var import_mongoose3 = __toESM(require("mongoose"));
+var MongooseSchema2 = import_mongoose3.default.Schema;
+var schema2 = new MongooseSchema2(
+  {
+    platform: {
+      enum: Object.values(import_enums.EnumOSPlatform),
+      required: true,
+      type: String
+    },
+    token: { required: true, type: String },
+    userId: { required: true, type: import_mongoose3.default.Schema.Types.ObjectId }
+  },
+  { timestamps: true }
+);
+var PushTokenModel = import_mongoose3.default.models.PushToken || import_mongoose3.default.model("PushToken", schema2);
+
+// src/service/sendPushNotifications.ts
+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 sendPushNotifications({
+  data,
+  message,
+  title,
+  userIds
+}) {
+  const pushTokens = await PushTokenModel.find({ userId: { $in: userIds } });
+  const expoTokens = pushTokens.map((token) => token.token);
+  if (!data) return;
+  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/service/updateAdStatus.ts
+var import_cluemart_shared13 = require("@timardex/cluemart-shared");
+
+// src/mongoose/Ad.ts
+var import_cluemart_shared5 = require("@timardex/cluemart-shared");
+var import_mongoose7 = __toESM(require("mongoose"));
+
+// src/mongoose/global.ts
+var import_cluemart_shared4 = require("@timardex/cluemart-shared");
+var import_mongoose6 = __toESM(require("mongoose"));
+
+// src/mongoose/Relation.ts
+var import_mongoose5 = __toESM(require("mongoose"));
+var import_cluemart_shared3 = require("@timardex/cluemart-shared");
+
+// src/mongoose/event/EventInfo.ts
+var import_cluemart_shared2 = require("@timardex/cluemart-shared");
+var import_mongoose4 = __toESM(require("mongoose"));
+var MongooseSchema3 = import_mongoose4.default.Schema;
+var StallTypeSchema = new MongooseSchema3(
+  {
+    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 dateTimeSchema = new MongooseSchema3(
+  {
+    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 paymentInfoSchema = new MongooseSchema3(
+  {
+    accountHolderName: { required: false, type: String },
+    accountNumber: { required: false, type: String },
+    link: { required: false, type: String },
+    paymentMethod: {
+      enum: Object.values(import_cluemart_shared2.EnumPaymentMethod),
+      required: true,
+      type: String
+    }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field
+);
+var requirementsSchema = new MongooseSchema3(
+  {
+    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 schema3 = new MongooseSchema3(
+  {
+    applicationDeadlineHours: { required: true, type: Number },
+    dateTime: [dateTimeSchema],
+    eventId: {
+      ref: "Event",
+      required: false,
+      type: import_mongoose4.default.Schema.Types.ObjectId
+    },
+    packInTime: { required: true, type: Number },
+    paymentDueHours: { required: true, type: Number },
+    paymentInfo: [paymentInfoSchema],
+    requirements: [requirementsSchema]
+  },
+  { timestamps: true }
+);
+var EventInfoModel = import_mongoose4.default.models.EventInfo || import_mongoose4.default.model("EventInfo", schema3);
+
+// src/mongoose/Relation.ts
+var MongooseSchema4 = import_mongoose5.default.Schema;
+var relationDatesSchema = new MongooseSchema4(
+  {
+    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(import_cluemart_shared3.EnumInviteStatus),
+      required: false,
+      type: String
+    }
+  },
+  { _id: false }
+);
+var RelationTypeSchema = new MongooseSchema4(
+  {
+    active: { default: true, required: true, type: Boolean },
+    chatId: {
+      ref: "Chat",
+      required: true,
+      type: import_mongoose5.default.Schema.Types.ObjectId
+    },
+    deletedAt: { default: null, required: false, type: Date },
+    eventId: {
+      ref: "Event",
+      required: true,
+      type: import_mongoose5.default.Schema.Types.ObjectId
+    },
+    lastUpdateBy: {
+      enum: Object.values(import_cluemart_shared3.EnumResourceType),
+      required: true,
+      type: String
+    },
+    relationDates: [relationDatesSchema],
+    relationType: {
+      enum: Object.values(import_cluemart_shared3.EnumRelationResource),
+      required: true,
+      type: String
+    },
+    vendorId: {
+      ref: "Vendor",
+      required: true,
+      type: import_mongoose5.default.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+RelationTypeSchema.index({
+  "relationDates.startDate": 1,
+  "relationDates.startTime": 1,
+  "relationDates.status": 1
+});
+var RelationModel = import_mongoose5.default.models.Relation || import_mongoose5.default.model("Relation", RelationTypeSchema);
+
+// src/mongoose/global.ts
+var MongooseSchema5 = import_mongoose6.default.Schema;
+var OwnerTypeSchema = new MongooseSchema5(
+  {
+    email: { required: true, type: String },
+    userId: {
+      ref: "User",
+      required: true,
+      type: import_mongoose6.default.Schema.Types.ObjectId
+    }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var SocialMediaTypeSchema = new MongooseSchema5(
+  {
+    link: { required: true, type: String },
+    name: { required: true, type: String }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field
+);
+var ResourceImageTypeSchema = new MongooseSchema5(
+  {
+    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 MongooseSchema5(
+  {
+    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 MongooseSchema5(
+  {
+    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 MongooseSchema5(
+  {
+    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 MongooseSchema5(
+  {
+    email: { required: false, type: String },
+    licence: {
+      enum: Object.values(import_cluemart_shared4.EnumUserLicence),
+      required: false,
+      type: String
+    },
+    resourceId: {
+      required: false,
+      type: String
+    },
+    resourceType: {
+      enum: Object.values(import_cluemart_shared4.EnumResourceType),
+      required: false,
+      type: String
+    }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var ContactDetailsSchema = new MongooseSchema5(
+  {
+    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 MongooseSchema5(
+  {
+    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 MongooseSchema5(
+  {
+    relationDates: {
+      default: [],
+      required: false,
+      type: [relationDatesSchema]
+    },
+    relationId: {
+      ref: "Relation",
+      required: false,
+      type: import_mongoose6.default.Schema.Types.ObjectId
+    }
+  },
+  { _id: false }
+);
+var baseResourceFields = {
+  active: { default: false, required: true, type: Boolean },
+  adIds: {
+    ref: "Ad",
+    required: false,
+    type: [import_mongoose6.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 MongooseSchema6 = import_mongoose7.default.Schema;
+var schema4 = new MongooseSchema6(
+  {
+    active: { default: true, type: Boolean },
+    adStyle: {
+      default: import_cluemart_shared5.EnumAdStyle.BLOOM,
+      enum: Object.values(import_cluemart_shared5.EnumAdStyle),
+      required: true,
+      type: String
+    },
+    adType: {
+      default: import_cluemart_shared5.EnumAdType.SPONSORED,
+      enum: Object.values(import_cluemart_shared5.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(import_cluemart_shared5.EnumResourceType),
+      required: true,
+      type: String
+    },
+    showOn: {
+      default: import_cluemart_shared5.EnumAdShowOn.FRONT_PAGE,
+      enum: Object.values(import_cluemart_shared5.EnumAdShowOn),
+      required: true,
+      type: String
+    },
+    socialMedia: [SocialMediaTypeSchema],
+    start: { required: true, type: Date },
+    status: {
+      default: import_cluemart_shared5.EnumAdStatus.ACTIVE,
+      enum: Object.values(import_cluemart_shared5.EnumAdStatus),
+      required: true,
+      type: String
+    },
+    targetRegion: { required: false, type: String }
+  },
+  {
+    timestamps: true
+  }
+);
+schema4.index({
+  end: 1,
+  start: 1,
+  status: 1
+});
+var AdModel = import_mongoose7.default.models.Ad || import_mongoose7.default.model("Ad", schema4);
+
+// src/mongoose/Chat.ts
+var import_cluemart_shared6 = require("@timardex/cluemart-shared");
+var import_mongoose8 = __toESM(require("mongoose"));
+var MongooseSchema7 = import_mongoose8.default.Schema;
+var MessageSchema = new MongooseSchema7(
+  {
+    content: { required: true, type: String },
+    senderAvatar: { required: false, type: String },
+    senderId: {
+      ref: "User",
+      required: true,
+      type: import_mongoose8.default.Schema.Types.ObjectId
+    },
+    senderName: { required: true, type: String }
+  },
+  { timestamps: true }
+);
+var ParticipantSchema = new MongooseSchema7(
+  {
+    active: { default: true, required: true, type: Boolean },
+    email: { required: true, type: String },
+    userId: {
+      ref: "User",
+      required: true,
+      type: import_mongoose8.default.Schema.Types.ObjectId
+    }
+  },
+  { _id: false }
+  // Prevents Mongoose from creating an additional _id field for subdocuments
+);
+var ChatSchema = new MongooseSchema7(
+  {
+    active: { default: true, required: true, type: Boolean },
+    chatName: { required: true, type: String },
+    chatType: {
+      enum: Object.values(import_cluemart_shared6.EnumChatType),
+      required: true,
+      type: String
+    },
+    deletedAt: { default: null, required: false, type: Date },
+    messages: [MessageSchema],
+    participants: [ParticipantSchema],
+    resourceInfo: {
+      eventId: {
+        ref: "Event",
+        required: false,
+        type: import_mongoose8.default.Schema.Types.ObjectId
+      },
+      vendorId: {
+        ref: "Vendor",
+        required: false,
+        type: import_mongoose8.default.Schema.Types.ObjectId
+      }
+    }
+  },
+  {
+    timestamps: true
+  }
+);
+var ChatModel = import_mongoose8.default.models.Chat || import_mongoose8.default.model("Chat", ChatSchema);
+
+// src/mongoose/ResourceActivity.ts
+var import_cluemart_shared7 = require("@timardex/cluemart-shared");
+var import_mongoose9 = __toESM(require("mongoose"));
+var MongooseSchema8 = import_mongoose9.default.Schema;
+var ActivitySchema = new MongooseSchema8(
+  {
+    activityType: {
+      enum: Object.values(import_cluemart_shared7.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(import_cluemart_shared7.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(import_cluemart_shared7.EnumResourceType),
+      required: true,
+      type: String
+    }
+  },
+  { timestamps: true }
+);
+schema5.index({ resourceId: 1, resourceType: 1 }, { unique: true });
+schema5.index({ "views.location": "2dsphere" });
+var ResourceActivityModel = import_mongoose9.default.models.ResourceActivity || import_mongoose9.default.model("ResourceActivity", schema5);
+
+// src/mongoose/Testers.ts
+var import_cluemart_shared8 = require("@timardex/cluemart-shared");
+var import_mongoose10 = __toESM(require("mongoose"));
+var MongooseSchema9 = import_mongoose10.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(import_cluemart_shared8.EnumOSPlatform),
+      required: true,
+      type: String
+    },
+    region: { required: true, type: String },
+    resourceType: {
+      enum: Object.values(import_cluemart_shared8.EnumResourceType),
+      required: true,
+      type: String
+    }
+  },
+  {
+    timestamps: true
+  }
+);
+var TesterModel = import_mongoose10.default.models.Tester || import_mongoose10.default.model("Tester", TesterSchema);
+
+// src/mongoose/User.ts
+var import_cluemart_shared9 = require("@timardex/cluemart-shared");
+var import_mongoose11 = __toESM(require("mongoose"));
+var MongooseSchema10 = import_mongoose11.default.Schema;
+var userActivityEventSchema = new MongooseSchema10(
+  {
+    resourceId: {
+      ref: "Event",
+      required: false,
+      type: import_mongoose11.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_mongoose11.default.Schema.Types.ObjectId]
+    },
+    vendors: {
+      ref: "Vendor",
+      required: false,
+      type: [import_mongoose11.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_mongoose11.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(import_cluemart_shared9.EnumUserLicence),
+      required: false,
+      type: [String]
+    },
+    partners: {
+      required: false,
+      type: [partnersSchema]
+    },
+    password: { required: true, type: String },
+    platform: {
+      enum: Object.values(import_cluemart_shared9.EnumOSPlatform),
+      required: false,
+      type: String
+    },
+    preferredRegion: {
+      required: true,
+      type: String
+    },
+    refreshToken: {
+      required: false,
+      type: String
+    },
+    role: {
+      default: import_cluemart_shared9.EnumUserRole.CUSTOMER,
+      enum: Object.values(import_cluemart_shared9.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_mongoose11.default.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+schema6.index({ "partners.email": 1 });
+var UserModel = import_mongoose11.default.models.User || import_mongoose11.default.model("User", schema6);
+
+// src/mongoose/VerificationToken.ts
+var import_mongoose12 = __toESM(require("mongoose"));
+var MongooseSchema11 = import_mongoose12.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_mongoose12.default.models.VerificationToken || import_mongoose12.default.model("VerificationToken", schema7);
+
+// src/mongoose/vendor/Vendor.ts
+var import_cluemart_shared10 = require("@timardex/cluemart-shared");
+var import_mongoose13 = __toESM(require("mongoose"));
+var MongooseSchema12 = import_mongoose13.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_mongoose13.default.Schema.Types.ObjectId
+    },
+    vendorType: {
+      enum: Object.values(import_cluemart_shared10.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_mongoose13.default.models.Vendor || import_mongoose13.default.model("Vendor", schema8);
+
+// src/mongoose/vendor/VendorInfo.ts
+var import_cluemart_shared11 = require("@timardex/cluemart-shared");
+var import_mongoose14 = __toESM(require("mongoose"));
+var MongooseSchema13 = import_mongoose14.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(import_cluemart_shared11.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_mongoose14.default.Schema.Types.ObjectId
+    }
+  },
+  { timestamps: true }
+);
+var VendorInfoModel = import_mongoose14.default.models.VendorInfo || import_mongoose14.default.model("VendorInfo", schema9);
+
+// src/mongoose/event/Event.ts
+var import_cluemart_shared12 = require("@timardex/cluemart-shared");
+var import_mongoose15 = __toESM(require("mongoose"));
+var MongooseSchema14 = import_mongoose15.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 dateTimeSchema2 = 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: [dateTimeSchema2],
+    eventInfoId: {
+      ref: "EventInfo",
+      required: false,
+      type: import_mongoose15.default.Schema.Types.ObjectId
+    },
+    eventType: {
+      enum: Object.values(import_cluemart_shared12.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_mongoose15.default.models.Event || import_mongoose15.default.model("Event", schema10);
+
+// src/service/updateAdStatus.ts
+async function updateAdStatuses() {
+  const now = /* @__PURE__ */ new Date();
+  const invalidResult = await AdModel.updateMany(
+    {
+      $or: [
+        { start: { $exists: false } },
+        { end: { $exists: false } },
+        { $expr: { $gt: ["$start", "$end"] } }
+      ]
+    },
+    { $set: { status: import_cluemart_shared13.EnumAdStatus.PAUSED } }
+  );
+  const expiredResult = await AdModel.updateMany(
+    { end: { $lte: now }, status: { $ne: import_cluemart_shared13.EnumAdStatus.EXPIRED } },
+    { $set: { status: import_cluemart_shared13.EnumAdStatus.EXPIRED } }
+  );
+  const activeResult = await AdModel.updateMany(
+    {
+      end: { $gt: now },
+      start: { $lte: now },
+      status: { $ne: import_cluemart_shared13.EnumAdStatus.ACTIVE }
+    },
+    { $set: { status: import_cluemart_shared13.EnumAdStatus.ACTIVE } }
+  );
+  const pausedResult = await AdModel.updateMany(
+    { start: { $gt: now }, status: { $ne: import_cluemart_shared13.EnumAdStatus.PAUSED } },
+    { $set: { status: import_cluemart_shared13.EnumAdStatus.PAUSED } }
+  );
+  console.log(
+    `\u2705 Ad statuses updated: invalid=${invalidResult.modifiedCount}, expired=${expiredResult.modifiedCount}, active=${activeResult.modifiedCount}, paused=${pausedResult.modifiedCount}`
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  connectToDatabase,
+  saveNotificationsInDb,
+  sendPushNotifications,
+  updateAdStatuses
+});
+//# sourceMappingURL=index.cjs.map