@mody-park-cha-raja/finance_common 1.0.3

package/dist/index.js

@@ -0,0 +1,789 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BadRequestException: () => BadRequestException,
+  BaseEntityModel: () => BaseEntityModel,
+  DateCodeUtils: () => DateCodeUtils,
+  DateUtil: () => DateUtil,
+  DonationHistoryModel: () => DonationHistoryModel,
+  DonationModel: () => DonationModel,
+  EntityFilterDataHelper: () => EntityFilterDataHelper,
+  EntityHistoryOperation: () => EntityHistoryOperation,
+  EntityList: () => EntityList,
+  ExpenseHistoryModel: () => ExpenseHistoryModel,
+  ExpenseModel: () => ExpenseModel,
+  ForbiddenException: () => ForbiddenException,
+  HttpException: () => HttpException,
+  NotFoundException: () => NotFoundException,
+  OrderByDirection: () => OrderByDirection,
+  RelationType: () => RelationType,
+  SponsorFor: () => SponsorFor,
+  SponsorHistoryModel: () => SponsorHistoryModel,
+  SponsorModel: () => SponsorModel,
+  TransactionHistoryModel: () => TransactionHistoryModel,
+  TransactionModel: () => TransactionModel,
+  UnauthorizedException: () => UnauthorizedException,
+  UserModel: () => UserModel,
+  VendorHistoryModel: () => VendorHistoryModel,
+  VendorModel: () => VendorModel,
+  definedValues: () => definedValues,
+  diffArrays: () => diffArrays,
+  entityListEntityModelMap: () => entityListEntityModelMap,
+  getObjectDiffingKeys: () => getObjectDiffingKeys,
+  groupBy: () => groupBy
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/enums/entity-history-operation.enum.ts
+var EntityHistoryOperation = /* @__PURE__ */ ((EntityHistoryOperation2) => {
+  EntityHistoryOperation2["CREATE"] = "CREATE";
+  EntityHistoryOperation2["UPDATE"] = "UPDATE";
+  EntityHistoryOperation2["DELETE"] = "DELETE";
+  return EntityHistoryOperation2;
+})(EntityHistoryOperation || {});
+
+// src/enums/sponsor-for.enum.ts
+var SponsorFor = /* @__PURE__ */ ((SponsorFor2) => {
+  SponsorFor2["GHEE"] = "ghee";
+  SponsorFor2["PRASAD"] = "prasad";
+  SponsorFor2["BANNER"] = "banner";
+  return SponsorFor2;
+})(SponsorFor || {});
+
+// src/utils/date-code.utils.ts
+var DateCodeUtils = class _DateCodeUtils {
+  constructor(dateCode) {
+    this.dateCode = dateCode;
+    this.stringifiedDateCode = String(this.dateCode);
+    if (!this.isValidYYYYMMDD()) {
+      throw new Error(
+        `Invalid date code: "${this.stringifiedDateCode}". Expected format: YYYYMMDD.`
+      );
+    }
+  }
+  isValidYYYYMMDD() {
+    if (!/^\d{8}$/.test(this.stringifiedDateCode)) return false;
+    const { year, month, day } = this.parseDateParts();
+    if (month < 1 || month > 12) return false;
+    if (day < 1 || day > 31) return false;
+    const date = new Date(year, month - 1, day);
+    return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day;
+  }
+  toLongDateString() {
+    const { year, month, day } = this.parseDateParts();
+    return new Date(year, month - 1, day).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+  }
+  addMonths(months) {
+    const { year, month, day } = this.parseDateParts();
+    const date = new Date(year, month - 1 + months, day);
+    const newYear = date.getFullYear();
+    const newMonth = String(date.getMonth() + 1).padStart(2, "0");
+    const newDay = String(date.getDate()).padStart(2, "0");
+    return `${newYear}${newMonth}${newDay}`;
+  }
+  addDays(days) {
+    const { year, month, day } = this.parseDateParts();
+    const date = new Date(year, month - 1, day);
+    date.setDate(date.getDate() + days);
+    const newYear = date.getFullYear();
+    const newMonth = String(date.getMonth() + 1).padStart(2, "0");
+    const newDay = String(date.getDate()).padStart(2, "0");
+    return `${newYear}${newMonth}${newDay}`;
+  }
+  addWeeks(weeks) {
+    return this.addDays(weeks * 7);
+  }
+  addYears(years) {
+    const { year, month, day } = this.parseDateParts();
+    const date = new Date(year + years, month - 1, day);
+    const newYear = date.getFullYear();
+    const newMonth = String(date.getMonth() + 1).padStart(2, "0");
+    const newDay = String(date.getDate()).padStart(2, "0");
+    return `${newYear}${newMonth}${newDay}`;
+  }
+  parseDateParts() {
+    return {
+      year: parseInt(this.stringifiedDateCode.substring(0, 4), 10),
+      month: parseInt(this.stringifiedDateCode.substring(4, 6), 10),
+      day: parseInt(this.stringifiedDateCode.substring(6, 8), 10)
+    };
+  }
+  static getCurrentYear() {
+    return (/* @__PURE__ */ new Date()).getFullYear();
+  }
+  static daysDiff(dateCode) {
+    const { year, month, day } = new _DateCodeUtils(dateCode).parseDateParts();
+    const target = new Date(year, month - 1, day);
+    const today = /* @__PURE__ */ new Date();
+    today.setHours(0, 0, 0, 0);
+    const diffMs = target.getTime() - today.getTime();
+    return Math.round(diffMs / (1e3 * 60 * 60 * 24));
+  }
+  static getCurrentDateCode() {
+    const today = /* @__PURE__ */ new Date();
+    const year = today.getFullYear();
+    const month = String(today.getMonth() + 1).padStart(2, "0");
+    const day = String(today.getDate()).padStart(2, "0");
+    return `${year}${month}${day}`;
+  }
+};
+
+// src/utils/date.utils.ts
+var DateUtil = class {
+  // Current time as epoch milliseconds
+  static now() {
+    return Date.now();
+  }
+  // Date object → epoch milliseconds
+  static toEpoch(date) {
+    return date.getTime();
+  }
+  // Epoch milliseconds → Date object
+  static toDate(epoch) {
+    return new Date(epoch);
+  }
+  // Epoch milliseconds → readable string
+  static toReadable(epoch) {
+    return new Date(epoch).toISOString();
+  }
+  // Add days to epoch → returns epoch
+  static addDays(epoch, days) {
+    return epoch + days * 24 * 60 * 60 * 1e3;
+  }
+  // Add months to epoch → returns epoch
+  static addMonths(epoch, months) {
+    const date = new Date(epoch);
+    date.setMonth(date.getMonth() + months);
+    return date.getTime();
+  }
+  // Add weeks to epoch → returns epoch
+  static addWeeks(epoch, weeks) {
+    return this.addDays(epoch, weeks * 7);
+  }
+  // Add years to epoch → returns epoch
+  static addYears(epoch, years) {
+    const date = new Date(epoch);
+    date.setFullYear(date.getFullYear() + years);
+    return date.getTime();
+  }
+  // Difference in days between two epochs
+  static daysDifference(epoch1, epoch2) {
+    return Math.ceil((epoch2 - epoch1) / (1e3 * 60 * 60 * 24));
+  }
+  // Check if epoch is today
+  static isToday(epoch) {
+    const date = new Date(epoch);
+    const today = /* @__PURE__ */ new Date();
+    return date.getDate() === today.getDate() && date.getMonth() === today.getMonth() && date.getFullYear() === today.getFullYear();
+  }
+  // Check if epoch is in the past
+  static isPast(epoch) {
+    return epoch < Date.now();
+  }
+  // Check if epoch is in the future
+  static isFuture(epoch) {
+    return epoch > Date.now();
+  }
+};
+
+// src/models/base.entity.model.ts
+var BaseEntityModel = class {
+  // populateRelations(searchResponse: ISearchV2Response): this {
+  //   const relations = (this.constructor as typeof BaseEntityModel).relations;
+  //   for (const [prop, config] of Object.entries(relations)) {
+  //     const { relationType, mappingProperty, searchProperty, entity } = config!;
+  //     // @ts-ignore
+  //     const fkValue = this[mappingProperty];
+  //     const bucket = searchResponse[entity] ?? [];
+  //     if (!bucket.length) continue;
+  //     if (relationType === RelationType.ONE) {
+  //       // @ts-ignore
+  //       const match = bucket.find((e) => e[searchProperty] === fkValue);
+  //       if (match) {
+  //         const hydrated = (
+  //           entityListEntityModelMap[entity] as (
+  //             e: EntityType<EntityList>,
+  //           ) => any
+  //         )(match);
+  //         // recursively populate relations on the hydrated model
+  //         hydrated.populateRelations(searchResponse);
+  //         this[prop as keyof this] = hydrated;
+  //       }
+  //     } else {
+  //       const matches = bucket.filter(
+  //         (e: any) => e[searchProperty] === fkValue,
+  //       );
+  //       this[prop as keyof this] = matches.map((e: EntityType<EntityList>) => {
+  //         const hydrated = (
+  //           entityListEntityModelMap[entity] as (
+  //             e: EntityType<EntityList>,
+  //           ) => any
+  //         )(e);
+  //         // recursively populate relations on each hydrated model
+  //         hydrated.populateRelations(searchResponse);
+  //         return hydrated;
+  //       }) as this[keyof this];
+  //     }
+  //   }
+  //   return this;
+  // }
+  populateRelations(searchResponse, visited = /* @__PURE__ */ new Set()) {
+    const selfKey = `${this.constructor.name}:${this.id}`;
+    if (visited.has(selfKey)) return this;
+    visited.add(selfKey);
+    const relations = this.constructor.relations;
+    for (const [prop, config] of Object.entries(relations)) {
+      const { relationType, mappingProperty, searchProperty, entity } = config;
+      const fkValue = this[mappingProperty];
+      const bucket = searchResponse[entity] ?? [];
+      if (!bucket.length) continue;
+      if (relationType === "ONE" /* ONE */) {
+        const match = bucket.find((e) => e[searchProperty] === fkValue);
+        if (match) {
+          const hydrated = entityListEntityModelMap[entity](match);
+          hydrated.populateRelations(searchResponse, visited);
+          this[prop] = hydrated;
+        }
+      } else {
+        const matches = bucket.filter(
+          (e) => e[searchProperty] === fkValue
+        );
+        this[prop] = matches.map((e) => {
+          const hydrated = entityListEntityModelMap[entity](e);
+          hydrated.populateRelations(searchResponse, visited);
+          return hydrated;
+        });
+      }
+    }
+    return this;
+  }
+};
+BaseEntityModel.relations = {};
+
+// src/models/donation.entity.model.ts
+var DonationModel = class _DonationModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.flatNo = "";
+    this.amount = 0;
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _DonationModel(), entity);
+  }
+};
+
+// src/models/donation-history.entity.model.ts
+var _DonationHistoryModel = class _DonationHistoryModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.entityId = 0;
+    this.data = "";
+    this.operation = "CREATE" /* CREATE */;
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _DonationHistoryModel(), entity);
+  }
+};
+_DonationHistoryModel.relations = {};
+var DonationHistoryModel = _DonationHistoryModel;
+
+// src/models/expense.entity.model.ts
+var ExpenseModel = class _ExpenseModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.name = "";
+    this.type = "";
+    this.vendorName = "";
+    this.amount = 0;
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _ExpenseModel(), entity);
+  }
+};
+
+// src/models/expense-history.entity.model.ts
+var _ExpenseHistoryModel = class _ExpenseHistoryModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.entityId = 0;
+    this.data = "";
+    this.operation = "CREATE" /* CREATE */;
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _ExpenseHistoryModel(), entity);
+  }
+};
+_ExpenseHistoryModel.relations = {};
+var ExpenseHistoryModel = _ExpenseHistoryModel;
+
+// src/models/sponsor.entity.model.ts
+var SponsorModel = class _SponsorModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.contactName = "";
+    this.contactNo = "";
+    this.sponsorFor = "ghee" /* GHEE */;
+    this.size = "";
+    this.amount = 0;
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _SponsorModel(), entity);
+  }
+};
+
+// src/models/sponsor-history.entity.model.ts
+var _SponsorHistoryModel = class _SponsorHistoryModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.entityId = 0;
+    this.data = "";
+    this.operation = "CREATE" /* CREATE */;
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _SponsorHistoryModel(), entity);
+  }
+};
+_SponsorHistoryModel.relations = {};
+var SponsorHistoryModel = _SponsorHistoryModel;
+
+// src/models/transaction.entity.model.ts
+var TransactionModel = class _TransactionModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.date = "";
+    this.type = "Income";
+    this.particulars = "";
+    this.amount = 0;
+    this.balanceAfter = 0;
+    this.referenceId = "";
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _TransactionModel(), entity);
+  }
+};
+
+// src/models/transaction-history.entity.model.ts
+var _TransactionHistoryModel = class _TransactionHistoryModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.entityId = 0;
+    this.data = "";
+    this.operation = "CREATE" /* CREATE */;
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _TransactionHistoryModel(), entity);
+  }
+};
+_TransactionHistoryModel.relations = {};
+var TransactionHistoryModel = _TransactionHistoryModel;
+
+// src/models/user.entity.model.ts
+var UserModel = class _UserModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.name = "";
+    this.password = "";
+    this.email = "";
+    this.phone = "";
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _UserModel(), entity);
+  }
+};
+
+// src/models/vendor.entity.model.ts
+var VendorModel = class _VendorModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.name = "";
+    this.type = "";
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _VendorModel(), entity);
+  }
+};
+
+// src/models/vendor-history.entity.model.ts
+var _VendorHistoryModel = class _VendorHistoryModel extends BaseEntityModel {
+  constructor() {
+    super();
+    this.id = 0;
+    this.entityId = 0;
+    this.data = "";
+    this.operation = "CREATE" /* CREATE */;
+    this.createdOn = 0;
+    this.updatedOn = 0;
+    this.createdBy = 0;
+    this.updatedBy = 0;
+  }
+  static populateFromEntity(entity) {
+    return Object.assign(new _VendorHistoryModel(), entity);
+  }
+};
+_VendorHistoryModel.relations = {};
+var VendorHistoryModel = _VendorHistoryModel;
+
+// src/utils/entity.utils.ts
+var EntityList = /* @__PURE__ */ ((EntityList2) => {
+  EntityList2["DONATION"] = "donation";
+  EntityList2["DONATION_HISTORY"] = "donation_history";
+  EntityList2["USER"] = "user";
+  EntityList2["EXPENSE"] = "expense";
+  EntityList2["EXPENSE_HISTORY"] = "expense_history";
+  EntityList2["VENDOR"] = "vendor";
+  EntityList2["VENDOR_HISTORY"] = "vendor_history";
+  EntityList2["TRANSACTION"] = "transaction";
+  EntityList2["TRANSACTION_HISTORY"] = "transaction_history";
+  EntityList2["SPONSOR"] = "sponsor";
+  EntityList2["SPONSOR_HISTORY"] = "sponsor_history";
+  return EntityList2;
+})(EntityList || {});
+
+// src/utils/entitiy-list-entity-model-map.ts
+var entityListEntityModelMap = {
+  ["donation" /* DONATION */]: DonationModel.populateFromEntity,
+  ["donation_history" /* DONATION_HISTORY */]: DonationHistoryModel.populateFromEntity,
+  ["user" /* USER */]: UserModel.populateFromEntity,
+  ["expense" /* EXPENSE */]: ExpenseModel.populateFromEntity,
+  ["expense_history" /* EXPENSE_HISTORY */]: ExpenseHistoryModel.populateFromEntity,
+  ["vendor" /* VENDOR */]: VendorModel.populateFromEntity,
+  ["vendor_history" /* VENDOR_HISTORY */]: VendorHistoryModel.populateFromEntity,
+  ["transaction" /* TRANSACTION */]: TransactionModel.populateFromEntity,
+  ["transaction_history" /* TRANSACTION_HISTORY */]: TransactionHistoryModel.populateFromEntity,
+  ["sponsor" /* SPONSOR */]: SponsorModel.populateFromEntity,
+  ["sponsor_history" /* SPONSOR_HISTORY */]: SponsorHistoryModel.populateFromEntity
+};
+
+// src/utils/error.utils.ts
+var HttpException = class extends Error {
+  constructor(message, statusCode, key, errors) {
+    super(message);
+    this.message = message;
+    this.statusCode = statusCode;
+    this.key = key;
+    this.errors = errors;
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  getResponse() {
+    return {
+      statusCode: this.statusCode,
+      message: this.message,
+      key: this.key,
+      errors: this.errors
+    };
+  }
+  getStatus() {
+    return this.statusCode;
+  }
+};
+var BadRequestException = class extends HttpException {
+  constructor(input, errors) {
+    if (typeof input === "object" && !Array.isArray(input)) {
+      super(input.message, 400, input.key, errors);
+    } else {
+      super(
+        Array.isArray(input) ? input.join(", ") : input,
+        400,
+        void 0,
+        errors
+      );
+    }
+  }
+};
+var NotFoundException = class extends HttpException {
+  constructor(input = "Not Found") {
+    if (typeof input === "object") {
+      super(input.message, 404, input.key);
+    } else {
+      super(input, 404);
+    }
+  }
+};
+var UnauthorizedException = class extends HttpException {
+  constructor(input = "Unauthorized") {
+    if (typeof input === "object") {
+      super(input.message, 401, input.key);
+    } else {
+      super(input, 401);
+    }
+  }
+};
+var ForbiddenException = class extends HttpException {
+  constructor(input = "Forbidden") {
+    if (typeof input === "object") {
+      super(input.message, 403, input.key);
+    } else {
+      super(input, 403);
+    }
+  }
+};
+
+// src/utils/helper.fns.ts
+function getObjectDiffingKeys(oldObject, newObject) {
+  const keysToExclude = [
+    "createdOn",
+    "createdBy"
+  ];
+  const keysOfOldObject = Object.keys(oldObject);
+  const keysOfNewObject = Object.keys(newObject);
+  if (keysOfOldObject.length !== keysOfNewObject.length) {
+    throw new BadRequestException({
+      key: "objects",
+      message: `Different objects recieved for diffing. Please check & try again.`
+    });
+  }
+  const oldDiffingKeys = {};
+  const newDiffingKeys = {};
+  for (const key of keysOfOldObject) {
+    if (keysToExclude.includes(key)) continue;
+    const oldVal = oldObject[key];
+    const newVal = newObject[key];
+    if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+      oldDiffingKeys[key] = oldVal;
+      newDiffingKeys[key] = newVal;
+    }
+  }
+  return newDiffingKeys;
+}
+function diffArrays(arr1, arr2) {
+  const set1 = new Set(arr1);
+  const set2 = new Set(arr2);
+  return {
+    present: arr1.filter((item) => set2.has(item)),
+    deleted: arr1.filter((item) => !set2.has(item)),
+    added: arr2.filter((item) => !set1.has(item))
+  };
+}
+function groupBy(items, key) {
+  const result = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const groupKey = String(item[key]);
+    if (!result.has(groupKey)) {
+      result.set(groupKey, []);
+    }
+    result.get(groupKey).push(item);
+  }
+  return result;
+}
+function definedValues(arr) {
+  return arr.filter((value) => value != null);
+}
+
+// src/utils/relation-config.utils.ts
+var RelationType = /* @__PURE__ */ ((RelationType2) => {
+  RelationType2["ONE"] = "ONE";
+  RelationType2["MANY"] = "MANY";
+  return RelationType2;
+})(RelationType || {});
+
+// src/utils/sql-utils.ts
+var OrderByDirection = /* @__PURE__ */ ((OrderByDirection2) => {
+  OrderByDirection2["ASC"] = "ASC";
+  OrderByDirection2["DESC"] = "DESC";
+  return OrderByDirection2;
+})(OrderByDirection || {});
+
+// src/helpers/entity-filter-data.helper.ts
+var EntityFilterDataHelper = class {
+  constructor(searchResponse) {
+    this.searchResponse = searchResponse;
+    this.entityModelsMap = {};
+    this.entityModelsMap = this.populateEntityModelsMap();
+  }
+  getEntityFromList(name) {
+    const populateFn = entityListEntityModelMap[name];
+    const data = this.searchResponse[name] ?? [];
+    return data.map(
+      (entity) => populateFn(
+        entity
+      )
+    );
+  }
+  // getEntityModelsMap(): EntityListEntityModelMap {
+  populateEntityModelsMap() {
+    const responseObj = {};
+    for (const key of Object.keys(this.searchResponse)) {
+      const populateFn = entityListEntityModelMap[key];
+      if (!populateFn) continue;
+      const raw = this.searchResponse[key];
+      if (!Array.isArray(raw)) continue;
+      responseObj[key] = this.searchResponse[key].map(
+        (entity) => populateFn(
+          entity
+        )
+      );
+    }
+    return responseObj;
+  }
+  getEntityModelsByFilter(entityName, filter) {
+    const filteredModels = this.entityModelsMap[entityName].filter(
+      (model) => filter.value.includes(model[filter.key])
+    );
+    if (filteredModels.length === 0) {
+      throw new BadRequestException({
+        key: `${filter.key}`,
+        message: `${entityName} with values: ${filter.value.join(", ")} not found. Please try with valid values.`
+      });
+    }
+    return filteredModels;
+  }
+  getEntityModelByFilter(entityName, filter) {
+    const filteredModel = this.entityModelsMap[entityName].filter(
+      (model) => model[filter.key] === filter.value
+    );
+    if (filteredModel.length === 0) {
+      throw new BadRequestException({
+        key: `${filter.key}`,
+        message: `${entityName} with values: ${filter.value} not found. Please try with valid values.`
+      });
+    }
+    return filteredModel[0];
+  }
+  // populateRelationsFor(entityNames: EntityList[]): EntityListEntityModelMap {
+  //   for (const entityName of entityNames) {
+  //     const models = this.entityModelsMap[entityName];
+  //     if (!models) continue;
+  //     for (const model of models) {
+  //       (model as unknown as BaseEntityModel).populateRelations(
+  //         this.searchResponse,
+  //       );
+  //     }
+  //   }
+  //   return this.entityModelsMap;
+  // }
+  populateRelationsFor(entityNames) {
+    for (const entityName of entityNames) {
+      const models = this.entityModelsMap[entityName];
+      if (!models) continue;
+      for (const model of models) {
+        model.populateRelations(
+          this.searchResponse,
+          /* @__PURE__ */ new Set()
+          // fresh set per top-level model
+        );
+      }
+    }
+    return this.entityModelsMap;
+  }
+  mergeEntity(entityName, savedEntity) {
+    const populateFn = entityListEntityModelMap[entityName];
+    const model = populateFn(
+      savedEntity
+    );
+    model.populateRelations(
+      this.searchResponse,
+      /* @__PURE__ */ new Set()
+    );
+    return model;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BadRequestException,
+  BaseEntityModel,
+  DateCodeUtils,
+  DateUtil,
+  DonationHistoryModel,
+  DonationModel,
+  EntityFilterDataHelper,
+  EntityHistoryOperation,
+  EntityList,
+  ExpenseHistoryModel,
+  ExpenseModel,
+  ForbiddenException,
+  HttpException,
+  NotFoundException,
+  OrderByDirection,
+  RelationType,
+  SponsorFor,
+  SponsorHistoryModel,
+  SponsorModel,
+  TransactionHistoryModel,
+  TransactionModel,
+  UnauthorizedException,
+  UserModel,
+  VendorHistoryModel,
+  VendorModel,
+  definedValues,
+  diffArrays,
+  entityListEntityModelMap,
+  getObjectDiffingKeys,
+  groupBy
+});
+//# sourceMappingURL=index.js.map