add prefix, suffix, and composite key delimiters

Author: jeremydaly

README.md

@@ -369,6 +369,9 @@ For more control over an attribute's behavior, you can specify an object as the
 | alias  | `string` | all | Adds a bidirectional alias to the attribute. All input methods can use either the attribute name or the alias when passing in data. Auto-parsing and the `parse` method will map attributes to their alias. |
 | map  | `string` | all | The inverse of the `alias` option, allowing you to specify your alias as the key and map it to an attribute name. |
 | setType  | `string` | `set` | Specifies the type for `set` attributes. Allowed values are `string`,`number`,`binary` |
+| delimiter  | `string` | *composite keys* | Specifies the delimiter to use if this attribute stores a composite key (see [Using an `array` for composite keys](#using-an-array-for-composite-keys)) |
+| prefix  | `string` | `string` | A prefix to be added to an attribute when saved to DynamoDB. This prefix will be removed when parsing the data. |
+| suffix  | `string` | `string` | A suffix to be added to an attribute when saved to DynamoDB. This suffix will be removed when parsing the data. |
 | partitionKey  | `boolean` or `string` | all | Flags an attribute as the 'partitionKey' for this Entity. If set to `true`, it will be mapped to the Table's `partitionKey`. If set to the name of an **index** defined on the Table, it will be mapped to the secondary index's `partitionKey` |
 | sortKey  | `boolean` or `string` | all | Flags an attribute as the 'sortKey' for this Entity. If set to `true`, it will be mapped to the Table's `sortKey`. If set to the name of an **index** defined on the Table, it will be mapped to the secondary index's `sortKey` |
 
@@ -390,7 +393,7 @@ attributes: {
 
 **NOTE:** The interface for composite keys may be changing in v0.2 to make it easier to customize.
 
-Composite keys in DynamoDB are incredibly useful for creating hierarchies, one-to-many relationships, and other powerful querying capabilities (see [here](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-sort-keys.html)). The DynamoDB Toolbox lets you easily work with composite keys in a number of ways. In many cases, there is no need to store the data in the same record twice if you are already combining it into a single attribute. By using composite key mappings, you can store data together in a single field, but still be able to structure input data *and* parse the output into separate attributes.
+Composite keys in DynamoDB are incredibly useful for creating hierarchies, one-to-many relationships, and other powerful querying capabilities (see [here](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-sort-keys.html)). The DynamoDB Toolbox lets you easily work with composite keys in a number of ways. In some cases, there is no need to store the data in the same record twice if you are already combining it into a single attribute. By using composite key mappings, you can store data together in a single field, but still be able to structure input data *and* parse the output into separate attributes.
 
 The basic syntax is to specify an `array` with the mapped attribute name as the first element, and the index in the composite key as the second element. For example:
 
@@ -404,7 +407,7 @@ attributes: {
 }
 ```
 
-This maps the `status` and `date` attributes to the `sk` attribute. If a `status` and `date` are supplied, they will be combined into the `sk` attribute as `[status]#[date]`. When the data is retrieved, the `parse` method will automatically split the `sk` attribute and return the values with `status` and `date` keys. By default, the values of composite keys are not stored as separate attributes, but that can be changed by adding in an option configuration as the third array element.
+This maps the `status` and `date` attributes to the `sk` attribute. If a `status` and `date` are supplied, they will be combined into the `sk` attribute as `[status]#[date]`. When the data is retrieved, the `parse` method will automatically split the `sk` attribute and return the values with `status` and `date` keys. By default, the values of composite keys are stored as separate attributes, but that can be changed by adding in an option configuration as the third array element.
 
 **Passing in a configuration**
 Composite key mappings are `string`s by default, but can be overridden by specifying either `string`,`number`, or `boolean` as the third element in the array. Composite keys are automatically coerced into `string`s, so only the aforementioned types are allowed. You can also pass in a configuration `object` as the third element. This uses the same configuration properties as above. In addition to these properties, you can also specify a `boolean` property of `save`. This will write the value to the mapped composite key, but also add a separate attribute that stores the value.
@@ -413,7 +416,7 @@ Composite key mappings are `string`s by default, but can be overridden by specif
 attributes: {
   user_id: { partitionKey: true  },
   sk: { hidden: true, sortKey: true },
-  status: ['sk',0, { type: 'boolean', save: true, default: true }],
+  status: ['sk',0, { type: 'boolean', save: false, default: true }],
   date: ['sk',1, { required: true }],
   ...
 }

__tests__/entities/simple-entity.js

@@ -10,7 +10,7 @@ module.exports = {
     sk: { type: 'string', hidden: true, sortKey: true },
     test: { type: 'string' },
     test_composite: ['sk',0, { save: true }],
-    test_composite2: ['sk',1],
+    test_composite2: ['sk',1, { save: false }],
     test_undefined: { default: () => undefined }
   }
 }

__tests__/entity-creation.unit.test.js

@@ -2,6 +2,8 @@
 const Table = require('../classes/Table')
 const Entity = require('../classes/Entity')
 
+const { DocumentClient } = require('./bootstrap-tests')
+
 describe('Entity creation', ()=> {
 
   it('creates basic entity w/ defaults', async () => {
@@ -343,4 +345,133 @@ describe('Entity creation', ()=> {
     expect(TestEntity._etAlias).toBe('entity')
   }) // creates entity w/ table
 
-})
+
+  it('creates entity composite key delimiter, prefix and suffix', async () => {
+  
+    // Create basic table
+    const TestTable = new Table({
+      name: 'test-table',
+      partitionKey: 'pk',
+      DocumentClient
+    })
+
+    // Create basic entity
+    const TestEntity = new Entity({
+      name: 'TestEnt',
+      attributes: {
+        pk: { partitionKey: true },
+        sk: { delimiter: '|', prefix: 'test---', suffix: '-end', map: 'skx' },
+        test0: ['sk',0],
+        test1: ['sk',1],
+        test2: ['sk',2],
+        comp1: {},
+        test0c: ['comp1',0, { save: false }],
+        test1c: ['comp1',1],
+        test2c: ['comp1',2]
+      },
+      table: TestTable,
+      timestamps: false
+    })
+
+    let result = TestEntity.putParams({
+      pk: 'test',
+      test0: '0',
+      test1: '1',
+      test2: '2',
+      test0c: '0',
+      test1c: 1,
+      test2c: '2'
+    })
+
+    expect(result).toEqual({
+      TableName: 'test-table',
+      Item: {
+        skx: 'test---0|1|2-end',
+        comp1: '0#1#2',
+        _et: 'TestEnt',
+        pk: 'test',
+        test0: '0',
+        test1: '1',
+        test2: '2',
+        test1c: '1',
+        test2c: '2'
+      }
+    })
+    
+    expect(TestEntity.parse({
+      skx: 'test---0|1|2-end',
+      comp1: '0#1#2',
+      _et: 'TestEnt',
+      pk: 'test',
+      test0: '0',
+      test1: '1',
+      test2: '2',
+      test1c: '1',
+      test2c: '2'
+    })).toEqual({
+      sk: '0|1|2',
+      test0c: '0',
+      comp1: '0#1#2',
+      entity: 'TestEnt',
+      pk: 'test',
+      test0: '0',
+      test1: '1',
+      test2: '2',
+      test1c: '1',
+      test2c: '2'
+    })
+
+
+  })
+
+
+  it('creates an attribute with a prefix and suffix', async () => {
+    
+    // Create basic table
+    const TestTable = new Table({
+      name: 'test-table',
+      partitionKey: 'pk',
+      DocumentClient
+    })
+
+    // Create basic entity
+    const TestEntity = new Entity({
+      name: 'TestEnt',
+      attributes: {
+        pk: { partitionKey: true, prefix: '#user#' },
+        test: { prefix: 'startX--', suffix: '--endX' },
+        num: { type: 'number' }
+      },
+      table: TestTable,
+      timestamps: false
+    })
+
+    let result = TestEntity.putParams({
+      pk: 'test',
+      test: 'testx',
+      num: 5
+    })
+
+    expect(result).toEqual({
+      TableName: 'test-table',
+      Item: {
+        _et: 'TestEnt',
+        pk: '#user#test',
+        test: 'startX--testx--endX',
+        num: 5
+      }
+    })
+    
+    expect(TestEntity.parse({
+        _et: 'TestEnt',
+        pk: '#user#test',
+        test: 'startX--testx--endX',
+        num: 5
+      })).toEqual({
+        entity: 'TestEnt', pk: 'test', test: 'testx', num: 5
+      })
+
+
+  }) // creates attribute with prefix/suffix
+
+})

__tests__/entity.parse.unit.test.js

@@ -79,7 +79,7 @@ describe('parse',()=>{
     expect(item).toEqual({
       pk: 'test@test.com',
       test_composite: 'test',
-      test_composite2: 'email',
+      test_composite2: 'email'
     })
   })
 

__tests__/entity.put.unit.test.js

@@ -35,8 +35,8 @@ const TestEntity = new Entity({
     test_number_set_type_coerce: { type: 'set', setType: 'number', coerce: true },
     test_binary: { type: 'binary' },
     simple_string: 'string',
-    test_composite: ['sort',0, { save: true }],
-    test_composite2: ['sort',1]
+    test_composite: ['sort',0],
+    test_composite2: ['sort',1, { save: false }]
   },
   table: TestTable
 })
@@ -53,8 +53,8 @@ const TestEntity2 = new Entity({
   attributes: {
     email: { type: 'string', partitionKey: true },
     sort: { type: 'string', map: 'sk' },
-    test_composite: ['sort',0, { save: true }],
-    test_composite2: ['sort',1]
+    test_composite: ['sort',0],
+    test_composite2: ['sort',1, { save: false }]
   },
   table: TestTable2
 })
@@ -145,6 +145,7 @@ describe('put',()=>{
       test_composite: 'test',
       test_composite2: 'test2'
     })
+    
     expect(Item.pk).toBe('test-pk')
     expect(Item.sk).toBe('override')
     expect(Item.test_composite).toBe('test')

__tests__/formatItem.unit.test.js

@@ -27,8 +27,8 @@ DefaultTable.entities = new Entity({
     list: { type: 'list', alias: 'list_alias' },
     list_alias2: { type: 'list', map: 'list2' },
     test: 'map',
-    linked1: ['sk',0],
-    linked2: ['sk',1]
+    linked1: ['sk',0, { save: false }],
+    linked2: ['sk',1, { save: false }]
   }
 })
 
@@ -64,7 +64,7 @@ describe('formatItem', () => {
   })
 
   it('formats item with linked fields', () => {
-    let result = formatItem(DocumentClient)(DefaultTable.User.schema.attributes,DefaultTable.User.linked,{ sk: 'test1#test2' })
+    let result = formatItem(DocumentClient)(DefaultTable.User.schema.attributes,DefaultTable.User.linked,{ sk: 'test1#test2' })  
     expect(result).toEqual({ sk: 'test1#test2', linked1: 'test1', linked2: 'test2' })
   })
 

__tests__/parseCompositeKey.unit.test.js

@@ -8,10 +8,10 @@ const attributes = {
 describe('parseCompositeKey', () => {
 
   it('converts item config to linked mapping', async () => {
-    let result = parseCompositeKey('linked',['sk',0, { save:true }],{linked:{}},attributes)  
-    expect(result).toEqual({ linked: { save: true, type: 'string', coerce: true, link: 'sk', pos: 0 } })
+    let result = parseCompositeKey('linked',['sk',0, { save:false }],{linked:{}},attributes)  
+    expect(result).toEqual({ linked: { save: false, type: 'string', coerce: true, link: 'sk', pos: 0 } })
     let result2 = parseCompositeKey('linked2',['sk',1],{linked:{}},attributes)  
-    expect(result2).toEqual({ linked2: { type: 'string', coerce: true, link: 'sk', pos: 1 } })
+    expect(result2).toEqual({ linked2: { save: true, type: 'string', coerce: true, link: 'sk', pos: 1 } })
   })
 
   it('fails on missing mapped field', async () => {

__tests__/tables/create-table.json

@@ -14,7 +14,7 @@
     },
     {
       "AttributeName": "GSI1sk",
-      "AttributeType": "S"
+      "AttributeType": "N"
     }
   ],
   "KeySchema": [

lib/formatItem.js

@@ -19,11 +19,16 @@ module.exports = (DocumentClient) => (attributes,linked,item,include=[]) => {
 
   return Object.keys(item).reduce((acc,field) => {
 
-    if (linked[field]) {
-      Object.assign(acc, linked[field].reduce((acc,f,i) => {
-        if (attributes[f].save || attributes[f].hidden || (include.length > 0 && !include.includes(f))) return acc
+    if (linked[field] || linked[attributes[field].alias]) {
+      Object.assign(acc, (linked[field] || linked[attributes[field].alias]).reduce((acc,f,i) => {
+        if (attributes[f].save || attributes[f].hidden || (include.length > 0 && !include.includes(f))) return acc    
         return Object.assign(acc,{
-          [attributes[f].alias || f]: validateType(attributes[f],f,item[field].split('#')[i])
+          [attributes[f].alias || f]: validateType(attributes[f],f,
+            item[field]
+              .replace(new RegExp(`^${escapeRegExp(attributes[field].prefix)}`),'')
+              .replace(new RegExp(`${escapeRegExp(attributes[field].suffix)}$`),'')
+              .split(attributes[field].delimiter || '#')[i]
+          )
         })
       },{}))
     }
@@ -32,7 +37,17 @@ module.exports = (DocumentClient) => (attributes,linked,item,include=[]) => {
     // Extract values from sets
     if (attributes[field] && attributes[field].type === 'set' && Array.isArray(item[field].values)) { item[field] = item[field].values } 
     return Object.assign(acc,{
-      [(attributes[field] && attributes[field].alias) || field]: item[field]
+      [(attributes[field] && attributes[field].alias) || field]: (
+        attributes[field].prefix || attributes[field].suffix
+          ? item[field]
+            .replace(new RegExp(`^${escapeRegExp(attributes[field].prefix)}`),'')
+            .replace(new RegExp(`${escapeRegExp(attributes[field].suffix)}$`),'')
+          : item[field]
+      )
     })
   },{})
 }
+
+function escapeRegExp(text) {
+  return text ? text.replace(/[-[\]{}()*+?.,\\^$|#]/g, '\\$&') : ''
+}

lib/normalizeData.js

@@ -18,7 +18,11 @@ module.exports = (DocumentClient) => (schema,linked,data,filter=false) => {
   let _data = Object.keys(data).reduce((acc,field) => {
 
     return Object.assign(acc,
-      schema[field] ? { [schema[field].map || field] : data[field] }
+      schema[field] ? { [schema[field].map || field] : (
+        schema[field].prefix || schema[field].suffix 
+          ? `${schema[field].prefix || ''}${data[field]}${schema[field].suffix || ''}`
+          : data[field]
+      )}
       : filter ? {} // this will filter out non-mapped fields
       : field === '$remove' ? { $remove: data[field] } // support for removes
       : error(`Field '${field}' does not have a mapping or alias`)
@@ -41,9 +45,12 @@ module.exports = (DocumentClient) => (schema,linked,data,filter=false) => {
     // TODO: add required fields
     // if (values.length > 0 && values.length !== linked[field].length) {
     //   error(`${linked[field].join(', ')} are all required for composite key`)
-    // } else
+    // } else  
+
     if (values.length === linked[attr].length) {
-      return Object.assign(acc, { [field]: values.join('#') })
+      return Object.assign(acc, { 
+        [field]: `${schema[attr].prefix || ''}${values.join(schema[attr].delimiter || '#')}${schema[attr].suffix || ''}`
+      })
     } else {
       return acc
     }