Normalisation de la réponse JSON du serveur avant la mise à jour de l'état Redux

Question

Mon paradigme préféré (et probablement celui de tout le monde) est que le serveur ne pense pas à sérialiser sa réponse JSON car il ne se soucie pas du client qui le consomme. Dit d'une autre manière, ma charge utile django JSON est écrite en cas de serpent selon les normes. Avant que ceci puisse mettre à jour l'état dans mon magasin de Redux les clefs devraient être mappées au cas de chameau selon les normes de Javascript. Les développeurs de Python ne croient pas que cela en vaille la peine, qu'il a un point juste, mais il se sent juste mal de ne pas suivre la convention.

Comment cela devrait-il être géré ??

Answer 1

Ce que j'ai l'habitude d'être est un middleware qui gère toutes mes demandes de récupération, là je peux intercepter la réponse et transformer les clés en camelCase en utilisant Humps.

// fetchMiddleware.js 
export default ({ dispatch, getState }) => next => (action) => { 
    if (typeof action === 'function') { 
    return action(dispatch, getState); 
    } 

    const { promise, types, ...rest } = action; 

    // this middleware expects a promise object in the action, 
    // the object contains all configurations to send the request to 
    // the server, if no promise is defined then it just ignores this action 
    if (!promise) { 
    return next(action); 
    } 

    return fetch(promise.url, promise) 
    .then(response => Promise.resolve(humps.camelizeKeys(response))) 
    .then(data => dispatch({ type: types[1], data })) 
    .catch(error => dispatch({ type: types[2], error })); 
} 

Ensuite, dans certains composants ou ailleurs, l'action sera expédié comme ceci:

store.dispatch({ 
    types: ['BEFORE_REQUEST', 'REQUEST_SUCCESS', 'REQUEST_FAIL'], 
    promise: { 
    url: 'some/api.json', 
    params: { x, y }, 
    }, 
}); 

J'ai habituellement un utilitaire pour gérer le Fetch, mais cela vous donnera l'idée sur la façon de faire face à la transformation de camelCase.

Answer 2

Il semble que vous vouliez un analyseur spécial et/ou un moteur de rendu pour basculer entre le boîtier du chameau et le boîtier du serpent. Si vous utilisez Django Rest Framework, vous pouvez utiliser le JSONRenderer pour créer une nouvelle sous-classe telle que CamelCaseJSONRenderer afin qu'elle permute automatiquement d'avant en arrière.

à la base, vous aurez envie de mettre en œuvre une fonction qui ressemble à quelque chose comme ceci:

def to_camelcase(string, lower_first_char=True): 
    """Takes snakecase string and converts to camelcase.""" 
    camelize = ''.join(char.capitalize() for char in word.split('_')) 
    result = (camelize[0].lower() + result[1:]) if lower_first else camelize 
    return result 

def parse(data, lower_first=True): 
    """Camelcase the keys of a dictionary or items of a list.""" 
    if isinstance(data, dict): 
     result = {to_camelcase(k): parse(v) for k, v in data.items()} 
    elif isinstance(data, list): 
     result = [parse(item) for item in data] 
    else: 
     result = data 
    return result 

Vous pouvez alors exécuter ces fonctions dans le CamelCaseJSONRenderer personnalisé et ajoutez le générateur de votre point de vue. De cette façon, tous les objets python sont snakecase sur le dos et camelcase dans votre javascript.