scan - Formateo de datos de DynamoDB a JSON normal en AWS Lambda

update dynamodb node

Question

Estoy usando AWS Lambda para escanear datos de una tabla DynamoDB . Esto es lo que recibo a cambio:

{
  "videos": [
    {
      "file": {
        "S": "file1.mp4"
      },
      "id": {
        "S": "1"
      },
      "canvas": {
        "S": "This is Canvas1"
      }
    },
    {
      "file": {
        "S": "main.mp4"
      },
      "id": {
        "S": "0"
      },
      "canvas": {
        "S": "this is a canvas"
      }
    }
  ]
}

Mi aplicación de aplicaciones para usuario está utilizando el adaptador de descanso de datos Ember que no acepta dicha respuesta. ¿Hay alguna manera de que pueda obtener el formato JSON normal? Existe este módulo NPM llamado dynamodb-marshaler para convertir los datos de DynamoDB a JSON normal. Estoy buscando una solución nativa si es posible.

Answer 1

AWS JavaScript SDK se actualizó recientemente con Document Client, que hace exactamente lo que necesita. Consulte los ejemplos de anuncios y uso aquí: http://blogs.aws.amazon.com/javascript/post/Tx1OVH5LUZAFC6T/Announcing-the-Amazon-DynamoDB-Document-Client-in-the-AWS-SDK-for-JavaScript

Answer 2

Aquí puedes encontrar la esencia que hace eso:

function mapper(data) {

let S = "S";
let SS = "SS";
let NN = "NN";
let NS = "NS";
let BS = "BS";
let BB = "BB";
let N = "N";
let BOOL = "BOOL";
let NULL = "NULL";
let M = "M";
let L = "L";

if (isObject(data)) {
    let keys = Object.keys(data);
    while (keys.length) {
        let key = keys.shift();
        let types = data[key];

        if (isObject(types) && types.hasOwnProperty(S)) {
            data[key] = types[S];
        } else if (isObject(types) && types.hasOwnProperty(N)) {
            data[key] = parseFloat(types[N]);
        } else if (isObject(types) && types.hasOwnProperty(BOOL)) {
            data[key] = types[BOOL];
        } else if (isObject(types) && types.hasOwnProperty(NULL)) {
            data[key] = null;
        } else if (isObject(types) && types.hasOwnProperty(M)) {
            data[key] = mapper(types[M]);
        } else if (isObject(types) && types.hasOwnProperty(L)) {
            data[key] = mapper(types[L]);
        } else if (isObject(types) && types.hasOwnProperty(SS)) {
            data[key] = types[SS];
        } else if (isObject(types) && types.hasOwnProperty(NN)) {
            data[key] = types[NN];
        } else if (isObject(types) && types.hasOwnProperty(BB)) {
            data[key] = types[BB];
        } else if (isObject(types) && types.hasOwnProperty(NS)) {
            data[key] = types[NS];
        } else if (isObject(types) && types.hasOwnProperty(BS)) {
            data[key] = types[BS];
        }
    }
}


return data;

function isObject(value) {
    return typeof value === "object" && value !== null;
}

}

https://gist.github.com/igorzg/c80c0de4ad5c4028cb26cfec415cc600

Answer 3

Creo que es solo un ejercicio de transformación personalizado para cada aplicación. Una conversión simple del formato de elemento de DynamoDB a su formato de aplicación podría verse así:

var response = {...} // your response from DynamoDB
var formattedObjects = response.videos.map(function(video) {
    return {
        "file": video.file.S,
        "id": video.id.S,
        "canvas": video.canvas.S
    };
});

Si desea crear un sistema genérico para esto, tendría que manejar los diversos tipos de AttributeValue de DynamoDB. Una función como la que aparece a continuación haría el trabajo, pero he dejado de lado el arduo trabajo de manejar la mayoría de los tipos de valores de atributos más complejos de DynamoDB:

function dynamoItemToPlainObj(dynamoItem) {
    var plainObj = {};
    for (var attributeName in dynamoItem) {
        var attribute = dynamoItem[attributeName];
        var attributeValue;
        for (var itemType in attribute) {
            switch (itemType) {
            case "S":
                attributeValue = attribute.S.toString();
                break;
            case "N":
                attributeValue = Number(attribute.N);
                break;
                // more attribute types...
            default:
                attributeValue = attribute[itemType].toString();
                break;
            }
        }
        plainObj[attributeName] = attributeValue;
    }
    return plainObj;
}    
var formattedObjects = response.videos.map(dynamoItemToPlainObj);

Answer 4

En realidad, debe usar la función AWSJavaScriptSDK de AWSJavaScriptSDK :

const AWS = require("aws-sdk");

exports.handler = function( event, context, callback ) {
  const newImages = event.Records.map(
        (record) => AWS.DynamoDB.Converter.unmarshall(record.dynamodb.NewImage)
  );
  console.log(''Converted records'', newImages);
  callback(null, `Success`);
}

Answer 5

Sé que es un poco viejo, pero tuve el mismo problema al procesar datos de flujo de dynamoDB en la función node js lambda. Utilicé la propuesta de @churro.

Importar SDK y convertidor de salida

var AWS = require("aws-sdk");
var parse = AWS.DynamoDB.Converter.output;

Usa la función de análisis con un pequeño truco.

exports.handler = function( event, context, callback ) {
  var docClient = new AWS.DynamoDB.DocumentClient();
  event.Records.forEach((record) => {
        console.log(record.eventID);
        console.log(record.eventName);
        console.log(''DynamoDB Record:'', parse({ "M": record.dynamodb.NewImage }));
    });
  callback(null, `Successfully processed ${event.Records.length} records.`);
}

Espero eso ayude

Answer 6

Si necesitas editor en línea prueba esto

https://2json.net/dynamo