@alextomas80/api-client-grupeta/src/services/strava.ts

Cliente API Grupeta CBR

type GetAccessTokenProps = {
  client_id: string;
  client_secret: string;
  code: string;
  grant_type?: string;
};

type GetAccessTokenResponse = {
  expires_at: number;
  expires_in: number;
  refresh_token: number;
  access_token: number;
  athlete: any;
};

export const getAccessTokenStrava = async ({
  client_id,
  client_secret,
  code,
  grant_type = "authorization_code",
}: GetAccessTokenProps): Promise<GetAccessTokenResponse> => {
  try {
    const tokenResponse = await fetch("https://www.strava.com/oauth/token", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        client_id,
        client_secret,
        code,
        grant_type: "authorization_code",
      }),
    });

    const tokenData = (await tokenResponse.json()) as GetAccessTokenResponse;
    return tokenData;
  } catch (error) {
    console.warn("No se ha podido completar la petición a Strava", error);
    throw new Error("No se ha podido completar la petición a Strava.");
  }
};

type RefreshTokenProps = {
  client_id: string;
  client_secret: string;
  refresh_token: string;
  grant_type?: string;
};

type RefreshTokenResponse = {
  token_type: string;
  access_token: string;
  expires_at: number;
  expires_in: number;
  refresh_token: string;
};

export const refreshTokenStrava = async ({
  client_id,
  client_secret,
  refresh_token,
  grant_type = "refresh_token",
}: RefreshTokenProps): Promise<RefreshTokenResponse> => {
  try {
    const response = await fetch("https://www.strava.com/oauth/token", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ client_id, client_secret, refresh_token, grant_type }),
    });

    const data = (await response.json()) as RefreshTokenResponse;
    return data;
  } catch (error) {
    console.warn("No se ha podido refrescar el token", error);
    throw new Error("No se ha podido refrescar el token.");
  }
};

export type RoutesStravaResponse = {
  id: string;
  name: string;
  distance: number;
  elevation_gain: number;
  estimated_moving_time: number;
};
export const getUserRoutes = async (userId: string, accessToken: string): Promise<RoutesStravaResponse[]> => {
  try {
    const response = await fetch(`https://www.strava.com/api/v3/athletes/${userId}/routes?per_page=200`, {
      method: "GET",
      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
    });

    const data = await response.json();

    return data.map((route: any) => {
      return {
        id: route.id_str,
        name: route.name,
        distance: route.distance,
        elevation_gain: route.elevation_gain,
        estimated_moving_time: route.estimated_moving_time,
      };
    });
  } catch (error) {
    console.warn("No se han podido obtener las rutas", error);
    throw new Error("No se han podido obtener las rutas");
  }
};