Almacenamiento de Archivos y Documentos en Comfaca Créditos

// nuxt.config.ts (fragmento)
runtimeConfig: {
  storage: {
    documentsPath: resolve(__dirname, env.STORAGE_DOCUMENTS_PATH || "storage/"),
    logs:          resolve(__dirname, env.STORAGE_LOGS_PATH     || "storage/"),
    uploads:       resolve(__dirname, env.STORAGE_UPLOADS_PATH  || "storage/")
  }
}

// server/services/storage/documento-storage.service.ts
class DocumentoStorage {
  private storagePath: string;

  constructor() {
    const config = useRuntimeConfig();
    this.storagePath = config.storage?.documentsPath || "./storage/documents";
  }

  /** Inicializa el directorio de storage (crea si no existe). */
  async inicializarStorage(): Promise<void> {
    try {
      await fs.mkdir(this.storagePath, { recursive: true });
    } catch (error) {
      console.error("Error al inicializar storage:", error);
    }
  }

  /** Guarda un documento PDF. Acepta contenido en base64 (string) o Buffer. */
  async guardarPdf(
    solicitudId: string,
    contenido: string | Buffer,
    nombre?: string
  ): Promise<string> {
    await this.inicializarStorage();
    const nombreArchivo = nombre || `solicitud_${solicitudId}.pdf`;
    const rutaArchivo = path.join(this.storagePath, nombreArchivo);

    if (typeof contenido === "string") {
      await fs.writeFile(rutaArchivo, contenido, "base64");
    } else {
      await fs.writeFile(rutaArchivo, contenido);
    }
    return rutaArchivo;
  }

  /** Lee un PDF del storage y devuelve su contenido en base64. Devuelve null si no existe. */
  async obtenerPdf(solicitudId: string, nombre?: string): Promise<string | null> {
    await this.inicializarStorage();
    const nombreArchivo = nombre || `solicitud_${solicitudId}.pdf`;
    const rutaArchivo = path.join(this.storagePath, nombreArchivo);
    try {
      const contenido = await fs.readFile(rutaArchivo);
      return contenido.toString("base64");
    } catch (error) {
      console.error("Error al obtener PDF:", error);
      return null;
    }
  }

  /** Elimina un PDF del storage. Devuelve true si fue exitoso, false si falló. */
  async eliminarPdf(solicitudId: string, nombre?: string): Promise<boolean> {
    await this.inicializarStorage();
    const nombreArchivo = nombre || `solicitud_${solicitudId}.pdf`;
    const rutaArchivo = path.join(this.storagePath, nombreArchivo);
    try {
      await fs.unlink(rutaArchivo);
      return true;
    } catch (error) {
      console.error("Error al eliminar PDF:", error);
      return false;
    }
  }

  /** Verifica si un PDF existe en el storage. */
  async existePdf(solicitudId: string, nombre?: string): Promise<boolean> {
    await this.inicializarStorage();
    const nombreArchivo = nombre || `solicitud_${solicitudId}.pdf`;
    const rutaArchivo = path.join(this.storagePath, nombreArchivo);
    try {
      await fs.access(rutaArchivo);
      return true;
    } catch {
      return false;
    }
  }
}

export const documentoStorage = new DocumentoStorage();
export default documentoStorage;

// nuxt.config.ts (fragmento runtimeConfig.sftp)
sftp: {
  env:                env.SFTP_ENV               || "dev",
  host:               env.SFTP_HOST              || "",
  port:               Number(env.SFTP_PORT)       || 22,
  username:           env.SFTP_USER              || "",
  password:           env.SFTP_PASSWORD          || "",
  // Autenticación por clave privada (recomendada en producción):
  private_key_base64: env.SFTP_PRIVATE_KEY_BASE64 || "",
  passphrase:         env.SFTP_PASSPHRASE        || "",
  // Directorio base remoto; las rutas relativas son relativas a este.
  base_path:          env.SFTP_BASE_PATH         || "/",
  ready_timeout:      Number(env.SFTP_READY_TIMEOUT_MS) || 20000
}

// server/services/shared/sftp-client.service.ts (fragmento)
const buildConnectionOptions = (cfg: SftpConfig) => {
  const options: Record<string, unknown> = {
    host: cfg.host,
    port: cfg.port,
    username: cfg.username,
    readyTimeout: cfg.ready_timeout,
    keepaliveInterval: 10000,
    keepaliveCountMax: 3
  };

  if (cfg.private_key_base64) {
    // Autenticación por clave privada (RSA / ED25519 en base64)
    options.privateKey = decodePrivateKey(cfg.private_key_base64);
    if (cfg.passphrase) {
      options.passphrase = cfg.passphrase;
    }
  } else {
    // Fallback: autenticación por contraseña
    options.password = cfg.password;
  }

  return options;
};

// prisma/schema.prisma
model documentos_postulantes {
  id              BigInt    @id @default(autoincrement()) @db.UnsignedBigInt
  username        String    @db.VarChar(100)       // Propietario del documento
  tipo_documento  String    @db.VarChar(50)        // Clasificación: cedula, nomina, etc.
  nombre_original String    @db.VarChar(255)       // Nombre original del archivo subido
  saved_filename  String    @db.VarChar(255)       // Nombre con el que se guardó en disco
  tipo_mime       String?   @db.VarChar(100)       // MIME type del archivo
  tamano_bytes    Int?                             // Tamaño en bytes
  ruta_archivo    String?   @db.VarChar(500)       // Ruta absoluta local
  api_path        String?   @db.VarChar(500)       // Ruta remota en SFTP (si aplica)
  api_filename    String?   @db.VarChar(255)       // Nombre del archivo en el servidor remoto
  solicitud_id    String    @db.VarChar(20)        // FK → solicitudes_credito.numero_solicitud
  activo          Boolean   @default(true)         // Soft delete
  created_at      DateTime? @db.Timestamp(0)
  updated_at      DateTime? @db.Timestamp(0)

  solicitudes_credito solicitudes_credito @relation(...)
  users               users               @relation(...)

  @@index([activo])
  @@index([api_path])
  @@index([solicitud_id])
  @@index([tipo_documento])
  @@index([username])
}