615 lines
19 KiB
TypeScript
615 lines
19 KiB
TypeScript
// src/lib/services/contract.service.ts
|
|
|
|
import { prisma } from "@/lib/db/prisma";
|
|
import { auth } from "@clerk/nextjs/server";
|
|
import { UTApi } from "uploadthing/server";
|
|
import type {
|
|
ContractFilters,
|
|
ContractStats,
|
|
ContractStatus,
|
|
ContractType,
|
|
} from "@/types/contract.types";
|
|
import { revalidatePath } from "next/cache";
|
|
import { NotificationService } from "@/lib/services/notification.service";
|
|
|
|
const utapi = new UTApi();
|
|
|
|
export async function saveContract(data: {
|
|
fileName: string;
|
|
fileUrl: string;
|
|
fileSize: number;
|
|
mimeType: string;
|
|
}) {
|
|
try {
|
|
const { userId } = await auth();
|
|
if (!userId) {
|
|
return { success: false, error: "Unauthorized" };
|
|
}
|
|
|
|
// Step 1: Create contract record (status: UPLOADED)
|
|
const contract = await ContractService.create({
|
|
...data,
|
|
userId,
|
|
});
|
|
|
|
// Keep uploaded contracts pending until the user manually clicks Analyze.
|
|
// Status stays as UPLOADED here.
|
|
|
|
revalidatePath("/contacts");
|
|
revalidatePath("/dashboard");
|
|
|
|
return {
|
|
success: true,
|
|
contract: {
|
|
id: contract.id,
|
|
fileName: contract.fileName,
|
|
fileUrl: contract.fileUrl,
|
|
status: contract.status,
|
|
},
|
|
};
|
|
} catch (error: unknown) {
|
|
console.error("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
|
|
console.error("❌ SAVE CONTRACT ERROR");
|
|
console.error("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
|
|
console.error(error);
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : "Unknown error",
|
|
};
|
|
}
|
|
}
|
|
|
|
export class ContractService {
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// CREATE CONTRACT
|
|
// Called after UploadThing upload completes
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async create(data: {
|
|
fileName: string;
|
|
fileUrl: string;
|
|
fileSize: number;
|
|
mimeType: string;
|
|
userId: string; // This is Clerk userId (clerkId)
|
|
}) {
|
|
// Find the internal database user by Clerk ID
|
|
const user = await prisma.user.findUnique({
|
|
where: { clerkId: data.userId },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new Error("User not found");
|
|
}
|
|
|
|
return await prisma.contract.create({
|
|
data: {
|
|
fileName: data.fileName,
|
|
fileUrl: data.fileUrl,
|
|
fileSize: data.fileSize,
|
|
mimeType: data.mimeType,
|
|
userId: user.id, // Use internal database User.id
|
|
status: "UPLOADED",
|
|
},
|
|
});
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// UPDATE WITH AI RESULTS
|
|
// Called after AI processing completes (Sprint 2)
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async updateWithAIResults(
|
|
id: string,
|
|
aiResults: {
|
|
title: string;
|
|
type: ContractType;
|
|
provider?: string;
|
|
policyNumber?: string;
|
|
startDate?: string | Date;
|
|
endDate?: string | Date;
|
|
premium?: number;
|
|
extractedText: string;
|
|
summary: string;
|
|
keyPoints: Record<string, unknown>;
|
|
},
|
|
) {
|
|
// Convert date strings to proper ISO-8601 DateTime format
|
|
const parseDate = (dateInput: string | Date | undefined): Date | null => {
|
|
if (!dateInput) return null;
|
|
|
|
if (dateInput instanceof Date) {
|
|
return dateInput;
|
|
}
|
|
|
|
// If it's a date string (YYYY-MM-DD), convert to ISO DateTime
|
|
if (typeof dateInput === "string") {
|
|
const date = new Date(`${dateInput}T00:00:00Z`);
|
|
return isNaN(date.getTime()) ? null : date;
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
const contract = await prisma.contract.update({
|
|
where: { id },
|
|
data: {
|
|
title: aiResults.title,
|
|
type: aiResults.type,
|
|
provider: aiResults.provider,
|
|
policyNumber: aiResults.policyNumber,
|
|
startDate: parseDate(aiResults.startDate),
|
|
endDate: parseDate(aiResults.endDate),
|
|
premium: aiResults.premium,
|
|
extractedText: aiResults.extractedText,
|
|
summary: aiResults.summary,
|
|
keyPoints: JSON.parse(JSON.stringify(aiResults.keyPoints)),
|
|
status: "COMPLETED",
|
|
},
|
|
});
|
|
|
|
// Check for upcoming deadlines after contract is completed
|
|
try {
|
|
const user = await prisma.user.findUnique({
|
|
where: { id: contract.userId },
|
|
select: { id: true },
|
|
});
|
|
|
|
if (user) {
|
|
await NotificationService.checkUpcomingDeadlines(user.id);
|
|
}
|
|
} catch (error) {
|
|
console.warn("Failed to check upcoming deadlines:", error);
|
|
// Don't fail the contract update if deadline check fails
|
|
}
|
|
|
|
return contract;
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// UPDATE STATUS
|
|
// Used during processing pipeline
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async updateStatus(id: string, status: ContractStatus) {
|
|
return await prisma.contract.update({
|
|
where: { id },
|
|
data: { status },
|
|
});
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// MARK FAILED WITH REASON
|
|
// Store user-visible reason in summary for failed analyses
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async markFailed(id: string, reason: string) {
|
|
const safeReason = reason.trim().slice(0, 900);
|
|
return await prisma.contract.update({
|
|
where: { id },
|
|
data: {
|
|
status: "FAILED",
|
|
summary: safeReason || "Analysis failed. Please try again.",
|
|
},
|
|
});
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// GET ALL CONTRACTS
|
|
// With optional filtering and search
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async getAll(filters?: ContractFilters) {
|
|
const { userId: clerkUserId } = await auth();
|
|
if (!clerkUserId) throw new Error("Unauthorized");
|
|
|
|
// Find the internal database user by Clerk ID
|
|
const user = await prisma.user.findUnique({
|
|
where: { clerkId: clerkUserId },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new Error("User not found");
|
|
}
|
|
|
|
interface WhereClause {
|
|
userId: string;
|
|
type?: ContractType;
|
|
status?: ContractStatus;
|
|
OR?: Array<{
|
|
title?: { contains: string; mode: "insensitive" };
|
|
provider?: { contains: string; mode: "insensitive" };
|
|
policyNumber?: { contains: string; mode: "insensitive" };
|
|
fileName?: { contains: string; mode: "insensitive" };
|
|
}>;
|
|
}
|
|
|
|
const where: WhereClause = { userId: user.id };
|
|
|
|
// Filter by type
|
|
if (filters?.type) {
|
|
where.type = filters.type;
|
|
}
|
|
|
|
// Filter by status
|
|
if (filters?.status) {
|
|
where.status = filters.status;
|
|
}
|
|
|
|
// Search across title, provider, policy number
|
|
if (filters?.search) {
|
|
where.OR = [
|
|
{ title: { contains: filters.search, mode: "insensitive" } },
|
|
{ provider: { contains: filters.search, mode: "insensitive" } },
|
|
{ policyNumber: { contains: filters.search, mode: "insensitive" } },
|
|
{ fileName: { contains: filters.search, mode: "insensitive" } },
|
|
];
|
|
}
|
|
|
|
return await prisma.contract.findMany({
|
|
where,
|
|
orderBy: { createdAt: "desc" },
|
|
include: {
|
|
user: {
|
|
select: {
|
|
firstName: true,
|
|
lastName: true,
|
|
email: true,
|
|
},
|
|
},
|
|
_count: {
|
|
select: {
|
|
ragChunks: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// GET SINGLE CONTRACT
|
|
// With authorization check
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async getById(id: string) {
|
|
const { userId: clerkUserId } = await auth();
|
|
if (!clerkUserId) throw new Error("Unauthorized");
|
|
|
|
// Find the internal database user by Clerk ID
|
|
const user = await prisma.user.findUnique({
|
|
where: { clerkId: clerkUserId },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new Error("User not found");
|
|
}
|
|
|
|
const contract = await prisma.contract.findUnique({
|
|
where: { id },
|
|
include: {
|
|
user: {
|
|
select: {
|
|
id: true,
|
|
clerkId: true,
|
|
firstName: true,
|
|
lastName: true,
|
|
email: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (!contract) {
|
|
throw new Error("Contract not found");
|
|
}
|
|
|
|
if (contract.userId !== user.id) {
|
|
throw new Error("Unauthorized to access this contract");
|
|
}
|
|
|
|
return contract;
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// DELETE CONTRACT
|
|
// With authorization check and UploadThing file deletion
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async delete(id: string) {
|
|
const { userId: clerkUserId } = await auth();
|
|
if (!clerkUserId) throw new Error("Unauthorized");
|
|
|
|
// Verify ownership and get contract details
|
|
const contract = await this.getById(id);
|
|
|
|
// Extract file key from UploadThing URL
|
|
// URL format: https://utfs.io/f/{fileKey}
|
|
const fileKey = this.extractFileKeyFromUrl(contract.fileUrl);
|
|
|
|
// Delete file from UploadThing storage
|
|
if (fileKey) {
|
|
try {
|
|
await utapi.deleteFiles(fileKey);
|
|
} catch (error) {
|
|
console.error("Failed to delete file from UploadThing:", error);
|
|
// Continue with database deletion even if UploadThing deletion fails
|
|
}
|
|
}
|
|
|
|
// Delete contract record from database
|
|
return await prisma.contract.delete({
|
|
where: { id },
|
|
});
|
|
}
|
|
|
|
static async deleteAllForUser(userId: string): Promise<number> {
|
|
const contracts = await prisma.contract.findMany({
|
|
where: { userId },
|
|
select: {
|
|
id: true,
|
|
fileUrl: true,
|
|
},
|
|
});
|
|
|
|
if (contracts.length === 0) {
|
|
return 0;
|
|
}
|
|
|
|
const fileKeys = contracts
|
|
.map((contract) => this.extractFileKeyFromUrl(contract.fileUrl))
|
|
.filter((value): value is string => Boolean(value));
|
|
|
|
if (fileKeys.length > 0) {
|
|
try {
|
|
await utapi.deleteFiles(fileKeys);
|
|
} catch (error) {
|
|
console.error("Failed to bulk delete files from UploadThing:", error);
|
|
}
|
|
}
|
|
|
|
const deleted = await prisma.contract.deleteMany({
|
|
where: { userId },
|
|
});
|
|
|
|
return deleted.count;
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// HELPER: Extract file key from UploadThing URL
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
private static extractFileKeyFromUrl(url: string): string | null {
|
|
try {
|
|
// UploadThing URL format: https://utfs.io/f/{fileKey}
|
|
const urlObj = new URL(url);
|
|
const pathParts = urlObj.pathname.split("/");
|
|
// Get the last part which is the file key
|
|
const fileKey = pathParts[pathParts.length - 1];
|
|
return fileKey || null;
|
|
} catch (error) {
|
|
console.error("Failed to extract file key from URL:", error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// GET STATISTICS
|
|
// Dashboard stats: total, active, expired, expiring soon
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async getStats(): Promise<ContractStats> {
|
|
const { userId: clerkUserId } = await auth();
|
|
if (!clerkUserId) throw new Error("Unauthorized");
|
|
|
|
// Find the internal database user by Clerk ID
|
|
const user = await prisma.user.findUnique({
|
|
where: { clerkId: clerkUserId },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new Error("User not found");
|
|
}
|
|
|
|
const now = new Date();
|
|
const thirtyDaysFromNow = new Date(
|
|
now.getTime() + 30 * 24 * 60 * 60 * 1000,
|
|
);
|
|
|
|
const [total, active, expired, expiringSoon] = await Promise.all([
|
|
// Total contracts
|
|
prisma.contract.count({
|
|
where: { userId: user.id },
|
|
}),
|
|
|
|
// Active (completed and not expired)
|
|
prisma.contract.count({
|
|
where: {
|
|
userId: user.id,
|
|
status: "COMPLETED",
|
|
OR: [
|
|
{ endDate: { gte: now } },
|
|
{ endDate: null }, // No end date
|
|
],
|
|
},
|
|
}),
|
|
|
|
// Expired (end date in the past)
|
|
prisma.contract.count({
|
|
where: {
|
|
userId: user.id,
|
|
endDate: {
|
|
lt: now,
|
|
not: null,
|
|
},
|
|
},
|
|
}),
|
|
|
|
// Expiring in next 30 days
|
|
prisma.contract.count({
|
|
where: {
|
|
userId: user.id,
|
|
endDate: {
|
|
gte: now,
|
|
lte: thirtyDaysFromNow,
|
|
},
|
|
},
|
|
}),
|
|
]);
|
|
|
|
return { total, active, expired, expiringSoon };
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// GET EXPIRING CONTRACTS
|
|
// Get contracts expiring within X days
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async getExpiring(daysAhead: number = 30) {
|
|
const { userId: clerkUserId } = await auth();
|
|
if (!clerkUserId) throw new Error("Unauthorized");
|
|
|
|
const user = await prisma.user.findUnique({
|
|
where: { clerkId: clerkUserId },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new Error("User not found");
|
|
}
|
|
|
|
const now = new Date();
|
|
const futureDate = new Date(
|
|
now.getTime() + daysAhead * 24 * 60 * 60 * 1000,
|
|
);
|
|
|
|
return await prisma.contract.findMany({
|
|
where: {
|
|
userId: user.id,
|
|
status: "COMPLETED",
|
|
endDate: {
|
|
gte: now,
|
|
lte: futureDate,
|
|
},
|
|
},
|
|
orderBy: {
|
|
endDate: "asc",
|
|
},
|
|
});
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// GET CONTRACTS BY TYPE
|
|
// Group contracts by type for analytics
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async getByType() {
|
|
const { userId: clerkUserId } = await auth();
|
|
if (!clerkUserId) throw new Error("Unauthorized");
|
|
|
|
const user = await prisma.user.findUnique({
|
|
where: { clerkId: clerkUserId },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new Error("User not found");
|
|
}
|
|
|
|
const contracts = await prisma.contract.groupBy({
|
|
by: ["type"],
|
|
where: { userId: user.id },
|
|
_count: {
|
|
type: true,
|
|
},
|
|
});
|
|
|
|
return contracts.map((item) => ({
|
|
type: item.type,
|
|
count: item._count.type,
|
|
}));
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// CHECK IF USER OWNS CONTRACT
|
|
// Quick ownership check (used for authorization)
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async isOwner(contractId: string, userId: string): Promise<boolean> {
|
|
const contract = await prisma.contract.findUnique({
|
|
where: { id: contractId },
|
|
select: { userId: true },
|
|
});
|
|
|
|
return contract?.userId === userId;
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// GET RECENT CONTRACTS
|
|
// For dashboard "recent activity"
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async getRecent(limit: number = 5) {
|
|
const { userId: clerkUserId } = await auth();
|
|
if (!clerkUserId) throw new Error("Unauthorized");
|
|
|
|
const user = await prisma.user.findUnique({
|
|
where: { clerkId: clerkUserId },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new Error("User not found");
|
|
}
|
|
|
|
return await prisma.contract.findMany({
|
|
where: { userId: user.id },
|
|
orderBy: { createdAt: "desc" },
|
|
take: limit,
|
|
select: {
|
|
id: true,
|
|
title: true,
|
|
fileName: true,
|
|
type: true,
|
|
status: true,
|
|
createdAt: true,
|
|
},
|
|
});
|
|
}
|
|
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// UPDATE PARTIAL
|
|
// Update specific fields (useful for editing)
|
|
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
static async updatePartial(
|
|
id: string,
|
|
data: {
|
|
title?: string;
|
|
type?: ContractType;
|
|
provider?: string;
|
|
policyNumber?: string;
|
|
startDate?: Date;
|
|
endDate?: Date;
|
|
premium?: number;
|
|
},
|
|
) {
|
|
const { userId } = await auth();
|
|
if (!userId) throw new Error("Unauthorized");
|
|
|
|
// Verify ownership
|
|
await this.getById(id);
|
|
|
|
return await prisma.contract.update({
|
|
where: { id },
|
|
data,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get user by Clerk ID
|
|
*
|
|
* Used to retrieve internal database user ID from Clerk authentication ID
|
|
* This is necessary because:
|
|
* - Clerk returns clerkId after authentication
|
|
* - Database stores internal User.id (CUID)
|
|
* - Contract operations need the internal User.id
|
|
*
|
|
* @param clerkId - Clerk authentication user ID
|
|
* @returns Internal database User object or null if not found
|
|
*/
|
|
static async getUserByClerkId(clerkId: string) {
|
|
return await prisma.user.findUnique({
|
|
where: { clerkId },
|
|
select: {
|
|
id: true,
|
|
clerkId: true,
|
|
email: true,
|
|
firstName: true,
|
|
lastName: true,
|
|
},
|
|
});
|
|
}
|
|
}
|