𝐎𝐁𝐉𝐄𝐂𝐓 Transformer Generator (Advanced) - Object — GTM Variable Template for GTM

𝐎𝐁𝐉𝐄𝐂𝐓 Transformer Generator (Advanced) - Object CORE GTM

Direct (.tpl)

Transforms object structure using key renaming, value transformation, and nesting rules.

Examples

Rename object keys

INPUT

Keep unmapped properties: true
Keep original keys when renaming: false
tkm: [

OUTPUT

{first_name: 'John', lastName: 'Doe', age: 30}

Flatten nested values

INPUT

Keep unmapped properties: true
Keep original keys when renaming: false
tkm: [

OUTPUT

{name: 'John', user: {firstName: 'John', age: 30}, status: 'active'}

GTM Configuration

This is what you'll see when you open this variable in Google Tag Manager. Hover the icons for details.

𝐎𝐁𝐉𝐄𝐂𝐓 Transformer Generator (Advanced) - Object

OBJECT ⬇

Source Object

Keep unmapped properties

Keep original keys when renaming

------------------------------------------------------- Key Mappings ⬇--------------------------------------------------------

💾 Define how to transform object properties.

Source Key: Path to read from source object
  • Simple: "firstName"
  • Nested: "user.firstName"
  • Complex: "['user']['firstName']" (requires path parser)

Target Key: Path to write to result object
  • Leave empty to keep same key name
  • Simple: "first_name"
  • Nested: "profile.name" (auto-creates nested structure)

Transform Function: Optional function to modify the value
  • Leave empty to copy value as-is
  • Examples: val => val.toUpperCase(), parseInt, val => val.trim()

Source KeyTarget Key (optional)Transform Function (optional)

⊖

Path Processing

Path Parser (optional)

⚙️ Optional function to normalize complex path syntax before processing: path => normalizedPath

Use this to support custom path formats:
• Bracket notation: "['user']['name']" → ["user", "name"]
• Array notation: "items[0].name" → ["items", "0", "name"]

Example parser:
path => path.replace(/[['"]/g, '.').replace(/['"]]/g, '').split('.').filter(x => x)

Custom Getter (optional)

⚙️ Optional function to customize property retrieval: (obj, path) => value

Default behavior: Handles dot notation and array paths.

Use this for:
  • Case-insensitive lookups
  • Special property access logic
  • Custom path resolution

Custom Setter (optional)

⚙️ Optional function to customize property assignment: (obj, path, value) => obj

Default behavior: Handles dot notation, auto-creates nested objects.

Use this for:
  • Validation before setting
  • Custom nested structure creation
  • Special assignment logic

Result Handling

Output Function (optional)

⚙️ Optional function to transform the final object before returning it (e.g., obj => JSON.stringify(obj), obj => Object.freeze(obj)). Useful for chaining transformations on the output.

Source Object string

💡 Type any text to see the result update live

🎯 Using special value — click input to type instead

Test with:

Falsy

Truthy

Keep unmapped properties

Keep original keys when renaming

table

Source KeyTarget Key (optional)Transform Function (optional)

🔗 Result Handling — Chain Variables

setPath()

Related Variables

Same category: GTM

Under the Hood

📜 View Implementation Code

/**
 * Transforms an object by renaming keys and/or applying functions to their values. Supports nested paths.
 * 
 * @param {Object} data.src - Source object to transform.
 * @param {boolean} data.kup - Whether to keep unmapped properties (properties not in mapping table).
 * @param {boolean} data.kor - Whether to keep original keys when renaming.
 * @param {Array<{key: string, tgt?: string, fnc?: Function}>} data.tkm - Key transformation mappings.
 * @param {Function} [data.prs] - Optional path parser to normalize complex paths (e.g., ["JJ"]["kko"] → ["JJ", "kko"]).
 * @param {Function} [data.get] - Optional custom getter (defaults to path-aware getter).
 * @param {Function} [data.set] - Optional custom setter (defaults to path-aware setter).
 * @param {Function|string} [data.out] - Optional output handler.
 * 
 * @returns {Object} Transformed object with renamed keys and transformed values.
 *
 * @framework ggLowCodeGTMKit
 */
const getType = require('getType');

const sourceObj = getType(data.src) === 'object' && data.src || {};
const keepUnmapped = data.kup;
const keepOriginal = data.kor;
const keyMappings = data.tkm || [];

const parsePath = function(path) {
    return getType(path) === 'array' 
        ? path.map(part => part.toString()) 
        : path.split('.');
};

const getPath = function(object, path) {
    if (getType(object) !== 'object' || object === null) {
        return undefined;
    }
    
    const pathParts = parsePath(path);
    
    let current = object;
    for (let i = 0; i < pathParts.length; i++) {
        const key = pathParts[i];
        if (current === null || current === undefined) {
            return undefined;
        }
        current = current[key];
    }
    return current;
};

const pathExists = function(object, path) {
    if (getType(object) !== 'object' || object === null) {
        return false;
    }
    
    const pathParts = parsePath(path);
    
    let current = object;
    for (let i = 0; i < pathParts.length; i++) {
        const key = pathParts[i];
        if (current === null || current === undefined || !current.hasOwnProperty(key)) {
            return false;
        }
        current = current[key];
    }
    return true;
};

const setPath = function(object, path, value) {
    if (getType(object) !== 'object' || object === null) {
        return object;
    }
    
    const pathParts = parsePath(path);
    
    let current = object;
    for (let i = 0; i < pathParts.length; i++) {
        const key = pathParts[i];
        if (i === pathParts.length - 1) {
            current[key] = value;
        } else {
            if (getType(current[key]) !== 'object' || current[key] === null) {
                current[key] = {};
            }
            current = current[key];
        }
    }
    
    return object;
};

const safeFunction = fn => typeof fn === 'function' ? fn : x => x;

const pathParser = safeFunction(data.prs);
const getter = typeof data.get === 'function' ? data.get : getPath;
const s

🧪 View Test Scenarios (12 tests)

✅ '[example] Rename object keys'
✅ Key rename with transform - should rename and transform value
✅ '[example] Flatten nested values'
✅ Flat source to nested target - should create nested structure
✅ Don't keep unmapped properties - should only include mapped properties
✅ Keep original keys when renaming - should have both old and new keys
✅ Empty target key - should use source key as target
✅ Keep both flags enabled - should keep unmapped and original renamed keys
✅ Empty source object - should return empty object
✅ Nested to nested rename - should transform nested structure
✅ Multiple nested transformations - should handle complex mappings
✅ Transform without rename - should transform value but keep same key