@timardex/cluemart-server-shared 1.1.34 → 1.1.36

package/dist/service/index.mjs

@@ -18,12 +18,15 @@ import {
   EventModel,
   GoogleImportedMarketModel,
   NotificationModel,
+  PartnerModel,
   PushTokenModel,
   UserModel,
   VendorModel,
   dateFormat,
+  isNonVisitorResourceType,
+  licenseNiceNames,
   timeFormat
-} from "../chunk-UGGLUJIR.mjs";
+} from "../chunk-DBGVZNUX.mjs";
 import "../chunk-6PNG5BI5.mjs";
 
 // src/service/promoCode/constants.ts
@@ -51,10 +54,28 @@ var mapArrayToOptions = (items) => items.map((item) => ({
   label: item,
   value: item
 }));
+var dateFormat2 = "DD-MM-YYYY";
+var timeFormat2 = "HH:mm";
 dayjs.extend(customParseFormat);
 dayjs.extend(utc);
 dayjs.extend(timezone);
 dayjs.extend(isSameOrAfter);
+var formatDate = (dateStr, display = "datetime", timeStr) => {
+  const dateTimeStr = timeStr ? `${dateStr} ${timeStr}` : dateStr;
+  const dateTime = timeStr ? dayjs(dateTimeStr, `${dateFormat2} ${timeFormat2}`) : dayjs(dateStr, dateFormat2);
+  const formattedDate = dateTime.format("dddd, D MMMM, YYYY");
+  const formattedTime = dateTime.format("h:mm a");
+  switch (display) {
+    case "date":
+      return formattedDate;
+    case "time":
+      return formattedTime;
+    case "datetime":
+      return `${formattedDate} at ${formattedTime}`;
+    default:
+      return formattedDate;
+  }
+};
 var futureTimePeriods = mapArrayToOptions(
   Object.values(EnumEventDateStatus2)
 ).filter(
@@ -96,7 +117,7 @@ var SHARE_RESOURCE_LABEL = {
   school: "School"
 };
 
-// node_modules/@timardex/cluemart-shared/dist/chunk-FGVNX6EN.mjs
+// node_modules/@timardex/cluemart-shared/dist/chunk-364EX22V.mjs
 var PROMO_CODE_PREFIX = "CM-";
 var OBJECT_ID_PATH_SEGMENT = "[a-f0-9]{24}";
 var OBJECT_ID_PATH_SEGMENT_END = `${OBJECT_ID_PATH_SEGMENT}$`;
@@ -109,7 +130,7 @@ var gameScreenIdentifierList = [
   {
     clue: "Where you can find your loyalties.",
     id: "coupons",
-    match: "/coupons"
+    match: "/profile/account/coupons"
   },
   {
     clue: "A single moment worth showing up for.",
@@ -139,7 +160,7 @@ var gameScreenIdentifierList = [
   {
     clue: "Where fun becomes a challenge.",
     id: "games",
-    match: "/games"
+    match: "/profile/account/games"
   },
   {
     clue: "Your starting point for everything.",
@@ -208,7 +229,7 @@ var gameScreenIdentifierList = [
   }
 ];
 
-// node_modules/@timardex/cluemart-shared/dist/chunk-UPFNTXDX.mjs
+// node_modules/@timardex/cluemart-shared/dist/chunk-5RXL62LO.mjs
 import dayjs2 from "dayjs";
 var statusOptions = [
   ...Object.values(EnumInviteStatus2).map((status) => ({
@@ -1390,7 +1411,7 @@ import dayjs3 from "dayjs";
 import timezone2 from "dayjs/plugin/timezone";
 import utc2 from "dayjs/plugin/utc";
 
-// src/service/license.ts
+// src/service/license/stripe/stripe.ts
 var PRO_EVENT_PLANS = /* @__PURE__ */ new Set([
   EnumUserLicence2.PRO_EVENT,
   EnumUserLicence2.PRO_PLUS_EVENT
@@ -1749,46 +1770,6 @@ async function updateAdStatuses() {
   );
 }
 
-// src/service/vendor.ts
-async function updateVendorBasedOnUserLicense(userId, licenceType) {
-  try {
-    const user = await UserModel.findById(userId).select("vendor").lean().exec();
-    if (!user?.vendor) {
-      console.warn(`[updateVendor] No vendor found for userId=${userId}`);
-      return;
-    }
-    const vendor = await VendorModel.findById(user.vendor).lean().exec();
-    if (!vendor) {
-      console.warn(`[updateVendor] Vendor not found for id=${user.vendor}`);
-      return;
-    }
-    const updateData = {};
-    const isStandardVendor = licenceType === EnumUserLicence.STANDARD_VENDOR;
-    if (isStandardVendor) {
-      updateData.availability = {
-        corporate: false,
-        private: false,
-        school: false
-      };
-      updateData.products = {
-        active: false,
-        productsList: vendor.products?.productsList ?? []
-      };
-      updateData.calendar = {
-        active: false,
-        calendarData: vendor.calendar?.calendarData ?? []
-      };
-    }
-    updateData.images = (vendor.images ?? []).map((image, index) => ({
-      ...image,
-      active: isStandardVendor ? index < 6 : true
-    }));
-    await VendorModel.updateOne({ _id: vendor._id }, { $set: updateData });
-  } catch (error) {
-    console.error("[updateVendorBasedOnUserLicense] Failed:", error);
-  }
-}
-
 // src/service/objectIdToString.ts
 import mongoose2 from "mongoose";
 function isValidObjectId(value) {
@@ -1979,32 +1960,1026 @@ function updateRelationDatesToUnavailable(relationDates, eventDateTime) {
     };
   });
 }
+
+// src/service/license/compliance/ensureUserLicenseCompliance.ts
+import dayjs8 from "dayjs";
+
+// src/service/license/compliance/utils.ts
+import dayjs7 from "dayjs";
+
+// src/service/license/compliance/event.ts
+var eventLicences = [
+  EnumUserLicence.STANDARD_EVENT,
+  EnumUserLicence.PRO_EVENT,
+  EnumUserLicence.PRO_PLUS_EVENT
+];
+async function handleEventLicenceCompliance(user, now) {
+  if (!user.licences || !user.events?.length) {
+    return;
+  }
+  await syncUserLicencesAfterExpiry(user._id, eventLicences, now, "extend");
+}
+
+// src/service/license/compliance/licenceExpiryPipeline.ts
+function buildLicenceExpiryPipeline(params) {
+  const {
+    downgradeBranches,
+    licenceTypes,
+    nowDate,
+    oneYearFromNow,
+    mode = "downgrade"
+  } = params;
+  const expiredInTarget = mode === "extend" ? {
+    // Extend: keep licenceType and all other fields, push expiry out by a year
+    $mergeObjects: ["$$lic", { expiryDate: oneYearFromNow }]
+  } : {
+    $cond: {
+      // Expired STANDARD_* → extend (keep, push expiry out by a year)
+      if: "$$isStandard",
+      then: {
+        $mergeObjects: ["$$lic", { expiryDate: oneYearFromNow }]
+      },
+      else: {
+        $cond: {
+          // Expired PRO_* / PRO_PLUS_* → downgrade and set new dates
+          if: { $ne: ["$$downgrade", null] },
+          then: {
+            $mergeObjects: [
+              "$$lic",
+              {
+                expiryDate: oneYearFromNow,
+                issuedDate: nowDate,
+                licenceType: "$$downgrade",
+                prevLicenceType: "$$lic.licenceType"
+              }
+            ]
+          },
+          // Unknown type in target set → keep as-is
+          else: "$$lic"
+        }
+      }
+    }
+  };
+  return [
+    {
+      // Stage 1: resolve each licence (extend / downgrade / keep)
+      $set: {
+        licences: {
+          // Remove null entries (e.g. pre-existing null licences kept by the map)
+          $filter: {
+            as: "x",
+            cond: { $ne: ["$$x", null] },
+            input: {
+              // Iterate over each licence in the document's licences array
+              $map: {
+                input: "$licences",
+                as: "lic",
+                in: {
+                  // Define variables once per licence for reuse in the condition tree
+                  $let: {
+                    vars: {
+                      // Target STANDARD_* type for this licence (from downgradeBranches)
+                      downgrade: {
+                        $switch: {
+                          branches: downgradeBranches.map((b) => ({
+                            case: {
+                              $eq: ["$$lic.licenceType", b.case]
+                            },
+                            then: b.then
+                          })),
+                          default: null
+                        }
+                      },
+                      // True if this licence has expiryDate <= now (expired)
+                      expired: {
+                        $and: [
+                          { $ne: ["$$lic", null] },
+                          { $lte: ["$$lic.expiryDate", nowDate] }
+                        ]
+                      },
+                      // True if this licence's type is in the list we're processing (e.g. vendor only)
+                      inTarget: { $in: ["$$lic.licenceType", licenceTypes] },
+                      // True if licenceType starts with "standard_" (e.g. standard_vendor)
+                      isStandard: {
+                        $regexMatch: {
+                          input: {
+                            $toString: { $ifNull: ["$$lic.licenceType", ""] }
+                          },
+                          regex: /^standard_/
+                        }
+                      }
+                    },
+                    // Compute the new value for this array element
+                    in: {
+                      $cond: {
+                        // Keep as-is: null licence, or not in target set, or not expired
+                        if: {
+                          $or: [
+                            { $eq: ["$$lic", null] },
+                            { $not: "$$inTarget" },
+                            { $gt: ["$$lic.expiryDate", nowDate] }
+                          ]
+                        },
+                        then: "$$lic",
+                        // In target set and expired — apply the configured handling
+                        else: expiredInTarget
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      // Stage 2: dedupe by licenceType — keep the entry with the latest expiryDate
+      // (ties broken by the latest issuedDate). Runs inside the same atomic updateOne.
+      $set: {
+        licences: {
+          $reduce: {
+            input: "$licences",
+            initialValue: [],
+            in: {
+              $let: {
+                vars: {
+                  current: "$$this",
+                  index: {
+                    $indexOfArray: [
+                      {
+                        $map: {
+                          input: "$$value",
+                          as: "item",
+                          in: "$$item.licenceType"
+                        }
+                      },
+                      "$$this.licenceType"
+                    ]
+                  }
+                },
+                in: {
+                  $cond: {
+                    if: { $eq: ["$$index", -1] },
+                    then: { $concatArrays: ["$$value", ["$$current"]] },
+                    else: {
+                      $map: {
+                        input: "$$value",
+                        as: "item",
+                        in: {
+                          $cond: {
+                            if: {
+                              $eq: [
+                                "$$item.licenceType",
+                                "$$current.licenceType"
+                              ]
+                            },
+                            then: {
+                              $cond: {
+                                if: {
+                                  $or: [
+                                    {
+                                      $gt: [
+                                        "$$current.expiryDate",
+                                        "$$item.expiryDate"
+                                      ]
+                                    },
+                                    {
+                                      $and: [
+                                        {
+                                          $eq: [
+                                            "$$current.expiryDate",
+                                            "$$item.expiryDate"
+                                          ]
+                                        },
+                                        {
+                                          $gt: [
+                                            "$$current.issuedDate",
+                                            "$$item.issuedDate"
+                                          ]
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                },
+                                then: "$$current",
+                                else: "$$item"
+                              }
+                            },
+                            else: "$$item"
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ];
+}
+
+// src/service/license/compliance/partner.ts
+var partnerLicences = [
+  EnumUserLicence.STANDARD_PARTNER
+];
+async function handlePartnerLicenceCompliance(user, now) {
+  if (!user.licences || !user.partner) {
+    return;
+  }
+  await syncUserLicencesAfterExpiry(user._id, partnerLicences, now, "extend");
+}
+
+// src/service/license/compliance/vendor.ts
+import dayjs6 from "dayjs";
+
+// src/service/license/models.ts
+import dayjs5 from "dayjs";
+import { GraphQLError } from "graphql";
+var LicenceExpiryDate = /* @__PURE__ */ ((LicenceExpiryDate2) => {
+  LicenceExpiryDate2["ONE_YEAR"] = "1 year";
+  LicenceExpiryDate2["ONE_MONTH"] = "1 month";
+  LicenceExpiryDate2["TWO_MONTHS"] = "2 months";
+  return LicenceExpiryDate2;
+})(LicenceExpiryDate || {});
+var LicenceCategory = /* @__PURE__ */ ((LicenceCategory2) => {
+  LicenceCategory2["EVENT"] = "event";
+  LicenceCategory2["PARTNER"] = "partner";
+  LicenceCategory2["VENDOR"] = "vendor";
+  LicenceCategory2["AFFILIATE"] = "affiliate";
+  LicenceCategory2["SCHOOL"] = "school";
+  return LicenceCategory2;
+})(LicenceCategory || {});
+var licenceCategoryMapping = {
+  [EnumUserLicence.PRO_EVENT]: "event" /* EVENT */,
+  [EnumUserLicence.PRO_PLUS_EVENT]: "event" /* EVENT */,
+  [EnumUserLicence.PRO_PLUS_VENDOR]: "vendor" /* VENDOR */,
+  [EnumUserLicence.PRO_VENDOR]: "vendor" /* VENDOR */,
+  [EnumUserLicence.STANDARD_EVENT]: "event" /* EVENT */,
+  [EnumUserLicence.STANDARD_PARTNER]: "partner" /* PARTNER */,
+  [EnumUserLicence.STANDARD_VENDOR]: "vendor" /* VENDOR */,
+  [EnumUserLicence.STANDARD_AFFILIATE]: "affiliate" /* AFFILIATE */,
+  [EnumUserLicence.STANDARD_SCHOOL]: "school" /* SCHOOL */
+};
+var licencePriority = {
+  [EnumUserLicence.PRO_PLUS_EVENT]: 3,
+  [EnumUserLicence.PRO_EVENT]: 2,
+  [EnumUserLicence.STANDARD_EVENT]: 1,
+  [EnumUserLicence.PRO_PLUS_VENDOR]: 3,
+  [EnumUserLicence.PRO_VENDOR]: 2,
+  [EnumUserLicence.STANDARD_VENDOR]: 1,
+  [EnumUserLicence.STANDARD_PARTNER]: 1,
+  [EnumUserLicence.STANDARD_AFFILIATE]: 1,
+  [EnumUserLicence.STANDARD_SCHOOL]: 1
+};
+var standardLicences = [
+  EnumUserLicence.STANDARD_VENDOR,
+  EnumUserLicence.STANDARD_EVENT,
+  EnumUserLicence.STANDARD_PARTNER
+];
+var standardLicenceSet = new Set(standardLicences);
+function isStandardLicence(licence) {
+  return standardLicenceSet.has(licence);
+}
+var categoryRegexMapping = {
+  ["event" /* EVENT */]: /_event$/,
+  ["partner" /* PARTNER */]: /_partner$/,
+  ["vendor" /* VENDOR */]: /_vendor$/,
+  ["affiliate" /* AFFILIATE */]: /_affiliate$/,
+  ["school" /* SCHOOL */]: /_school$/
+};
+var categoryFallbackLicence = {
+  ["event" /* EVENT */]: EnumUserLicence.STANDARD_EVENT,
+  ["partner" /* PARTNER */]: EnumUserLicence.STANDARD_PARTNER,
+  ["vendor" /* VENDOR */]: EnumUserLicence.STANDARD_VENDOR,
+  ["affiliate" /* AFFILIATE */]: EnumUserLicence.STANDARD_AFFILIATE,
+  ["school" /* SCHOOL */]: EnumUserLicence.STANDARD_SCHOOL
+};
+var LicenceFilterInput = {
+  INPUT_USER_LICENCES: "$licences"
+};
+function getLicenceCategory(licence) {
+  const category = licenceCategoryMapping[licence];
+  if (!category) {
+    throw new Error(`Missing licence category mapping for ${licence}`);
+  }
+  return category;
+}
+function getHighestLicenceForCategory(licences, category) {
+  const categoryLicences = (licences ?? []).map((licence) => licence.licenceType).filter(
+    (licenceType) => Boolean(licenceType && getLicenceCategory(licenceType) === category)
+  );
+  let highestLicence = null;
+  let highestPriority = Number.NEGATIVE_INFINITY;
+  for (const licenceType of categoryLicences) {
+    const priority = licencePriority[licenceType];
+    if (priority > highestPriority) {
+      highestPriority = priority;
+      highestLicence = licenceType;
+    }
+  }
+  return highestLicence;
+}
+function createLicenceObject(expiryDate, licenceType) {
+  const today = dayjs5();
+  const expiryDateMapping = {
+    ["1 year" /* ONE_YEAR */]: today.add(1, "year").endOf("day").toDate(),
+    ["1 month" /* ONE_MONTH */]: today.add(1, "month").endOf("day").toDate(),
+    ["2 months" /* TWO_MONTHS */]: today.add(2, "month").endOf("day").toDate()
+  };
+  const licenceObject = {
+    expiryDate: expiryDateMapping[expiryDate],
+    issuedDate: today.toDate(),
+    licenceType
+  };
+  return licenceObject;
+}
+var buildLicenceReplacePipeline = ({
+  fallbackType,
+  inputField,
+  licenceObject,
+  typeRegex
+}) => [
+  {
+    $set: {
+      licences: {
+        $concatArrays: [
+          {
+            $filter: {
+              as: "licence",
+              cond: {
+                $not: {
+                  $regexMatch: {
+                    input: {
+                      $toString: {
+                        $ifNull: ["$$licence.licenceType", fallbackType]
+                      }
+                    },
+                    regex: typeRegex
+                  }
+                }
+              },
+              input: { $ifNull: [inputField, []] }
+            }
+          },
+          [licenceObject]
+        ]
+      }
+    }
+  }
+];
+async function replaceUserLicenceWithObject({
+  userId,
+  licenceObject,
+  protectHigherLicence = true
+}) {
+  const user = await UserModel.findById(userId, { licences: 1 }).lean();
+  if (!user) throw new GraphQLError("User not found");
+  if (user.licences?.some((l) => l.licenceType === licenceObject.licenceType)) {
+    return;
+  }
+  const updatedLicenceObject = {
+    ...licenceObject,
+    prevLicenceType: user.licences?.find(
+      (l) => getLicenceCategory(l.licenceType) === getLicenceCategory(licenceObject.licenceType)
+    )?.licenceType
+  };
+  const category = getLicenceCategory(updatedLicenceObject.licenceType);
+  if (protectHigherLicence) {
+    const highestLicence = getHighestLicenceForCategory(
+      user.licences,
+      category
+    );
+    if (highestLicence && licencePriority[highestLicence] > licencePriority[updatedLicenceObject.licenceType]) {
+      return;
+    }
+  }
+  await UserModel.updateOne(
+    { _id: userId },
+    buildLicenceReplacePipeline({
+      fallbackType: categoryFallbackLicence[category],
+      inputField: LicenceFilterInput.INPUT_USER_LICENCES,
+      licenceObject: updatedLicenceObject,
+      typeRegex: categoryRegexMapping[category]
+    })
+  );
+}
+var upgradeUserToLicence = async ({
+  licenceType,
+  expiryDate,
+  userId
+}) => {
+  const licenceObject = createLicenceObject(expiryDate, licenceType);
+  await replaceUserLicenceWithObject({ licenceObject, userId });
+  const user = await UserModel.findById(userId).exec();
+  return {
+    licenceObject,
+    updatedUser: user
+  };
+};
+async function checkOwnerHasLicence({
+  userId,
+  resourceType
+}) {
+  try {
+    const owner = await UserModel.findById(userId);
+    if (!owner) throw new GraphQLError("Owner not found");
+    const categoryByResource = {
+      [EnumResourceType.EVENT]: "event" /* EVENT */,
+      [EnumResourceType.PARTNER]: "partner" /* PARTNER */,
+      [EnumResourceType.VENDOR]: "vendor" /* VENDOR */,
+      [EnumResourceType.AFFILIATE]: "affiliate" /* AFFILIATE */,
+      [EnumResourceType.SCHOOL]: "school" /* SCHOOL */
+    };
+    if (!isNonVisitorResourceType(resourceType)) {
+      throw new GraphQLError(`Invalid resource type: ${resourceType}.`);
+    }
+    const requiredCategory = categoryByResource[resourceType];
+    const activeLicence = owner.licences?.some((licence) => {
+      if (!licence.licenceType) return false;
+      return getLicenceCategory(licence.licenceType) === requiredCategory;
+    });
+    if (!activeLicence) {
+      throw new GraphQLError(
+        `Owner does not have an active licence. Cannot update ${resourceType}.`
+      );
+    }
+  } catch (error) {
+    if (error instanceof GraphQLError) {
+      throw error;
+    }
+    throw new GraphQLError(
+      error instanceof Error ? `Failed to check user licence: ${error.message}` : "Failed to check user licence"
+    );
+  }
+}
+
+// src/service/license/compliance/vendor.ts
+async function updateVendorBasedOnUserLicense(userId, licenceType) {
+  try {
+    const user = await UserModel.findById(userId).select("vendor").lean().exec();
+    if (!user?.vendor) {
+      console.warn(`[updateVendor] No vendor found for userId=${userId}`);
+      return;
+    }
+    const vendor = await VendorModel.findById(user.vendor).lean().exec();
+    if (!vendor) {
+      console.warn(`[updateVendor] Vendor not found for id=${user.vendor}`);
+      return;
+    }
+    const updateData = {};
+    const isStandardVendor = licenceType === EnumUserLicence.STANDARD_VENDOR;
+    if (isStandardVendor) {
+      updateData.availability = {
+        corporate: false,
+        private: false,
+        school: false
+      };
+      updateData.products = {
+        active: false,
+        productsList: vendor.products?.productsList ?? []
+      };
+      updateData.calendar = {
+        active: false,
+        calendarData: vendor.calendar?.calendarData ?? []
+      };
+    }
+    updateData.images = (vendor.images ?? []).map((image, index) => ({
+      ...image,
+      active: isStandardVendor ? index < 6 : true
+    }));
+    await VendorModel.updateOne({ _id: vendor._id }, { $set: updateData });
+  } catch (error) {
+    console.error("[updateVendorBasedOnUserLicense] Failed:", error);
+  }
+}
+var vendorLicences = [
+  EnumUserLicence.STANDARD_VENDOR,
+  EnumUserLicence.PRO_VENDOR,
+  EnumUserLicence.PRO_PLUS_VENDOR
+];
+async function handleVendorLicenceCompliance(user, now) {
+  if (!user.licences || !user.vendor) {
+    return;
+  }
+  const vendorLicencesOfUser = user.licences.filter(
+    (licence) => licence?.licenceType?.includes("vendor")
+  );
+  if (vendorLicencesOfUser.length === 0) {
+    return;
+  }
+  const proLicences = vendorLicencesOfUser.filter(
+    (licence) => licence.licenceType !== EnumUserLicence.STANDARD_VENDOR
+  );
+  const expiredProLicence = proLicences.some(
+    (licence) => !dayjs6(licence.expiryDate).isAfter(now)
+  );
+  const hasValidProLicence = hasValidLicence(proLicences, vendorLicences, now);
+  const hasExpiredVendorLicence = vendorLicencesOfUser.some(
+    (licence) => !dayjs6(licence.expiryDate).isAfter(now)
+  );
+  if (!hasExpiredVendorLicence) {
+    return;
+  }
+  let vendor = null;
+  if (expiredProLicence) {
+    vendor = await VendorModel.findOne({
+      _id: user.vendor,
+      active: true,
+      deletedAt: null,
+      "owner.userId": user._id
+    }).lean().exec();
+  }
+  await syncUserLicencesAfterExpiry(user._id, vendorLicences, now, "downgrade");
+  if (!expiredProLicence || !vendor || hasValidProLicence) {
+    return;
+  }
+  await updateVendorBasedOnUserLicense(
+    user._id,
+    EnumUserLicence.STANDARD_VENDOR
+  );
+  const payload = {
+    data: {
+      resourceId: String(vendor._id),
+      resourceName: vendor.name,
+      resourceType: EnumNotificationResourceType.DOWNGRADED_VENDOR
+    },
+    message: `Your Vendor license has been downgraded due to licence expiration.`,
+    title: `Vendor License Downgraded`,
+    type: EnumNotificationType.SYSTEM,
+    userIds: [user._id]
+  };
+  await sendDeactivationNotification(payload, user._id, vendor.name, "vendor");
+}
+async function vendorOwnerHasProLicence(vendorId) {
+  const vendor = await VendorModel.findOne({
+    _id: vendorId,
+    active: true,
+    deletedAt: null
+  }).lean().exec();
+  if (!vendor) {
+    return false;
+  }
+  const owner = await UserModel.findById(vendor.owner.userId, { licences: 1 }).lean().exec();
+  const highestVendorLicence = getHighestLicenceForCategory(
+    owner?.licences,
+    "vendor" /* VENDOR */
+  );
+  return highestVendorLicence !== null && licencePriority[highestVendorLicence] >= licencePriority[EnumUserLicence.PRO_VENDOR];
+}
+
+// src/service/license/compliance/utils.ts
+async function syncUserLicencesAfterExpiry(userId, licenceTypes, now, mode = "downgrade") {
+  const nowDate = now.toDate();
+  const oneYearFromNow = now.add(1, "year").endOf("day").toDate();
+  const pipeline = buildLicenceExpiryPipeline({
+    downgradeBranches: [
+      {
+        case: EnumUserLicence.PRO_PLUS_VENDOR,
+        then: EnumUserLicence.STANDARD_VENDOR
+      },
+      {
+        case: EnumUserLicence.PRO_VENDOR,
+        then: EnumUserLicence.STANDARD_VENDOR
+      }
+    ],
+    licenceTypes,
+    mode,
+    nowDate,
+    oneYearFromNow
+  });
+  await UserModel.updateOne({ _id: userId }, pipeline).exec();
+}
+function hasValidLicence(licences, licenceTypes, now) {
+  return licences.some(
+    (licence) => licenceTypes.includes(licence.licenceType) && dayjs7(licence.expiryDate).isAfter(now)
+  );
+}
+async function sendDeactivationNotification(payload, userId, resourceName, resourceType) {
+  const sent = await notifyUsers({ payload });
+  if (!sent) {
+    console.error(
+      `\u274C ${resourceType} notification not confirmed for user ${String(userId)} for "${resourceName}"`
+    );
+    return;
+  }
+  console.log(
+    `\u2705 Sent ${resourceType} notification to user ${String(userId)} for "${resourceName}"`
+  );
+}
+async function processUserCompliance(user, now) {
+  if (!user.licences) {
+    return;
+  }
+  await Promise.all([
+    handleVendorLicenceCompliance(user, now),
+    handlePartnerLicenceCompliance(user, now),
+    handleEventLicenceCompliance(user, now)
+  ]);
+}
+
+// src/service/license/compliance/ensureUserLicenseCompliance.ts
+async function ensureUserLicenseCompliance() {
+  const now = dayjs8();
+  console.log(`\u{1F50D} Checking license compliance at ${now.format()}`);
+  const nowDate = now.toDate();
+  const users = await UserModel.find({
+    licences: {
+      $elemMatch: {
+        expiryDate: {
+          $lte: nowDate
+          // Expired or expiring today
+        }
+      }
+    }
+  });
+  console.log(
+    `\u{1F4CA} Found ${users.length} users with expired or expiring licenses`
+  );
+  if (!users.length) {
+    console.log("No users with licenses to process.");
+    return;
+  }
+  let processedCount = 0;
+  let errorCount = 0;
+  for (const user of users) {
+    try {
+      await processUserCompliance(user, now);
+      processedCount++;
+    } catch (err) {
+      errorCount++;
+      console.error(
+        `\u274C Error processing license compliance for user ${String(user._id)}:`,
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+  const errorMessage = errorCount > 0 ? `, ${errorCount} errors` : "";
+  console.log(
+    `\u2705 Processed ${processedCount} users successfully${errorMessage}`
+  );
+}
+
+// src/service/license/reminder/event.ts
+async function getEventResourceInfo(userId, eventIds) {
+  const event = await EventModel.findOne({
+    _id: { $in: eventIds },
+    active: true,
+    deletedAt: null,
+    "owner.userId": userId
+  }).lean().exec();
+  if (!event) {
+    return null;
+  }
+  return {
+    resourceId: String(event._id),
+    resourceName: event.name
+  };
+}
+
+// src/service/license/reminder/partner.ts
+async function getPartnerResourceInfo(userId, partnerId) {
+  const partner = await PartnerModel.findOne({
+    _id: partnerId,
+    active: true,
+    deletedAt: null,
+    "owner.userId": userId
+  }).lean().exec();
+  if (!partner) {
+    return null;
+  }
+  return {
+    resourceId: String(partner._id),
+    resourceName: partner.name
+  };
+}
+
+// src/service/license/reminder/remindUsersAboutLicenseExpiration.ts
+import dayjs10 from "dayjs";
+
+// src/service/license/reminder/utils.ts
+import dayjs9 from "dayjs";
+
+// src/service/license/reminder/vendor.ts
+async function getVendorResourceInfo(userId, vendorId) {
+  const vendor = await VendorModel.findOne({
+    _id: vendorId,
+    active: true,
+    deletedAt: null,
+    "owner.userId": userId
+  }).lean().exec();
+  if (!vendor) {
+    return null;
+  }
+  return {
+    resourceId: String(vendor._id),
+    resourceName: vendor.name
+  };
+}
+
+// src/service/license/reminder/utils.ts
+async function checkAndCreateNotification(payload) {
+  const query = {
+    message: payload.message,
+    title: payload.title,
+    userId: payload.userIds[0]
+  };
+  if (payload.data.resourceId) {
+    query["data.resourceId"] = payload.data.resourceId;
+  }
+  const notificationDoc = {
+    createdAt: /* @__PURE__ */ new Date(),
+    data: payload.data,
+    isRead: false,
+    message: payload.message,
+    title: payload.title,
+    type: payload.type,
+    userId: payload.userIds[0]
+  };
+  try {
+    const result = await UserModel.db.collection("notifications").findOneAndUpdate(
+      query,
+      { $setOnInsert: notificationDoc },
+      {
+        includeResultMetadata: true,
+        returnDocument: "after",
+        upsert: true
+      }
+    );
+    const wasInserted = result?.lastErrorObject?.upserted != null;
+    return !wasInserted;
+  } catch (error) {
+    console.error(
+      `\u274C Error atomically checking notification:`,
+      error instanceof Error ? error.message : error
+    );
+    return true;
+  }
+}
+function isLicenseExpiringIn7Days(expiryDate, now) {
+  const expiry = dayjs9(expiryDate);
+  const daysUntilExpiry = expiry.diff(now, "day", true);
+  return daysUntilExpiry >= 6.5 && daysUntilExpiry <= 7.5;
+}
+function getLicenseName(licenceType) {
+  return licenseNiceNames[licenceType] || licenceType;
+}
+function getNotificationTypes(isVendorLicense, isPartnerLicense) {
+  if (isVendorLicense) {
+    return {
+      notificationType: EnumNotificationType.SYSTEM,
+      resourceType: EnumNotificationResourceType.EXPIRATION_REMINDER_VENDOR
+    };
+  }
+  if (isPartnerLicense) {
+    return {
+      notificationType: EnumNotificationType.SYSTEM,
+      resourceType: EnumNotificationResourceType.EXPIRATION_REMINDER_PARTNER
+    };
+  }
+  return {
+    notificationType: EnumNotificationType.SYSTEM,
+    resourceType: EnumNotificationResourceType.EXPIRATION_REMINDER_EVENT
+  };
+}
+async function getLicenseResourceInfo(user, licence) {
+  const isVendorLicense = vendorLicences.includes(licence.licenceType);
+  const isPartnerLicense = partnerLicences.includes(licence.licenceType);
+  const licenceName = getLicenseName(licence.licenceType);
+  const { notificationType, resourceType } = getNotificationTypes(
+    isVendorLicense,
+    isPartnerLicense
+  );
+  if (isVendorLicense && user.vendor) {
+    const vendorInfo = await getVendorResourceInfo(user._id, user.vendor);
+    if (!vendorInfo) {
+      return null;
+    }
+    return {
+      ...vendorInfo,
+      notificationType,
+      resourceType
+    };
+  }
+  if (eventLicences.includes(licence.licenceType) && user.events?.length) {
+    const eventInfo = await getEventResourceInfo(user._id, user.events);
+    if (!eventInfo) {
+      return null;
+    }
+    return {
+      ...eventInfo,
+      notificationType,
+      resourceType
+    };
+  }
+  if (isPartnerLicense && user.partner) {
+    const partnerInfo = await getPartnerResourceInfo(user._id, user.partner);
+    if (!partnerInfo) {
+      return null;
+    }
+    return {
+      ...partnerInfo,
+      notificationType,
+      resourceType
+    };
+  }
+  return {
+    notificationType,
+    resourceId: String(user._id),
+    resourceName: licenceName,
+    resourceType
+  };
+}
+function getLicenceExpiryMode(licenceType) {
+  return licenceType === EnumUserLicence.PRO_VENDOR || licenceType === EnumUserLicence.PRO_PLUS_VENDOR ? "downgrade" : "extend";
+}
+async function sendLicenseReminder(user, licence) {
+  const licenceName = getLicenseName(licence.licenceType);
+  const expiryDate = dayjs9(licence.expiryDate).format(dateFormat);
+  const userId = String(user._id);
+  const resourceInfo = await getLicenseResourceInfo(user, licence);
+  if (!resourceInfo) {
+    console.log(
+      `\u23ED\uFE0F Skipping 7-day reminder for user ${userId}, license ${licence.licenceType} (no resource info)`
+    );
+    return;
+  }
+  const isExtension = getLicenceExpiryMode(licence.licenceType) === "extend";
+  const payload = {
+    data: {
+      resourceId: resourceInfo.resourceId,
+      resourceName: resourceInfo.resourceName,
+      resourceType: resourceInfo.resourceType
+    },
+    message: isExtension ? `Your ${licenceName} will be automatically extended for another year on ${formatDate(expiryDate, "date")}.` : `Your ${licenceName} expires in 7 days (${formatDate(expiryDate, "date")}). Renew now to avoid deactivation.`,
+    title: isExtension ? "License Extension Reminder" : "License Expiring Soon",
+    type: resourceInfo.notificationType,
+    userIds: [user._id]
+  };
+  const alreadyExists = await checkAndCreateNotification(payload);
+  if (alreadyExists) {
+    console.log(
+      `\u23ED\uFE0F Skipping 7-day reminder to user ${userId} for ${licenceName} (notification already exists)`
+    );
+    return;
+  }
+  await sendPushNotifications(payload);
+  console.log(`\u2705 Sent 7-day reminder to user ${userId} for ${licenceName}`);
+}
+async function processLicenseReminder(user, licence, now) {
+  if (dayjs9(licence.expiryDate).isBefore(now)) {
+    return false;
+  }
+  if (!isLicenseExpiringIn7Days(licence.expiryDate, now)) {
+    return false;
+  }
+  return true;
+}
+async function sendReminderSafely(user, licence) {
+  try {
+    await sendLicenseReminder(user, licence);
+    return true;
+  } catch (err) {
+    console.error(
+      `\u274C Error sending reminder to user ${String(user._id)} for license ${licence.licenceType}:`,
+      err instanceof Error ? err.message : err
+    );
+    return false;
+  }
+}
+async function processUserLicenseReminders(user, now) {
+  if (!user.licences) {
+    return 0;
+  }
+  const validLicences = user.licences.filter((licence) => licence !== null);
+  if (validLicences.length === 0) {
+    return 0;
+  }
+  const licenceChecks = await Promise.all(
+    validLicences.map(async (licence) => {
+      try {
+        const shouldSend = await processLicenseReminder(user, licence, now);
+        return { licence, shouldSend };
+      } catch (err) {
+        console.error(
+          `\u274C Error checking license reminder for user ${String(user._id)} for license ${licence.licenceType}:`,
+          err instanceof Error ? err.message : err
+        );
+        return { licence, shouldSend: false };
+      }
+    })
+  );
+  const licencesToNotify = licenceChecks.filter((check) => check.shouldSend).map((check) => check.licence);
+  if (!licencesToNotify.length) {
+    return 0;
+  }
+  const results = await Promise.all(
+    licencesToNotify.map((licence) => sendReminderSafely(user, licence))
+  );
+  return results.filter(Boolean).length;
+}
+
+// src/service/license/reminder/remindUsersAboutLicenseExpiration.ts
+async function remindUsersAboutLicenseExpiration() {
+  const now = dayjs10();
+  console.log(`\u{1F50D} Checking for licenses expiring in 7 days at ${now.format()}`);
+  const minExpiryDate = now.add(6.5, "day").toDate();
+  const maxExpiryDate = now.add(7.5, "day").toDate();
+  const users = await UserModel.find({
+    licences: {
+      $elemMatch: {
+        expiryDate: {
+          $gte: minExpiryDate,
+          $lte: maxExpiryDate
+        }
+      }
+    }
+  });
+  console.log(
+    `\u{1F4CA} Found ${users.length} users with licenses expiring in 7 days`
+  );
+  if (!users.length) {
+    console.log("No users with licenses to process.");
+    return;
+  }
+  let totalReminderCount = 0;
+  for (const user of users) {
+    try {
+      const reminderCount = await processUserLicenseReminders(user, now);
+      totalReminderCount += reminderCount;
+    } catch (err) {
+      console.error(
+        `\u274C Error processing license reminders for user ${String(user._id)}:`,
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+  console.log(
+    `\u2705 Processed ${users.length} users, sent ${totalReminderCount} license expiration reminders`
+  );
+}
 export {
   ACTIVE_NOT_DELETED_FILTER,
+  LicenceCategory,
+  LicenceExpiryDate,
   SUBSCRIPTION_REWARD_TIMEZONE,
   activeAffiliateCodeExists,
   awardAffiliateVendorSubscriptionRewards,
+  buildLicenceExpiryPipeline,
+  checkOwnerHasLicence,
   connectToDatabase,
   convertObjectIdsToStrings,
+  createLicenceObject,
   didRemoveAnyEventDates,
+  ensureUserLicenseCompliance,
+  eventLicences,
   findAffiliateByPromoCode,
   findEventOrImportedMarketById,
+  getEventResourceInfo,
+  getHighestLicenceForCategory,
+  getLicenceCategory,
+  getLicenceExpiryMode,
+  getPartnerResourceInfo,
   getPayingEventStripeSubscriptionPlan,
   getPayingStripeSubscriptionPlan,
   getPayingVendorStripeSubscriptionPlan,
   getSubscriptionRewardPeriodBounds,
+  getVendorResourceInfo,
+  handleEventLicenceCompliance,
+  handlePartnerLicenceCompliance,
+  handleVendorLicenceCompliance,
+  hasValidLicence,
+  isStandardLicence,
   isValidObjectId,
+  licenceCategoryMapping,
+  licencePriority,
   mapVendorLicenceToSubscriptionRewardType,
   normalizeAffiliatePromoCodes,
   normalizePromoCode,
   notifyUsers,
+  partnerLicences,
+  processLicenseReminder,
+  processUserCompliance,
+  processUserLicenseReminders,
   publishNotificationEvents,
+  remindUsersAboutLicenseExpiration,
+  replaceUserLicenceWithObject,
   saveNotificationsInDb,
+  sendDeactivationNotification,
+  sendLicenseReminder,
   sendPushNotifications,
+  sendReminderSafely,
+  syncUserLicencesAfterExpiry,
   updateAdStatuses,
   updateAllEventDateTimeStatuses,
   updateRelationDatesToUnavailable,
   updateSingleDateTimeStatus,
-  updateVendorBasedOnUserLicense
+  updateVendorBasedOnUserLicense,
+  upgradeUserToLicence,
+  vendorLicences,
+  vendorOwnerHasProLicence
 };
 //# sourceMappingURL=index.mjs.map