Privacidad por Diseño: Checklist técnico para la Ley 7593/2025

import * as import zz from "zod";

// Schema que rechaza datos innecesarios por diseño
export const 
const ContactFormSchema: z.ZodObject<{
    email: z.ZodEmail;
    message: z.ZodString;
}, z.core.$strict>ContactFormSchema = import zz.
function strictObject<{
    email: z.ZodEmail;
    message: z.ZodString;
}>(shape: {
    email: z.ZodEmail;
    message: z.ZodString;
}, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueInvalidType<unknown> | z.core.$ZodIssueUnrecognizedKeys>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<{
    email: z.ZodEmail;
    message: z.ZodString;
}, z.core.$strict>strictObject({
  email: z.ZodEmailemail: import zz.function email(params?: string | z.core.$ZodEmailParams): z.ZodEmailemail(),
  message: z.ZodStringmessage: import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string()._ZodString<$ZodStringInternals<string>>.min(minLength: number, params?: string | z.core.$ZodCheckMinLengthParams): z.ZodStringmin(10)._ZodString<$ZodStringInternals<string>>.max(maxLength: number, params?: string | z.core.$ZodCheckMaxLengthParams): z.ZodStringmax(500),
  // Sin teléfono, sin nombre completo, sin dirección
  // Si el negocio necesita más datos, justificarlo explícitamente
}); // z.strictObject() rechaza campos no definidos

export type 
type ContactForm = {
    email: string;
    message: string;
}ContactForm = import zz.
type infer<T> = T extends {
    _zod: {
        output: any;
    };
} ? T["_zod"]["output"] : unknown
export inferinfer<typeof 
const ContactFormSchema: z.ZodObject<{
    email: z.ZodEmail;
    message: z.ZodString;
}, z.core.$strict>ContactFormSchema>;

export interface ConsentRecord {
  ConsentRecord.userId: stringuserId: string;
  ConsentRecord.purpose: stringpurpose: string;
  ConsentRecord.timestamp: Datetimestamp: Date;
  ConsentRecord.userAgent: stringuserAgent: string;
  // El hash del texto legal vigente al momento del consentimiento
  ConsentRecord.legalTextVersion: stringlegalTextVersion: string;
}

export async function function recordConsent(userId: string, purpose: string, request: Request): Promise<ConsentRecord>recordConsent(
  userId: stringuserId: string,
  purpose: stringpurpose: string,
  request: Requestrequest: Request,
): interface Promise<T>
Represents the completion of an asynchronous operationPromise<ConsentRecord> {
  const const result: anyresult = await 
const db: {
    consent: {
        create: (args: any) => Promise<any>;
    };
}db.
consent: {
    create: (args: any) => Promise<any>;
}consent.create: (args: any) => Promise<any>create({
    
data: {
    userId: string;
    purpose: string;
    timestamp: Date;
    userAgent: string;
    legalTextVersion: string;
}data: {
      userId: stringuserId,
      purpose: stringpurpose,
      timestamp: Datetimestamp: new 
var Date: DateConstructor
new () => Date (+4 overloads)Date(),
      userAgent: stringuserAgent: request: Requestrequest.
Request.headers: {
    get(name: string): string | null;
}headers.function get(name: string): string | nullget("user-agent") ?? "unknown",
      legalTextVersion: stringlegalTextVersion: function getCurrentLegalVersion(): stringgetCurrentLegalVersion(),
    },
  });

  return {
    ConsentRecord.userId: stringuserId: const result: anyresult.userId,
    ConsentRecord.purpose: stringpurpose: const result: anyresult.purpose,
    ConsentRecord.timestamp: Datetimestamp: const result: anyresult.timestamp,
    ConsentRecord.userAgent: stringuserAgent: const result: anyresult.userAgent,
    ConsentRecord.legalTextVersion: stringlegalTextVersion: const result: anyresult.legalTextVersion,
  };
}

// Helper que anonimiza emails para retención
function function anonymizeEmail(): stringanonymizeEmail(): string {
  return `anon-${
const crypto: {
    randomUUID: () => string;
}crypto.randomUUID: () => stringrandomUUID()}@anonimizado.local`;
}

// Job diario que purga datos expirados (cron: 0 2 * * *)
export async function function purgeExpiredData(): Promise<void>purgeExpiredData() {
  const const RETENTION_DAYS: 365RETENTION_DAYS = 365;
  const const cutoff: Datecutoff = new 
var Date: DateConstructor
new () => Date (+4 overloads)Date();
  const cutoff: Datecutoff.Date.setDate(date: number): number
Sets the numeric day-of-the-month value of the Date object using local time.
@paramdate A numeric value equal to the day of the month.setDate(const cutoff: Datecutoff.Date.getDate(): number
Gets the day-of-the-month, using local time.getDate() - const RETENTION_DAYS: 365RETENTION_DAYS);

  // Eliminar registros de consentimiento expirados
  const 
const deleted: {
    count: number;
}deleted = await 
const db: {
    consent: {
        deleteMany: (args: any) => Promise<{
            count: number;
        }>;
    };
    user: {
        updateMany: (args: any) => Promise<any>;
    };
}db.
consent: {
    deleteMany: (args: any) => Promise<{
        count: number;
    }>;
}consent.
deleteMany: (args: any) => Promise<{
    count: number;
}>deleteMany({
    
where: {
    updatedAt: {
        lt: Date;
    };
}where: { 
updatedAt: {
    lt: Date;
}updatedAt: { lt: Datelt: const cutoff: Datecutoff } },
  });

  // Los datos personales sin propósito activa también se eliminan
  await 
const db: {
    consent: {
        deleteMany: (args: any) => Promise<{
            count: number;
        }>;
    };
    user: {
        updateMany: (args: any) => Promise<any>;
    };
}db.
user: {
    updateMany: (args: any) => Promise<any>;
}user.updateMany: (args: any) => Promise<any>updateMany({
    
where: {
    AND: ({
        lastActiveAt: {
            lt: Date;
        };
    } | {
        purposeConsent: null;
    })[];
}where: {
      
type AND: ({
    lastActiveAt: {
        lt: Date;
    };
} | {
    purposeConsent: null;
})[]AND: [{ 
lastActiveAt: {
    lt: Date;
}lastActiveAt: { lt: Datelt: const cutoff: Datecutoff } }, { purposeConsent: nullpurposeConsent: null }],
    },
    
data: {
    email: string;
    name: string;
    status: string;
}data: {
      email: stringemail: function anonymizeEmail(): stringanonymizeEmail(),
      name: stringname: "Usuario Anonimizado",
      // Soft delete → hard delete tras 30 días
      status: stringstatus: "pending_deletion",
    },
  });

  var console: Consoleconsole.Console.log(...data: any[]): void
The **`console.log()`** static method outputs a message to the console.

[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)log(`Purga completada: ${
const deleted: {
    count: number;
}deleted.count: numbercount ?? 0} registros eliminados`);
}

// POST /api/user/:id/export
export async function 
function exportUserData(userId: string): Promise<{
    personalData: {
        email: any;
        name: any;
        createdAt: any;
    };
    consents: any;
    orders: any;
}>exportUserData(userId: stringuserId: string) {
  const const user: anyuser = await 
const db: {
    user: {
        findUnique: (args: any) => Promise<any>;
        update: (args: any) => Promise<any>;
    };
    consent: {
        deleteMany: (args: any) => Promise<any>;
    };
    auditLog: {
        create: (args: any) => Promise<any>;
    };
}db.
user: {
    findUnique: (args: any) => Promise<any>;
    update: (args: any) => Promise<any>;
}user.findUnique: (args: any) => Promise<any>findUnique({
    
where: {
    id: string;
}where: { id: stringid: userId: stringuserId },
    
include: {
    consents: boolean;
    orders: {
        select: {
            id: boolean;
            date: boolean;
            total: boolean;
        };
    };
}include: {
      consents: booleanconsents: true,
      
orders: {
    select: {
        id: boolean;
        date: boolean;
        total: boolean;
    };
}orders: { 
select: {
    id: boolean;
    date: boolean;
    total: boolean;
}select: { id: booleanid: true, date: booleandate: true, total: booleantotal: true } },
      // Solo datos necesarios — no joins innecesarios
    },
  });

  if (!const user: anyuser) {
    throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)Error("Usuario no encontrado");
  }

  // Generar JSON portátil (formato estándar)
  return {
    
personalData: {
    email: any;
    name: any;
    createdAt: any;
}personalData: {
      email: anyemail: const user: anyuser.email ?? "",
      name: anyname: const user: anyuser.name ?? "",
      createdAt: anycreatedAt: const user: anyuser.createdAt,
    },
    consents: anyconsents: const user: anyuser.consents,
    orders: anyorders: const user: anyuser.orders,
  };
}

// DELETE /api/user/:id
export async function function deleteUserData(userId: string): Promise<void>deleteUserData(userId: stringuserId: string) {
  // 1. Anonimizar datos antes de eliminar
  await 
const db: {
    user: {
        findUnique: (args: any) => Promise<any>;
        update: (args: any) => Promise<any>;
    };
    consent: {
        deleteMany: (args: any) => Promise<any>;
    };
    auditLog: {
        create: (args: any) => Promise<any>;
    };
}db.
user: {
    findUnique: (args: any) => Promise<any>;
    update: (args: any) => Promise<any>;
}user.update: (args: any) => Promise<any>update({
    
where: {
    id: string;
}where: { id: stringid: userId: stringuserId },
    
data: {
    email: string;
    name: string;
}data: {
      email: stringemail: `deleted-${userId: stringuserId}@anonimizado.local`,
      name: stringname: "Eliminado por solicitud",
    },
  });

  // 2. Eliminar consentimientos (ya no son válidos)
  await 
const db: {
    user: {
        findUnique: (args: any) => Promise<any>;
        update: (args: any) => Promise<any>;
    };
    consent: {
        deleteMany: (args: any) => Promise<any>;
    };
    auditLog: {
        create: (args: any) => Promise<any>;
    };
}db.
consent: {
    deleteMany: (args: any) => Promise<any>;
}consent.deleteMany: (args: any) => Promise<any>deleteMany({ 
where: {
    userId: string;
}where: { userId: stringuserId } });

  // 3. Log de auditoría: quién eliminó, cuándo y por qué
  await 
const db: {
    user: {
        findUnique: (args: any) => Promise<any>;
        update: (args: any) => Promise<any>;
    };
    consent: {
        deleteMany: (args: any) => Promise<any>;
    };
    auditLog: {
        create: (args: any) => Promise<any>;
    };
}db.
auditLog: {
    create: (args: any) => Promise<any>;
}auditLog.create: (args: any) => Promise<any>create({
    
data: {
    action: "USER_DELETED";
    userId: string;
    timestamp: Date;
}data: {
      action: "USER_DELETED"action: "USER_DELETED" as type const = "USER_DELETED"const,
      userId: stringuserId,
      timestamp: Datetimestamp: new 
var Date: DateConstructor
new () => Date (+4 overloads)Date(),
    },
  });
}