[OQI-008] feat: Add PostgreSQL repositories for portfolio module
- Created portfolio.repository.ts with CRUD operations for portfolios and allocations - Created goal.repository.ts with CRUD operations for portfolio goals - Updated portfolio.service.ts to use repositories with in-memory fallback - Migrated createPortfolio, getPortfolio, getUserPortfolios methods - Migrated updateAllocations, executeRebalance methods - Migrated createGoal, getUserGoals, updateGoalProgress, deleteGoal methods - Added helper functions for mapping between repo and service types Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Adrian Flores Cortes
parent
4322caf69a
commit
f40dfa8061
430
src/modules/portfolio/repositories/goal.repository.ts
Normal file
430
src/modules/portfolio/repositories/goal.repository.ts
Normal file
@ -0,0 +1,430 @@
|
||||
/**
|
||||
* Portfolio Goal Repository
|
||||
* Handles database operations for portfolio goals
|
||||
*/
|
||||
|
||||
import { db } from '../../../shared/database';
|
||||
|
||||
// ============================================================================
|
||||
// Types
|
||||
// ============================================================================
|
||||
|
||||
export type GoalStatus = 'active' | 'completed' | 'abandoned';
|
||||
|
||||
export interface GoalRow {
|
||||
id: string;
|
||||
user_id: string;
|
||||
portfolio_id: string | null;
|
||||
name: string;
|
||||
description: string | null;
|
||||
target_amount: string;
|
||||
current_amount: string;
|
||||
target_date: Date;
|
||||
monthly_contribution: string;
|
||||
progress: string;
|
||||
projected_completion_date: Date | null;
|
||||
months_remaining: number | null;
|
||||
required_monthly_contribution: string | null;
|
||||
status: GoalStatus;
|
||||
completed_at: Date | null;
|
||||
created_at: Date;
|
||||
updated_at: Date;
|
||||
}
|
||||
|
||||
export interface PortfolioGoal {
|
||||
id: string;
|
||||
userId: string;
|
||||
portfolioId: string | null;
|
||||
name: string;
|
||||
description: string | null;
|
||||
targetAmount: number;
|
||||
currentAmount: number;
|
||||
targetDate: Date;
|
||||
monthlyContribution: number;
|
||||
progress: number;
|
||||
projectedCompletionDate: Date | null;
|
||||
monthsRemaining: number | null;
|
||||
requiredMonthlyContribution: number | null;
|
||||
status: GoalStatus;
|
||||
completedAt: Date | null;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
export interface CreateGoalInput {
|
||||
userId: string;
|
||||
portfolioId?: string;
|
||||
name: string;
|
||||
description?: string;
|
||||
targetAmount: number;
|
||||
targetDate: Date;
|
||||
monthlyContribution: number;
|
||||
currentAmount?: number;
|
||||
}
|
||||
|
||||
export interface UpdateGoalInput {
|
||||
name?: string;
|
||||
description?: string;
|
||||
targetAmount?: number;
|
||||
currentAmount?: number;
|
||||
targetDate?: Date;
|
||||
monthlyContribution?: number;
|
||||
portfolioId?: string | null;
|
||||
status?: GoalStatus;
|
||||
}
|
||||
|
||||
export interface GoalFilters {
|
||||
userId?: string;
|
||||
portfolioId?: string;
|
||||
status?: GoalStatus;
|
||||
limit?: number;
|
||||
offset?: number;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Helper Functions
|
||||
// ============================================================================
|
||||
|
||||
function mapRowToGoal(row: GoalRow): PortfolioGoal {
|
||||
return {
|
||||
id: row.id,
|
||||
userId: row.user_id,
|
||||
portfolioId: row.portfolio_id,
|
||||
name: row.name,
|
||||
description: row.description,
|
||||
targetAmount: parseFloat(row.target_amount),
|
||||
currentAmount: parseFloat(row.current_amount || '0'),
|
||||
targetDate: row.target_date,
|
||||
monthlyContribution: parseFloat(row.monthly_contribution || '0'),
|
||||
progress: parseFloat(row.progress || '0'),
|
||||
projectedCompletionDate: row.projected_completion_date,
|
||||
monthsRemaining: row.months_remaining,
|
||||
requiredMonthlyContribution: row.required_monthly_contribution
|
||||
? parseFloat(row.required_monthly_contribution)
|
||||
: null,
|
||||
status: row.status,
|
||||
completedAt: row.completed_at,
|
||||
createdAt: row.created_at,
|
||||
updatedAt: row.updated_at,
|
||||
};
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Repository Class
|
||||
// ============================================================================
|
||||
|
||||
class GoalRepository {
|
||||
/**
|
||||
* Create a new goal
|
||||
*/
|
||||
async create(input: CreateGoalInput): Promise<PortfolioGoal> {
|
||||
const result = await db.query<GoalRow>(
|
||||
`INSERT INTO portfolio.portfolio_goals (
|
||||
user_id, portfolio_id, name, description, target_amount,
|
||||
current_amount, target_date, monthly_contribution
|
||||
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
|
||||
RETURNING *`,
|
||||
[
|
||||
input.userId,
|
||||
input.portfolioId || null,
|
||||
input.name,
|
||||
input.description || null,
|
||||
input.targetAmount,
|
||||
input.currentAmount ?? 0,
|
||||
input.targetDate,
|
||||
input.monthlyContribution,
|
||||
]
|
||||
);
|
||||
|
||||
return mapRowToGoal(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find goal by ID
|
||||
*/
|
||||
async findById(id: string): Promise<PortfolioGoal | null> {
|
||||
const result = await db.query<GoalRow>(
|
||||
'SELECT * FROM portfolio.portfolio_goals WHERE id = $1',
|
||||
[id]
|
||||
);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return mapRowToGoal(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find goals by user ID
|
||||
*/
|
||||
async findByUserId(userId: string): Promise<PortfolioGoal[]> {
|
||||
const result = await db.query<GoalRow>(
|
||||
`SELECT * FROM portfolio.portfolio_goals
|
||||
WHERE user_id = $1
|
||||
ORDER BY target_date ASC`,
|
||||
[userId]
|
||||
);
|
||||
|
||||
return result.rows.map(mapRowToGoal);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find active goals by user ID
|
||||
*/
|
||||
async findActiveByUserId(userId: string): Promise<PortfolioGoal[]> {
|
||||
const result = await db.query<GoalRow>(
|
||||
`SELECT * FROM portfolio.portfolio_goals
|
||||
WHERE user_id = $1 AND status = 'active'
|
||||
ORDER BY target_date ASC`,
|
||||
[userId]
|
||||
);
|
||||
|
||||
return result.rows.map(mapRowToGoal);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find goals by portfolio ID
|
||||
*/
|
||||
async findByPortfolioId(portfolioId: string): Promise<PortfolioGoal[]> {
|
||||
const result = await db.query<GoalRow>(
|
||||
`SELECT * FROM portfolio.portfolio_goals
|
||||
WHERE portfolio_id = $1 AND status = 'active'
|
||||
ORDER BY target_date ASC`,
|
||||
[portfolioId]
|
||||
);
|
||||
|
||||
return result.rows.map(mapRowToGoal);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find all goals with filters
|
||||
*/
|
||||
async findAll(filters: GoalFilters = {}): Promise<{
|
||||
goals: PortfolioGoal[];
|
||||
total: number;
|
||||
}> {
|
||||
const conditions: string[] = [];
|
||||
const values: (string | GoalStatus | number)[] = [];
|
||||
let paramIndex = 1;
|
||||
|
||||
if (filters.userId) {
|
||||
conditions.push(`user_id = $${paramIndex++}`);
|
||||
values.push(filters.userId);
|
||||
}
|
||||
|
||||
if (filters.portfolioId) {
|
||||
conditions.push(`portfolio_id = $${paramIndex++}`);
|
||||
values.push(filters.portfolioId);
|
||||
}
|
||||
|
||||
if (filters.status) {
|
||||
conditions.push(`status = $${paramIndex++}`);
|
||||
values.push(filters.status);
|
||||
}
|
||||
|
||||
const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
|
||||
|
||||
// Get total count
|
||||
const countResult = await db.query<{ count: string }>(
|
||||
`SELECT COUNT(*) as count FROM portfolio.portfolio_goals ${whereClause}`,
|
||||
values
|
||||
);
|
||||
const total = parseInt(countResult.rows[0].count);
|
||||
|
||||
// Get goals
|
||||
let query = `
|
||||
SELECT * FROM portfolio.portfolio_goals
|
||||
${whereClause}
|
||||
ORDER BY target_date ASC
|
||||
`;
|
||||
|
||||
if (filters.limit) {
|
||||
query += ` LIMIT $${paramIndex++}`;
|
||||
values.push(filters.limit);
|
||||
}
|
||||
|
||||
if (filters.offset) {
|
||||
query += ` OFFSET $${paramIndex++}`;
|
||||
values.push(filters.offset);
|
||||
}
|
||||
|
||||
const result = await db.query<GoalRow>(query, values);
|
||||
|
||||
return {
|
||||
goals: result.rows.map(mapRowToGoal),
|
||||
total,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Update goal
|
||||
*/
|
||||
async update(id: string, input: UpdateGoalInput): Promise<PortfolioGoal | null> {
|
||||
const updates: string[] = [];
|
||||
const values: (string | number | Date | null)[] = [];
|
||||
let paramIndex = 1;
|
||||
|
||||
if (input.name !== undefined) {
|
||||
updates.push(`name = $${paramIndex++}`);
|
||||
values.push(input.name);
|
||||
}
|
||||
|
||||
if (input.description !== undefined) {
|
||||
updates.push(`description = $${paramIndex++}`);
|
||||
values.push(input.description);
|
||||
}
|
||||
|
||||
if (input.targetAmount !== undefined) {
|
||||
updates.push(`target_amount = $${paramIndex++}`);
|
||||
values.push(input.targetAmount);
|
||||
}
|
||||
|
||||
if (input.currentAmount !== undefined) {
|
||||
updates.push(`current_amount = $${paramIndex++}`);
|
||||
values.push(input.currentAmount);
|
||||
}
|
||||
|
||||
if (input.targetDate !== undefined) {
|
||||
updates.push(`target_date = $${paramIndex++}`);
|
||||
values.push(input.targetDate);
|
||||
}
|
||||
|
||||
if (input.monthlyContribution !== undefined) {
|
||||
updates.push(`monthly_contribution = $${paramIndex++}`);
|
||||
values.push(input.monthlyContribution);
|
||||
}
|
||||
|
||||
if (input.portfolioId !== undefined) {
|
||||
updates.push(`portfolio_id = $${paramIndex++}`);
|
||||
values.push(input.portfolioId);
|
||||
}
|
||||
|
||||
if (input.status !== undefined) {
|
||||
updates.push(`status = $${paramIndex++}`);
|
||||
values.push(input.status);
|
||||
}
|
||||
|
||||
if (updates.length === 0) {
|
||||
return this.findById(id);
|
||||
}
|
||||
|
||||
values.push(id);
|
||||
|
||||
const result = await db.query<GoalRow>(
|
||||
`UPDATE portfolio.portfolio_goals
|
||||
SET ${updates.join(', ')}
|
||||
WHERE id = $${paramIndex}
|
||||
RETURNING *`,
|
||||
values
|
||||
);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return mapRowToGoal(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update goal progress
|
||||
*/
|
||||
async updateProgress(id: string, currentAmount: number): Promise<PortfolioGoal | null> {
|
||||
return this.update(id, { currentAmount });
|
||||
}
|
||||
|
||||
/**
|
||||
* Mark goal as completed
|
||||
*/
|
||||
async complete(id: string): Promise<PortfolioGoal | null> {
|
||||
const result = await db.query<GoalRow>(
|
||||
`UPDATE portfolio.portfolio_goals
|
||||
SET status = 'completed', completed_at = NOW()
|
||||
WHERE id = $1 AND status = 'active'
|
||||
RETURNING *`,
|
||||
[id]
|
||||
);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return mapRowToGoal(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Mark goal as abandoned
|
||||
*/
|
||||
async abandon(id: string): Promise<PortfolioGoal | null> {
|
||||
const result = await db.query<GoalRow>(
|
||||
`UPDATE portfolio.portfolio_goals
|
||||
SET status = 'abandoned'
|
||||
WHERE id = $1 AND status = 'active'
|
||||
RETURNING *`,
|
||||
[id]
|
||||
);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return mapRowToGoal(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete goal
|
||||
*/
|
||||
async delete(id: string): Promise<boolean> {
|
||||
const result = await db.query(
|
||||
'DELETE FROM portfolio.portfolio_goals WHERE id = $1',
|
||||
[id]
|
||||
);
|
||||
return (result.rowCount || 0) > 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get goal statistics for user
|
||||
*/
|
||||
async getStatsByUserId(userId: string): Promise<{
|
||||
totalGoals: number;
|
||||
activeGoals: number;
|
||||
completedGoals: number;
|
||||
totalTargetAmount: number;
|
||||
totalCurrentAmount: number;
|
||||
overallProgress: number;
|
||||
}> {
|
||||
const result = await db.query<{
|
||||
total_goals: string;
|
||||
active_goals: string;
|
||||
completed_goals: string;
|
||||
total_target: string;
|
||||
total_current: string;
|
||||
}>(
|
||||
`SELECT
|
||||
COUNT(*) as total_goals,
|
||||
COUNT(*) FILTER (WHERE status = 'active') as active_goals,
|
||||
COUNT(*) FILTER (WHERE status = 'completed') as completed_goals,
|
||||
COALESCE(SUM(target_amount), 0) as total_target,
|
||||
COALESCE(SUM(current_amount), 0) as total_current
|
||||
FROM portfolio.portfolio_goals
|
||||
WHERE user_id = $1`,
|
||||
[userId]
|
||||
);
|
||||
|
||||
const row = result.rows[0];
|
||||
const totalTarget = parseFloat(row.total_target);
|
||||
const totalCurrent = parseFloat(row.total_current);
|
||||
|
||||
return {
|
||||
totalGoals: parseInt(row.total_goals),
|
||||
activeGoals: parseInt(row.active_goals),
|
||||
completedGoals: parseInt(row.completed_goals),
|
||||
totalTargetAmount: totalTarget,
|
||||
totalCurrentAmount: totalCurrent,
|
||||
overallProgress: totalTarget > 0 ? (totalCurrent / totalTarget) * 100 : 0,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Export singleton instance
|
||||
export const goalRepository = new GoalRepository();
|
||||
6
src/modules/portfolio/repositories/index.ts
Normal file
6
src/modules/portfolio/repositories/index.ts
Normal file
@ -0,0 +1,6 @@
|
||||
/**
|
||||
* Portfolio Repositories - Index
|
||||
*/
|
||||
|
||||
export * from './portfolio.repository';
|
||||
export * from './goal.repository';
|
||||
597
src/modules/portfolio/repositories/portfolio.repository.ts
Normal file
597
src/modules/portfolio/repositories/portfolio.repository.ts
Normal file
@ -0,0 +1,597 @@
|
||||
/**
|
||||
* Portfolio Repository
|
||||
* Handles database operations for portfolios and allocations
|
||||
*/
|
||||
|
||||
import { db } from '../../../shared/database';
|
||||
|
||||
// ============================================================================
|
||||
// Types
|
||||
// ============================================================================
|
||||
|
||||
export type RiskProfile = 'conservative' | 'moderate' | 'aggressive';
|
||||
export type AllocationStatus = 'active' | 'inactive' | 'rebalancing';
|
||||
|
||||
export interface PortfolioRow {
|
||||
id: string;
|
||||
user_id: string;
|
||||
name: string;
|
||||
description: string | null;
|
||||
risk_profile: RiskProfile;
|
||||
total_value: string;
|
||||
total_cost: string;
|
||||
unrealized_pnl: string;
|
||||
unrealized_pnl_percent: string;
|
||||
day_change_percent: string | null;
|
||||
week_change_percent: string | null;
|
||||
month_change_percent: string | null;
|
||||
all_time_change_percent: string | null;
|
||||
is_active: boolean;
|
||||
is_primary: boolean;
|
||||
last_rebalanced_at: Date | null;
|
||||
created_at: Date;
|
||||
updated_at: Date;
|
||||
}
|
||||
|
||||
export interface Portfolio {
|
||||
id: string;
|
||||
userId: string;
|
||||
name: string;
|
||||
description: string | null;
|
||||
riskProfile: RiskProfile;
|
||||
totalValue: number;
|
||||
totalCost: number;
|
||||
unrealizedPnl: number;
|
||||
unrealizedPnlPercent: number;
|
||||
dayChangePercent: number;
|
||||
weekChangePercent: number;
|
||||
monthChangePercent: number;
|
||||
allTimeChangePercent: number;
|
||||
isActive: boolean;
|
||||
isPrimary: boolean;
|
||||
lastRebalancedAt: Date | null;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
export interface AllocationRow {
|
||||
id: string;
|
||||
portfolio_id: string;
|
||||
asset: string;
|
||||
target_percent: string;
|
||||
current_percent: string;
|
||||
deviation: string;
|
||||
quantity: string;
|
||||
avg_cost: string;
|
||||
current_price: string;
|
||||
value: string;
|
||||
cost: string;
|
||||
pnl: string;
|
||||
pnl_percent: string;
|
||||
status: AllocationStatus;
|
||||
last_updated_at: Date;
|
||||
created_at: Date;
|
||||
}
|
||||
|
||||
export interface PortfolioAllocation {
|
||||
id: string;
|
||||
portfolioId: string;
|
||||
asset: string;
|
||||
targetPercent: number;
|
||||
currentPercent: number;
|
||||
deviation: number;
|
||||
quantity: number;
|
||||
avgCost: number;
|
||||
currentPrice: number;
|
||||
value: number;
|
||||
cost: number;
|
||||
pnl: number;
|
||||
pnlPercent: number;
|
||||
status: AllocationStatus;
|
||||
lastUpdatedAt: Date;
|
||||
createdAt: Date;
|
||||
}
|
||||
|
||||
export interface CreatePortfolioInput {
|
||||
userId: string;
|
||||
name: string;
|
||||
description?: string;
|
||||
riskProfile: RiskProfile;
|
||||
totalValue?: number;
|
||||
totalCost?: number;
|
||||
isPrimary?: boolean;
|
||||
}
|
||||
|
||||
export interface UpdatePortfolioInput {
|
||||
name?: string;
|
||||
description?: string;
|
||||
riskProfile?: RiskProfile;
|
||||
totalValue?: number;
|
||||
totalCost?: number;
|
||||
unrealizedPnl?: number;
|
||||
unrealizedPnlPercent?: number;
|
||||
dayChangePercent?: number;
|
||||
weekChangePercent?: number;
|
||||
monthChangePercent?: number;
|
||||
allTimeChangePercent?: number;
|
||||
isActive?: boolean;
|
||||
isPrimary?: boolean;
|
||||
lastRebalancedAt?: Date;
|
||||
}
|
||||
|
||||
export interface CreateAllocationInput {
|
||||
portfolioId: string;
|
||||
asset: string;
|
||||
targetPercent: number;
|
||||
currentPercent?: number;
|
||||
quantity?: number;
|
||||
avgCost?: number;
|
||||
currentPrice?: number;
|
||||
value?: number;
|
||||
cost?: number;
|
||||
}
|
||||
|
||||
export interface UpdateAllocationInput {
|
||||
targetPercent?: number;
|
||||
currentPercent?: number;
|
||||
deviation?: number;
|
||||
quantity?: number;
|
||||
avgCost?: number;
|
||||
currentPrice?: number;
|
||||
value?: number;
|
||||
cost?: number;
|
||||
pnl?: number;
|
||||
pnlPercent?: number;
|
||||
status?: AllocationStatus;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Helper Functions
|
||||
// ============================================================================
|
||||
|
||||
function mapRowToPortfolio(row: PortfolioRow): Portfolio {
|
||||
return {
|
||||
id: row.id,
|
||||
userId: row.user_id,
|
||||
name: row.name,
|
||||
description: row.description,
|
||||
riskProfile: row.risk_profile,
|
||||
totalValue: parseFloat(row.total_value || '0'),
|
||||
totalCost: parseFloat(row.total_cost || '0'),
|
||||
unrealizedPnl: parseFloat(row.unrealized_pnl || '0'),
|
||||
unrealizedPnlPercent: parseFloat(row.unrealized_pnl_percent || '0'),
|
||||
dayChangePercent: parseFloat(row.day_change_percent || '0'),
|
||||
weekChangePercent: parseFloat(row.week_change_percent || '0'),
|
||||
monthChangePercent: parseFloat(row.month_change_percent || '0'),
|
||||
allTimeChangePercent: parseFloat(row.all_time_change_percent || '0'),
|
||||
isActive: row.is_active,
|
||||
isPrimary: row.is_primary,
|
||||
lastRebalancedAt: row.last_rebalanced_at,
|
||||
createdAt: row.created_at,
|
||||
updatedAt: row.updated_at,
|
||||
};
|
||||
}
|
||||
|
||||
function mapRowToAllocation(row: AllocationRow): PortfolioAllocation {
|
||||
return {
|
||||
id: row.id,
|
||||
portfolioId: row.portfolio_id,
|
||||
asset: row.asset,
|
||||
targetPercent: parseFloat(row.target_percent || '0'),
|
||||
currentPercent: parseFloat(row.current_percent || '0'),
|
||||
deviation: parseFloat(row.deviation || '0'),
|
||||
quantity: parseFloat(row.quantity || '0'),
|
||||
avgCost: parseFloat(row.avg_cost || '0'),
|
||||
currentPrice: parseFloat(row.current_price || '0'),
|
||||
value: parseFloat(row.value || '0'),
|
||||
cost: parseFloat(row.cost || '0'),
|
||||
pnl: parseFloat(row.pnl || '0'),
|
||||
pnlPercent: parseFloat(row.pnl_percent || '0'),
|
||||
status: row.status,
|
||||
lastUpdatedAt: row.last_updated_at,
|
||||
createdAt: row.created_at,
|
||||
};
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Repository Class
|
||||
// ============================================================================
|
||||
|
||||
class PortfolioRepository {
|
||||
// ==========================================================================
|
||||
// Portfolio CRUD
|
||||
// ==========================================================================
|
||||
|
||||
/**
|
||||
* Create a new portfolio
|
||||
*/
|
||||
async create(input: CreatePortfolioInput): Promise<Portfolio> {
|
||||
const result = await db.query<PortfolioRow>(
|
||||
`INSERT INTO portfolio.portfolios (
|
||||
user_id, name, description, risk_profile, total_value, total_cost, is_primary
|
||||
) VALUES ($1, $2, $3, $4, $5, $6, $7)
|
||||
RETURNING *`,
|
||||
[
|
||||
input.userId,
|
||||
input.name,
|
||||
input.description || null,
|
||||
input.riskProfile,
|
||||
input.totalValue ?? 0,
|
||||
input.totalCost ?? 0,
|
||||
input.isPrimary ?? false,
|
||||
]
|
||||
);
|
||||
|
||||
return mapRowToPortfolio(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find portfolio by ID
|
||||
*/
|
||||
async findById(id: string): Promise<Portfolio | null> {
|
||||
const result = await db.query<PortfolioRow>(
|
||||
'SELECT * FROM portfolio.portfolios WHERE id = $1',
|
||||
[id]
|
||||
);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return mapRowToPortfolio(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find portfolios by user ID
|
||||
*/
|
||||
async findByUserId(userId: string): Promise<Portfolio[]> {
|
||||
const result = await db.query<PortfolioRow>(
|
||||
`SELECT * FROM portfolio.portfolios
|
||||
WHERE user_id = $1 AND is_active = true
|
||||
ORDER BY is_primary DESC, created_at DESC`,
|
||||
[userId]
|
||||
);
|
||||
|
||||
return result.rows.map(mapRowToPortfolio);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find primary portfolio for user
|
||||
*/
|
||||
async findPrimaryByUserId(userId: string): Promise<Portfolio | null> {
|
||||
const result = await db.query<PortfolioRow>(
|
||||
`SELECT * FROM portfolio.portfolios
|
||||
WHERE user_id = $1 AND is_primary = true AND is_active = true`,
|
||||
[userId]
|
||||
);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return mapRowToPortfolio(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update portfolio
|
||||
*/
|
||||
async update(id: string, input: UpdatePortfolioInput): Promise<Portfolio | null> {
|
||||
const updates: string[] = [];
|
||||
const values: (string | number | boolean | Date | null)[] = [];
|
||||
let paramIndex = 1;
|
||||
|
||||
if (input.name !== undefined) {
|
||||
updates.push(`name = $${paramIndex++}`);
|
||||
values.push(input.name);
|
||||
}
|
||||
|
||||
if (input.description !== undefined) {
|
||||
updates.push(`description = $${paramIndex++}`);
|
||||
values.push(input.description);
|
||||
}
|
||||
|
||||
if (input.riskProfile !== undefined) {
|
||||
updates.push(`risk_profile = $${paramIndex++}`);
|
||||
values.push(input.riskProfile);
|
||||
}
|
||||
|
||||
if (input.totalValue !== undefined) {
|
||||
updates.push(`total_value = $${paramIndex++}`);
|
||||
values.push(input.totalValue);
|
||||
}
|
||||
|
||||
if (input.totalCost !== undefined) {
|
||||
updates.push(`total_cost = $${paramIndex++}`);
|
||||
values.push(input.totalCost);
|
||||
}
|
||||
|
||||
if (input.unrealizedPnl !== undefined) {
|
||||
updates.push(`unrealized_pnl = $${paramIndex++}`);
|
||||
values.push(input.unrealizedPnl);
|
||||
}
|
||||
|
||||
if (input.unrealizedPnlPercent !== undefined) {
|
||||
updates.push(`unrealized_pnl_percent = $${paramIndex++}`);
|
||||
values.push(input.unrealizedPnlPercent);
|
||||
}
|
||||
|
||||
if (input.dayChangePercent !== undefined) {
|
||||
updates.push(`day_change_percent = $${paramIndex++}`);
|
||||
values.push(input.dayChangePercent);
|
||||
}
|
||||
|
||||
if (input.weekChangePercent !== undefined) {
|
||||
updates.push(`week_change_percent = $${paramIndex++}`);
|
||||
values.push(input.weekChangePercent);
|
||||
}
|
||||
|
||||
if (input.monthChangePercent !== undefined) {
|
||||
updates.push(`month_change_percent = $${paramIndex++}`);
|
||||
values.push(input.monthChangePercent);
|
||||
}
|
||||
|
||||
if (input.allTimeChangePercent !== undefined) {
|
||||
updates.push(`all_time_change_percent = $${paramIndex++}`);
|
||||
values.push(input.allTimeChangePercent);
|
||||
}
|
||||
|
||||
if (input.isActive !== undefined) {
|
||||
updates.push(`is_active = $${paramIndex++}`);
|
||||
values.push(input.isActive);
|
||||
}
|
||||
|
||||
if (input.isPrimary !== undefined) {
|
||||
updates.push(`is_primary = $${paramIndex++}`);
|
||||
values.push(input.isPrimary);
|
||||
}
|
||||
|
||||
if (input.lastRebalancedAt !== undefined) {
|
||||
updates.push(`last_rebalanced_at = $${paramIndex++}`);
|
||||
values.push(input.lastRebalancedAt);
|
||||
}
|
||||
|
||||
if (updates.length === 0) {
|
||||
return this.findById(id);
|
||||
}
|
||||
|
||||
values.push(id);
|
||||
|
||||
const result = await db.query<PortfolioRow>(
|
||||
`UPDATE portfolio.portfolios
|
||||
SET ${updates.join(', ')}
|
||||
WHERE id = $${paramIndex}
|
||||
RETURNING *`,
|
||||
values
|
||||
);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return mapRowToPortfolio(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Deactivate portfolio
|
||||
*/
|
||||
async deactivate(id: string): Promise<Portfolio | null> {
|
||||
return this.update(id, { isActive: false });
|
||||
}
|
||||
|
||||
// ==========================================================================
|
||||
// Allocation CRUD
|
||||
// ==========================================================================
|
||||
|
||||
/**
|
||||
* Create allocation
|
||||
*/
|
||||
async createAllocation(input: CreateAllocationInput): Promise<PortfolioAllocation> {
|
||||
const result = await db.query<AllocationRow>(
|
||||
`INSERT INTO portfolio.portfolio_allocations (
|
||||
portfolio_id, asset, target_percent, current_percent, quantity,
|
||||
avg_cost, current_price, value, cost
|
||||
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
|
||||
RETURNING *`,
|
||||
[
|
||||
input.portfolioId,
|
||||
input.asset,
|
||||
input.targetPercent,
|
||||
input.currentPercent ?? 0,
|
||||
input.quantity ?? 0,
|
||||
input.avgCost ?? 0,
|
||||
input.currentPrice ?? 0,
|
||||
input.value ?? 0,
|
||||
input.cost ?? 0,
|
||||
]
|
||||
);
|
||||
|
||||
return mapRowToAllocation(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create multiple allocations
|
||||
*/
|
||||
async createAllocations(allocations: CreateAllocationInput[]): Promise<PortfolioAllocation[]> {
|
||||
if (allocations.length === 0) return [];
|
||||
|
||||
const values: (string | number)[] = [];
|
||||
const placeholders: string[] = [];
|
||||
let paramIndex = 1;
|
||||
|
||||
for (const input of allocations) {
|
||||
placeholders.push(
|
||||
`($${paramIndex++}, $${paramIndex++}, $${paramIndex++}, $${paramIndex++}, $${paramIndex++}, $${paramIndex++}, $${paramIndex++}, $${paramIndex++}, $${paramIndex++})`
|
||||
);
|
||||
values.push(
|
||||
input.portfolioId,
|
||||
input.asset,
|
||||
input.targetPercent,
|
||||
input.currentPercent ?? 0,
|
||||
input.quantity ?? 0,
|
||||
input.avgCost ?? 0,
|
||||
input.currentPrice ?? 0,
|
||||
input.value ?? 0,
|
||||
input.cost ?? 0
|
||||
);
|
||||
}
|
||||
|
||||
const result = await db.query<AllocationRow>(
|
||||
`INSERT INTO portfolio.portfolio_allocations (
|
||||
portfolio_id, asset, target_percent, current_percent, quantity,
|
||||
avg_cost, current_price, value, cost
|
||||
) VALUES ${placeholders.join(', ')}
|
||||
RETURNING *`,
|
||||
values
|
||||
);
|
||||
|
||||
return result.rows.map(mapRowToAllocation);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find allocations by portfolio ID
|
||||
*/
|
||||
async findAllocationsByPortfolioId(portfolioId: string): Promise<PortfolioAllocation[]> {
|
||||
const result = await db.query<AllocationRow>(
|
||||
`SELECT * FROM portfolio.portfolio_allocations
|
||||
WHERE portfolio_id = $1 AND status = 'active'
|
||||
ORDER BY target_percent DESC`,
|
||||
[portfolioId]
|
||||
);
|
||||
|
||||
return result.rows.map(mapRowToAllocation);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find allocation by ID
|
||||
*/
|
||||
async findAllocationById(id: string): Promise<PortfolioAllocation | null> {
|
||||
const result = await db.query<AllocationRow>(
|
||||
'SELECT * FROM portfolio.portfolio_allocations WHERE id = $1',
|
||||
[id]
|
||||
);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return mapRowToAllocation(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update allocation
|
||||
*/
|
||||
async updateAllocation(id: string, input: UpdateAllocationInput): Promise<PortfolioAllocation | null> {
|
||||
const updates: string[] = [];
|
||||
const values: (string | number | null)[] = [];
|
||||
let paramIndex = 1;
|
||||
|
||||
if (input.targetPercent !== undefined) {
|
||||
updates.push(`target_percent = $${paramIndex++}`);
|
||||
values.push(input.targetPercent);
|
||||
}
|
||||
|
||||
if (input.currentPercent !== undefined) {
|
||||
updates.push(`current_percent = $${paramIndex++}`);
|
||||
values.push(input.currentPercent);
|
||||
}
|
||||
|
||||
if (input.deviation !== undefined) {
|
||||
updates.push(`deviation = $${paramIndex++}`);
|
||||
values.push(input.deviation);
|
||||
}
|
||||
|
||||
if (input.quantity !== undefined) {
|
||||
updates.push(`quantity = $${paramIndex++}`);
|
||||
values.push(input.quantity);
|
||||
}
|
||||
|
||||
if (input.avgCost !== undefined) {
|
||||
updates.push(`avg_cost = $${paramIndex++}`);
|
||||
values.push(input.avgCost);
|
||||
}
|
||||
|
||||
if (input.currentPrice !== undefined) {
|
||||
updates.push(`current_price = $${paramIndex++}`);
|
||||
values.push(input.currentPrice);
|
||||
}
|
||||
|
||||
if (input.value !== undefined) {
|
||||
updates.push(`value = $${paramIndex++}`);
|
||||
values.push(input.value);
|
||||
}
|
||||
|
||||
if (input.cost !== undefined) {
|
||||
updates.push(`cost = $${paramIndex++}`);
|
||||
values.push(input.cost);
|
||||
}
|
||||
|
||||
if (input.pnl !== undefined) {
|
||||
updates.push(`pnl = $${paramIndex++}`);
|
||||
values.push(input.pnl);
|
||||
}
|
||||
|
||||
if (input.pnlPercent !== undefined) {
|
||||
updates.push(`pnl_percent = $${paramIndex++}`);
|
||||
values.push(input.pnlPercent);
|
||||
}
|
||||
|
||||
if (input.status !== undefined) {
|
||||
updates.push(`status = $${paramIndex++}`);
|
||||
values.push(input.status);
|
||||
}
|
||||
|
||||
if (updates.length === 0) {
|
||||
return this.findAllocationById(id);
|
||||
}
|
||||
|
||||
updates.push(`last_updated_at = NOW()`);
|
||||
values.push(id);
|
||||
|
||||
const result = await db.query<AllocationRow>(
|
||||
`UPDATE portfolio.portfolio_allocations
|
||||
SET ${updates.join(', ')}
|
||||
WHERE id = $${paramIndex}
|
||||
RETURNING *`,
|
||||
values
|
||||
);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return mapRowToAllocation(result.rows[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete allocations by portfolio ID
|
||||
*/
|
||||
async deleteAllocationsByPortfolioId(portfolioId: string): Promise<number> {
|
||||
const result = await db.query(
|
||||
'DELETE FROM portfolio.portfolio_allocations WHERE portfolio_id = $1',
|
||||
[portfolioId]
|
||||
);
|
||||
return result.rowCount || 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Update allocations to inactive and create new ones
|
||||
*/
|
||||
async replaceAllocations(
|
||||
portfolioId: string,
|
||||
allocations: CreateAllocationInput[]
|
||||
): Promise<PortfolioAllocation[]> {
|
||||
// Mark existing as inactive
|
||||
await db.query(
|
||||
`UPDATE portfolio.portfolio_allocations
|
||||
SET status = 'inactive'
|
||||
WHERE portfolio_id = $1 AND status = 'active'`,
|
||||
[portfolioId]
|
||||
);
|
||||
|
||||
// Create new allocations
|
||||
return this.createAllocations(allocations);
|
||||
}
|
||||
}
|
||||
|
||||
// Export singleton instance
|
||||
export const portfolioRepository = new PortfolioRepository();
|
||||
@ -1,10 +1,22 @@
|
||||
/**
|
||||
* Portfolio Service
|
||||
* Manages user portfolios, allocations, and rebalancing
|
||||
*
|
||||
* Supports both PostgreSQL repository and in-memory fallback
|
||||
*/
|
||||
|
||||
import { v4 as uuidv4 } from 'uuid';
|
||||
import { marketService } from '../../trading/services/market.service';
|
||||
import {
|
||||
portfolioRepository,
|
||||
Portfolio as RepoPortfolio,
|
||||
PortfolioAllocation as RepoAllocation,
|
||||
RiskProfile as RepoRiskProfile,
|
||||
} from '../repositories/portfolio.repository';
|
||||
import {
|
||||
goalRepository,
|
||||
PortfolioGoal as RepoGoal,
|
||||
} from '../repositories/goal.repository';
|
||||
|
||||
// ============================================================================
|
||||
// Types
|
||||
@ -109,7 +121,75 @@ const DEFAULT_ALLOCATIONS: Record<RiskProfile, { asset: string; percent: number
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// In-Memory Storage
|
||||
// Helper Functions for Repository Mapping
|
||||
// ============================================================================
|
||||
|
||||
function mapRepoPortfolioToService(
|
||||
repo: RepoPortfolio,
|
||||
allocations: RepoAllocation[]
|
||||
): Portfolio {
|
||||
return {
|
||||
id: repo.id,
|
||||
userId: repo.userId,
|
||||
name: repo.name,
|
||||
riskProfile: repo.riskProfile as RiskProfile,
|
||||
allocations: allocations.map(mapRepoAllocationToService),
|
||||
totalValue: repo.totalValue,
|
||||
totalCost: repo.totalCost,
|
||||
unrealizedPnl: repo.unrealizedPnl,
|
||||
unrealizedPnlPercent: repo.unrealizedPnlPercent,
|
||||
realizedPnl: 0, // Not stored in DB yet
|
||||
lastRebalanced: repo.lastRebalancedAt,
|
||||
createdAt: repo.createdAt,
|
||||
updatedAt: repo.updatedAt,
|
||||
};
|
||||
}
|
||||
|
||||
function mapRepoAllocationToService(repo: RepoAllocation): PortfolioAllocation {
|
||||
return {
|
||||
id: repo.id,
|
||||
portfolioId: repo.portfolioId,
|
||||
asset: repo.asset,
|
||||
targetPercent: repo.targetPercent,
|
||||
currentPercent: repo.currentPercent,
|
||||
quantity: repo.quantity,
|
||||
value: repo.value,
|
||||
cost: repo.cost,
|
||||
pnl: repo.pnl,
|
||||
pnlPercent: repo.pnlPercent,
|
||||
deviation: repo.deviation,
|
||||
};
|
||||
}
|
||||
|
||||
function mapRepoGoalToService(repo: RepoGoal): PortfolioGoal {
|
||||
// Map DB status to service status
|
||||
let status: 'on_track' | 'at_risk' | 'behind' = 'on_track';
|
||||
if (repo.status === 'completed') {
|
||||
status = 'on_track';
|
||||
} else if (repo.progress < 50 && repo.monthsRemaining && repo.monthsRemaining < 6) {
|
||||
status = 'behind';
|
||||
} else if (repo.progress < 75 && repo.monthsRemaining && repo.monthsRemaining < 3) {
|
||||
status = 'at_risk';
|
||||
}
|
||||
|
||||
return {
|
||||
id: repo.id,
|
||||
userId: repo.userId,
|
||||
name: repo.name,
|
||||
targetAmount: repo.targetAmount,
|
||||
currentAmount: repo.currentAmount,
|
||||
targetDate: repo.targetDate,
|
||||
monthlyContribution: repo.monthlyContribution,
|
||||
progress: repo.progress,
|
||||
projectedCompletion: repo.projectedCompletionDate,
|
||||
status,
|
||||
createdAt: repo.createdAt,
|
||||
updatedAt: repo.updatedAt,
|
||||
};
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// In-Memory Storage (fallback)
|
||||
// ============================================================================
|
||||
|
||||
const portfolios: Map<string, Portfolio> = new Map();
|
||||
@ -120,6 +200,8 @@ const goals: Map<string, PortfolioGoal> = new Map();
|
||||
// ============================================================================
|
||||
|
||||
class PortfolioService {
|
||||
private useDatabase = true; // Toggle for DB vs in-memory
|
||||
|
||||
// ==========================================================================
|
||||
// Portfolio Management
|
||||
// ==========================================================================
|
||||
@ -135,6 +217,35 @@ class PortfolioService {
|
||||
): Promise<Portfolio> {
|
||||
const defaultAllocations = DEFAULT_ALLOCATIONS[riskProfile];
|
||||
|
||||
if (this.useDatabase) {
|
||||
try {
|
||||
// Create portfolio in DB
|
||||
const repoPortfolio = await portfolioRepository.create({
|
||||
userId,
|
||||
name,
|
||||
riskProfile: riskProfile as RepoRiskProfile,
|
||||
totalValue: initialValue,
|
||||
totalCost: initialValue,
|
||||
});
|
||||
|
||||
// Create allocations
|
||||
const repoAllocations = await portfolioRepository.createAllocations(
|
||||
defaultAllocations.map((a) => ({
|
||||
portfolioId: repoPortfolio.id,
|
||||
asset: a.asset,
|
||||
targetPercent: a.percent,
|
||||
currentPercent: a.percent,
|
||||
value: (initialValue * a.percent) / 100,
|
||||
cost: (initialValue * a.percent) / 100,
|
||||
}))
|
||||
);
|
||||
|
||||
return mapRepoPortfolioToService(repoPortfolio, repoAllocations);
|
||||
} catch {
|
||||
// Fall back to in-memory on DB error
|
||||
}
|
||||
}
|
||||
|
||||
const portfolio: Portfolio = {
|
||||
id: uuidv4(),
|
||||
userId,
|
||||
@ -176,6 +287,20 @@ class PortfolioService {
|
||||
* Get portfolio by ID
|
||||
*/
|
||||
async getPortfolio(portfolioId: string): Promise<Portfolio | null> {
|
||||
if (this.useDatabase) {
|
||||
try {
|
||||
const repoPortfolio = await portfolioRepository.findById(portfolioId);
|
||||
if (repoPortfolio) {
|
||||
const repoAllocations = await portfolioRepository.findAllocationsByPortfolioId(portfolioId);
|
||||
const portfolio = mapRepoPortfolioToService(repoPortfolio, repoAllocations);
|
||||
await this.updatePortfolioValues(portfolio);
|
||||
return portfolio;
|
||||
}
|
||||
} catch {
|
||||
// Fall back to in-memory on DB error
|
||||
}
|
||||
}
|
||||
|
||||
const portfolio = portfolios.get(portfolioId);
|
||||
if (!portfolio) return null;
|
||||
|
||||
@ -189,6 +314,24 @@ class PortfolioService {
|
||||
* Get user portfolios
|
||||
*/
|
||||
async getUserPortfolios(userId: string): Promise<Portfolio[]> {
|
||||
if (this.useDatabase) {
|
||||
try {
|
||||
const repoPortfolios = await portfolioRepository.findByUserId(userId);
|
||||
if (repoPortfolios.length > 0) {
|
||||
const portfolioList: Portfolio[] = [];
|
||||
for (const repo of repoPortfolios) {
|
||||
const allocations = await portfolioRepository.findAllocationsByPortfolioId(repo.id);
|
||||
const portfolio = mapRepoPortfolioToService(repo, allocations);
|
||||
await this.updatePortfolioValues(portfolio);
|
||||
portfolioList.push(portfolio);
|
||||
}
|
||||
return portfolioList;
|
||||
}
|
||||
} catch {
|
||||
// Fall back to in-memory on DB error
|
||||
}
|
||||
}
|
||||
|
||||
const userPortfolios = Array.from(portfolios.values())
|
||||
.filter((p) => p.userId === userId);
|
||||
|
||||
@ -205,17 +348,40 @@ class PortfolioService {
|
||||
portfolioId: string,
|
||||
allocations: { asset: string; targetPercent: number }[]
|
||||
): Promise<Portfolio> {
|
||||
const portfolio = portfolios.get(portfolioId);
|
||||
if (!portfolio) {
|
||||
throw new Error(`Portfolio not found: ${portfolioId}`);
|
||||
}
|
||||
|
||||
// Validate total is 100%
|
||||
const total = allocations.reduce((sum, a) => sum + a.targetPercent, 0);
|
||||
if (Math.abs(total - 100) > 0.01) {
|
||||
throw new Error('Allocations must sum to 100%');
|
||||
}
|
||||
|
||||
if (this.useDatabase) {
|
||||
try {
|
||||
const repoPortfolio = await portfolioRepository.findById(portfolioId);
|
||||
if (repoPortfolio) {
|
||||
// Replace allocations in DB
|
||||
const repoAllocations = await portfolioRepository.replaceAllocations(
|
||||
portfolioId,
|
||||
allocations.map((a) => ({
|
||||
portfolioId,
|
||||
asset: a.asset,
|
||||
targetPercent: a.targetPercent,
|
||||
}))
|
||||
);
|
||||
|
||||
const portfolio = mapRepoPortfolioToService(repoPortfolio, repoAllocations);
|
||||
await this.updatePortfolioValues(portfolio);
|
||||
return portfolio;
|
||||
}
|
||||
} catch {
|
||||
// Fall back to in-memory on DB error
|
||||
}
|
||||
}
|
||||
|
||||
const portfolio = portfolios.get(portfolioId);
|
||||
if (!portfolio) {
|
||||
throw new Error(`Portfolio not found: ${portfolioId}`);
|
||||
}
|
||||
|
||||
// Update allocations
|
||||
portfolio.allocations = allocations.map((a) => {
|
||||
const existing = portfolio.allocations.find((e) => e.asset === a.asset);
|
||||
@ -308,6 +474,26 @@ class PortfolioService {
|
||||
portfolio.lastRebalanced = new Date();
|
||||
portfolio.updatedAt = new Date();
|
||||
|
||||
if (this.useDatabase) {
|
||||
try {
|
||||
// Update portfolio last rebalanced
|
||||
await portfolioRepository.update(portfolioId, {
|
||||
lastRebalancedAt: new Date(),
|
||||
});
|
||||
|
||||
// Update allocations to match targets
|
||||
const repoAllocations = await portfolioRepository.findAllocationsByPortfolioId(portfolioId);
|
||||
for (const alloc of repoAllocations) {
|
||||
await portfolioRepository.updateAllocation(alloc.id, {
|
||||
currentPercent: alloc.targetPercent,
|
||||
deviation: 0,
|
||||
});
|
||||
}
|
||||
} catch {
|
||||
// Continue with in-memory state
|
||||
}
|
||||
}
|
||||
|
||||
return portfolio;
|
||||
}
|
||||
|
||||
@ -365,6 +551,21 @@ class PortfolioService {
|
||||
targetDate: Date,
|
||||
monthlyContribution: number
|
||||
): Promise<PortfolioGoal> {
|
||||
if (this.useDatabase) {
|
||||
try {
|
||||
const repoGoal = await goalRepository.create({
|
||||
userId,
|
||||
name,
|
||||
targetAmount,
|
||||
targetDate,
|
||||
monthlyContribution,
|
||||
});
|
||||
return mapRepoGoalToService(repoGoal);
|
||||
} catch {
|
||||
// Fall back to in-memory on DB error
|
||||
}
|
||||
}
|
||||
|
||||
const goal: PortfolioGoal = {
|
||||
id: uuidv4(),
|
||||
userId,
|
||||
@ -390,6 +591,17 @@ class PortfolioService {
|
||||
* Get user goals
|
||||
*/
|
||||
async getUserGoals(userId: string): Promise<PortfolioGoal[]> {
|
||||
if (this.useDatabase) {
|
||||
try {
|
||||
const repoGoals = await goalRepository.findByUserId(userId);
|
||||
if (repoGoals.length > 0) {
|
||||
return repoGoals.map(mapRepoGoalToService);
|
||||
}
|
||||
} catch {
|
||||
// Fall back to in-memory on DB error
|
||||
}
|
||||
}
|
||||
|
||||
return Array.from(goals.values())
|
||||
.filter((g) => g.userId === userId)
|
||||
.map((g) => {
|
||||
@ -405,6 +617,17 @@ class PortfolioService {
|
||||
goalId: string,
|
||||
currentAmount: number
|
||||
): Promise<PortfolioGoal> {
|
||||
if (this.useDatabase) {
|
||||
try {
|
||||
const repoGoal = await goalRepository.updateProgress(goalId, currentAmount);
|
||||
if (repoGoal) {
|
||||
return mapRepoGoalToService(repoGoal);
|
||||
}
|
||||
} catch {
|
||||
// Fall back to in-memory on DB error
|
||||
}
|
||||
}
|
||||
|
||||
const goal = goals.get(goalId);
|
||||
if (!goal) {
|
||||
throw new Error(`Goal not found: ${goalId}`);
|
||||
@ -423,6 +646,17 @@ class PortfolioService {
|
||||
* Delete a goal
|
||||
*/
|
||||
async deleteGoal(goalId: string): Promise<boolean> {
|
||||
if (this.useDatabase) {
|
||||
try {
|
||||
const deleted = await goalRepository.delete(goalId);
|
||||
if (deleted) {
|
||||
return true;
|
||||
}
|
||||
} catch {
|
||||
// Fall back to in-memory on DB error
|
||||
}
|
||||
}
|
||||
|
||||
return goals.delete(goalId);
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user