Kevin O'Neill
f8b464feec
- Fixed player seek flicker on podcasts (30s skip buttons) - Added dual-layer seek lock mechanism to prevent stale time updates - Optimized cached podcast seeking (direct seek before reload fallback) - Large skips now execute immediately for responsive feel - Mood mix performance optimizations
627 lines
21 KiB
TypeScript
627 lines
21 KiB
TypeScript
/**
|
|
* Mood Bucket Service
|
|
*
|
|
* Handles pre-computed mood assignments for fast mood mix generation.
|
|
* Tracks are assigned to mood buckets during audio analysis, enabling
|
|
* instant mood mix generation through simple database lookups.
|
|
*/
|
|
|
|
import { prisma } from "../utils/db";
|
|
|
|
// Mood configuration with scoring rules
|
|
// Primary = uses ML mood predictions (enhanced mode)
|
|
// Fallback = uses basic audio features (standard mode)
|
|
export const MOOD_CONFIG = {
|
|
happy: {
|
|
name: "Happy & Upbeat",
|
|
color: "from-yellow-400 to-orange-500",
|
|
icon: "Smile",
|
|
// Primary: ML mood prediction
|
|
primary: { moodHappy: { min: 0.5 }, moodSad: { max: 0.4 } },
|
|
// Fallback: basic audio features
|
|
fallback: { valence: { min: 0.6 }, energy: { min: 0.5 } },
|
|
},
|
|
sad: {
|
|
name: "Melancholic",
|
|
color: "from-blue-600 to-indigo-700",
|
|
icon: "CloudRain",
|
|
primary: { moodSad: { min: 0.5 }, moodHappy: { max: 0.4 } },
|
|
fallback: { valence: { max: 0.35 }, keyScale: "minor" },
|
|
},
|
|
chill: {
|
|
name: "Chill & Relaxed",
|
|
color: "from-teal-400 to-cyan-500",
|
|
icon: "Wind",
|
|
primary: { moodRelaxed: { min: 0.5 }, moodAggressive: { max: 0.3 } },
|
|
fallback: { energy: { max: 0.5 }, arousal: { max: 0.5 } },
|
|
},
|
|
energetic: {
|
|
name: "High Energy",
|
|
color: "from-red-500 to-orange-600",
|
|
icon: "Zap",
|
|
primary: { arousal: { min: 0.6 }, energy: { min: 0.7 } },
|
|
fallback: { bpm: { min: 120 }, energy: { min: 0.7 } },
|
|
},
|
|
party: {
|
|
name: "Dance Party",
|
|
color: "from-pink-500 to-rose-600",
|
|
icon: "PartyPopper",
|
|
primary: { moodParty: { min: 0.5 }, danceability: { min: 0.6 } },
|
|
fallback: { danceability: { min: 0.7 }, energy: { min: 0.6 } },
|
|
},
|
|
focus: {
|
|
name: "Focus Mode",
|
|
color: "from-purple-600 to-violet-700",
|
|
icon: "Brain",
|
|
primary: { instrumentalness: { min: 0.5 }, moodRelaxed: { min: 0.3 } },
|
|
fallback: {
|
|
instrumentalness: { min: 0.5 },
|
|
energy: { min: 0.2, max: 0.6 },
|
|
},
|
|
},
|
|
melancholy: {
|
|
name: "Deep Feels",
|
|
color: "from-gray-700 to-slate-800",
|
|
icon: "Moon",
|
|
primary: { moodSad: { min: 0.4 }, valence: { max: 0.4 } },
|
|
fallback: { valence: { max: 0.35 }, keyScale: "minor" },
|
|
},
|
|
aggressive: {
|
|
name: "Intense",
|
|
color: "from-red-700 to-gray-900",
|
|
icon: "Flame",
|
|
primary: { moodAggressive: { min: 0.5 } },
|
|
fallback: { energy: { min: 0.8 }, arousal: { min: 0.7 } },
|
|
},
|
|
acoustic: {
|
|
name: "Acoustic Vibes",
|
|
color: "from-amber-500 to-yellow-600",
|
|
icon: "Guitar",
|
|
primary: { moodAcoustic: { min: 0.5 }, moodElectronic: { max: 0.4 } },
|
|
fallback: {
|
|
acousticness: { min: 0.6 },
|
|
energy: { min: 0.3, max: 0.6 },
|
|
},
|
|
},
|
|
} as const;
|
|
|
|
export type MoodType = keyof typeof MOOD_CONFIG;
|
|
export const VALID_MOODS = Object.keys(MOOD_CONFIG) as MoodType[];
|
|
|
|
// Mood gradient colors for mix display
|
|
const MOOD_GRADIENTS: Record<MoodType, string> = {
|
|
happy: "linear-gradient(to bottom, rgba(217, 119, 6, 0.5), rgba(161, 98, 7, 0.4), rgba(68, 64, 60, 0.4))",
|
|
sad: "linear-gradient(to bottom, rgba(30, 58, 138, 0.6), rgba(88, 28, 135, 0.5), rgba(15, 23, 42, 0.4))",
|
|
chill: "linear-gradient(to bottom, rgba(17, 94, 89, 0.6), rgba(22, 78, 99, 0.5), rgba(15, 23, 42, 0.4))",
|
|
energetic:
|
|
"linear-gradient(to bottom, rgba(153, 27, 27, 0.6), rgba(124, 45, 18, 0.5), rgba(68, 64, 60, 0.4))",
|
|
party: "linear-gradient(to bottom, rgba(162, 28, 175, 0.6), rgba(131, 24, 67, 0.5), rgba(59, 7, 100, 0.4))",
|
|
focus: "linear-gradient(to bottom, rgba(91, 33, 182, 0.6), rgba(88, 28, 135, 0.5), rgba(15, 23, 42, 0.4))",
|
|
melancholy:
|
|
"linear-gradient(to bottom, rgba(51, 65, 85, 0.6), rgba(30, 58, 138, 0.5), rgba(17, 24, 39, 0.4))",
|
|
aggressive:
|
|
"linear-gradient(to bottom, rgba(69, 10, 10, 0.7), rgba(17, 24, 39, 0.6), rgba(0, 0, 0, 0.5))",
|
|
acoustic:
|
|
"linear-gradient(to bottom, rgba(146, 64, 14, 0.6), rgba(124, 45, 18, 0.5), rgba(68, 64, 60, 0.4))",
|
|
};
|
|
|
|
interface TrackWithAnalysis {
|
|
id: string;
|
|
analysisMode: string | null;
|
|
moodHappy: number | null;
|
|
moodSad: number | null;
|
|
moodRelaxed: number | null;
|
|
moodAggressive: number | null;
|
|
moodParty: number | null;
|
|
moodAcoustic: number | null;
|
|
moodElectronic: number | null;
|
|
valence: number | null;
|
|
energy: number | null;
|
|
arousal: number | null;
|
|
danceability: number | null;
|
|
acousticness: number | null;
|
|
instrumentalness: number | null;
|
|
bpm: number | null;
|
|
keyScale: string | null;
|
|
}
|
|
|
|
export class MoodBucketService {
|
|
/**
|
|
* Calculate mood scores for a track and assign to appropriate buckets
|
|
* Called after audio analysis completes
|
|
* Returns array of mood names the track was assigned to
|
|
*/
|
|
async assignTrackToMoods(trackId: string): Promise<string[]> {
|
|
const track = await prisma.track.findUnique({
|
|
where: { id: trackId },
|
|
select: {
|
|
id: true,
|
|
analysisStatus: true,
|
|
analysisMode: true,
|
|
moodHappy: true,
|
|
moodSad: true,
|
|
moodRelaxed: true,
|
|
moodAggressive: true,
|
|
moodParty: true,
|
|
moodAcoustic: true,
|
|
moodElectronic: true,
|
|
valence: true,
|
|
energy: true,
|
|
arousal: true,
|
|
danceability: true,
|
|
acousticness: true,
|
|
instrumentalness: true,
|
|
bpm: true,
|
|
keyScale: true,
|
|
},
|
|
});
|
|
|
|
if (!track || track.analysisStatus !== "completed") {
|
|
console.log(
|
|
`[MoodBucket] Track ${trackId} not analyzed yet, skipping`
|
|
);
|
|
return [];
|
|
}
|
|
|
|
const moodScores = this.calculateMoodScores(track);
|
|
|
|
// Upsert mood bucket entries for each mood with score > 0
|
|
const upsertPromises = Object.entries(moodScores)
|
|
.filter(([_, score]) => score > 0)
|
|
.map(([mood, score]) =>
|
|
prisma.moodBucket.upsert({
|
|
where: {
|
|
trackId_mood: { trackId, mood },
|
|
},
|
|
create: {
|
|
trackId,
|
|
mood,
|
|
score,
|
|
},
|
|
update: {
|
|
score,
|
|
},
|
|
})
|
|
);
|
|
|
|
// Also delete mood buckets where score dropped to 0
|
|
const deletePromises = Object.entries(moodScores)
|
|
.filter(([_, score]) => score === 0)
|
|
.map(([mood]) =>
|
|
prisma.moodBucket.deleteMany({
|
|
where: { trackId, mood },
|
|
})
|
|
);
|
|
|
|
await Promise.all([...upsertPromises, ...deletePromises]);
|
|
|
|
const assignedMoods = Object.entries(moodScores)
|
|
.filter(([_, score]) => score > 0)
|
|
.map(([mood]) => mood);
|
|
|
|
console.log(
|
|
`[MoodBucket] Track ${trackId} assigned to moods: ${
|
|
assignedMoods.join(", ") || "none"
|
|
}`
|
|
);
|
|
|
|
return assignedMoods;
|
|
}
|
|
|
|
/**
|
|
* Calculate mood scores for a track based on its audio features
|
|
* Returns a score 0-1 for each mood (0 = not matching, 1 = perfect match)
|
|
*/
|
|
calculateMoodScores(track: TrackWithAnalysis): Record<MoodType, number> {
|
|
const isEnhanced = track.analysisMode === "enhanced";
|
|
const scores: Record<MoodType, number> = {
|
|
happy: 0,
|
|
sad: 0,
|
|
chill: 0,
|
|
energetic: 0,
|
|
party: 0,
|
|
focus: 0,
|
|
melancholy: 0,
|
|
aggressive: 0,
|
|
acoustic: 0,
|
|
};
|
|
|
|
for (const [mood, config] of Object.entries(MOOD_CONFIG)) {
|
|
const rules = isEnhanced ? config.primary : config.fallback;
|
|
const score = this.evaluateMoodRules(track, rules);
|
|
scores[mood as MoodType] = score;
|
|
}
|
|
|
|
return scores;
|
|
}
|
|
|
|
/**
|
|
* Evaluate mood rules against track features
|
|
* Returns a score 0-1 based on how well the track matches the rules
|
|
*/
|
|
private evaluateMoodRules(
|
|
track: TrackWithAnalysis,
|
|
rules: Record<string, any>
|
|
): number {
|
|
let totalScore = 0;
|
|
let ruleCount = 0;
|
|
|
|
for (const [field, constraints] of Object.entries(rules)) {
|
|
const value = track[field as keyof TrackWithAnalysis];
|
|
|
|
// Skip if value is null
|
|
if (value === null || value === undefined) {
|
|
continue;
|
|
}
|
|
|
|
ruleCount++;
|
|
|
|
// Handle string equality (e.g., keyScale: "minor")
|
|
if (typeof constraints === "string") {
|
|
totalScore += value === constraints ? 1 : 0;
|
|
continue;
|
|
}
|
|
|
|
// Handle numeric range constraints
|
|
const numValue = value as number;
|
|
const { min, max } = constraints as { min?: number; max?: number };
|
|
|
|
// Calculate how well the value matches the constraint
|
|
let fieldScore = 0;
|
|
|
|
if (min !== undefined && max !== undefined) {
|
|
// Range constraint - value should be between min and max
|
|
if (numValue >= min && numValue <= max) {
|
|
// Perfect match in range
|
|
fieldScore = 1;
|
|
} else if (numValue < min) {
|
|
// Below range - linearly decrease score
|
|
fieldScore = Math.max(0, 1 - (min - numValue) * 2);
|
|
} else {
|
|
// Above range - linearly decrease score
|
|
fieldScore = Math.max(0, 1 - (numValue - max) * 2);
|
|
}
|
|
} else if (min !== undefined) {
|
|
// Minimum constraint - higher is better
|
|
if (numValue >= min) {
|
|
// Score increases with value above threshold
|
|
fieldScore = Math.min(1, 0.5 + (numValue - min) * 0.5);
|
|
} else {
|
|
// Below minimum - partial credit
|
|
fieldScore = Math.max(0, (numValue / min) * 0.5);
|
|
}
|
|
} else if (max !== undefined) {
|
|
// Maximum constraint - lower is better
|
|
if (numValue <= max) {
|
|
// Score increases as value decreases below threshold
|
|
fieldScore = Math.min(1, 0.5 + (max - numValue) * 0.5);
|
|
} else {
|
|
// Above maximum - partial credit
|
|
fieldScore = Math.max(
|
|
0,
|
|
((1 - numValue) / (1 - max)) * 0.5
|
|
);
|
|
}
|
|
}
|
|
|
|
totalScore += fieldScore;
|
|
}
|
|
|
|
// No rules matched (missing data)
|
|
if (ruleCount === 0) return 0;
|
|
|
|
// Average score across all rules, with minimum threshold
|
|
const avgScore = totalScore / ruleCount;
|
|
|
|
// Only assign to mood if score is above 0.5 threshold
|
|
return avgScore >= 0.5 ? avgScore : 0;
|
|
}
|
|
|
|
/**
|
|
* Get mood presets with track counts for the UI
|
|
*/
|
|
async getMoodPresets(): Promise<
|
|
{
|
|
id: string;
|
|
name: string;
|
|
color: string;
|
|
icon: string;
|
|
trackCount: number;
|
|
}[]
|
|
> {
|
|
// Count tracks per mood in parallel
|
|
const countPromises = VALID_MOODS.map(async (mood) => {
|
|
const count = await prisma.moodBucket.count({
|
|
where: { mood, score: { gte: 0.5 } },
|
|
});
|
|
const config = MOOD_CONFIG[mood];
|
|
return {
|
|
id: mood,
|
|
name: config.name,
|
|
color: config.color,
|
|
icon: config.icon,
|
|
trackCount: count,
|
|
};
|
|
});
|
|
|
|
return Promise.all(countPromises);
|
|
}
|
|
|
|
/**
|
|
* Get a mood mix for a specific mood
|
|
* Fast lookup from pre-computed MoodBucket table
|
|
*/
|
|
async getMoodMix(
|
|
mood: MoodType,
|
|
limit: number = 15
|
|
): Promise<{
|
|
id: string;
|
|
mood: string;
|
|
name: string;
|
|
description: string;
|
|
trackIds: string[];
|
|
coverUrls: string[];
|
|
trackCount: number;
|
|
color: string;
|
|
} | null> {
|
|
if (!VALID_MOODS.includes(mood)) {
|
|
throw new Error(`Invalid mood: ${mood}`);
|
|
}
|
|
|
|
const config = MOOD_CONFIG[mood];
|
|
|
|
// Get top tracks for this mood, randomly sampled
|
|
// First get IDs with high scores, then randomly select
|
|
const moodBuckets = await prisma.moodBucket.findMany({
|
|
where: { mood, score: { gte: 0.5 } },
|
|
select: { trackId: true, score: true },
|
|
orderBy: { score: "desc" },
|
|
take: 100, // Pool to sample from
|
|
});
|
|
|
|
if (moodBuckets.length < 8) {
|
|
console.log(
|
|
`[MoodBucket] Not enough tracks for mood ${mood}: ${moodBuckets.length}`
|
|
);
|
|
return null;
|
|
}
|
|
|
|
// Randomly sample from the pool
|
|
const shuffled = [...moodBuckets].sort(() => Math.random() - 0.5);
|
|
const selectedIds = shuffled.slice(0, limit).map((b) => b.trackId);
|
|
|
|
// Get cover URLs for the selected tracks
|
|
const tracks = await prisma.track.findMany({
|
|
where: { id: { in: selectedIds } },
|
|
select: {
|
|
id: true,
|
|
album: { select: { coverUrl: true } },
|
|
},
|
|
});
|
|
|
|
// Preserve order of selectedIds
|
|
const orderedTracks = selectedIds
|
|
.map((id) => tracks.find((t) => t.id === id))
|
|
.filter(Boolean);
|
|
const coverUrls = orderedTracks
|
|
.filter((t) => t?.album.coverUrl)
|
|
.slice(0, 4)
|
|
.map((t) => t!.album.coverUrl!);
|
|
|
|
const timestamp = Date.now();
|
|
return {
|
|
id: `mood-${mood}-${timestamp}`,
|
|
mood,
|
|
name: `${config.name} Mix`,
|
|
description: `Tracks that match your ${config.name.toLowerCase()} vibe`,
|
|
trackIds: orderedTracks.map((t) => t!.id),
|
|
coverUrls,
|
|
trackCount: orderedTracks.length,
|
|
color: MOOD_GRADIENTS[mood],
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Save a mood mix as the user's active mood mix
|
|
* Returns the saved mix for immediate UI update
|
|
*/
|
|
async saveUserMoodMix(
|
|
userId: string,
|
|
mood: MoodType,
|
|
limit: number = 15
|
|
): Promise<{
|
|
id: string;
|
|
mood: string;
|
|
name: string;
|
|
description: string;
|
|
trackIds: string[];
|
|
coverUrls: string[];
|
|
trackCount: number;
|
|
color: string;
|
|
generatedAt: string;
|
|
} | null> {
|
|
// Generate a fresh mix
|
|
const mix = await this.getMoodMix(mood, limit);
|
|
if (!mix) return null;
|
|
|
|
const config = MOOD_CONFIG[mood];
|
|
const generatedAt = new Date();
|
|
|
|
// Upsert the user's mood mix
|
|
await prisma.userMoodMix.upsert({
|
|
where: { userId },
|
|
create: {
|
|
userId,
|
|
mood,
|
|
trackIds: mix.trackIds,
|
|
coverUrls: mix.coverUrls,
|
|
generatedAt,
|
|
},
|
|
update: {
|
|
mood,
|
|
trackIds: mix.trackIds,
|
|
coverUrls: mix.coverUrls,
|
|
generatedAt,
|
|
},
|
|
});
|
|
|
|
console.log(
|
|
`[MoodBucket] Saved ${mood} mix for user ${userId} (${mix.trackCount} tracks)`
|
|
);
|
|
|
|
// Return with user-specific naming
|
|
return {
|
|
id: `your-mood-mix-${generatedAt.getTime()}`,
|
|
mood,
|
|
name: `Your ${config.name} Mix`,
|
|
description: `Based on your ${config.name.toLowerCase()} preferences`,
|
|
trackIds: mix.trackIds,
|
|
coverUrls: mix.coverUrls,
|
|
trackCount: mix.trackCount,
|
|
color: MOOD_GRADIENTS[mood],
|
|
generatedAt: generatedAt.toISOString(),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get user's current saved mood mix for display on home page
|
|
*/
|
|
async getUserMoodMix(userId: string): Promise<{
|
|
id: string;
|
|
type: string;
|
|
mood: string;
|
|
name: string;
|
|
description: string;
|
|
trackIds: string[];
|
|
coverUrls: string[];
|
|
trackCount: number;
|
|
color: string;
|
|
} | null> {
|
|
const userMix = await prisma.userMoodMix.findUnique({
|
|
where: { userId },
|
|
});
|
|
|
|
if (!userMix) return null;
|
|
|
|
const mood = userMix.mood as MoodType;
|
|
if (!VALID_MOODS.includes(mood)) return null;
|
|
|
|
const config = MOOD_CONFIG[mood];
|
|
|
|
return {
|
|
id: `your-mood-mix-${userMix.generatedAt.getTime()}`,
|
|
type: "mood",
|
|
mood,
|
|
name: `Your ${config.name} Mix`,
|
|
description: `Based on your ${config.name.toLowerCase()} preferences`,
|
|
trackIds: userMix.trackIds,
|
|
coverUrls: userMix.coverUrls,
|
|
trackCount: userMix.trackIds.length,
|
|
color: MOOD_GRADIENTS[mood],
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Backfill mood buckets for all analyzed tracks
|
|
* Used for initial population or after schema changes
|
|
*/
|
|
async backfillAllTracks(
|
|
batchSize: number = 100
|
|
): Promise<{ processed: number; assigned: number }> {
|
|
let processed = 0;
|
|
let assigned = 0;
|
|
let skip = 0;
|
|
|
|
console.log("[MoodBucket] Starting backfill of all analyzed tracks...");
|
|
|
|
while (true) {
|
|
const tracks = await prisma.track.findMany({
|
|
where: { analysisStatus: "completed" },
|
|
select: {
|
|
id: true,
|
|
analysisMode: true,
|
|
moodHappy: true,
|
|
moodSad: true,
|
|
moodRelaxed: true,
|
|
moodAggressive: true,
|
|
moodParty: true,
|
|
moodAcoustic: true,
|
|
moodElectronic: true,
|
|
valence: true,
|
|
energy: true,
|
|
arousal: true,
|
|
danceability: true,
|
|
acousticness: true,
|
|
instrumentalness: true,
|
|
bpm: true,
|
|
keyScale: true,
|
|
},
|
|
skip,
|
|
take: batchSize,
|
|
});
|
|
|
|
if (tracks.length === 0) break;
|
|
|
|
for (const track of tracks) {
|
|
const moodScores = this.calculateMoodScores(track);
|
|
const moodsToAssign = Object.entries(moodScores)
|
|
.filter(([_, score]) => score > 0)
|
|
.map(([mood, score]) => ({
|
|
trackId: track.id,
|
|
mood,
|
|
score,
|
|
}));
|
|
|
|
if (moodsToAssign.length > 0) {
|
|
// Use upsert for each mood
|
|
await Promise.all(
|
|
moodsToAssign.map((data) =>
|
|
prisma.moodBucket.upsert({
|
|
where: {
|
|
trackId_mood: {
|
|
trackId: data.trackId,
|
|
mood: data.mood,
|
|
},
|
|
},
|
|
create: {
|
|
trackId: data.trackId,
|
|
mood: data.mood,
|
|
score: data.score,
|
|
},
|
|
update: {
|
|
score: data.score,
|
|
},
|
|
})
|
|
)
|
|
);
|
|
assigned += moodsToAssign.length;
|
|
}
|
|
|
|
processed++;
|
|
}
|
|
|
|
skip += batchSize;
|
|
console.log(
|
|
`[MoodBucket] Backfill progress: ${processed} tracks processed, ${assigned} mood assignments`
|
|
);
|
|
}
|
|
|
|
console.log(
|
|
`[MoodBucket] Backfill complete: ${processed} tracks processed, ${assigned} mood assignments`
|
|
);
|
|
return { processed, assigned };
|
|
}
|
|
|
|
/**
|
|
* Clear all mood bucket data for a track
|
|
* Used when a track is re-analyzed
|
|
*/
|
|
async clearTrackMoods(trackId: string): Promise<void> {
|
|
await prisma.moodBucket.deleteMany({
|
|
where: { trackId },
|
|
});
|
|
}
|
|
}
|
|
|
|
export const moodBucketService = new MoodBucketService();
|