如何使用nodejs将数据添加到dynamoDB中的多条记录的列表中？

Question

Need solution to to add data to a List, of multiple records in dynamoDB using nodejs. Appreciate in advance.. Scenario i have 2 user.

user1 = {
  id: '',
  email: '',
  sendRequest: [
  ],
  request: [
  ],
  friendsList: [
  ],

};

user2 = {
  id: '',
  email: '',
  sendRequest: [
  ],
  request: [
  ],
  friendsList: [
  ],
 
};

If user1 sends a request to user2. i need to add requested user details to "user1.sendRequest" and also sender details to "user2.request" list.

I have tried below code but it only update 2nd item in TransactWriteItem object.

    TransactItems: [
      {
        Update: {
          TableName: usersTabel,
          Key: {
            id: { S: reqBody.reqId }
          },
          UpdateExpression: 'SET #sendRequest = list_append(if_not_exists(#sendRequest, :empty_list), :updateValue)',
          ExpressionAttributeNames: {
            '#sendRequest': 'sendRequest'
          },
          ExpressionAttributeValues: {
            ':updateValue': { L: [initiatorPost] },
            ':empty_list': { L: [] },
          },
        },
        Update: {
          TableName: usersTabel,
          Key: {
            id: { S: reqBody.sub }
          },
          UpdateExpression: 'SET #request = list_append(if_not_exists(#request, :empty_list), :updateValue)',
          ExpressionAttributeNames: {
            '#request': 'request'
          },
          ExpressionAttributeValues: {
            ':updateValue': { L: [recieverPost] },
            ':empty_list': { L: [] },
          },
        }
      }
    ]
  }


  return db
    .transactWriteItems(TransactItems)
    .promise()
    .then(() => {
      const callBackResponse = reqBody;
      callBackResponse.status ="success"
      callback(null, response(201, callBackResponse));
    })
    .catch((err) => response(null, response(err.statusCode, err)));

with new suggested approach.

Answer 1

New approach

I tested this approach works as expected:

var db = new AWS.DynamoDB.DocumentClient();
let updateItems = {
  TransactItems: [
    {
      Update: {
        TableName: usersTabel,
        Key: {
          id: reqBody.reqId
        },
        UpdateExpression: 'SET sendRequest = list_append(if_not_exists(sendRequest, :emptyValue), :updateValue)',
        ExpressionAttributeValues: {
          ':emptyValue': [],
          ':updateValue': [initiatorPost]
        }
      },
      Update: {
        TableName: usersTabel,
        Key: {
          id: reqBody.sub
        },
        UpdateExpression: 'SET myRequest = list_append(if_not_exists(myRequest, :emptyValue), :updateValue)',
        ExpressionAttributeValues: {
          ':emptyValue': [],
          ':updateValue': [recieverPost]
        }
      }
    }
  ]
}

return db.transactWrite(updateItems).promise().then(res => {
  console.log(res)
}).catch(err => {
  console.log(err, " ERROR")
});

Let me know if you get other issue through...

Answer 2

Below code works. Please suggest better solution if any?

'use strict';
const AWS = require('aws-sdk');
const db = new AWS.DynamoDB({ apiVersion: '2019.11.21' });

const usersTabel = process.env.USERS_TABLE;

function response(statusCode, message) {
  return {
    statusCode: statusCode,
    body: JSON.stringify(message),
    "headers": {"Access-Control-Allow-Origin":"*"}
  };
}

module.exports.sendRequest = (event, context, callback) => {
  // const reqBody = event;
  console.log("check event::::::::"+event);
  console.log("reqBody.reqId"+event.reqId);
  console.log("reqBody.sub"+event.sub)
  const reqBody = event;
  // const reqBody = JSON.parse(event.body);

  if (
    !reqBody.reqId ||
    reqBody.reqId.trim() === '' ||
    !reqBody.sub ||
    reqBody.sub.trim() === '' ||
    !reqBody.email ||
    reqBody.email.trim() === ''
  ) {
    return callback(
      null,
      response(400, {
        error: 'Post must have a reqId, sub and email and they must not be empty'
      })
    );
  }

  const initiatorPost = {
    M: {
      createdAt: { S: new Date().toISOString() },
      sub: { S: reqBody.sub },
      email: { S: reqBody.email }
    }
  };
  const recieverPost = {
    M: {
      createdAt: { S: new Date().toISOString() },
      sub: { S: reqBody.reqId },
      email: { S: reqBody.reqEmail },
      friendshipStatus: { S: "pending" }
    }
  };
  
  const TransactItems1 = {
    TransactItems: [
      {
        Update: {
          TableName: usersTabel,
          Key: {
            id: { S: reqBody.reqId }
          },
          UpdateExpression: 'SET #sendRequests = list_append(#sendRequests, :updateValue)',
          ExpressionAttributeNames: {
            '#sendRequests': 'sendRequests'
          },
          ExpressionAttributeValues: {
            ':updateValue': { L: [initiatorPost] }
          },
        }
      }
    ]
  };
  const TransactItems2 = {
    TransactItems: [
      {
        Update: {
          TableName: usersTabel,
          Key: {
            id: { S: reqBody.sub }
          },
          UpdateExpression: 'set #myRequests = list_append(#myRequests, :updateValue)',
          ExpressionAttributeNames: {
            '#myRequests': 'myRequests'
          },
          ExpressionAttributeValues: {
            ':updateValue': { L: [recieverPost] }
          },
        }
      }
    ]
  }

  return db
    .transactWriteItems(TransactItems1)
    .promise()
    .then(() => {
      return db
              .transactWriteItems(TransactItems2)
              .promise()
              .then(() => {
                const callBackResponse = reqBody;
                callBackResponse.status ="success"
                callback(null, response(201, callBackResponse));
              })
              .catch((err) => response(null, response(err.statusCode, err)));
    })
    .catch((err) => response(null, response(err.statusCode, err)));

};

Answer 3

Fixed the syntax and works as expected. Below is the Before(where i had issue) and After(is the fix).

Before.
TransactItems: [
  {
   Update: {},
   Update: {},
  }
]

After
TransactItems: [
  {
   Update: {},
  },
  {
   Update: {},
  }
]

whole code.

const params = {
        TransactItems: [
            {
                Update: {
                    TableName: usersTabel,
                    Key: {
                        id: { S: reqBody.reqId }
                    },
                    UpdateExpression: 'SET #sendRequests = list_append(#sendRequests, :updateValue)',
                    ExpressionAttributeNames: {
                        '#sendRequests': 'sendRequests'
                    },
                    ExpressionAttributeValues: {
                        ':updateValue': { L: [initiatorPost] }
                    },
                }
            },
            {
                Update: {
                    TableName: usersTabel,
                    Key: {
                        id: { S: reqBody.sub }
                    },
                    UpdateExpression: 'SET #myRequests = list_append(#myRequests, :updateValue)',
                    ExpressionAttributeNames: {
                        '#myRequests': 'myRequests'
                    },
                    ExpressionAttributeValues: {
                        ':updateValue': { L: [recieverPost] }
                    },
                }
            }
       
        ]
    };