create-crm-tmp 2.0.0 → 2.1.0

package/template/src/lib/qstash.ts

@@ -0,0 +1,65 @@
+import { Client, Receiver } from '@upstash/qstash';
+
+type SyncJobPayload = {
+  jobId: string;
+};
+
+export class QstashAuthError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'QstashAuthError';
+  }
+}
+
+function getQstashClient() {
+  const token = process.env.QSTASH_TOKEN;
+  if (!token) {
+    throw new Error('QSTASH_TOKEN manquant');
+  }
+  return new Client({ token });
+}
+
+function getWorkerUrl() {
+  const explicit = process.env.GOOGLE_SHEET_SYNC_WORKER_URL;
+  if (explicit) return explicit;
+
+  const appUrl =  process.env.NEXT_PUBLIC_APP_URL ?? process.env.VERCEL_PROJECT_PRODUCTION_URL;
+  if (!appUrl) {
+    throw new Error('NEXT_PUBLIC_APP_URL manquant pour publier le job QStash');
+  }
+  const normalized = appUrl.startsWith('http') ? appUrl : `https://${appUrl}`;
+  return `${normalized}/api/jobs/google-sheet/process`;
+}
+
+export async function publishGoogleSheetSyncJob(payload: SyncJobPayload) {
+  const client = getQstashClient();
+  const workerUrl = getWorkerUrl();
+
+  await client.publishJSON({
+    url: workerUrl,
+    body: payload,
+    retries: 2,
+  });
+}
+
+export async function verifyQstashRequest(signature: string | null, body: string): Promise<void> {
+  const currentKey = process.env.QSTASH_CURRENT_SIGNING_KEY;
+  const nextKey = process.env.QSTASH_NEXT_SIGNING_KEY;
+
+  if (!currentKey || !nextKey) {
+    throw new Error('QSTASH_CURRENT_SIGNING_KEY / QSTASH_NEXT_SIGNING_KEY manquants');
+  }
+  if (!signature) {
+    throw new QstashAuthError('Signature QStash manquante');
+  }
+
+  const receiver = new Receiver({
+    currentSigningKey: currentKey,
+    nextSigningKey: nextKey,
+  });
+
+  await receiver.verify({
+    signature,
+    body,
+  });
+}

package/template/src/lib/reminder-state-server.ts

@@ -0,0 +1,80 @@
+import { randomUUID } from 'crypto';
+import { Prisma } from '@/lib/prisma';
+import {
+  REMINDERS_CLEAR_ALL_ID,
+  REMINDER_STATE_TTL_CLEARED_MS,
+  REMINDER_STATE_TTL_READ_MS,
+  type ReminderClearMetadata,
+} from '@/lib/reminder-state';
+
+export type ReminderLogEvent =
+  | 'reminders_fetch'
+  | 'reminder_state_read'
+  | 'reminder_state_upsert'
+  | 'reminders_clear_all'
+  | 'reminders_clear_undo'
+  | 'reminders_fallback_missing_table';
+
+export function getRequestId(request: Request): string {
+  const fromHeader = request.headers.get('x-request-id')?.trim();
+  return fromHeader && fromHeader.length > 0 ? fromHeader : randomUUID();
+}
+
+export function logReminderEvent(payload: {
+  event: ReminderLogEvent;
+  requestId: string;
+  userId?: string;
+  countCandidates?: number;
+  countReturned?: number;
+  degraded?: boolean;
+  durationMs?: number;
+  extra?: Record<string, unknown>;
+}) {
+  console.log(
+    JSON.stringify({
+      ...payload,
+      ts: new Date().toISOString(),
+    }),
+  );
+}
+
+export function isMissingReminderStateTableError(error: unknown): boolean {
+  if (error instanceof Prisma.PrismaClientKnownRequestError) {
+    if (error.code === 'P2021') return true;
+  }
+  const msg = error instanceof Error ? error.message : String(error);
+  return /user_reminder_state|relation .* does not exist|table .* does not exist/i.test(msg);
+}
+
+/** Filtre Prisma : lignes non expirées (ou sans TTL pour rétrocompat). */
+export function reminderStateNotExpired(now: Date): Prisma.UserReminderStateWhereInput {
+  return {
+    OR: [{ expiresAt: null }, { expiresAt: { gt: now } }],
+  };
+}
+
+export function computeExpiresAtForUpsert(
+  reminderId: string,
+  status: 'READ' | 'DISMISSED' | 'CLEARED',
+  now: Date,
+): Date | null {
+  if (reminderId === REMINDERS_CLEAR_ALL_ID && status === 'CLEARED') {
+    return new Date(now.getTime() + REMINDER_STATE_TTL_CLEARED_MS);
+  }
+  if (status === 'READ' || status === 'DISMISSED') {
+    return new Date(now.getTime() + REMINDER_STATE_TTL_READ_MS);
+  }
+  return null;
+}
+
+export function parseClearMetadata(raw: Prisma.JsonValue | null | undefined): ReminderClearMetadata | null {
+  if (raw == null || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  const o = raw as Record<string, unknown>;
+  if (typeof o.undoUntil !== 'string') return null;
+  const prev = o.previousClearedAt;
+  if (prev != null && typeof prev !== 'string') return null;
+  return {
+    undoUntil: o.undoUntil,
+    previousClearedAt: prev == null ? null : prev,
+  };
+}

package/template/src/lib/reminder-state.ts

@@ -0,0 +1,29 @@
+export const REMINDERS_CLEAR_ALL_ID = '__all__';
+
+export const REMINDER_READ_STATUSES = new Set(['READ', 'DISMISSED']);
+
+/** TTL états READ / DISMISSED par rappel */
+export const REMINDER_STATE_TTL_READ_MS = 30 * 24 * 60 * 60 * 1000;
+
+/** TTL état global CLEARED (__all__) */
+export const REMINDER_STATE_TTL_CLEARED_MS = 7 * 24 * 60 * 60 * 1000;
+
+/** Fenêtre d’annulation après « Vider les rappels » */
+export const REMINDERS_CLEAR_UNDO_WINDOW_MS = 15_000;
+
+/** Métadonnées JSON sur la ligne __all__ pour l’undo */
+export type ReminderClearMetadata = {
+  undoUntil: string;
+  previousClearedAt: string | null;
+};
+
+/** Polling des rappels (cloche + toasts). Plus court qu’1 min pour éviter d’attendre un refresh manuel. */
+export const REMINDERS_POLL_INTERVAL_MS = 15_000;
+
+/** À émettre après création / MAJ de tâche avec rappel pour rafraîchir immédiatement. */
+export const REMINDERS_REFRESH_EVENT = 'reminders:refresh';
+
+export function requestRemindersRefresh() {
+  globalThis.dispatchEvent(new Event(REMINDERS_REFRESH_EVENT));
+}
+

package/template/src/lib/supabase-storage.ts

@@ -0,0 +1,113 @@
+import { createClient, type SupabaseClient } from '@supabase/supabase-js';
+
+const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL!;
+const supabaseServiceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY!;
+
+let _adminClient: SupabaseClient | null = null;
+
+function getAdminClient(): SupabaseClient {
+  if (!_adminClient) {
+    if (!supabaseUrl || !supabaseServiceRoleKey) {
+      throw new Error(
+        'NEXT_PUBLIC_SUPABASE_URL et SUPABASE_SERVICE_ROLE_KEY doivent être configurés.',
+      );
+    }
+    _adminClient = createClient(supabaseUrl, supabaseServiceRoleKey, {
+      auth: { autoRefreshToken: false, persistSession: false },
+    });
+  }
+  return _adminClient;
+}
+
+export const BUCKETS = {
+  CONTACTS: 'contacts',
+  EDITOR_IMAGES: 'editor-images',
+} as const;
+
+export type BucketName = (typeof BUCKETS)[keyof typeof BUCKETS];
+
+function buildStoragePath(prefix: string, entityId: string, fileName: string): string {
+  const uuid = crypto.randomUUID();
+  const sanitized = fileName.replaceAll(/[^a-zA-Z0-9._-]/g, '_');
+  return `${prefix}/${entityId}/${uuid}-${sanitized}`;
+}
+
+export function buildContactFilePath(contactId: string, fileName: string): string {
+  return buildStoragePath('files', contactId, fileName);
+}
+
+export function buildEditorImagePath(fileName: string): string {
+  const uuid = crypto.randomUUID();
+  const sanitized = fileName.replaceAll(/[^a-zA-Z0-9._-]/g, '_');
+  return `images/${uuid}-${sanitized}`;
+}
+
+export async function uploadFile(
+  bucket: BucketName,
+  path: string,
+  data: Buffer | Blob,
+  contentType: string,
+): Promise<{ storagePath: string }> {
+  const client = getAdminClient();
+  const { error } = await client.storage.from(bucket).upload(path, data, {
+    contentType,
+    upsert: true,
+  });
+  if (error) throw new Error(`Erreur upload Supabase: ${error.message}`);
+  return { storagePath: path };
+}
+
+export async function createSignedUploadUrl(
+  bucket: BucketName,
+  path: string,
+): Promise<{ signedUrl: string; token: string; storagePath: string }> {
+  const client = getAdminClient();
+  const { data, error } = await client.storage.from(bucket).createSignedUploadUrl(path);
+  if (error || !data) {
+    throw new Error(`Erreur création signed upload URL: ${error?.message ?? 'unknown'}`);
+  }
+  return { signedUrl: data.signedUrl, token: data.token, storagePath: path };
+}
+
+export async function createSignedDownloadUrl(
+  bucket: BucketName,
+  path: string,
+  expiresIn = 3600,
+): Promise<string> {
+  const client = getAdminClient();
+  const { data, error } = await client.storage.from(bucket).createSignedUrl(path, expiresIn);
+  if (error || !data?.signedUrl) {
+    throw new Error(`Erreur création signed download URL: ${error?.message ?? 'unknown'}`);
+  }
+  return data.signedUrl;
+}
+
+export async function downloadFile(
+  bucket: BucketName,
+  path: string,
+): Promise<{ buffer: Buffer; mimeType: string }> {
+  const client = getAdminClient();
+  const { data, error } = await client.storage.from(bucket).download(path);
+  if (error || !data) {
+    throw new Error(`Erreur téléchargement Supabase: ${error?.message ?? 'unknown'}`);
+  }
+  const buffer = Buffer.from(await data.arrayBuffer());
+  return { buffer, mimeType: data.type };
+}
+
+export async function deleteFile(bucket: BucketName, path: string): Promise<void> {
+  const client = getAdminClient();
+  const { error } = await client.storage.from(bucket).remove([path]);
+  if (error) {
+    throw new Error(`Erreur suppression Supabase: ${error.message}`);
+  }
+}
+
+export async function deleteFiles(bucket: BucketName, paths: string[]): Promise<void> {
+  if (paths.length === 0) return;
+  const client = getAdminClient();
+  const { error } = await client.storage.from(bucket).remove(paths);
+  if (error) {
+    throw new Error(`Erreur suppression batch Supabase: ${error.message}`);
+  }
+}

package/template/src/lib/template-variables.ts

@@ -14,19 +14,31 @@ export interface ContactVariables {
   city?: string | null;
   postalCode?: string | null;
   companyName?: string | null;
-  company?: { name?: string | null } | null;
+  company?: {
+    name?: string | null;
+    address?: string | null;
+    city?: string | null;
+    postalCode?: string | null;
+  } | null;
+  jobTitle?: string | null;
+  website?: string | null;
+  origin?: string | null;
+  statusName?: string | null;
+  assignedCommercialName?: string | null;
+  assignedTeleproName?: string | null;
+  closingReason?: string | null;
+  createdAt?: Date | string | null;
 }
 
 export interface TemplateVariable {
   key: string;
   description: string;
-  section: 'contact' | 'lieu' | 'tournee';
+  section: 'contact' | 'crm';
 }
 
 export const VARIABLE_SECTIONS = {
   contact: { label: 'Contact', color: 'indigo' },
-  lieu: { label: 'Lieu & contacts sur place', color: 'blue' },
-  tournee: { label: 'Tournée', color: 'emerald' },
+  crm: { label: 'CRM', color: 'emerald' },
 } as const;
 
 export const AVAILABLE_VARIABLES: TemplateVariable[] = [
@@ -52,33 +64,46 @@ export const AVAILABLE_VARIABLES: TemplateVariable[] = [
     description: 'Nom de l’entreprise ou structure du contact.',
     section: 'contact',
   },
-  // Lieu
-  { key: '{{placeName}}', description: 'Nom du lieu.', section: 'lieu' },
-  { key: '{{placeAddress}}', description: 'Adresse complète du lieu.', section: 'lieu' },
+  // CRM
+  { key: '{{jobTitle}}', description: 'Poste / fonction du contact.', section: 'crm' },
+  { key: '{{website}}', description: 'Site web du contact ou de son entreprise.', section: 'crm' },
+  { key: '{{origin}}', description: 'Origine ou source du lead.', section: 'crm' },
+  { key: '{{statusName}}', description: 'Nom du statut actuel du contact.', section: 'crm' },
   {
-    key: '{{placeContactName}}',
-    description: 'Nom de la personne à contacter sur place.',
-    section: 'lieu',
+    key: '{{assignedCommercialName}}',
+    description: 'Nom du commercial assigné au contact.',
+    section: 'crm',
   },
-  // Tournée
   {
-    key: '{{tourName}}',
-    description: 'Libellé auto de tournée (région + semaine ISO).',
-    section: 'tournee',
+    key: '{{closingReason}}',
+    description: 'Motif de fermeture (si le contact a le statut Fermé).',
+    section: 'crm',
   },
-  // { key: '{{tourNumber}}', description: 'Numéro unique de la tournée.', section: 'tournee' },
   {
-    key: '{{presenceStart}}',
-    description: 'Date et heure de début de la présence (ex. lundi 10 mars 2026 à 09:00).',
-    section: 'tournee',
+    key: '{{assignedTeleproName}}',
+    description: 'Nom du télépro assigné au contact.',
+    section: 'crm',
   },
   {
-    key: '{{presenceEnd}}',
-    description: 'Date et heure de fin de la présence (ex. lundi 10 mars 2026 à 12:00).',
-    section: 'tournee',
+    key: '{{createdAt}}',
+    description: 'Date de création du contact (format dd/mm/yyyy).',
+    section: 'crm',
+  },
+  {
+    key: '{{companyAddress}}',
+    description: 'Adresse de l\'entreprise liée au contact.',
+    section: 'crm',
+  },
+  {
+    key: '{{companyCity}}',
+    description: 'Ville du siège de l\'entreprise.',
+    section: 'crm',
+  },
+  {
+    key: '{{companyPostalCode}}',
+    description: 'Code postal de l\'entreprise.',
+    section: 'crm',
   },
-  { key: '{{city}}', description: 'Ville où se déroule la tournée.', section: 'tournee' },
-  { key: '{{postalCode}}', description: 'Code postal de la tournée.', section: 'tournee' },
 ];
 
 /**
@@ -101,6 +126,48 @@ export function replaceTemplateVariables(template: string, variables: ContactVar
     /\{\{companyName\}\}/g,
     variables.company?.name ?? variables.companyName ?? '',
   );
+  result = result.replace(/\{\{jobTitle\}\}/g, variables.jobTitle || '');
+  result = result.replace(/\{\{website\}\}/g, variables.website || '');
+  result = result.replace(/\{\{origin\}\}/g, variables.origin || '');
+  result = result.replace(/\{\{statusName\}\}/g, variables.statusName || '');
+  result = result.replace(
+    /\{\{assignedCommercialName\}\}/g,
+    variables.assignedCommercialName || '',
+  );
+  result = result.replace(
+    /\{\{assignedTeleproName\}\}/g,
+    variables.assignedTeleproName || '',
+  );
+  result = result.replace(/\{\{closingReason\}\}/g, variables.closingReason || '');
+  result = result.replace(
+    /\{\{companyAddress\}\}/g,
+    variables.company?.address ?? '',
+  );
+  result = result.replace(
+    /\{\{companyCity\}\}/g,
+    variables.company?.city ?? '',
+  );
+  result = result.replace(
+    /\{\{companyPostalCode\}\}/g,
+    variables.company?.postalCode ?? '',
+  );
+
+  // createdAt formaté (dd/mm/yyyy)
+  let createdAtStr = '';
+  if (variables.createdAt) {
+    const d =
+      typeof variables.createdAt === 'string'
+        ? new Date(variables.createdAt)
+        : variables.createdAt;
+    if (!isNaN(d.getTime())) {
+      createdAtStr = d.toLocaleDateString('fr-FR', {
+        day: '2-digit',
+        month: '2-digit',
+        year: 'numeric',
+      });
+    }
+  }
+  result = result.replace(/\{\{createdAt\}\}/g, createdAtStr);
 
   // Variable composée : fullName
   const fullName = [variables.firstName, variables.lastName].filter(Boolean).join(' ') || '';
@@ -108,3 +175,77 @@ export function replaceTemplateVariables(template: string, variables: ContactVar
 
   return result;
 }
+
+/**
+ * Construit l'objet ContactVariables à partir d'un contact (shape flexible).
+ */
+export function buildContactVariables(contact: {
+  firstName?: string | null;
+  lastName?: string | null;
+  civility?: string | null;
+  email?: string | null;
+  phone?: string | null;
+  secondaryPhone?: string | null;
+  address?: string | null;
+  city?: string | null;
+  postalCode?: string | null;
+  company?: {
+    name?: string | null;
+    address?: string | null;
+    city?: string | null;
+    postalCode?: string | null;
+  } | null;
+  companyName?: string | null;
+  jobTitle?: string | null;
+  website?: string | null;
+  origin?: string | null;
+  status?: { name?: string | null } | null;
+  statusName?: string | null;
+  assignedCommercial?: {
+    name?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
+  } | null;
+  assignedTelepro?: {
+    name?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
+  } | null;
+  closingReason?: string | null;
+  createdAt?: Date | string | null;
+}): ContactVariables {
+  const commercialName = contact.assignedCommercial
+    ? (contact.assignedCommercial.name ??
+        [contact.assignedCommercial.firstName, contact.assignedCommercial.lastName]
+          .filter(Boolean)
+          .join(' ')) || ''
+    : '';
+  const teleproName = contact.assignedTelepro
+    ? (contact.assignedTelepro.name ??
+        [contact.assignedTelepro.firstName, contact.assignedTelepro.lastName]
+          .filter(Boolean)
+          .join(' ')) || ''
+    : '';
+  return {
+    firstName: contact.firstName || '',
+    lastName: contact.lastName || '',
+    civility: contact.civility || '',
+    email: contact.email || '',
+    phone: contact.phone || '',
+    secondaryPhone: contact.secondaryPhone || '',
+    address: contact.address || '',
+    city: contact.city || '',
+    postalCode: contact.postalCode || '',
+    companyName: contact.company?.name ?? contact.companyName ?? '',
+    company: contact.company || null,
+    jobTitle: contact.jobTitle || '',
+    website: contact.website || '',
+    origin: contact.origin || '',
+    statusName: contact.status?.name ?? contact.statusName ?? '',
+    assignedCommercialName: commercialName,
+    assignedTeleproName: teleproName,
+    closingReason: contact.closingReason || '',
+    createdAt: contact.createdAt || null,
+  };
+}
+

package/template/src/lib/utils.ts

@@ -58,6 +58,51 @@ export function formatDateTime(dateString: string | null): string {
   return DATE_TIME_FORMATTER.format(new Date(dateString));
 }
 
+/**
+ * Parse une chaîne en Date pour les imports (création de contact).
+ * Accepte ISO (yyyy-mm-dd), dd/mm/yyyy, dd-mm-yyyy.
+ * Retourne null si invalide ou vide.
+ */
+export function parseImportDate(value: string | null | undefined): Date | null {
+  if (value == null || String(value).trim() === '') return null;
+  const s = String(value).trim();
+  if (/^\d{4}-\d{2}-\d{2}(T|\s|$)/.test(s)) {
+    const d = new Date(s);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  const parts = s.match(/^(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{2,4})/);
+  if (parts) {
+    const [, a, b, year] = parts;
+    const y = year.length === 2 ? 2000 + parseInt(year, 10) : parseInt(year, 10);
+    const n1 = parseInt(a, 10);
+    const n2 = parseInt(b, 10);
+    const day = n1 > 31 ? n2 : n1;
+    const month = n1 > 31 ? n1 : n2;
+    const d = new Date(y, month - 1, day);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  const d = new Date(s);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+/**
+ * Retourne un message toast adapte a l'environnement :
+ * - En développement : affiche le message utilisateur + le détail technique
+ * - En production : affiche uniquement le message utilisateur
+ */
+export function devToast(userMessage: string, devDetail?: unknown): string {
+  if (process.env.NODE_ENV === 'development' && devDetail) {
+    const detail =
+      devDetail instanceof Error
+        ? devDetail.message
+        : typeof devDetail === 'string'
+          ? devDetail
+          : JSON.stringify(devDetail);
+    return `${userMessage}\n\n🔧 ${detail}`;
+  }
+  return userMessage;
+}
+
 export function indexToColumn(index: number): string {
   let col = '';
   let n = index + 1;