feat(nestjs): migrate to NestJS

packages/server/src/modules/EventsTracker/EventTracker.module.ts

@@ -0,0 +1,46 @@
+import { Module } from '@nestjs/common';
+import { SaleInvoiceEventsTracker } from './events/SaleInvoicesEventsTracker';
+import { SaleEstimateEventsTracker } from './events/SaleEstimateEventsTracker';
+import { PaymentMadeEventsTracker } from './events/PaymentMadeEventsTracker';
+import { PaymentReceivedEventsTracker } from './events/PaymentReceivedEventsTracker';
+import { BillEventsTracker } from './events/BillEventsTracker';
+import { AccountEventsTracker } from './events/AccountEventsTracker';
+import { ExpenseEventsTracker } from './events/ExpenseEventsTracker';
+import { AuthenticationEventsTracker } from './events/AuthenticationEventsTracker';
+import { ItemEventsTracker } from './events/ItemEventsTracker';
+import { BankTransactionEventsTracker } from './events/BankTransactionEventsTracker';
+import { CustomerEventsTracker } from './events/CustomerEventsTracker';
+import { VendorEventsTracker } from './events/VendorEventsTracker';
+import { ManualJournalEventsTracker } from './events/ManualJournalEventsTracker';
+import { BankRuleEventsTracker } from './events/BankRuleEventsTracker';
+import { PdfTemplateEventsTracker } from './events/PdfTemplateEventsTracker';
+import { PaymentMethodEventsTracker } from './events/PaymentMethodEventsTracker';
+import { PaymentLinkEventsTracker } from './events/PaymentLinkEventsTracker';
+import { StripeIntegrationEventsTracker } from './events/StripeIntegrationEventsTracker';
+import { PostHogModule } from './postHog.module';
+
+@Module({
+  imports: [PostHogModule],
+  providers: [
+    SaleInvoiceEventsTracker,
+    SaleEstimateEventsTracker,
+    PaymentMadeEventsTracker,
+    PaymentReceivedEventsTracker,
+    BillEventsTracker,
+    AccountEventsTracker,
+    ExpenseEventsTracker,
+    AuthenticationEventsTracker,
+    ItemEventsTracker,
+    BankTransactionEventsTracker,
+    CustomerEventsTracker,
+    VendorEventsTracker,
+    ManualJournalEventsTracker,
+    BankRuleEventsTracker,
+    PdfTemplateEventsTracker,
+    PaymentMethodEventsTracker,
+    PaymentLinkEventsTracker,
+    StripeIntegrationEventsTracker,
+    // ReportsEventsTracker,
+  ],
+})
+export class EventTrackerModule {}

packages/server/src/modules/EventsTracker/EventTracker.service.ts

@@ -0,0 +1,52 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { TenancyContext } from '../Tenancy/TenancyContext.service';
+import { POSTHOG_PROVIDER } from './PostHog.constants';
+
+export interface IdentifyMessage {
+  distinctId: string;
+  properties?: Record<string | number, any>;
+  disableGeoip?: boolean;
+}
+
+export interface EventMessage extends IdentifyMessage {
+  event: string;
+  groups?: Record<string, string | number>; // Mapping of group type to group id
+  sendFeatureFlags?: boolean;
+  timestamp?: Date;
+  uuid?: string;
+}
+
+@Injectable()
+export class EventTrackerService {
+  constructor(
+    private readonly tenancyContext: TenancyContext,
+    @Inject(POSTHOG_PROVIDER) private readonly posthog: any,
+  ) {}
+
+  /**
+   * Track tenant an event.
+   * @param event - The event to track.
+   */
+  public async trackEvent(event: Omit<EventMessage, 'distinctId'>) {
+    // Cannot continue if the Posthog not configured.
+    if (!this.posthog) return;
+
+    const tenant = await this.tenancyContext.getTenant();
+    const authorizedUser = await this.tenancyContext.getSystemUser();
+
+    if (!tenant || !authorizedUser) {
+      throw new Error('Tenant or authorized user not found');
+    }
+    const distinctId = `tenant-${tenant.id}-user-${authorizedUser.id}`;
+    const properties = {
+      ...event.properties,
+      tenantId: tenant.id,
+      userId: authorizedUser.id,
+    };
+    this.posthog.capture({
+      ...event,
+      distinctId,
+      properties,
+    });
+  }
+}

packages/server/src/modules/EventsTracker/PostHog.constants.ts

@@ -0,0 +1 @@
+export const POSTHOG_PROVIDER = 'POSTHOG_PROVIDER';

packages/server/src/modules/EventsTracker/event-tracker.ts

@@ -0,0 +1,130 @@
+export const SALE_INVOICE_CREATED = 'Sale invoice created';
+export const SALE_INVOICE_EDITED = 'Sale invoice edited';
+export const SALE_INVOICE_DELETED = 'Sale invoice deleted';
+export const SALE_INVOICE_MAIL_DELIVERED = 'Sale invoice mail delivered';
+export const SALE_INVOICE_VIEWED = 'Sale invoice viewed';
+export const SALE_INVOICE_PDF_VIEWED = 'Sale invoice PDF viewed';
+export const SALE_INVOICE_MAIL_SENT = 'Sale invoice mail sent';
+export const SALE_INVOICE_MAIL_REMINDER_SENT =
+  'Sale invoice reminder mail sent';
+
+export const SALE_ESTIMATE_CREATED = 'Sale estimate created';
+export const SALE_ESTIMATE_EDITED = 'Sale estimate edited';
+export const SALE_ESTIMATE_DELETED = 'Sale estimate deleted';
+export const SALE_ESTIMATE_PDF_VIEWED = 'Sale estimate PDF viewed';
+export const SALE_ESTIMATE_VIEWED = 'Sale estimate viewed';
+export const SALE_ESTIMATE_MAIL_SENT = 'Sale estimate mail sent';
+
+export const PAYMENT_RECEIVED_CREATED = 'Payment received created';
+export const PAYMENT_RECEIVED_EDITED = 'payment received edited';
+export const PAYMENT_RECEIVED_DELETED = 'Payment received deleted';
+export const PAYMENT_RECEIVED_PDF_VIEWED = 'Payment received PDF viewed';
+export const PAYMENT_RECEIVED_MAIL_SENT = 'Payment received mail sent';
+
+export const SALE_RECEIPT_PDF_VIEWED = 'Sale credit PDF viewed';
+export const SALE_RECEIPT_MAIL_SENT = 'Sale credit mail sent';
+
+export const CREDIT_NOTE_PDF_VIEWED = 'Credit note PDF viewed';
+export const CREDIT_NOTE_MAIL_SENT = 'Credit note mail sent';
+
+export const BILL_CREATED = 'Bill created';
+export const BILL_EDITED = 'Bill edited';
+export const BILL_DELETED = 'Bill deleted';
+
+export const PAYMENT_MADE_CREATED = 'Payment made created';
+export const PAYMENT_MADE_EDITED = 'Payment made edited';
+export const PAYMENT_MADE_DELETED = 'Payment made deleted';
+
+export const EXPENSE_CREATED = 'Expense created';
+export const EXPENSE_EDITED = 'Expense edited';
+export const EXPENSE_DELETED = 'Expense deleted';
+
+export const ACCOUNT_CREATED = 'Account created';
+export const ACCOUNT_EDITED = 'Account Edited';
+export const ACCOUNT_DELETED = 'Account deleted';
+export const ACCOUNT_VIEWED = 'Account viewed';
+
+export const ITEM_EVENT_CREATED = 'Item created';
+export const ITEM_EVENT_EDITED = 'Item edited';
+export const ITEM_EVENT_DELETED = 'Item deleted';
+export const ITEM_EVENT_VIEWED = 'Item viewed';
+
+export const AUTH_SIGNED_UP = 'Auth Signed-up';
+export const AUTH_RESET_PASSWORD = 'Auth reset password';
+
+export const SUBSCRIPTION_CANCELLED = 'Subscription cancelled';
+export const SUBSCRIPTION_RESUMED = 'Subscription resumed';
+export const SUBSCRIPTION_PLAN_CHANGED = 'Subscription plan changed';
+export const SUBSCRIPTION_PAYMENT_SUCCEED = 'Subscription payment succeed';
+export const SUBSCRIPTION_PAYMENT_FAILED = 'Subscription payment failed';
+
+export const CUSTOMER_CREATED = 'Customer created';
+export const CUSTOMER_EDITED = 'Customer edited';
+export const CUSTOMER_DELETED = 'Customer deleted';
+
+export const VENDOR_CREATED = 'Vendor created';
+export const VENDOR_EDITED = 'Vendor edited';
+export const VENDOR_DELETED = 'Vendor deleted';
+
+export const TRANSACTIONS_LOCKING_LOCKED = 'Transactions locking locked';
+export const TRANSACTIONS_LOCKING_LOCKING_CANCELLED =
+  'Transactions locking cancelled';
+export const TRANSACTIONS_LOCKING_PARTIALLY_UNLOCKED =
+  'Transactions locking partially unlocked';
+export const TRANSACTIONS_LOCKING_PARTIALLY_UNLOCK_CANCELLED =
+  'Transactions locking partially unlock cancelled';
+
+export const BANK_TRANSACTION_MATCHED = 'Bank transaction matching deleted';
+export const BANK_TRANSACTION_EXCLUDED = 'Bank transaction excluded';
+export const BANK_TRANSACTION_CATEGORIZED = 'Bank transaction categorized';
+export const BANK_TRANSACTION_UNCATEGORIZED = 'Bank transaction uncategorized';
+export const BANK_ACCOUNT_DISCONNECTED = 'Bank account disconnected';
+
+export const MANUAL_JOURNAL_CREATED = 'Manual journal created';
+export const MANUAL_JOURNAL_EDITED = 'Manual journal edited';
+export const MANUAL_JOURNAL_DELETED = 'Manual journal deleted';
+export const MANUAL_JOURNAL_PUBLISHED = 'Manual journal published';
+
+export const BANK_RULE_CREATED = 'Bank rule created';
+export const BANK_RULE_EDITED = 'Bank rule edited';
+export const BANK_RULE_DELETED = 'Bank rule deleted';
+
+export const PDF_TEMPLATE_CREATED = 'PDF template created';
+export const PDF_TEMPLATE_EDITED = 'PDF template edited';
+export const PDF_TEMPLATE_DELETED = 'PDF template deleted';
+export const PDF_TEMPLATE_ASSIGNED_DEFAULT = 'PDF template assigned as default';
+
+export const PAYMENT_METHOD_EDITED = 'Payment method edited';
+export const PAYMENT_METHOD_DELETED = 'Payment method deleted';
+
+export const INVOICE_PAYMENT_LINK_GENERATED = 'Invoice payment link generated';
+
+export const STRIPE_INTEGRAION_CONNECTED =
+  'Stripe integration oauth2 connected';
+
+// # Event Groups
+export const ACCOUNT_GROUP = 'Account';
+export const ITEM_GROUP = 'Item';
+export const AUTH_GROUP = 'Auth';
+export const SALE_GROUP = 'Sale';
+export const PAYMENT_GROUP = 'Payment';
+export const BILL_GROUP = 'Bill';
+export const EXPENSE_GROUP = 'Expense';
+
+// # Reports
+export const BALANCE_SHEET_VIEWED = 'Balance sheet viewed';
+export const TRIAL_BALANCE_SHEET_VIEWED = 'Trial balance sheet viewed';
+export const PROFIT_LOSS_SHEET_VIEWED = 'Profit loss sheet viewed';
+export const CASHFLOW_STATEMENT_VIEWED = 'Cashflow statement viewed';
+export const GENERAL_LEDGER_VIEWED = 'General ledger viewed';
+export const JOURNAL_VIEWED = 'Journal viewed';
+export const RECEIVABLE_AGING_VIEWED = 'Receivable aging viewed';
+export const PAYABLE_AGING_VIEWED = 'Payable aging viewed';
+export const CUSTOMER_BALANCE_SUMMARY_VIEWED =
+  'Customer balance summary viewed';
+export const VENDOR_BALANCE_SUMMARY_VIEWED = 'Vendor balance summary viewed';
+export const INVENTORY_VALUATION_VIEWED = 'Inventory valuation viewed';
+export const CUSTOMER_TRANSACTIONS_VIEWED = 'Customer transactions viewed';
+export const VENDOR_TRANSACTIONS_VIEWED = 'Vendor transactions viewed';
+export const SALES_BY_ITEM_VIEWED = 'Sales by item viewed';
+export const PURCHASES_BY_ITEM_VIEWED = 'Purchases by item viewed';

packages/server/src/modules/EventsTracker/events/AccountEventsTracker.ts

@@ -0,0 +1,52 @@
+import { Injectable } from '@nestjs/common';
+import {
+  IAccountEventCreatedPayload,
+  IAccountEventEditedPayload,
+  IAccountEventDeletedPayload,
+} from '../../Accounts/Accounts.types';
+import { EventTrackerService } from '../EventTracker.service';
+import {
+  ACCOUNT_CREATED,
+  ACCOUNT_EDITED,
+  ACCOUNT_DELETED,
+  ACCOUNT_VIEWED,
+} from '../event-tracker';
+import { events } from '@/common/events/events';
+import { OnEvent } from '@nestjs/event-emitter';
+
+@Injectable()
+export class AccountEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.accounts.onCreated)
+  public handleTrackAccountCreatedEvent({}: IAccountEventCreatedPayload) {
+    this.posthog.trackEvent({
+      event: ACCOUNT_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.accounts.onEdited)
+  public handleTrackEditedAccountEvent({}: IAccountEventEditedPayload) {
+    this.posthog.trackEvent({
+      event: ACCOUNT_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.accounts.onDeleted)
+  public handleTrackDeletedAccountEvent({}: IAccountEventDeletedPayload) {
+    this.posthog.trackEvent({
+      event: ACCOUNT_DELETED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.accounts.onViewed)
+  public handleTrackAccountViewedEvent({}) {
+    this.posthog.trackEvent({
+      event: ACCOUNT_VIEWED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/AuthenticationEventsTracker.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { EventTrackerService } from '../EventTracker.service';
+import { AUTH_SIGNED_UP } from '../event-tracker';
+import { events } from '@/common/events/events';
+
+@Injectable()
+export class AuthenticationEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  // @OnEvent(events.auth.onSignedUp)
+  // public handleTrackSignUpEvent({ user }: IAuthSignedUpEventPayload) {
+  //   this.posthog.trackEvent({
+  //     event: AUTH_SIGNED_UP,
+  //     properties: {
+  //       firstName: user.firstName,
+  //       lastName: user.lastName,
+  //       email: user.email,
+  //     },
+  //   });
+  // }
+}

packages/server/src/modules/EventsTracker/events/BankRuleEventsTracker.ts

@@ -0,0 +1,43 @@
+import {
+  IBankRuleEventCreatedPayload,
+  IBankRuleEventEditedPayload,
+  IBankRuleEventDeletedPayload,
+} from '../../BankRules/types';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import {
+  BANK_RULE_CREATED,
+  BANK_RULE_EDITED,
+  BANK_RULE_DELETED,
+} from '../event-tracker';
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+
+@Injectable()
+export class BankRuleEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.bankRules.onCreated)
+  public handleTrackBankRuleCreatedEvent({}: IBankRuleEventCreatedPayload) {
+    this.posthog.trackEvent({
+      event: BANK_RULE_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.bankRules.onEdited)
+  public handleTrackEditedBankRuleEvent({}: IBankRuleEventEditedPayload) {
+    this.posthog.trackEvent({
+      event: BANK_RULE_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.bankRules.onDeleted)
+  public handleTrackDeletedBankRuleEvent({}: IBankRuleEventDeletedPayload) {
+    this.posthog.trackEvent({
+      event: BANK_RULE_DELETED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/BankTransactionEventsTracker.ts

@@ -0,0 +1,63 @@
+import {
+  BANK_TRANSACTION_MATCHED,
+  BANK_TRANSACTION_EXCLUDED,
+  BANK_TRANSACTION_CATEGORIZED,
+  BANK_TRANSACTION_UNCATEGORIZED,
+  BANK_ACCOUNT_DISCONNECTED,
+} from '../event-tracker';
+import { Injectable } from '@nestjs/common';
+import { EventTrackerService } from '../EventTracker.service';
+import { OnEvent } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { IBankTransactionMatchedEventPayload } from '@/modules/BankingMatching/types';
+import { IBankTransactionExcludedEventPayload } from '@/modules/BankingTransactionsExclude/types/BankTransactionsExclude.types';
+import {
+  ICashflowTransactionCategorizedPayload,
+  ICashflowTransactionUncategorizedPayload,
+} from '@/modules/BankingTransactions/types/BankingTransactions.types';
+import { IBankAccountDisconnectedEventPayload } from '@/modules/BankingAccounts/types/BankAccounts.types';
+
+@Injectable()
+export class BankTransactionEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.bankMatch.onMatched)
+  public handleTrackBankTransactionMatchedEvent({}: IBankTransactionMatchedEventPayload) {
+    this.posthog.trackEvent({
+      event: BANK_TRANSACTION_MATCHED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.bankTransactions.onExcluded)
+  public handleTrackBankTransactionExcludedEvent({}: IBankTransactionExcludedEventPayload) {
+    this.posthog.trackEvent({
+      event: BANK_TRANSACTION_EXCLUDED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.cashflow.onTransactionCategorized)
+  public handleTrackBankTransactionCategorizedEvent({}: ICashflowTransactionCategorizedPayload) {
+    this.posthog.trackEvent({
+      event: BANK_TRANSACTION_CATEGORIZED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.cashflow.onTransactionUncategorized)
+  public handleTrackBankTransactionUncategorizedEvent({}: ICashflowTransactionUncategorizedPayload) {
+    this.posthog.trackEvent({
+      event: BANK_TRANSACTION_UNCATEGORIZED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.bankAccount.onDisconnected)
+  public handleTrackBankAccountDisconnectedEvent({}: IBankAccountDisconnectedEventPayload) {
+    this.posthog.trackEvent({
+      event: BANK_ACCOUNT_DISCONNECTED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/BillEventsTracker.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@nestjs/common';
+import {
+  IBillPaymentEventCreatedPayload,
+  IBillPaymentEventEditedPayload,
+  IBillPaymentEventDeletedPayload,
+} from '../../BillPayments/types/BillPayments.types';
+import { EventTrackerService } from '../EventTracker.service';
+import { BILL_CREATED, BILL_EDITED, BILL_DELETED } from '../event-tracker';
+import { events } from '@/common/events/events';
+import { OnEvent } from '@nestjs/event-emitter';
+
+@Injectable()
+export class BillEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.bill.onCreated)
+  public handleTrackBillCreatedEvent({}: IBillPaymentEventCreatedPayload) {
+    this.posthog.trackEvent({
+      event: BILL_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.bill.onEdited)
+  public handleTrackEditedBillEvent({}: IBillPaymentEventEditedPayload) {
+    this.posthog.trackEvent({
+      event: BILL_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.bill.onDeleted)
+  public handleTrackDeletedBillEvent({}: IBillPaymentEventDeletedPayload) {
+    this.posthog.trackEvent({
+      event: BILL_DELETED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/CustomerEventsTracker.ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import {
+  ICustomerEventCreatedPayload,
+  ICustomerEventEditedPayload,
+  ICustomerEventDeletedPayload,
+} from '../../Customers/types/Customers.types';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import {
+  CUSTOMER_CREATED,
+  CUSTOMER_EDITED,
+  CUSTOMER_DELETED,
+} from '../event-tracker';
+
+@Injectable()
+export class CustomerEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.customers.onCreated)
+  public handleTrackCustomerCreatedEvent({}: ICustomerEventCreatedPayload) {
+    this.posthog.trackEvent({
+      event: CUSTOMER_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.customers.onEdited)
+  public handleTrackEditedCustomerEvent({}: ICustomerEventEditedPayload) {
+    this.posthog.trackEvent({
+      event: CUSTOMER_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.customers.onDeleted)
+  public handleTrackDeletedCustomerEvent({}: ICustomerEventDeletedPayload) {
+    this.posthog.trackEvent({
+      event: CUSTOMER_DELETED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/ExpenseEventsTracker.ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import {
+  IExpenseCreatedPayload,
+  IExpenseEventEditPayload,
+  IExpenseEventDeletePayload,
+} from '../../Expenses/Expenses.types';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import {
+  EXPENSE_CREATED,
+  EXPENSE_EDITED,
+  EXPENSE_DELETED,
+} from '../event-tracker';
+
+@Injectable()
+export class ExpenseEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.expenses.onCreated)
+  public handleTrackExpenseCreatedEvent({}: IExpenseCreatedPayload) {
+    this.posthog.trackEvent({
+      event: EXPENSE_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.expenses.onEdited)
+  public handleTrackEditedExpenseEvent({}: IExpenseEventEditPayload) {
+    this.posthog.trackEvent({
+      event: EXPENSE_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.expenses.onDeleted)
+  public handleTrackDeletedExpenseEvent({}: IExpenseEventDeletePayload) {
+    this.posthog.trackEvent({
+      event: EXPENSE_DELETED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/ItemEventsTracker.ts

@@ -0,0 +1,52 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import {
+  IItemEventCreatedPayload,
+  IItemEventEditedPayload,
+  IItemEventDeletedPayload,
+} from '@/interfaces/Item';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import {
+  ITEM_EVENT_CREATED,
+  ITEM_EVENT_EDITED,
+  ITEM_EVENT_DELETED,
+  ITEM_EVENT_VIEWED,
+} from '../event-tracker';
+
+@Injectable()
+export class ItemEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.item.onCreated)
+  public handleTrackItemCreatedEvent({}: IItemEventCreatedPayload) {
+    this.posthog.trackEvent({
+      event: ITEM_EVENT_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.item.onEdited)
+  public handleTrackEditedItemEvent({}: IItemEventEditedPayload) {
+    this.posthog.trackEvent({
+      event: ITEM_EVENT_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.item.onDeleted)
+  public handleTrackDeletedItemEvent({}: IItemEventDeletedPayload) {
+    this.posthog.trackEvent({
+      event: ITEM_EVENT_DELETED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.item.onViewed)
+  public handleTrackViewedItemEvent({}: IItemEventDeletedPayload) {
+    this.posthog.trackEvent({
+      event: ITEM_EVENT_VIEWED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/ManualJournalEventsTracker.ts

@@ -0,0 +1,49 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import {
+  IManualJournalEventCreatedPayload,
+  IManualJournalEventEditedPayload,
+  IManualJournalEventDeletedPayload,
+} from '../../ManualJournals/types/ManualJournals.types';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import {
+  MANUAL_JOURNAL_CREATED,
+  MANUAL_JOURNAL_EDITED,
+  MANUAL_JOURNAL_DELETED,
+} from '../event-tracker';
+
+@Injectable()
+export class ManualJournalEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.manualJournals.onCreated)
+  public handleTrackManualJournalCreatedEvent(
+    payload: IManualJournalEventCreatedPayload,
+  ) {
+    this.posthog.trackEvent({
+      event: MANUAL_JOURNAL_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.manualJournals.onEdited)
+  public handleTrackEditedManualJournalEvent(
+    payload: IManualJournalEventEditedPayload,
+  ) {
+    this.posthog.trackEvent({
+      event: MANUAL_JOURNAL_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.manualJournals.onDeleted)
+  public handleTrackDeletedManualJournalEvent(
+    payload: IManualJournalEventDeletedPayload,
+  ) {
+    this.posthog.trackEvent({
+      event: MANUAL_JOURNAL_DELETED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/PaymentLinkEventsTracker.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import { INVOICE_PAYMENT_LINK_GENERATED } from '../event-tracker';
+
+@Injectable()
+export class PaymentLinkEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.saleInvoice.onPublicLinkGenerated)
+  public handleTrackInvoicePublicLinkGeneratedEvent() {
+    this.posthog.trackEvent({
+      event: INVOICE_PAYMENT_LINK_GENERATED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/PaymentMadeEventsTracker.ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import {
+  IBillPaymentEventCreatedPayload,
+  IBillPaymentEditingPayload,
+  IBillPaymentEventDeletedPayload,
+} from '../../BillPayments/types/BillPayments.types';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import {
+  PAYMENT_MADE_CREATED,
+  PAYMENT_MADE_EDITED,
+  PAYMENT_MADE_DELETED,
+} from '../event-tracker';
+
+@Injectable()
+export class PaymentMadeEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.billPayment.onCreated)
+  public handleTrackPaymentMadeCreatedEvent({}: IBillPaymentEventCreatedPayload) {
+    this.posthog.trackEvent({
+      event: PAYMENT_MADE_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.billPayment.onEdited)
+  public handleTrackEditedPaymentMadeEvent({}: IBillPaymentEditingPayload) {
+    this.posthog.trackEvent({
+      event: PAYMENT_MADE_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.billPayment.onDeleted)
+  public handleTrackDeletedPaymentMadeEvent({}: IBillPaymentEventDeletedPayload) {
+    this.posthog.trackEvent({
+      event: PAYMENT_MADE_DELETED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/PaymentMethodEventsTracker.ts

@@ -0,0 +1,29 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import {
+  PAYMENT_METHOD_EDITED,
+  PAYMENT_METHOD_DELETED,
+} from '../event-tracker';
+
+@Injectable()
+export class PaymentMethodEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.paymentMethod.onEdited)
+  public handleTrackPaymentMethodEditedEvent({}) {
+    this.posthog.trackEvent({
+      event: PAYMENT_METHOD_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.paymentMethod.onDeleted)
+  public handleTrackPaymentMethodDeletedEvent({}) {
+    this.posthog.trackEvent({
+      event: PAYMENT_METHOD_DELETED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/PaymentReceivedEventsTracker.ts

@@ -0,0 +1,61 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import {
+  IPaymentReceivedCreatedPayload,
+  IPaymentReceivedEditedPayload,
+  IPaymentReceivedDeletedPayload,
+} from '../../PaymentReceived/types/PaymentReceived.types';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import {
+  PAYMENT_RECEIVED_CREATED,
+  PAYMENT_RECEIVED_EDITED,
+  PAYMENT_RECEIVED_DELETED,
+  PAYMENT_RECEIVED_PDF_VIEWED,
+  PAYMENT_RECEIVED_MAIL_SENT,
+} from '../event-tracker';
+
+@Injectable()
+export class PaymentReceivedEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.paymentReceive.onCreated)
+  public handleTrackPaymentReceivedCreatedEvent({}: IPaymentReceivedCreatedPayload) {
+    this.posthog.trackEvent({
+      event: PAYMENT_RECEIVED_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.paymentReceive.onEdited)
+  public handleTrackEditedPaymentReceivedEvent({}: IPaymentReceivedEditedPayload) {
+    this.posthog.trackEvent({
+      event: PAYMENT_RECEIVED_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.paymentReceive.onDeleted)
+  public handleTrackDeletedPaymentReceivedEvent({}: IPaymentReceivedDeletedPayload) {
+    this.posthog.trackEvent({
+      event: PAYMENT_RECEIVED_DELETED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.paymentReceive.onPdfViewed)
+  public handleTrackPdfViewedPaymentReceivedEvent({}: IPaymentReceivedDeletedPayload) {
+    this.posthog.trackEvent({
+      event: PAYMENT_RECEIVED_PDF_VIEWED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.paymentReceive.onMailSent)
+  public handleTrackMailSentPaymentReceivedEvent({}: IPaymentReceivedDeletedPayload) {
+    this.posthog.trackEvent({
+      event: PAYMENT_RECEIVED_MAIL_SENT,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/PdfTemplateEventsTracker.ts

@@ -0,0 +1,47 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import {
+  PDF_TEMPLATE_CREATED,
+  PDF_TEMPLATE_EDITED,
+  PDF_TEMPLATE_DELETED,
+  PDF_TEMPLATE_ASSIGNED_DEFAULT,
+} from '../event-tracker';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+
+@Injectable()
+export class PdfTemplateEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.pdfTemplate.onCreated)
+  public handleTrackPdfTemplateCreatedEvent({}) {
+    this.posthog.trackEvent({
+      event: PDF_TEMPLATE_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.pdfTemplate.onEdited)
+  public handleTrackEditedPdfTemplateEvent({}) {
+    this.posthog.trackEvent({
+      event: PDF_TEMPLATE_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.pdfTemplate.onDeleted)
+  public handleTrackDeletedPdfTemplateEvent({}) {
+    this.posthog.trackEvent({
+      event: PDF_TEMPLATE_DELETED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.pdfTemplate.onAssignedDefault)
+  public handleTrackAssignedAsDefaultPdfTemplateEvent({}) {
+    this.posthog.trackEvent({
+      event: PDF_TEMPLATE_ASSIGNED_DEFAULT,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/ReportsEventsTracker.ts

@@ -0,0 +1,240 @@
+// import { Inject, Service } from 'typedi';
+// import { EventSubscriber } from '@/lib/EventPublisher/EventPublisher';
+// import { ReportsEvents } from '@/constants/event-tracker';
+// import { PosthogService } from '../EventTracker.service';
+// import events from '@/subscribers/events';
+// import {
+//   BALANCE_SHEET_VIEWED,
+//   TRIAL_BALANCE_SHEET_VIEWED,
+//   PROFIT_LOSS_SHEET_VIEWED,
+//   CASHFLOW_STATEMENT_VIEWED,
+//   GENERAL_LEDGER_VIEWED,
+//   JOURNAL_VIEWED,
+//   RECEIVABLE_AGING_VIEWED,
+//   PAYABLE_AGING_VIEWED,
+//   CUSTOMER_BALANCE_SUMMARY_VIEWED,
+//   VENDOR_BALANCE_SUMMARY_VIEWED,
+//   INVENTORY_VALUATION_VIEWED,
+//   CUSTOMER_TRANSACTIONS_VIEWED,
+//   VENDOR_TRANSACTIONS_VIEWED,
+//   SALES_BY_ITEM_VIEWED,
+//   PURCHASES_BY_ITEM_VIEWED,
+// } from '@/constants/event-tracker';
+
+// @Service()
+// export class ReportsEventsTracker extends EventSubscriber {
+//   @Inject()
+//   private posthog: PosthogService;
+
+//   /**
+//    * Constructor method.
+//    */
+//   public attach(bus) {
+//     bus.subscribe(
+//       events.reports.onBalanceSheetViewed,
+//       this.handleTrackBalanceSheetViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onTrialBalanceSheetView,
+//       this.handleTrackTrialBalanceSheetViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onProfitLossSheetViewed,
+//       this.handleTrackProfitLossSheetViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onCashflowStatementViewed,
+//       this.handleTrackCashflowStatementViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onGeneralLedgerViewed,
+//       this.handleTrackGeneralLedgerViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onJournalViewed,
+//       this.handleTrackJournalViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onReceivableAgingViewed,
+//       this.handleTrackReceivableAgingViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onPayableAgingViewed,
+//       this.handleTrackPayableAgingViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onCustomerBalanceSummaryViewed,
+//       this.handleTrackCustomerBalanceSummaryViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onVendorBalanceSummaryViewed,
+//       this.handleTrackVendorBalanceSummaryViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onInventoryValuationViewed,
+//       this.handleTrackInventoryValuationViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onCustomerTransactionsViewed,
+//       this.handleTrackCustomerTransactionsViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onVendorTransactionsViewed,
+//       this.handleTrackVendorTransactionsViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onSalesByItemViewed,
+//       this.handleTrackSalesByItemViewedEvent
+//     );
+//     bus.subscribe(
+//       events.reports.onPurchasesByItemViewed,
+//       this.handleTrackPurchasesByItemViewedEvent
+//     );
+//   }
+
+//   private handleTrackBalanceSheetViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: BALANCE_SHEET_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackTrialBalanceSheetViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: TRIAL_BALANCE_SHEET_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackProfitLossSheetViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: PROFIT_LOSS_SHEET_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackCashflowStatementViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: CASHFLOW_STATEMENT_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackGeneralLedgerViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: GENERAL_LEDGER_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackJournalViewedEvent({ tenantId }: ReportsEvents) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: JOURNAL_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackReceivableAgingViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: RECEIVABLE_AGING_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackPayableAgingViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: PAYABLE_AGING_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackCustomerBalanceSummaryViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: CUSTOMER_BALANCE_SUMMARY_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackVendorBalanceSummaryViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: VENDOR_BALANCE_SUMMARY_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackInventoryValuationViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: INVENTORY_VALUATION_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackCustomerTransactionsViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: CUSTOMER_TRANSACTIONS_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackVendorTransactionsViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: VENDOR_TRANSACTIONS_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackSalesByItemViewedEvent({ tenantId }: ReportsEvents) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: SALES_BY_ITEM_VIEWED,
+//       properties: {},
+//     });
+//   }
+
+//   private handleTrackPurchasesByItemViewedEvent(
+//     { tenantId }: ReportsEvents
+//   ) {
+//     this.posthog.trackEvent({
+//       distinctId: `tenant-${tenantId}`,
+//       event: PURCHASES_BY_ITEM_VIEWED,
+//       properties: {},
+//     });
+//   }
+// }

packages/server/src/modules/EventsTracker/events/SaleEstimateEventsTracker.ts

@@ -0,0 +1,70 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import {
+  ISaleEstimateCreatedPayload,
+  ISaleEstimateEditedPayload,
+  ISaleEstimateDeletedPayload,
+} from '../../SaleEstimates/types/SaleEstimates.types';
+import { EventTrackerService } from '../EventTracker.service';
+import {
+  SALE_ESTIMATE_CREATED,
+  SALE_ESTIMATE_EDITED,
+  SALE_ESTIMATE_DELETED,
+  SALE_ESTIMATE_PDF_VIEWED,
+  SALE_ESTIMATE_VIEWED,
+  SALE_ESTIMATE_MAIL_SENT,
+} from '../event-tracker';
+import { events } from '@/common/events/events';
+
+@Injectable()
+export class SaleEstimateEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.saleEstimate.onCreated)
+  public handleTrackEstimateCreatedEvent({}: ISaleEstimateCreatedPayload) {
+    this.posthog.trackEvent({
+      event: SALE_ESTIMATE_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.saleEstimate.onEdited)
+  public handleTrackEditedEstimateEvent({}: ISaleEstimateEditedPayload) {
+    this.posthog.trackEvent({
+      event: SALE_ESTIMATE_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.saleEstimate.onDeleted)
+  public handleTrackDeletedEstimateEvent({}: ISaleEstimateDeletedPayload) {
+    this.posthog.trackEvent({
+      event: SALE_ESTIMATE_DELETED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.saleEstimate.onPdfViewed)
+  public handleTrackPdfViewedEstimateEvent({}: ISaleEstimateDeletedPayload) {
+    this.posthog.trackEvent({
+      event: SALE_ESTIMATE_PDF_VIEWED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.saleEstimate.onViewed)
+  public handleTrackViewedEstimateEvent({}) {
+    this.posthog.trackEvent({
+      event: SALE_ESTIMATE_VIEWED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.saleEstimate.onMailSent)
+  public handleTrackMailSentEstimateEvent({}) {
+    this.posthog.trackEvent({
+      event: SALE_ESTIMATE_MAIL_SENT,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/SaleInvoicesEventsTracker.ts

@@ -0,0 +1,69 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import {
+  ISaleInvoiceCreatedPayload,
+  ISaleInvoiceEditedPayload,
+} from '../../SaleInvoices/SaleInvoice.types';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import {
+  SALE_INVOICE_CREATED,
+  SALE_INVOICE_DELETED,
+  SALE_INVOICE_EDITED,
+  SALE_INVOICE_MAIL_SENT,
+  SALE_INVOICE_PDF_VIEWED,
+  SALE_INVOICE_VIEWED,
+} from '../event-tracker';
+
+@Injectable()
+export class SaleInvoiceEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.saleInvoice.onCreated)
+  public handleTrackInvoiceCreatedEvent({}: ISaleInvoiceCreatedPayload) {
+    this.posthog.trackEvent({
+      event: SALE_INVOICE_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.saleInvoice.onEdited)
+  public handleTrackEditedInvoiceEvent({}: ISaleInvoiceEditedPayload) {
+    this.posthog.trackEvent({
+      event: SALE_INVOICE_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.saleInvoice.onDeleted)
+  public handleTrackDeletedInvoiceEvent({}: ISaleInvoiceEditedPayload) {
+    this.posthog.trackEvent({
+      event: SALE_INVOICE_DELETED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.saleInvoice.onViewed)
+  public handleTrackViewedInvoiceEvent({}) {
+    this.posthog.trackEvent({
+      event: SALE_INVOICE_VIEWED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.saleInvoice.onPdfViewed)
+  public handleTrackPdfViewedInvoiceEvent({}) {
+    this.posthog.trackEvent({
+      event: SALE_INVOICE_PDF_VIEWED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.saleInvoice.onMailSent)
+  public handleTrackMailSentInvoiceEvent({}) {
+    this.posthog.trackEvent({
+      event: SALE_INVOICE_MAIL_SENT,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/StripeIntegrationEventsTracker.ts

@@ -0,0 +1,19 @@
+import { events } from '@/common/events/events';
+import { ISaleInvoiceCreatedPayload } from '@/modules/SaleInvoices/SaleInvoice.types';
+import { OnEvent } from '@nestjs/event-emitter';
+import { STRIPE_INTEGRAION_CONNECTED } from '../event-tracker';
+import { EventTrackerService } from '../EventTracker.service';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class StripeIntegrationEventsTracker {
+  constructor(private readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.stripeIntegration.onOAuthCodeGranted)
+  public handleTrackOAuthCodeGrantedTrackEvent({}: ISaleInvoiceCreatedPayload) {
+    this.posthog.trackEvent({
+      event: STRIPE_INTEGRAION_CONNECTED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/SubscriptionEventsTracker.ts

@@ -0,0 +1,48 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { ITransactionsLockingPartialUnlocked } from '../../TransactionsLocking/types/TransactionsLocking.types';
+import { EventTrackerService } from '../EventTracker.service';
+import {
+  TRANSACTIONS_LOCKING_LOCKED,
+  TRANSACTIONS_LOCKING_LOCKING_CANCELLED,
+  TRANSACTIONS_LOCKING_PARTIALLY_UNLOCK_CANCELLED,
+  TRANSACTIONS_LOCKING_PARTIALLY_UNLOCKED,
+} from '../event-tracker';
+import { events } from '@/common/events/events';
+
+@Injectable()
+export class TransactionsLockingEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.transactionsLocking.locked)
+  public handleTransactionsLockingLockedEvent({}: ITransactionsLockingPartialUnlocked) {
+    this.posthog.trackEvent({
+      event: TRANSACTIONS_LOCKING_LOCKED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.transactionsLocking.lockCanceled)
+  public handleTransactionsLockingCancelledEvent({}: ITransactionsLockingPartialUnlocked) {
+    this.posthog.trackEvent({
+      event: TRANSACTIONS_LOCKING_LOCKING_CANCELLED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.transactionsLocking.partialUnlocked)
+  public handleTransactionsLockingPartiallyUnlockedEvent({}: ITransactionsLockingPartialUnlocked) {
+    this.posthog.trackEvent({
+      event: TRANSACTIONS_LOCKING_PARTIALLY_UNLOCKED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.transactionsLocking.partialUnlockCanceled)
+  public handleTransactionsLockingPartiallyUnlockCancelledEvent({}: ITransactionsLockingPartialUnlocked) {
+    this.posthog.trackEvent({
+      event: TRANSACTIONS_LOCKING_PARTIALLY_UNLOCK_CANCELLED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/TransactionsLockingEventsTracker.ts

@@ -0,0 +1,56 @@
+import {
+  SUBSCRIPTION_CANCELLED,
+  SUBSCRIPTION_PAYMENT_FAILED,
+  SUBSCRIPTION_PAYMENT_SUCCEED,
+  SUBSCRIPTION_PLAN_CHANGED,
+  SUBSCRIPTION_RESUMED,
+} from '../event-tracker';
+import { OnEvent } from '@nestjs/event-emitter';
+import { Injectable } from '@nestjs/common';
+import { EventTrackerService } from '../EventTracker.service';
+
+import { events } from '@/common/events/events';
+@Injectable()
+export class TransactionsLockingEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.subscription.onSubscriptionResumed)
+  public handleSubscriptionResumedEvent() {
+    this.posthog.trackEvent({
+      event: SUBSCRIPTION_RESUMED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.subscription.onSubscriptionCancelled)
+  public handleSubscriptionCancelledEvent() {
+    this.posthog.trackEvent({
+      event: SUBSCRIPTION_CANCELLED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.subscription.onSubscriptionPlanChanged)
+  public handleSubscriptionPlanChangedEvent() {
+    this.posthog.trackEvent({
+      event: SUBSCRIPTION_PLAN_CHANGED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.subscription.onSubscriptionPaymentFailed)
+  public handleSubscriptionPaymentFailedEvent() {
+    this.posthog.trackEvent({
+      event: SUBSCRIPTION_PAYMENT_FAILED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.subscription.onSubscriptionPaymentSucceed)
+  public handleSubscriptionPaymentSucceed() {
+    this.posthog.trackEvent({
+      event: SUBSCRIPTION_PAYMENT_SUCCEED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/events/VendorEventsTracker.ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@nestjs/common';
+import {
+  IVendorEventCreatedPayload,
+  IVendorEventEditedPayload,
+  IVendorEventDeletedPayload,
+} from '../../Vendors/types/Vendors.types';
+import { EventTrackerService } from '../EventTracker.service';
+import { events } from '@/common/events/events';
+import {
+  VENDOR_CREATED,
+  VENDOR_EDITED,
+  VENDOR_DELETED,
+} from '../event-tracker';
+import { OnEvent } from '@nestjs/event-emitter';
+
+@Injectable()
+export class VendorEventsTracker {
+  constructor(public readonly posthog: EventTrackerService) {}
+
+  @OnEvent(events.vendors.onCreated)
+  public handleTrackVendorCreatedEvent({}: IVendorEventCreatedPayload) {
+    this.posthog.trackEvent({
+      event: VENDOR_CREATED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.vendors.onEdited)
+  public handleTrackEditedVendorEvent({}: IVendorEventEditedPayload) {
+    this.posthog.trackEvent({
+      event: VENDOR_EDITED,
+      properties: {},
+    });
+  }
+
+  @OnEvent(events.vendors.onDeleted)
+  public handleTrackDeletedVendorEvent({}: IVendorEventDeletedPayload) {
+    this.posthog.trackEvent({
+      event: VENDOR_DELETED,
+      properties: {},
+    });
+  }
+}

packages/server/src/modules/EventsTracker/postHog.module.ts

@@ -0,0 +1,27 @@
+import { Module } from '@nestjs/common';
+import { PostHog } from 'posthog-node';
+import { EventTrackerService } from './EventTracker.service';
+import { ConfigService } from '@nestjs/config';
+import { POSTHOG_PROVIDER } from './PostHog.constants';
+import { TenancyContext } from '../Tenancy/TenancyContext.service';
+
+@Module({
+  providers: [
+    EventTrackerService,
+    TenancyContext,
+    {
+      provide: POSTHOG_PROVIDER,
+      useFactory: (configService: ConfigService) => {
+        if (configService.get('posthog.apiKey')) {
+          return new PostHog(configService.get('posthog.apiKey'), {
+            host: configService.get('posthog.host'),
+          });
+        }
+        return null;
+      },
+      inject: [ConfigService],
+    },
+  ],
+  exports: [EventTrackerService, POSTHOG_PROVIDER],
+})
+export class PostHogModule {}