https://github.com/articulate/dynamoo
https://github.com/articulate/dynamoo
Last synced: about 1 year ago
JSON representation
- Host: GitHub
- URL: https://github.com/articulate/dynamoo
- Owner: articulate
- License: mit
- Created: 2018-11-19T05:55:08.000Z (over 7 years ago)
- Default Branch: master
- Last Pushed: 2019-11-22T16:53:17.000Z (over 6 years ago)
- Last Synced: 2025-04-12T13:57:47.237Z (over 1 year ago)
- Language: JavaScript
- Homepage:
- Size: 38.1 KB
- Stars: 2
- Watchers: 55
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
```
_______
< dynamoo >
-------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||
```
# dynamoo
[](https://www.npmjs.com/package/dynamoo)
[](https://www.npmjs.com/package/dynamoo)
[](https://travis-ci.org/articulate/dynamoo)
[](https://coveralls.io/github/articulate/dynamoo?branch=master)
Serialize and parse DynamoDB items.
## API
- [`serialize`](#serialize)
- [`parse`](#parse)
- [Caveat emptor](#caveat-emptor)
### `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:
```js
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:
```js
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:
```js
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:
```js
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:
```js
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! :heart_eyes:
```js
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. :wink: