Nationwide Polamorous Matrimony

    dynamoo

    0.1.0 • Public • Published
    _______
    < dynamoo >
     -------
            \   ^__^
             \  (oo)\_______
                (__)\       )\/\
                    ||----w |
                    ||     ||
    

    dynamoo

    npm version npm downloads Build Status Coverage Status

    Serialize and parse DynamoDB items.

    API

    serialize

    Serializing data to store in DynamoDB is hard, but dynamoo makes it easier. Suppose you have this item you want to putItem to DynamoDB:

    const item = {
      bool: true,
      func: Function.prototype,
      list: ['a', 1, false, null, { key: 'val' }],
      map: { key: 'val', nested: ['list'] },
      null: null,
      num: 42,
      set: new Set(['a', 'a', 'b']),
      string: 'strung',
      undef: undefined
    }

    Just serialize that data before sending, like this:

    const AWS = require('aws-sdk')
    const { serialize } = require('dynamoo')
     
    const dynamo = new AWS.DynamoDB()
     
    dynamo.putItem({ Item: serialize(item), TableName }, console.log)

    The serialized Item that gets sent looks like this:

    const Item = {
      bool: { BOOL: true },
      list: {
        L: [
          { S: 'a' },
          { N: '1' },
          { BOOL: false },
          { NULL: true },
          { M: { key: { S: 'val' } } }
        ]
      },
      map: {
        M: {
          key: { S: 'val' },
          nested: { L: [{ S: 'list' }] }
        }
      },
      null: { NULL: true },
      num: { N: '42' },
      set: { SS: ['a', 'b'] },
      string: { S: 'strung' }
    }

    Wow! It's like magic! Notice that any Function or undefined attributes are ignored, since the former doesn't serialize, and the latter technically doesn't exist.

    parse

    But wait... what about querying DynamoDB? The data.Items that are found need to be parsed. Got you covered on that as well:

    const { parse } = require('dynamoo')
     
    dynamo.query(params, (err, data) =>
      console.log(data.Items.map(parse))
    )

    Notice that parse accepts a single Item. So for query you'll need to .map(), but for getItem, you can use it like this:

    dynamo.getItem({ Key, TableName }, (err, data) =>
      console.log(parse(data.Item))
    )

    The careful observer will notice that - with the exception of Function and undefined attributes - the serialize and parse functions are isomorphic! 😍

    const { expect } = require('chai')
     
    expect(parse(serialize(item))).to.eql(item)

    Caveat emptor

    By design, dynamoo only supports the following data types for attributes:

    • Array
    • Boolean
    • null
    • Number
    • Object
    • Set (of strings)
    • String

    If you want to use any other fancier types, such as Map, or Set of numbers, etc., then you may need to do some additional work. Or file an issue. 😉

    Install

    npm i dynamoo

    DownloadsWeekly Downloads

    103

    Version

    0.1.0

    License

    MIT

    Unpacked Size

    6.65 kB

    Total Files

    4

    Last publish

    Collaborators

    • flintinatux