Create index.js

index.js

@@ -0,0 +1,198 @@
+require('dotenv').config();
+const express = require('express');
+const mongoose = require('mongoose');
+const OpenAI = require('openai');
+
+const { MONGO_URI, OPENAI_API_KEY, PORT = 3000 } = process.env;
+
+if (!MONGO_URI) {
+  throw new Error('MONGO_URI missing in environment variables');
+}
+
+if (!OPENAI_API_KEY) {
+  throw new Error('OPENAI_API_KEY missing in environment variables');
+}
+
+const openai = new OpenAI({ apiKey: OPENAI_API_KEY });
+const app = express();
+app.use(express.json());
+
+mongoose
+  .connect(MONGO_URI)
+  .then(() => {
+    console.log('MongoDB connected');
+  })
+  .catch((error) => {
+    console.error('Mongo connection error', error);
+    process.exit(1);
+  });
+
+const BudgetSchema = new mongoose.Schema(
+  {
+    name: String,
+    status: String,
+    createdBy: { type: mongoose.Schema.Types.ObjectId, required: true },
+    period: String,
+    maxAmount: Number,
+    spendAmount: Number,
+    remainingAmount: Number,
+    notifications: [String],
+    rollover: mongoose.Schema.Types.Mixed,
+    headCategories: mongoose.Schema.Types.Mixed,
+  },
+  {
+    collection: 'budgets',
+    strict: false,
+  }
+);
+
+const Budget = mongoose.model('Budget', BudgetSchema);
+
+const TransactionSchema = new mongoose.Schema(
+  {
+    user: { type: mongoose.Schema.Types.ObjectId, required: true },
+    type: String,
+    amount: Number,
+    date: Date,
+  },
+  {
+    collection: 'transactions',
+    strict: false,
+  }
+);
+
+const Transaction = mongoose.model('Transaction', TransactionSchema);
+
+const scorePrompt = (budgets, transactions) => {
+  const normalizedBudgets = budgets.map((budget) => ({
+    name: budget.name,
+    status: budget.status,
+    period: budget.period,
+    maxAmount: budget.maxAmount,
+    spendAmount: budget.spendAmount,
+    remainingAmount: budget.remainingAmount,
+    rollover: budget.rollover,
+    notifications: budget.notifications,
+    headCategories: Array.isArray(budget.headCategories)
+      ? budget.headCategories.map((head) => ({
+          spendLimitType: head.spendLimitType,
+          spendAmount: head.spendAmount,
+          maxAmount: head.maxAmount,
+          remainingAmount: head.remainingAmount,
+          notifications: head.notifications,
+        }))
+      : [],
+  }));
+
+  const trimmedTransactions = transactions.map((txn) => ({
+    type: txn.type,
+    amount: txn.amount,
+    date: txn.date ? new Date(txn.date).toISOString().split('T')[0] : null,
+  }));
+
+  return `
+You are a financial wellness expert. Using any available budgets and recent transactions below, rate the user's financial health on a scale of 0-100 (0 = critical, 100 = excellent). Budgets or transactions may be empty; rely on whichever data is present.
+
+Budgets:
+${JSON.stringify(normalizedBudgets, null, 2)}
+
+Transactions (last 30 days):
+${JSON.stringify(trimmedTransactions, null, 2)}
+
+Consider utilization versus limits, warning notifications, rollover behavior, and transaction-level cash flow trends. Respond ONLY with valid JSON in the form {"score": number, "explanation": "text"} with score rounded to the nearest integer.
+`;
+};
+
+app.get('/', (_, res) => {
+  res.json({ status: 'Financial Health Score service is running' });
+});
+
+app.post('/financial-score', async (req, res) => {
+  const { userId } = req.body;
+
+  if (!userId) {
+    return res.status(400).json({ error: 'userId is required in the request body' });
+  }
+
+  let createdBy;
+  try {
+    createdBy = new mongoose.Types.ObjectId(userId);
+  } catch (error) {
+    return res.status(400).json({ error: 'userId must be a valid Mongo ObjectId' });
+  }
+
+  try {
+    const budgets = await Budget.find({ createdBy }).lean();
+
+    const thirtyDaysAgo = new Date();
+    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+    const transactions = await Transaction.find({
+      user: createdBy,
+      date: { $gte: thirtyDaysAgo },
+    })
+      .sort({ date: -1 })
+      .limit(100)
+      .lean();
+
+    if (!budgets.length && !transactions.length) {
+      return res.json({
+        userId,
+        score: 0,
+        explanation: "You haven't used the app yet.\nNo budgets or transactions were found to score.",
+      });
+    }
+
+    const response = await openai.responses.create({
+      model: 'gpt-4o-mini',
+      input: scorePrompt(budgets, transactions),
+      temperature: 0.6,
+    });
+
+    const modelOutput =
+      response.output?.[0]?.content?.[0]?.text || response.output?.[0]?.content || '';
+
+    const extractJson = (text) => {
+      const trimmed = (text || '').trim();
+      const fenceMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+      const candidate = fenceMatch ? fenceMatch[1].trim() : trimmed;
+      return JSON.parse(candidate);
+    };
+
+    let parsed;
+    try {
+      parsed = extractJson(modelOutput);
+    } catch (error) {
+      return res.status(502).json({
+        error: 'Unable to parse OpenAI response',
+        rawResponse: modelOutput,
+      });
+    }
+
+    if (typeof parsed.score !== 'number' || !parsed.explanation) {
+      return res.status(502).json({
+        error: 'OpenAI response missing score or explanation',
+        rawResponse: modelOutput,
+      });
+    }
+
+    const explanationSentences = parsed.explanation
+      .replace(/\s+/g, ' ')
+      .split(/(?<=\.)\s+/)
+      .filter(Boolean)
+      .slice(0, 2);
+
+    return res.json({
+      userId,
+      score: Math.max(0, Math.min(100, Math.round(parsed.score))),
+      explanation: explanationSentences.join('\\n') || parsed.explanation,
+    });
+  } catch (error) {
+    console.error('Error generating financial score', error);
+    return res.status(500).json({ error: 'Failed to generate financial score' });
+  }
+});
+
+app.listen(PORT, () => {
+  console.log(`Server is running on port ${PORT}`);
+});