{ 'id': req.body.groups.id, 'title': req.body.groups.title, 'teamMemberIds': [ req.body.groups.teamMemberIds] }]

You cannot access fields of array's elements like this: req.body.groups.id, req.body.groups.title and req.body.groups.teamMemberIDs. In order to get the fields in the nested array you would have to do something like this req.body.groups[index].id.

But doing all of that is not necessary, since your req.body and mongoose schema are the same you can simply pass in the whole req.body.groups into groups like shown below.

app.post(`/api/add`, async (req, res) => {
    collection.create( {  'id': req.body.id, 
                        'name': req.body.name, 
                        'date': req.body.date,
                        'groups': req.body.groups //change this line of code.
                    }, 
    (err, result ) => {
        if (err) {
            console.log('error', err)
        } else {
            console.log('updated', result);
            res.status(200).send(result);
        }
    })
});

Or even better you could just add the entire req.body to collection.create()

app.post(`/api/add`, async (req, res) => {
    collection.create(req.body, 
    (err, result ) => {
        if (err) {
            console.log('error', err)
        } else {
            console.log('updated', result);
            res.status(200).send(result);
        }
    })
});

In case when your req.body and mongoose schema have different formats, then for the array parts you can use the array method map to change the array format prior to document creation.

You can use body-parser in your app.js like this:

app.use(bodyParser.urlencoded({ 
     extended: true 
}));

Let's say you are receiving array in the post request body with the key: users you will parse it like this:

req.body.users

(It contains the users array)

req.write(JSON.stringify(myobj));

router.post('myroute', function( req, res ){
    console.dir(req.body);
})

The /transfer endpoint receives obj as 'array[0]': '3', 'array[1]': '4', 'array[2]': '5' because the Content-Type of the HTTP request is application/x-www-form-urlencoded -- in the request.post() option, form property is used.

In order to send JSON object to /transfer, the Content-Type should be application/json. In module request, it can be implemented as below:

var request = require('request');

var obj={
  tag: 'false',
  array: [ '3', '4', '5']
};

// requestb.in URL is used here for example, but it can be replaced.
request({
  url: 'https://requestb.in/srp1bmsr',
  method: 'post',
  body: obj,
  json: true
}, function(err, response, body) {
  if(err){
    // deal with error.
  }else{
    // deal with success response.
  }
});

According to module request's document, body and json in the code means:

body - entity body for PATCH, POST and PUT requests. Must be a Buffer, String or ReadStream. If json is true, then body must be a JSON-serializable object.

json - sets body to JSON representation of value and adds Content-type: application/json header. Additionally, parses the response body as JSON.

Because the body here is and array, to get the Id property, you'd need to use body[0].Id.

But if there's ever a chance that there's more than one object in the array, to get each of the Ids, you'd have to loop over the body:

for(let i = 0, l = body.length; i < l; i++) { console.log(body[i].Id); // gets the Id property of this specific object in body }

Trying to access and Array from an multipart-form-data is a little bit tricky, but you can inspect the req.body and figure it out, the best solution for me in this case will be, since I think you're using jQuery or for that matter, native XMLHttpRequest or Fetch, you can send the form content as application/json, quick jQuery example:

const data = {
  fields: [1, 2, 3]
}
jQuery.ajax({
   data: JSON.stringify(data),
   contentType: 'application/json'
})

Then in your express route you can access in a very comfortable manner, like this:

app.post('/route', function(req, res) {
    const fieldsArray = req.body.field;
})

Hope this will be helpful, cheers.

In Rest GET methods uses the URL as the method to transfer information if you want to use the property data in your AJAX call to send more information you need to change the method to a POST method.

So in the server you change your declaration to:

app.post( instead of app.get(

Figured it out. I just had to stringify the data on the front end, and then parse it on the back end. Like this:

Front end ajax call. I JSON.stringify the array data.

 $.ajax({
                url: '/postGateway',
                method: 'POST',
                data: {
                    analyst: analyst,
                    building_number: building_number,
                    commodity_tag: commodity_tag,
                    meter: meter,
                    timestamp: JSON.stringify(timestamp),
                    values: JSON.stringify(values),
                    reason: JSON.stringify(reason),
                    notes: JSON.stringify(notes)

                },
})

And then I parse the req.body variables in the back end. And now my data submits perfectly!

const postdata = JSON.stringify({
                'analyst': analyst,
                'building_number': building_number,
                'commodity_tag': commodity_tag,
                'meter': meter,
                'data': {
                    'timestamp': JSON.parse(timestamp),
                    'value': JSON.parse(values),
                    'reason': JSON.parse(reason),
                    'notes': JSON.parse(notes)
                }
            })

You can send your array with the Postman by following the steps below:

your json must be like this:

    {
    "data" : [
                {   "name": "ABC",
                    "amount": 1500                    
                },
                {   "name": "NNS",
                    "amount": 5800                    
                },
                {   "name": "GED",
                    "amount": 3500                    
                },
                {   "name": "PQ",
                    "amount": 5500                    
                }
        ]
    }

and you can retrieve this POST query in node (express) like this:

    var bodyParser = require('body-parser')
    app.use( bodyParser.json() );       // to support JSON-encoded bodies
    app.use(bodyParser.urlencoded({     // to support URL-encoded bodies
      extended: true
    })); 

    app.post('/people', function(req, res, next) {
      //show received data
       console.log(req.body.data);
    });

It's quite easy if you read the manual of request. All you should do is replace the form by querystring rather than object, in your case this should be:

amounts=15&amounts=30

the only thing I'm not sure is the above expression works in your web server. As I know it works well in java struts. So if not you may try amounts[]=15&amounts[]=30 instead. Hope it help.

Ok, from your question I understand that you want to manipulate the POST Body like a json array then use qs library by making extended true

app.use(bodyParser.urlencoded({ extended: true }));

Basically a comment on @udidu's good answer, but I want markdown formatting so I'll post it as an answer. Here's some minor improvement suggestions:

• Omit everything but the path from the url "/deleteIds" on the javascript side so it will work no matter how it is served.

• You can send the array as a JSON string without an object wrapper

  $.ajax({
      url: '/deleteIds',
      type: 'DELETE',
      data: JSON.stringify([1, 2, 3]),
      contentType: "application/json",
      processData: false,
      success: function(data){
          console.log(data);
      }
  });
  

• In the server, the array will be available as just req.body

• As per REST conventions, this should be using the HTTP DELETE method (I've changed the jquery. You will also need to change the express code to do app.del instead of app.post).

One option is using a JSON format.

http://server/url?array=["foo","bar"]

Server side

var arr = JSON.parse(req.query.array);

Or your own format

http://server/url?array=foo,bar

Server side

var arr = req.query.array.split(',');