Skip to main content

Variable: helpers

const helpers: object

Defined in: packages/core/src/helpers.ts:13

Common helper functions for data processing

Type Declaration​

assert​

assert: <T>(condition, message) => CallableDeterministic<T, T, undefined>

Assert a condition, throw if false

Type Parameters​

T​

T = unknown

Parameters​

condition​

(data) => boolean

message​

string

Returns​

CallableDeterministic<T, T, undefined>

clone​

clone: <T>() => CallableDeterministic<T, T, undefined>

Deep clone using JSON (simple objects only)

Type Parameters​

T​

T

Returns​

CallableDeterministic<T, T, undefined>

compose​

compose: <A, B, C>(f, g) => CallableDeterministic<A, C, undefined>

Compose two functions

Type Parameters​

A​

A

B​

B

C​

C

Parameters​

f​

(b) => C

g​

(a) => B

Returns​

CallableDeterministic<A, C, undefined>

constant​

constant: <T>(value) => CallableDeterministic<any, T, undefined>

Return constant value (ignore input)

Type Parameters​

T​

T

Parameters​

value​

T

Returns​

CallableDeterministic<any, T, undefined>

delay​

delay: <T>(ms) => CallableDeterministic<T, T, undefined>

Delay processing by specified milliseconds

Type Parameters​

T​

T = unknown

Parameters​

ms​

number

Returns​

CallableDeterministic<T, T, undefined>

extract​

extract: <T, K>(field) => CallableDeterministic<T, T[K], undefined>

Extract a single field from an object

Type Parameters​

T​

T

K​

K extends string | number | symbol

Parameters​

field​

K

Returns​

CallableDeterministic<T, T[K], undefined>

Example​

const extractMessage = helpers.extract<FormData, 'message'>('message');
const message = await extractMessage(formData); // Returns formData.message

filter​

filter: <T>(predicate) => CallableDeterministic<T[], T[], undefined>

Filter array items

Type Parameters​

T​

T

Parameters​

predicate​

(item) => boolean

Returns​

CallableDeterministic<T[], T[], undefined>

Example​

const filterActive = helpers.filter((user: User) => user.active);
const activeUsers = await filterActive(users);

first​

first: <T>() => CallableDeterministic<T[], T, undefined>

Get first item from array

Type Parameters​

T​

T

Returns​

CallableDeterministic<T[], T, undefined>

flatten​

flatten: <T>() => CallableDeterministic<T[][], T[], undefined>

Flatten nested arrays one level deep

Type Parameters​

T​

T

Returns​

CallableDeterministic<T[][], T[], undefined>

fromEntries​

fromEntries: <T>() => CallableDeterministic<[string, T][], Record<string, T>, undefined>

Create object from key-value pairs

Type Parameters​

T​

T = unknown

Returns​

CallableDeterministic<[string, T][], Record<string, T>, undefined>

last​

last: <T>() => CallableDeterministic<T[], T, undefined>

Get last item from array

Type Parameters​

T​

T

Returns​

CallableDeterministic<T[], T, undefined>

log​

log: <T>(prefix?) => CallableDeterministic<T, T, undefined>

Log data and pass through (for debugging)

Type Parameters​

T​

T = unknown

Parameters​

prefix?​

string

Returns​

CallableDeterministic<T, T, undefined>

map​

map: <T, U>(fn) => CallableDeterministic<T[], U[], undefined>

Map array items

Type Parameters​

T​

T

U​

U

Parameters​

fn​

(item) => U

Returns​

CallableDeterministic<T[], U[], undefined>

Example​

const getNames = helpers.map((user: User) => user.name);
const names = await getNames(users);

merge​

merge: <T>() => CallableDeterministic<T[], T, undefined>

Merge multiple objects

Type Parameters​

T​

T extends object

Returns​

CallableDeterministic<T[], T, undefined>

mergeValidations​

mergeValidations: (results) => object

Merge validation results from an array

Expects each result to have: { valid: boolean, errors: string[], warnings: string[] }

Parameters​

results​

object[]

Returns​

object

errorCount​

errorCount: number

errors​

errors: string[]

isValid​

isValid: boolean

warningCount​

warningCount: number

warnings​

warnings: string[]

Example​

const results = [
  { valid: true, errors: [], warnings: ['short'] },
  { valid: false, errors: ['invalid email'], warnings: [] }
];
const merged = helpers.mergeValidations(results);
// { isValid: false, errors: ['invalid email'], warnings: ['short'], ... }

omit​

omit: <T, K>(...fields) => CallableDeterministic<T, T, undefined>

Omit specific fields from an object

Type Parameters​

T​

T

K​

K extends string | number | symbol

Parameters​

fields​

...K[]

Returns​

CallableDeterministic<T, T, undefined>

Example​

const omitSensitive = helpers.omit<User, 'password' | 'ssn'>('password', 'ssn');
const safe = await omitSensitive(user);

parseJSON​

parseJSON: <T>() => CallableDeterministic<string, T, undefined>

Parse JSON string

Type Parameters​

T​

T = unknown

Returns​

CallableDeterministic<string, T, undefined>

passthrough​

passthrough: <T>() => CallableDeterministic<T, T, undefined>

Pass through data unchanged

Type Parameters​

T​

T

Returns​

CallableDeterministic<T, T, undefined>

Example​

const passthrough = helpers.passthrough<FormData>();
const result = await passthrough(data); // Returns data unchanged

pick​

pick: <T, K>(...fields) => CallableDeterministic<T, Pick<T, K>, undefined>

Pick specific fields from an object

Type Parameters​

T​

T

K​

K extends string | number | symbol

Parameters​

fields​

...K[]

Returns​

CallableDeterministic<T, Pick<T, K>, undefined>

Example​

const pickFields = helpers.pick<User, 'name' | 'email'>('name', 'email');
const subset = await pickFields(user); // { name, email }

reduce​

reduce: <T, U>(fn, initial) => CallableDeterministic<T[], U, undefined>

Reduce array

Type Parameters​

T​

T

U​

U

Parameters​

fn​

(acc, item) => U

initial​

U

Returns​

CallableDeterministic<T[], U, undefined>

Example​

const sum = helpers.reduce((acc: number, n: number) => acc + n, 0);
const total = await sum(numbers);

tap​

tap: <T>(fn) => CallableDeterministic<T, T, undefined>

Tap into data flow for side effects

Type Parameters​

T​

T

Parameters​

fn​

(data) => void

Returns​

CallableDeterministic<T, T, undefined>

toEntries​

toEntries: <T>() => CallableDeterministic<Record<string, T>, [string, T][], undefined>

Convert object to key-value pairs

Type Parameters​

T​

T

Returns​

CallableDeterministic<Record<string, T>, [string, T][], undefined>

toJSON​

toJSON: <T>(pretty?) => CallableDeterministic<T, string, undefined>

Stringify to JSON

Type Parameters​

T​

T = unknown

Parameters​

pretty?​

boolean

Returns​

CallableDeterministic<T, string, undefined>

unwrap​

unwrap: <T, K>(key) => CallableDeterministic<Record<K, T>, Record<K, T>[K], undefined>

Unwrap data from a container object

Type Parameters​

T​

T

K​

K extends string

Parameters​

key​

K

Returns​

CallableDeterministic<Record<K, T>, Record<K, T>[K], undefined>

withMeta​

withMeta: <T, M>(meta) => CallableDeterministic<T, T & M, undefined>

Add custom metadata fields to data

Type Parameters​

T​

T extends object

M​

M extends Record<string, unknown>

Parameters​

meta​

M

Returns​

CallableDeterministic<T, T & M, undefined>

Example​

const addMeta = helpers.withMeta({ version: '1.0', env: 'prod' });
const result = await addMeta(data);
// { ...data, version: '1.0', env: 'prod' }

withTimestamp​

withTimestamp: <T>() => CallableDeterministic<T, T & object, undefined>

Add timestamp metadata to data

Type Parameters​

T​

T extends object

Returns​

CallableDeterministic<T, T & object, undefined>

Example​

const addTimestamp = helpers.withTimestamp<Result>();
const result = await addTimestamp(data);
// { ...data, timestamp: '2025-10-29T...' }

wrap​

wrap: <T, K>(key) => CallableDeterministic<T, Record<K, T>, undefined>

Wrap data in a container object

Type Parameters​

T​

T

K​

K extends string

Parameters​

key​

K

Returns​

CallableDeterministic<T, Record<K, T>, undefined>