feat: Implement Strategic Treasury, Liquidity Forecasting

models/ExchangeHedge.js

@@ -0,0 +1,88 @@
+const mongoose = require('mongoose');
+
+/**
+ * ExchangeHedge Model
+ * Manages FX risk through hedging strategies for multi-currency operations
+ */
+const exchangeHedgeSchema = new mongoose.Schema({
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+        index: true
+    },
+    hedgeId: {
+        type: String,
+        unique: true,
+        required: true
+    },
+    baseCurrency: {
+        type: String,
+        required: true,
+        uppercase: true
+    },
+    targetCurrency: {
+        type: String,
+        required: true,
+        uppercase: true
+    },
+    hedgeType: {
+        type: String,
+        enum: ['forward_contract', 'option', 'swap', 'natural_hedge'],
+        required: true
+    },
+    notionalAmount: {
+        type: Number,
+        required: true
+    },
+    contractRate: {
+        type: Number,
+        required: true
+    },
+    marketRate: {
+        type: Number,
+        default: null
+    },
+    maturityDate: {
+        type: Date,
+        required: true
+    },
+    status: {
+        type: String,
+        enum: ['active', 'settled', 'expired', 'cancelled'],
+        default: 'active'
+    },
+    effectiveness: {
+        hedgeRatio: { type: Number, default: 1.0 },
+        gainLoss: { type: Number, default: 0 },
+        mtmValue: { type: Number, default: 0 } // Mark-to-Market
+    },
+    counterparty: {
+        name: String,
+        rating: String
+    },
+    linkedTransactions: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Transaction'
+    }],
+    notes: String
+}, {
+    timestamps: true
+});
+
+// Calculate MTM value before saving
+exchangeHedgeSchema.pre('save', function (next) {
+    if (this.marketRate && this.contractRate) {
+        const rateDiff = this.marketRate - this.contractRate;
+        this.effectiveness.mtmValue = rateDiff * this.notionalAmount;
+        this.effectiveness.gainLoss = this.effectiveness.mtmValue;
+    }
+    next();
+});
+
+// Indexes
+exchangeHedgeSchema.index({ userId: 1, status: 1 });
+exchangeHedgeSchema.index({ maturityDate: 1, status: 1 });
+exchangeHedgeSchema.index({ baseCurrency: 1, targetCurrency: 1 });
+
+module.exports = mongoose.model('ExchangeHedge', exchangeHedgeSchema);

models/LiquidityThreshold.js

@@ -0,0 +1,76 @@
+const mongoose = require('mongoose');
+
+/**
+ * LiquidityThreshold Model
+ * Defines alert triggers and automated actions when cash runway falls below critical levels
+ */
+const liquidityThresholdSchema = new mongoose.Schema({
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+        index: true
+    },
+    vaultId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'TreasuryVault',
+        required: true
+    },
+    thresholdName: {
+        type: String,
+        required: true
+    },
+    thresholdType: {
+        type: String,
+        enum: ['absolute', 'percentage', 'runway_days'],
+        required: true
+    },
+    triggerValue: {
+        type: Number,
+        required: true
+    },
+    currentValue: {
+        type: Number,
+        default: 0
+    },
+    severity: {
+        type: String,
+        enum: ['info', 'warning', 'critical', 'emergency'],
+        default: 'warning'
+    },
+    alertChannels: [{
+        type: String,
+        enum: ['email', 'sms', 'dashboard', 'webhook']
+    }],
+    automatedActions: [{
+        actionType: {
+            type: String,
+            enum: ['freeze_spending', 'notify_stakeholders', 'trigger_rebalance', 'liquidate_assets']
+        },
+        actionParams: mongoose.Schema.Types.Mixed
+    }],
+    lastTriggered: {
+        type: Date,
+        default: null
+    },
+    triggerCount: {
+        type: Number,
+        default: 0
+    },
+    isActive: {
+        type: Boolean,
+        default: true
+    },
+    cooldownPeriod: {
+        type: Number,
+        default: 24 // hours
+    }
+}, {
+    timestamps: true
+});
+
+// Index for efficient threshold monitoring
+liquidityThresholdSchema.index({ userId: 1, vaultId: 1, isActive: 1 });
+liquidityThresholdSchema.index({ severity: 1, isActive: 1 });
+
+module.exports = mongoose.model('LiquidityThreshold', liquidityThresholdSchema);

models/TreasuryVault.js

@@ -0,0 +1,75 @@
+const mongoose = require('mongoose');
+
+/**
+ * TreasuryVault Model
+ * Represents a centralized cash/asset pool for enterprise treasury management
+ */
+const treasuryVaultSchema = new mongoose.Schema({
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+        index: true
+    },
+    vaultName: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    vaultType: {
+        type: String,
+        enum: ['operating', 'reserve', 'investment', 'forex'],
+        default: 'operating'
+    },
+    currency: {
+        type: String,
+        required: true,
+        default: 'INR',
+        uppercase: true
+    },
+    balance: {
+        type: Number,
+        required: true,
+        default: 0
+    },
+    allocatedFunds: {
+        type: Number,
+        default: 0
+    },
+    availableLiquidity: {
+        type: Number,
+        default: 0
+    },
+    linkedAccounts: [{
+        accountId: { type: mongoose.Schema.Types.ObjectId, ref: 'Account' },
+        allocationPercentage: { type: Number, min: 0, max: 100 }
+    }],
+    restrictions: {
+        minBalance: { type: Number, default: 0 },
+        maxWithdrawal: { type: Number, default: null },
+        requiresApproval: { type: Boolean, default: false }
+    },
+    metadata: {
+        purpose: String,
+        riskProfile: { type: String, enum: ['conservative', 'moderate', 'aggressive'], default: 'moderate' },
+        autoRebalance: { type: Boolean, default: false }
+    },
+    isActive: {
+        type: Boolean,
+        default: true
+    }
+}, {
+    timestamps: true
+});
+
+// Pre-save hook to calculate available liquidity
+treasuryVaultSchema.pre('save', function (next) {
+    this.availableLiquidity = this.balance - this.allocatedFunds;
+    next();
+});
+
+// Index for performance
+treasuryVaultSchema.index({ userId: 1, vaultType: 1 });
+treasuryVaultSchema.index({ currency: 1, isActive: 1 });
+
+module.exports = mongoose.model('TreasuryVault', treasuryVaultSchema);