create-crm-tmp 1.1.3 → 2.1.0

package/template/src/app/api/jobs/google-sheet/process/route.ts

@@ -0,0 +1,84 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { runGoogleSheetSync } from '@/lib/google-sheet-sync-runner';
+import { QstashAuthError, verifyQstashRequest } from '@/lib/qstash';
+
+export async function POST(request: NextRequest) {
+  let bodyText = '';
+  let parsedJobId: string | null = null;
+  try {
+    bodyText = await request.text();
+    const signature = request.headers.get('upstash-signature');
+    await verifyQstashRequest(signature, bodyText);
+
+    const body = JSON.parse(bodyText) as { jobId?: string };
+    const jobId = body.jobId;
+    parsedJobId = jobId ?? null;
+    if (!jobId) {
+      return NextResponse.json({ error: 'jobId manquant' }, { status: 400 });
+    }
+
+    const claimed = await prisma.googleSheetSyncJob.updateMany({
+      where: {
+        id: jobId,
+        status: 'QUEUED',
+      },
+      data: {
+        status: 'RUNNING',
+        startedAt: new Date(),
+      },
+    });
+
+    if (claimed.count === 0) {
+      return NextResponse.json({ ok: true, skipped: true });
+    }
+
+    const job = await prisma.googleSheetSyncJob.findUnique({
+      where: { id: jobId },
+      select: { requestedByUserId: true, configId: true },
+    });
+    if (!job) {
+      return NextResponse.json({ error: 'Job introuvable' }, { status: 404 });
+    }
+
+    const result = await runGoogleSheetSync({
+      sessionUserId: job.requestedByUserId,
+      requestedConfigId: job.configId ?? undefined,
+    });
+
+    await prisma.googleSheetSyncJob.update({
+      where: { id: jobId },
+      data: {
+        status: 'SUCCEEDED',
+        finishedAt: new Date(),
+        result: result as object,
+      },
+    });
+
+    return NextResponse.json({ ok: true });
+  } catch (error: any) {
+    if (error instanceof QstashAuthError) {
+      return NextResponse.json({ error: 'Signature QStash invalide' }, { status: 401 });
+    }
+    console.error('Erreur worker Google Sheet:', error);
+    try {
+      if (!parsedJobId && bodyText) {
+        const parsed = JSON.parse(bodyText) as { jobId?: string };
+        parsedJobId = parsed.jobId ?? null;
+      }
+      if (parsedJobId) {
+        await prisma.googleSheetSyncJob.update({
+          where: { id: parsedJobId },
+          data: {
+            status: 'FAILED',
+            finishedAt: new Date(),
+            error: error?.message || 'Erreur worker',
+          },
+        });
+      }
+    } catch {
+      // ignore
+    }
+    return NextResponse.json({ error: 'Erreur worker' }, { status: 500 });
+  }
+}

package/template/src/app/api/jobs/google-sheet/schedule/route.ts

@@ -0,0 +1,50 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { enqueueGoogleSheetSyncJob } from '@/lib/google-sheet-sync-jobs';
+import { QstashAuthError, verifyQstashRequest } from '@/lib/qstash';
+
+/**
+ * Déclenchement planifié de la synchro Google Sheets.
+ *
+ * - Planification : **Upstash QStash Schedule** en `POST` avec header `upstash-signature` (corps signé).
+ * - Optionnel : déclenchement manuel / secours avec `Authorization: Bearer <CRON_SECRET>` (`CRON_SECRET` sur l’hébergeur).
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const cronSecret = process.env.CRON_SECRET;
+    const authHeader = request.headers.get('authorization');
+    const expectedBearer = cronSecret ? `Bearer ${cronSecret}` : null;
+    const isVercelCron =
+      Boolean(expectedBearer && authHeader === expectedBearer);
+
+    if (!isVercelCron) {
+      const signature = request.headers.get('upstash-signature');
+      if (signature) {
+        const body = await request.text();
+        await verifyQstashRequest(signature, body);
+      } else {
+        return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+      }
+    }
+
+    const job = await enqueueGoogleSheetSyncJob({
+      requestedByUserId: null,
+      configId: null,
+      triggerType: 'SCHEDULED',
+    });
+
+    return NextResponse.json(
+      {
+        ok: true,
+        jobId: job.id,
+        status: job.status,
+      },
+      { status: 202 },
+    );
+  } catch (error: any) {
+    if (error instanceof QstashAuthError) {
+      return NextResponse.json({ error: 'Signature QStash invalide' }, { status: 401 });
+    }
+    console.error('Erreur schedule Google Sheet:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

package/template/src/app/api/reminders/clear/route.ts

@@ -0,0 +1,120 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma, Prisma } from '@/lib/prisma';
+import {
+  REMINDERS_CLEAR_ALL_ID,
+  REMINDERS_CLEAR_UNDO_WINDOW_MS,
+} from '@/lib/reminder-state';
+import {
+  computeExpiresAtForUpsert,
+  getRequestId,
+  isMissingReminderStateTableError,
+  logReminderEvent,
+} from '@/lib/reminder-state-server';
+
+export async function POST(request: NextRequest) {
+  const started = Date.now();
+  const requestId = getRequestId(request);
+
+  try {
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const now = new Date();
+    const undoUntil = new Date(now.getTime() + REMINDERS_CLEAR_UNDO_WINDOW_MS);
+    const expiresAt = computeExpiresAtForUpsert(REMINDERS_CLEAR_ALL_ID, 'CLEARED', now);
+
+    try {
+      const existing = await prisma.userReminderState.findUnique({
+        where: {
+          userId_reminderId: {
+            userId: session.user.id,
+            reminderId: REMINDERS_CLEAR_ALL_ID,
+          },
+        },
+        select: {
+          status: true,
+          clearedCutoffAt: true,
+          updatedAt: true,
+        },
+      });
+
+      const previousClearedAt =
+        existing?.status === 'CLEARED'
+          ? (existing.clearedCutoffAt ?? existing.updatedAt).toISOString()
+          : null;
+
+      const metadata: Prisma.InputJsonValue = {
+        undoUntil: undoUntil.toISOString(),
+        previousClearedAt,
+      };
+
+      const clearState = await prisma.userReminderState.upsert({
+        where: {
+          userId_reminderId: {
+            userId: session.user.id,
+            reminderId: REMINDERS_CLEAR_ALL_ID,
+          },
+        },
+        update: {
+          status: 'CLEARED',
+          clearedCutoffAt: now,
+          metadata,
+          expiresAt,
+        },
+        create: {
+          userId: session.user.id,
+          reminderId: REMINDERS_CLEAR_ALL_ID,
+          status: 'CLEARED',
+          clearedCutoffAt: now,
+          metadata,
+          expiresAt,
+        },
+        select: {
+          clearedCutoffAt: true,
+          updatedAt: true,
+        },
+      });
+
+      const clearedAt = (clearState.clearedCutoffAt ?? clearState.updatedAt).toISOString();
+
+      logReminderEvent({
+        event: 'reminders_clear_all',
+        requestId,
+        userId: session.user.id,
+        degraded: false,
+        durationMs: Date.now() - started,
+      });
+
+      return NextResponse.json({
+        success: true,
+        clearedAt,
+        undoUntil: undoUntil.toISOString(),
+        degraded: false,
+      });
+    } catch (err) {
+      if (isMissingReminderStateTableError(err)) {
+        logReminderEvent({
+          event: 'reminders_fallback_missing_table',
+          requestId,
+          userId: session.user.id,
+          degraded: true,
+          durationMs: Date.now() - started,
+        });
+        return NextResponse.json({
+          success: true,
+          clearedAt: now.toISOString(),
+          undoUntil: undoUntil.toISOString(),
+          degraded: true,
+        });
+      }
+      throw err;
+    }
+  } catch (error: unknown) {
+    const msg = error instanceof Error ? error.message : 'Erreur serveur';
+    console.error('Erreur lors du vidage des rappels:', error);
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}

package/template/src/app/api/reminders/clear/undo/route.ts

@@ -0,0 +1,112 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma, Prisma } from '@/lib/prisma';
+import { REMINDERS_CLEAR_ALL_ID } from '@/lib/reminder-state';
+import {
+  computeExpiresAtForUpsert,
+  getRequestId,
+  isMissingReminderStateTableError,
+  logReminderEvent,
+  parseClearMetadata,
+} from '@/lib/reminder-state-server';
+
+export async function POST(request: NextRequest) {
+  const started = Date.now();
+  const requestId = getRequestId(request);
+
+  try {
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const now = new Date();
+
+    try {
+      const row = await prisma.userReminderState.findUnique({
+        where: {
+          userId_reminderId: {
+            userId: session.user.id,
+            reminderId: REMINDERS_CLEAR_ALL_ID,
+          },
+        },
+        select: {
+          status: true,
+          reminderId: true,
+          metadata: true,
+        },
+      });
+
+      if (!row || row.status !== 'CLEARED') {
+        return NextResponse.json({ error: 'Rien à annuler.' }, { status: 400 });
+      }
+
+      const meta = parseClearMetadata(row.metadata);
+      if (!meta || now.getTime() > new Date(meta.undoUntil).getTime()) {
+        logReminderEvent({
+          event: 'reminders_clear_undo',
+          requestId,
+          userId: session.user.id,
+          degraded: false,
+          durationMs: Date.now() - started,
+          extra: { rejected: true, reason: 'undo_expired' },
+        });
+        return NextResponse.json({ error: "Délai d'annulation dépassé." }, { status: 400 });
+      }
+
+      if (meta.previousClearedAt === null) {
+        await prisma.userReminderState.delete({
+          where: {
+            userId_reminderId: {
+              userId: session.user.id,
+              reminderId: REMINDERS_CLEAR_ALL_ID,
+            },
+          },
+        });
+      } else {
+        const previous = new Date(meta.previousClearedAt);
+        const expiresAt = computeExpiresAtForUpsert(REMINDERS_CLEAR_ALL_ID, 'CLEARED', now);
+        await prisma.userReminderState.update({
+          where: {
+            userId_reminderId: {
+              userId: session.user.id,
+              reminderId: REMINDERS_CLEAR_ALL_ID,
+            },
+          },
+          data: {
+            clearedCutoffAt: previous,
+            metadata: Prisma.JsonNull,
+            expiresAt,
+          },
+        });
+      }
+
+      logReminderEvent({
+        event: 'reminders_clear_undo',
+        requestId,
+        userId: session.user.id,
+        degraded: false,
+        durationMs: Date.now() - started,
+        extra: { restoredPrevious: meta.previousClearedAt != null },
+      });
+
+      return NextResponse.json({ success: true, degraded: false });
+    } catch (err) {
+      if (isMissingReminderStateTableError(err)) {
+        logReminderEvent({
+          event: 'reminders_fallback_missing_table',
+          requestId,
+          userId: session.user.id,
+          degraded: true,
+          durationMs: Date.now() - started,
+        });
+        return NextResponse.json({ success: true, degraded: true });
+      }
+      throw err;
+    }
+  } catch (error: unknown) {
+    const msg = error instanceof Error ? error.message : 'Erreur serveur';
+    console.error('Erreur lors de l’annulation du vidage des rappels:', error);
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}

package/template/src/app/api/reminders/route.ts

@@ -1,9 +1,20 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
+import { REMINDERS_CLEAR_ALL_ID, REMINDER_READ_STATUSES } from '@/lib/reminder-state';
+import {
+  getRequestId,
+  isMissingReminderStateTableError,
+  logReminderEvent,
+  reminderStateNotExpired,
+} from '@/lib/reminder-state-server';
 
 // GET /api/reminders - Récupérer tous les rappels de l'utilisateur
 export async function GET(request: NextRequest) {
+  const started = Date.now();
+  const requestId = getRequestId(request);
+  let degraded = false;
+
   try {
     const session = await auth.api.getSession({
       headers: request.headers,
@@ -14,20 +25,19 @@ export async function GET(request: NextRequest) {
     }
 
     const now = new Date();
-    const future = new Date(now);
-    future.setDate(future.getDate() + 7); // 7 jours à venir
+    const start = new Date(now);
+    start.setDate(start.getDate() - 7);
+    const end = new Date(now);
+    end.setDate(end.getDate() + 1);
 
-    // Récupérer toutes les tâches non complétées de l'utilisateur avec rappels
+    // Récupérer les tâches non complétées de l'utilisateur dans une fenêtre proche
     const tasks = await prisma.task.findMany({
       where: {
         assignedUserId: session.user.id,
         completed: false,
         scheduledAt: {
-          gte: now,
-          lte: future,
-        },
-        reminderMinutesBefore: {
-          not: null,
+          gte: start,
+          lte: end,
         },
       },
       include: {
@@ -51,47 +61,163 @@ export async function GET(request: NextRequest) {
       orderBy: {
         scheduledAt: 'asc',
       },
+      take: 100,
     });
 
-    // Formater les rappels - inclure toutes les tâches avec rappels
-    const reminders = tasks
-      .filter((task) => {
-        if (!task.reminderMinutesBefore) return false;
+    const reminderCandidates = tasks
+      .flatMap((task) => {
         const scheduled = new Date(task.scheduledAt);
-        const reminderTime = new Date(scheduled.getTime() - task.reminderMinutesBefore * 60 * 1000);
-        // Inclure les rappels qui sont passés mais pas encore à l'heure de la tâche
-        // ou les rappels qui sont à venir (dans les 7 prochains jours)
-        const timeUntilReminder = reminderTime.getTime() - now.getTime();
-        return (
-          (reminderTime <= now && now < scheduled) ||
-          (timeUntilReminder > 0 && timeUntilReminder < 7 * 24 * 60 * 60 * 1000)
-        );
+        const entries: Array<{
+          id: string;
+          taskId: string;
+          kind: 'due' | 'reminder';
+          type: string;
+          title: string | null;
+          description: string;
+          priority: string;
+          scheduledAt: Date;
+          reminderTime: string;
+          reminderMinutesBefore: number | null;
+          contact: typeof task.contact;
+          assignedUser: typeof task.assignedUser;
+        }> = [];
+
+        const diffMs = now.getTime() - scheduled.getTime();
+        if (diffMs >= 0) {
+          entries.push({
+            id: `${task.id}-due`,
+            taskId: task.id,
+            kind: 'due',
+            type: task.type,
+            title: task.title,
+            description: task.description,
+            priority: task.priority,
+            scheduledAt: task.scheduledAt,
+            reminderTime: scheduled.toISOString(),
+            reminderMinutesBefore: task.reminderMinutesBefore,
+            contact: task.contact,
+            assignedUser: task.assignedUser,
+          });
+        }
+
+        if (task.reminderMinutesBefore != null && task.reminderMinutesBefore > 0) {
+          const reminderTime = new Date(scheduled.getTime() - task.reminderMinutesBefore * 60 * 1000);
+          const diffReminderMs = now.getTime() - reminderTime.getTime();
+          if (diffReminderMs >= 0 && now < scheduled) {
+            entries.push({
+              id: `${task.id}-reminder`,
+              taskId: task.id,
+              kind: 'reminder',
+              type: task.type,
+              title: task.title,
+              description: task.description,
+              priority: task.priority,
+              scheduledAt: task.scheduledAt,
+              reminderTime: reminderTime.toISOString(),
+              reminderMinutesBefore: task.reminderMinutesBefore,
+              contact: task.contact,
+              assignedUser: task.assignedUser,
+            });
+          }
+        }
+
+        return entries;
+      });
+
+    const reminderIds = reminderCandidates.map((reminder) => reminder.id);
+    const countCandidates = reminderCandidates.length;
+
+    let reminderStates: Array<{
+      reminderId: string;
+      status: string;
+      updatedAt: Date;
+      clearedCutoffAt: Date | null;
+    }> = [];
+
+    try {
+      reminderStates = await prisma.userReminderState.findMany({
+        where: {
+          userId: session.user.id,
+          AND: [
+            {
+              OR: [{ reminderId: { in: reminderIds } }, { reminderId: REMINDERS_CLEAR_ALL_ID }],
+            },
+            reminderStateNotExpired(now),
+          ],
+        },
+        select: {
+          reminderId: true,
+          status: true,
+          updatedAt: true,
+          clearedCutoffAt: true,
+        },
+      });
+    } catch (err) {
+      if (isMissingReminderStateTableError(err)) {
+        degraded = true;
+        logReminderEvent({
+          event: 'reminders_fallback_missing_table',
+          requestId,
+          userId: session.user.id,
+          degraded: true,
+          durationMs: Date.now() - started,
+        });
+      } else {
+        throw err;
+      }
+    }
+
+    const clearState = reminderStates.find(
+      (state) => state.reminderId === REMINDERS_CLEAR_ALL_ID && state.status === 'CLEARED',
+    );
+    const clearedAt = clearState
+      ? (clearState.clearedCutoffAt ?? clearState.updatedAt)
+      : null;
+    const stateByReminderId = new Map(
+      reminderStates
+        .filter((state) => state.reminderId !== REMINDERS_CLEAR_ALL_ID)
+        .map((state) => [state.reminderId, state]),
+    );
+
+    const reminders = reminderCandidates
+      .filter((reminder) => {
+        if (!clearedAt) return true;
+        return new Date(reminder.reminderTime).getTime() > clearedAt.getTime();
       })
-      .map((task) => {
-        const scheduled = new Date(task.scheduledAt);
-        const reminderTime = new Date(
-          scheduled.getTime() - (task.reminderMinutesBefore || 0) * 60 * 1000,
+      .map((reminder) => {
+        const state = stateByReminderId.get(reminder.id);
+        const isRead = Boolean(state && REMINDER_READ_STATUSES.has(state.status as 'READ' | 'DISMISSED'));
+        const isDismissed = state?.status === 'DISMISSED';
+        const isClearedByCutoff = Boolean(
+          clearedAt && new Date(reminder.reminderTime).getTime() <= clearedAt.getTime(),
         );
 
         return {
-          id: `${task.id}-reminder`,
-          taskId: task.id,
-          type: task.type,
-          title: task.title,
-          description: task.description,
-          priority: task.priority,
-          scheduledAt: task.scheduledAt,
-          reminderTime: reminderTime.toISOString(),
-          reminderMinutesBefore: task.reminderMinutesBefore,
-          contact: task.contact,
-          assignedUser: task.assignedUser,
+          ...reminder,
+          isRead,
+          isDismissed,
+          isClearedByCutoff,
         };
       })
-      .sort((a, b) => new Date(a.scheduledAt).getTime() - new Date(b.scheduledAt).getTime());
+      .sort((a, b) => new Date(b.reminderTime).getTime() - new Date(a.reminderTime).getTime());
+
+    logReminderEvent({
+      event: 'reminders_fetch',
+      requestId,
+      userId: session.user.id,
+      countCandidates,
+      countReturned: reminders.length,
+      degraded,
+      durationMs: Date.now() - started,
+    });
+
+    const headers: Record<string, string> = {};
+    if (degraded) headers['x-reminders-degraded'] = '1';
 
-    return NextResponse.json(reminders);
-  } catch (error: any) {
+    return NextResponse.json(reminders, { headers });
+  } catch (error: unknown) {
+    const msg = error instanceof Error ? error.message : 'Erreur serveur';
     console.error('Erreur lors de la récupération des rappels:', error);
-    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+    return NextResponse.json({ error: msg }, { status: 500 });
   }
 }