@terascope/data-mate / index

index

Variables

FieldTransform

const FieldTransform: object

Defined in: data-mate/src/index.ts:13

Type declaration

repository

repository: Repository

decodeBase64()

decodes a base64 encoded value if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const str = 'hello world';
const encoded = encodeBase64(str);

const results = FieldTransform.decodeBase64(encoded)
results === str

 FieldTransform.decodeBase64([encoded]) === [str]

decodeHex()

decodes the hex encoded input if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const source = 'hello world';
const encoded = encodeHex(source);

FieldTransform.decodeHex(encoded); // source;
FieldTransform.decodeHex([encoded]); // [source];

decodeURL()

decodes a URL encoded value if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`StringInput`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const source = 'HELLO AND GOODBYE';
const encoded = 'HELLO%20AND%20GOODBYE';

FieldTransform.decodeURL(encoded); // source;
FieldTransform.decodeURL([encoded]); //[source];

encodeBase64()

converts a value into a base64 encoded value if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const str = 'hello world';

const encodedValue = FieldTransform.encodeBase64(str);
const arrayOfEncodedValues = FieldTransform.encodeBase64([str]);

encodeHex()

hex encodes the input if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const source = 'hello world';

FieldTransform.encodeHex(source);
const arrayOfEncodedValues = FieldTransform.encodeHex([source]);

encodeMD5()

MD5 encodes the input if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const source = 'hello world';

FieldTransform.encodeMD5(source);
const arrayOfEncodedValues = FieldTransform.encodeHex([source]);

encodeSHA()

SHA encodes the input to the hash specified

if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`	*
`_parentContext`?	`unknown`	-
`__namedParameters`?	{ `digest`: `string`; `hash`: `string`; }	-
`__namedParameters.digest`?	`string`	-
`__namedParameters.hash`?	`string`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

*
 * const data = 'some string';
 * const config = { hash: 'sha256', digest: 'hex'};
 * fieldTransform.encodeSHA(data , {}, config)
 * const arrayOfEncodedValues = FieldTransform.encodeSHA([source], {}, config);
 *
 *

encodeSHA1()

converts the value to a SHA1 encoded value if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const source = 'hello world';

FieldTransform.encodeSHA1(source);
const arrayOfEncodedValues = FieldTransform.encodeSHA([source]);

encodeURL()

URL encodes a value if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`StringInput`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const source = 'HELLO AND GOODBYE';
const encoded = 'HELLO%20AND%20GOODBYE';

FieldTransform.encodeURL(source); // encoded;
const arrayOfEncodedValues = FieldTransform.encodeURL([source]);

extract()

Can extract values from a string input. You may either specify a regex, a jexl expression, or specify the start and end from which the extraction will take all values between if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type
`_input`	`unknown`
`_parentContext`	`AnyObject`
`_args`	`ExtractFieldConfig`

Returns

any

returns null if input is null/undefined

Example

const config = { start: '<', end: '>' }
 const results1 = FieldTransform.extract('<hello>', { field: '<hello>' }, config);
 results1; // 'hello';

const results2 = FieldTransform.extract('bar', { foo: 'bar' }, { jexlExp: '[foo]' });
results2; // ['bar'];

const results3 = FieldTransform.extract('hello',  { field: 'hello'}, { regex: 'he.*' });
results3; // ['hello'];

const config2 = { regex: 'he.*', isMultiValue: false };
const results = FieldTransform.extract('hello',  { field: 'hello'}, config2);
results; // 'hello';

const context =  { field: ['<hello>', '<world>'] };
const results = FieldTransform.extract(['<hello>', '<world>'], context, config);
results; // ['hello', 'world'];

formatDate()

Function that will format a number or date string to a given date format provided

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`	`unknown`	-
`args`	`FormatDateConfig`	format is the shape that the date will be, resolution is only needed when input is a number

Returns

null | string | string[]

returns null if input is null/undefined

Example

const config = { format: 'MMM do yy' };
const results1 = FieldTransform.formatDate('2020-01-14T20:34:01.034Z', {}, config)
results1 === 'Jan 14th 20';

const results2 = FieldTransform.formatDate('March 3, 2019', {}, { format: 'M/d/yyyy' })
results2 === '3/3/2019';

const config =  { format: 'yyyy-MM-dd', resolution: 'seconds' };
const results3 = FieldTransform.formatDate(1581013130, {}, config)
results3 === '2020-02-06';

const config =  { format: 'yyyy-MM-dd' };
const results = FieldTransform.formatDate([1581013130856, undefined], {}, config)
results // ['2020-02-06']);

map()

This function is used to map an array of values with any FieldTransform method

Parameters

Parameter	Type	Description
`input`	`any`[]	an array of any value
`parentContext`	`any`[]	-
`args`	{ `fn`: `string`; `options`: `any`; }	fn any FieldTransform function name, options is an object with any additional parameters needed
`args.fn`	`string`	-
`args.options`?	`any`	-

Returns

null | any[]

returns the mapped values, return null if input is null/undefined

Example

const array = ['hello', 'world', 'goodbye'];
 const results = FieldTransform.map(array, array, { fn: 'truncate', options: { size: 3 } }
 results === ['hel', 'wor', 'goo']

parseDate()

Will use date-fns parse against the input and return a date object

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`	`unknown`	-
`args`	`ParseDateConfig`

Returns

null | Date | (null | Date)[]

returns null if input is null/undefined

Example

const result = FieldTransform.parseDate('2020-01-10-00:00', {}, { format: 'yyyy-MM-ddxxx' })
result === new Date('2020-01-10T00:00:00.000Z');

const result = FieldTransform.parseDate('Jan 10, 2020-00:00', {}, { format: 'MMM dd, yyyyxxx' })
result === new Date('2020-01-10T00:00:00.000Z');

const result = FieldTransform.parseDate(1581025950223, {}, { format: 'T' })
result === new Date('2020-02-06T21:52:30.223Z');

const result = FieldTransform.parseDate(1581025950, {}, { format: 't' })
result === new Date('2020-02-06T21:52:30.000Z');

const result = FieldTransform.parseDate('1581025950', {} { format: 't' })
result === new Date('2020-02-06T21:52:30.000Z');

parseJSON()

Parses the json input if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-

Returns

any

returns null if input is null/undefined

Example

const obj = { hello: 'world' };
const json = JSON.stringify(obj);
const results = FieldTransform.parseJSON(json);
results === obj

FieldTransform.parseJSON([json]); // [obj]

replaceLiteral()

This function replaces the searched value with the replace value

Parameters

Parameter	Type	Description
`input`	`StringInput`
`_parentContext`	`unknown`	-
`__namedParameters`	`ReplaceLiteralConfig`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const context = { key: 'Hi bob' };
FieldTransform.replaceLiteral('Hi bob', context, { search: 'bob', replace: 'mel' }) === 'Hi mel';
FieldTransform.replaceLiteral('Hi Bob', context, { search: 'bob', replace: 'Mel' }) === 'Hi Bob';

const data = ['Hi bob', 'hello bob'];
const config = { search: 'bob', replace: 'mel' };
FieldTransform.replaceLiteral(data, {}, config) // ['Hi mel', 'hello mel'];

replaceRegex()

This function replaces chars in a string based off the regex value provided

Parameters

Parameter	Type	Description
`input`	`StringInput`
`_parentContext`	`unknown`	-
`__namedParameters`	`ReplaceRegexConfig`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const config1 =  { regex: 's|e', replace: 'd' };
const results1 = FieldTransform.replaceRegex('somestring', {}, config1)
results1 === 'domestring'

const config2 = { regex: 's|e', replace: 'd', global: true };
const results2 = FieldTransform.replaceRegex('somestring', {}, config)
results2 === 'domddtring'

const config3 = {
  regex: 'm|t', replace: 'W', global: true, ignoreCase: true
};
const results3 = FieldTransform.replaceRegex('soMesTring', {}, config3))
results3 === 'soWesWring'

setDefault()

This function is used to set a value if input is null or undefined, otherwise the input value is returned

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`	`unknown`	-
`args`	{ `value`: `any`; }	value is what will be given when input is null/undefined
`args.value`	`any`	-

Returns

any

Example

const results = FieldTransform.setDefault(undefined, {}, { value: 'someValue' });
results === 'someValue';

setField()

This function is not meant to be used programmatically please use RecordTransform.setField instead

Parameters

Parameter	Type	Description
`_input`	`unknown`	This value will be discarded
`_parentContext`	`unknown`	-
`args`	{ `value`: `any`; }	value will be used to set field
`args.value`	`any`	-

Returns

any

splitString()

Converts a string to an array of characters split by the delimiter provided

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-
`args`?	{ `delimiter`: `string`; }	delimter defaults to an empty string
`args.delimiter`?	`string`	-

Returns

null | string[] | string[][]

Example

FieldTransform.splitString('astring'); // ['a', 's', 't', 'r', 'i', 'n', 'g'];
FieldTransform.splitString('astring', {}, { delimiter: ',' }); // ['astring'];
expect(FieldTransform.splitString(
     'a-stri-ng', {}, { delimiter: '-' }
)).toEqual(['a', 'stri', 'ng']);

toBoolean()

Converts values to booleans if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-

Returns

null | boolean | boolean[]

returns null if input is null/undefined

Example

FieldTransform.toBoolean('0'); // false
FieldTransform.toBoolean(['foo', 'false', null]); // [true, false];

toCamelCase()

Will convert a string, or an array of strings to camel case;

Parameters

Parameter	Type	Description
`input`	`string`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.toCamelCase('I need camel case'); // 'iNeedCamelCase';
FieldTransform.toCamelCase('happyBirthday'); // 'happyBirthday';
FieldTransform.toCamelCase('what_is_this'); // 'whatIsThis';

const array = ['what_is_this', 'I need camel case'];
FieldTransform.toCamelCase(array); // ['whatIsThis', 'iNeedCamelCase'];

toGeoPoint()

Converts the value into a geo-point if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-

Returns

null | { lat: number; lon: number; } | object[]

returns null if input is null/undefined

Example

fieldTransform.toGeoPoint('60, 40'); // { lon: 40, lat: 60 };
fieldTransform.toGeoPoint([40, 60]); // { lon: 40, lat: 60 };
fieldTransform.toGeoPoint({ lat: 40, lon: 60 }); // { lon: 60, lat: 40 };
fieldTransform.toGeoPoint({ latitude: 40, longitude: 60 }); // { lon: 60, lat: 40 }

const results = FieldTransform.toGeoPoint(['60, 40', null, [50, 60]]);
results === [{ lon: 40, lat: 60 },{ lon: 50, lat: 60 }];

toISDN()

Parses a string or number to a fully validated phone number if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`	string
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

a fully validated phone number, returns null if input is null/undefined

Example

FieldTransform.toISDN('+33-1-22-33-44-55'); // '33122334455';
FieldTransform.toISDN('1(800)FloWErs'); // '18003569377';
FieldTransform.toISDN(['1(800)FloWErs','+33-1-22-33-44-55' ]); // ['18003569377', '33122334455'];

toISO8601()

Converts a date string or number to an ISO date

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-
`args`?	{ `resolution`: `"seconds"` \| `"milliseconds"`; }	if input is a number, you may specify the resolution of that number, defaults to seconds
`args.resolution`?	`"seconds"` \| `"milliseconds"`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.toISO8601('2020-01-01'); // '2020-01-01T00:00:00.000Z';

const config = { resolution: 'seconds' };
FieldTransform.toISO8601(1580418907, {}, config); // '2020-01-30T21:15:07.000Z';

const data = ['2020-01-01', '2020-01-02'];
FieldTransform.toISO8601(data); // ['2020-01-01T00:00:00.000Z', '2020-01-02T00:00:00.000Z'];

toJSON()

Converts input to JSON if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-
`__namedParameters`?	{ `pretty`: `boolean`; }	-
`__namedParameters.pretty`?	`boolean`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const obj = { hello: 'world' };

FieldTransform.toJSON(obj); // '{"hello": "world"}'
FieldTransform.toJSON([obj]); // ['{"hello": "world"}']

toKebabCase()

Will convert a string, or an array of strings to kebab case

Parameters

Parameter	Type	Description
`input`	`string`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.toKebabCase('I need kebab case'); // 'i-need-kebab-case';
FieldTransform.toKebabCase('happyBirthday'); // 'happy-birthday';
FieldTransform.toKebabCase('what_is_this'); // 'what-is-this';
FieldTransform.toKebabCase('this-should-be-kebab'); // 'this-should-be-kebab';

const array = ['happyBirthday', 'what_is_this']
FieldTransform.toKebabCase(array); // ['happy-birthday', 'what-is-this'];

toLowerCase()

Converts strings to lowercase if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`StringInput`	string
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.toLowerCase('UPPERCASE'); // 'uppercase';
 FieldTransform.toLowerCase(['MixEd', null, 'UPPER']); // ['mixed', 'upper'];

toNumber()

Converts a value to a number if possible if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-
`args`?	{ `booleanLike`: `boolean`; }
`args.booleanLike`?	`boolean`	-

Returns

null | number | number[]

returns null if input is null/undefined

Example

FieldTransform.toNumber('12321'); // 12321;
FieldTransform.toNumber('000011'); // 11;
FieldTransform.toNumber('true', {}, { booleanLike: true }); // 1;
FieldTransform.toNumber(null, {}, { booleanLike: true }); // 0;
FieldTransform.toNumber(null); // null;
FieldTransform.toNumber(['000011', '12321']); // [11, 12321];

toPascalCase()

Converts a string, or an array of strings to pascal case

Parameters

Parameter	Type	Description
`input`	`string`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.toPascalCase('I need pascal case'); // 'INeedPascalCase';
FieldTransform.toPascalCase('happyBirthday'); // 'HappyBirthday';
FieldTransform.toPascalCase('what_is_this'); // 'WhatIsThis';

const array = ['happyBirthday', 'what_is_this']
FieldTransform.toKebabCase(array); // ['HappyBirthday', 'WhatIsThis'];

toSnakeCase()

Converts a string, or an array of strings to snake case

Parameters

Parameter	Type	Description
`input`	`string`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.toSnakeCase('I need snake case'); // 'i_need_snake_case';
FieldTransform.toSnakeCase('happyBirthday'); // 'happy_birthday';
FieldTransform.toSnakeCase('what_is_this'); // 'what_is_this';

const array = ['happyBirthday', 'what_is_this']
FieldTransform.toKebabCase(array); // ['happy_birthday', 'what_is_this'];

toString()

Converts values to strings if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.toString(true); // 'true';
FieldTransform.toString([true, undefined, false]); // ['true', 'false'];

toTitleCase()

Converts a string, or an array of strings to title case

Parameters

Parameter	Type	Description
`input`	`string`
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.toTitleCase('I need some capitols'); // 'I Need Some Capitols';
FieldTransform.toTitleCase('happyBirthday'); // 'Happy Birthday';
FieldTransform.toTitleCase('what_is_this'); // 'What Is This';

toUnixTime()

Converts a given date to its time in milliseconds or seconds

Parameters

Parameter	Type	Description
`input`	`unknown`
`_parentContext`?	`unknown`	-
`__namedParameters`?	{ `ms`: `boolean`; }	-
`__namedParameters.ms`?	`boolean`	-

Returns

null | number | number[]

returns null if input is null/undefined

Example

FieldTransform.toUnixTime('2020-01-01'); // 1577836800;
FieldTransform.toUnixTime('Jan 1, 2020 UTC'); // 1577836800;
FieldTransform.toUnixTime('2020 Jan, 1 UTC'); // 1577836800;

FieldTransform.toUnixTime(1580418907000); // 1580418907;
FieldTransform.toUnixTime(1580418907000, {}, { ms: true }); // 1580418907000;

FieldTransform.toUnixTime(['Jan 1, 2020 UTC', '2020 Jan, 1 UTC']); // [1577836800, 1577836800];

toUpperCase()

Converts strings to UpperCase if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`StringInput`	string or string[]
`_parentContext`?	`unknown`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.toUpperCase('lowercase'); // 'LOWERCASE';
 FieldTransform.toUpperCase(['MixEd', null, 'lower']); // ['MIXED', 'LOWER'];

trim()

Will trim the input if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`StringInput`	string
`parentContext`?	`unknown`	-
`args`?	{ `char`: `string`; }	a single char or word that will be cut out
`args.char`?	`string`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.trim('right    '); // 'right';
FieldTransform.trim('fast cars race fast', {}, { char: 'fast' }); // ' cars race ';
FieldTransform.trim('   string    ')).toBe('string');
FieldTransform.trim('   left')).toBe('left');
FieldTransform.trim('.*.*a regex test.*.*.*.* stuff', {}, { char: '.*' }); // 'a regex test'
FieldTransform.trim('\t\r\rtrim this\r\r', {}, { char: '\r' }); // 'trim this'
FieldTransform.trim('        '); // ''
FieldTransform.trim(['right    ', '   left']); // ['right', 'left'];

trimEnd()

Will trim the end of the input if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`StringInput`	string
`_parentContext`?	`unknown`	-
`args`?	{ `char`: `string`; }
`args.char`?	`string`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.trimEnd('    Hello Bob    '); // '    Hello Bob';
FieldTransform.trimEnd('iiii-wordiwords-iii', {}, { char: 'i' }); // 'iiii-wordiwords';
FieldTransform.trimEnd(['    Hello Bob    ', 'right    ']); // ['    Hello Bob', 'right'];

trimStart()

Will trim the beginning of the input if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`StringInput`	string
`_parentContext`?	`unknown`	-
`args`?	{ `char`: `string`; }
`args.char`?	`string`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

const config = { char: 'i' };
FieldTransform.trimStart('    Hello Bob    '); // 'Hello Bob    ';
FieldTransform.trimStart('iiii-wordiwords-iii', {}, config); // '-wordiwords-iii';
FieldTransform.trimStart(['    Hello Bob    ', 'right    ']); // ['Hello Bob    ', 'right    '];

truncate()

Will truncate the input to the length of the size given if given an array it will convert everything in the array excluding null/undefined values

Parameters

Parameter	Type	Description
`input`	`StringInput`	string
`_parentContext`	`unknown`	-
`args`	{ `size`: `number`; }
`args.size`	`number`	-

Returns

null | string | string[]

returns null if input is null/undefined

Example

FieldTransform.truncate('thisisalongstring', {}, { size: 4 }); // 'this';
FieldTransform.truncate(['hello', null, 'world'], {}, { size: 2 }); // ['he', 'wo'];

RecordTransform

const RecordTransform: object

Defined in: data-mate/src/index.ts:19

Type declaration

repository

repository: Repository

copyField()

Will copy a field to another field

Parameters

Parameter	Type	Description
`input`	`RecordInput`	-
`_parentContext`	`RecordInput`	-
`args`	{ `from`: `string`; `to`: `string`; }
`args.from`	`string`	-
`args.to`	`string`	-

Returns

null | AnyObject

object

Example

const obj = { hello: 'world', other: 'stuff' };
const config = { from: 'other', to: 'myCopy' };
const results = RecordTransform.copyField(cloneDeep(obj), cloneDeep(obj), config);
results; // { hello: 'world', other: 'stuff', myCopy: 'stuff' };

dedupe()

returns an array with only unique values

Type Parameters

Type Parameter	Default type
`T`	`any`

Parameters

Parameter	Type	Description
`input`	`any`[]
`_parentContext`?	`unknown`[]	-

Returns

null | T[]

returns null if input is null/undefined

Example

const results = FieldTransform.dedupe([1, 2, 2, 3, 3, 3, undefined, 4])
results === [1, 2, 3, 4]

const results = RecordTransform.dedupe([
  { hello: 'world' },
  { hello: 'world' },
  { other: 'obj' },
])
results === [{ hello: 'world' }, { other: 'obj' }];

dropFields()

removes fields from a record

Parameters

Parameter	Type	Description
`input`	`RecordInput`	-
`_parentContext`	`RecordInput`	-
`args`	{ `fields`: `string`[]; }
`args.fields`	`string`[]	-

Returns

null | AnyObject

object

Example

const obj = { hello: 'world', other: 'stuff', last: 'thing' };
const config = { fields: ['other', 'last']} ;
const results = RecordTransform.dropFields(cloneDeep(obj), cloneDeep(obj), config);
results; // { hello: 'world' };

renameField()

This will migrate a fields value to a new field name

Parameters

Parameter	Type	Description
`input`	`RecordInput`	-
`_parentContext`	`RecordInput`	-
`args`	{ `from`: `string`; `to`: `string`; }
`args.from`	`string`	-
`args.to`	`string`	-

Returns

null | AnyObject

object

Example

const obj = { hello: 'world' };
const config = { from: 'hello', to: 'goodbye' };
const results = RecordTransform.renameField(cloneDeep(obj), cloneDeep(obj), config);
results === { goodbye: 'world' };

setField()

Sets a field on a record with the given value

Parameters

Parameter	Type	Description
`input`	`RecordInput`	-
`_parentContext`	`RecordInput`	-
`args`	{ `field`: `string`; `value`: `any`; }
`args.field`	`string`	-
`args.value`	`any`	-

Returns

null | AnyObject

object

Example

const obj = { hello: 'world' };
const config = { field: 'other', value: 'stuff' };
const results = RecordTransform.setField(cloneDeep(obj), cloneDeep(obj), config);
results === { hello: 'world', other: 'stuff' };

transformRecord()

Will execute a jexl expression. Can use data-mate functions inside the jexl expression. You do not need to specify the parent context argument as that is automatically the document used as to call it.

Parameters

Parameter	Type
`_input`	`RecordInput`
`_parentContext`	`RecordInput`
`_args`	`any`

Returns

null | AnyObject

object

Example

const obj = { hello: 'world', other: 'stuff' };
const config = { query: '[hello]', field: 'final' };
const results = RecordTransform.transformRecord(clone, clone, config)
results === { hello: 'world', other: 'stuff', final: ['world'] });

const obj = { foo: 'bar' };
const config = {
  jexlExp: 'foo|extract({ jexlExp: "foo|toUpperCase" })', field: 'final'
};

const mixedData = [obj, undefined, null];

const results = RecordTransform.transformRecord(
   mixedData, mixedData, config
)

results === [{ foo: 'bar', final: 'BAR' }];