Complete JSON Tools Guide: 22 Essential Tools for Developers

// Minified JSON (hard to read)
const minified = '{"name":"John","age":30,"city":"New York","hobbies":["reading","coding"]}';

// Formatted JSON (readable)
const formatted = JSON.stringify(JSON.parse(minified), null, 2);

console.log(formatted);
/*
{
  "name": "John",
  "age": 30,
  "city": "New York",
  "hobbies": [
    "reading",
    "coding"
  ]
}
*/

// Custom indentation (4 spaces)
const formatted4 = JSON.stringify(JSON.parse(minified), null, 4);

// Beautify with custom options
function beautifyJSON(json, options = {}) {
  const {
    indent = 2,
    sortKeys = false,
    removeEmpty = false
  } = options;

  let parsed = JSON.parse(json);

  // Sort keys alphabetically
  if (sortKeys) {
    parsed = sortObject(parsed);
  }

  // Remove null/empty values
  if (removeEmpty) {
    parsed = removeEmptyValues(parsed);
  }

  return JSON.stringify(parsed, null, indent);
}

function sortObject(obj) {
  if (typeof obj !== 'object' || obj === null) return obj;
  if (Array.isArray(obj)) return obj.map(sortObject);

  return Object.keys(obj)
    .sort()
    .reduce((result, key) => {
      result[key] = sortObject(obj[key]);
      return result;
    }, {});
}

// Usage
const json = '{"z":1,"a":2,"m":3}';
console.log(beautifyJSON(json, { sortKeys: true }));

// Simple validation
function validateJSON(jsonString) {
  try {
    JSON.parse(jsonString);
    return { valid: true, errors: [] };
  } catch (error) {
    return {
      valid: false,
      errors: [{
        message: error.message,
        line: extractLineNumber(error.message)
      }]
    };
  }
}

// Detailed error reporting
function validateWithDetails(jsonString) {
  const errors = [];

  // Check for common mistakes
  if (jsonString.includes("'")) {
    errors.push("Single quotes are not allowed. Use double quotes.");
  }

  if (/,\s*[}\]]/.test(jsonString)) {
    errors.push("Trailing commas are not allowed.");
  }

  if (/[{,]\s*[a-zA-Z_][a-zA-Z0-9_]*\s*:/.test(jsonString)) {
    errors.push("Object keys must be in double quotes.");
  }

  // Try parsing
  try {
    JSON.parse(jsonString);
    if (errors.length === 0) {
      return { valid: true, errors: [] };
    }
  } catch (error) {
    errors.push(`Parse error: ${error.message}`);
  }

  return { valid: false, errors };
}

// Usage
const invalid = "{'name': 'John', 'age': 30,}";
const result = validateWithDetails(invalid);
console.log(result);

// Parse and analyze JSON structure
function analyzeJSON(jsonString) {
  const data = JSON.parse(jsonString);

  function analyze(obj, path = '$') {
    const info = {
      path,
      type: Array.isArray(obj) ? 'array' : typeof obj,
      value: obj
    };

    if (typeof obj === 'object' && obj !== null) {
      info.keys = Object.keys(obj);
      info.size = Array.isArray(obj) ? obj.length : Object.keys(obj).length;

      if (!Array.isArray(obj)) {
        info.children = Object.entries(obj).map(([key, value]) =>
          analyze(value, `${path}.${key}`)
        );
      }
    }

    return info;
  }

  return analyze(data);
}

// Usage
const json = '{"user":{"name":"John","age":30},"tags":["dev","js"]}';
const structure = analyzeJSON(json);
console.log(JSON.stringify(structure, null, 2));

// JSON Schema validation
const Ajv = require('ajv');
const ajv = new Ajv();

// Define schema
const schema = {
  type: 'object',
  properties: {
    name: { type: 'string', minLength: 1 },
    age: { type: 'number', minimum: 0, maximum: 120 },
    email: { type: 'string', format: 'email' },
    roles: {
      type: 'array',
      items: { type: 'string' },
      minItems: 1
    }
  },
  required: ['name', 'email']
};

// Compile schema
const validate = ajv.compile(schema);

// Validate data
const data = {
  name: 'John Doe',
  age: 30,
  email: '[email protected]',
  roles: ['admin', 'user']
};

const valid = validate(data);
if (!valid) {
  console.log('Validation errors:', validate.errors);
} else {
  console.log('Data is valid!');
}

// Minify JSON (remove whitespace)
function minifyJSON(json) {
  return JSON.stringify(JSON.parse(json));
}

// Before minification (150 bytes)
const formatted = `{
  "name": "John Doe",
  "age": 30,
  "city": "New York",
  "hobbies": [
    "reading",
    "coding"
  ]
}`;

// After minification (76 bytes - 49% reduction)
const minified = minifyJSON(formatted);
console.log(minified);
// {"name":"John Doe","age":30,"city":"New York","hobbies":["reading","coding"]}

console.log(`Original: ${formatted.length} bytes`);
console.log(`Minified: ${minified.length} bytes`);
console.log(`Savings: ${((1 - minified.length/formatted.length) * 100).toFixed(1)}%`);

// Build script example (package.json)
{
  "scripts": {
    "build": "node scripts/minify-json.js",
    "dev": "node server.js --format-json"
  }
}

// minify-json.js
const fs = require('fs');
const path = require('path');

function minifyJSONFiles(dir) {
  const files = fs.readdirSync(dir);

  files.forEach(file => {
    if (path.extname(file) === '.json') {
      const filePath = path.join(dir, file);
      const content = fs.readFileSync(filePath, 'utf8');

      // Minify
      const minified = JSON.stringify(JSON.parse(content));

      // Write to dist folder
      const outPath = path.join('dist', file);
      fs.writeFileSync(outPath, minified);

      console.log(`Minified: ${file}`);
    }
  });
}

minifyJSONFiles('./config');

// Convert JSON to XML
function jsonToXML(json, rootName = 'root') {
  function convertNode(obj, nodeName) {
    if (typeof obj !== 'object' || obj === null) {
      return `<${nodeName}>${escapeXML(String(obj))}</${nodeName}>`;
    }

    if (Array.isArray(obj)) {
      return obj.map(item => convertNode(item, nodeName)).join('');
    }

    const children = Object.entries(obj)
      .map(([key, value]) => convertNode(value, key))
      .join('');

    return `<${nodeName}>${children}</${nodeName}>`;
  }

  function escapeXML(str) {
    return str
      .replace(/&/g, '&amp;')
      .replace(/</g, '&lt;')
      .replace(/>/g, '&gt;')
      .replace(/"/g, '&quot;')
      .replace(/'/g, '&apos;');
  }

  const obj = typeof json === 'string' ? JSON.parse(json) : json;
  return `<?xml version="1.0" encoding="UTF-8"?>\n${convertNode(obj, rootName)}`;
}

// Usage
const json = {
  user: {
    name: 'John',
    age: 30,
    roles: ['admin', 'user']
  }
};

const xml = jsonToXML(json, 'data');
console.log(xml);

// Convert XML to JSON (using xml2js)
const xml2js = require('xml2js');

const xml = `<?xml version="1.0"?>
<user>
  <name>John</name>
  <age>30</age>
  <roles>
    <role>admin</role>
    <role>user</role>
  </roles>
</user>`;

const parser = new xml2js.Parser({
  explicitArray: false,
  mergeAttrs: true
});

parser.parseString(xml, (err, result) => {
  if (err) {
    console.error('Parse error:', err);
  } else {
    console.log(JSON.stringify(result, null, 2));
  }
});

// Convert JSON array to CSV
function jsonToCSV(jsonArray) {
  if (!Array.isArray(jsonArray) || jsonArray.length === 0) {
    return '';
  }

  // Get headers from first object
  const headers = Object.keys(jsonArray[0]);

  // Create header row
  const csvHeaders = headers.join(',');

  // Create data rows
  const csvRows = jsonArray.map(obj => {
    return headers.map(header => {
      const value = obj[header];
      // Handle values with commas, quotes, newlines
      if (typeof value === 'string' && /[,\n"]/.test(value)) {
        return `"${value.replace(/"/g, '""')}"`;
      }
      return value ?? '';
    }).join(',');
  });

  return [csvHeaders, ...csvRows].join('\n');
}

// Usage
const users = [
  { name: 'John Doe', age: 30, city: 'New York' },
  { name: 'Jane Smith', age: 25, city: 'Los Angeles' },
  { name: 'Bob Johnson', age: 35, city: 'Chicago' }
];

const csv = jsonToCSV(users);
console.log(csv);
/*
name,age,city
John Doe,30,New York
Jane Smith,25,Los Angeles
Bob Johnson,35,Chicago
*/

// Convert CSV to JSON
function csvToJSON(csv) {
  const lines = csv.trim().split('\n');
  const headers = lines[0].split(',').map(h => h.trim());

  return lines.slice(1).map(line => {
    const values = parseCSVLine(line);
    return headers.reduce((obj, header, index) => {
      obj[header] = values[index] || '';
      return obj;
    }, {});
  });
}

function parseCSVLine(line) {
  const result = [];
  let current = '';
  let inQuotes = false;

  for (let i = 0; i < line.length; i++) {
    const char = line[i];

    if (char === '"') {
      if (inQuotes && line[i + 1] === '"') {
        current += '"';
        i++;
      } else {
        inQuotes = !inQuotes;
      }
    } else if (char === ',' && !inQuotes) {
      result.push(current.trim());
      current = '';
    } else {
      current += char;
    }
  }

  result.push(current.trim());
  return result;
}

// Usage
const csv = `name,age,city
John Doe,30,New York
Jane Smith,25,Los Angeles`;

const json = csvToJSON(csv);
console.log(JSON.stringify(json, null, 2));

// Convert JSON to YAML
const yaml = require('js-yaml');

const json = {
  apiVersion: 'v1',
  kind: 'Service',
  metadata: {
    name: 'my-service',
    labels: {
      app: 'myapp'
    }
  },
  spec: {
    selector: {
      app: 'myapp'
    },
    ports: [
      {
        protocol: 'TCP',
        port: 80,
        targetPort: 9376
      }
    ]
  }
};

const yamlStr = yaml.dump(json, {
  indent: 2,
  lineWidth: -1
});

console.log(yamlStr);
/*
apiVersion: v1
kind: Service
metadata:
  name: my-service
  labels:
    app: myapp
spec:
  selector:
    app: myapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 9376
*/

// Convert YAML to JSON
const yaml = require('js-yaml');

const yamlStr = `
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database_url: postgres://localhost:5432/mydb
  max_connections: "100"
  enable_logging: "true"
`;

try {
  const json = yaml.load(yamlStr);
  console.log(JSON.stringify(json, null, 2));
} catch (e) {
  console.error('YAML parse error:', e.message);
}

// JSON Editor with Monaco (VS Code editor)
import * as monaco from 'monaco-editor';

const editor = monaco.editor.create(document.getElementById('editor'), {
  value: '{"name": "John", "age": 30}',
  language: 'json',
  theme: 'vs-dark',
  automaticLayout: true,
  formatOnPaste: true,
  formatOnType: true,
  minimap: { enabled: false },
  scrollBeyondLastLine: false,
  wordWrap: 'on'
});

// Validation
monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
  validate: true,
  schemas: [{
    uri: 'http://myschema',
    fileMatch: ['*'],
    schema: {
      type: 'object',
      properties: {
        name: { type: 'string' },
        age: { type: 'number' }
      }
    }
  }]
});

// Get formatted value
function getFormattedJSON() {
  return editor.getAction('editor.action.formatDocument').run();
}

// JSON Tree Viewer
function createJSONTree(data, container) {
  function createNode(obj, path = '$') {
    const ul = document.createElement('ul');

    if (typeof obj !== 'object' || obj === null) {
      const li = document.createElement('li');
      li.className = 'json-value';
      li.textContent = `${path}: ${JSON.stringify(obj)}`;
      return li;
    }

    Object.entries(obj).forEach(([key, value]) => {
      const li = document.createElement('li');
      const isExpandable = typeof value === 'object' && value !== null;

      if (isExpandable) {
        const toggle = document.createElement('span');
        toggle.className = 'toggle';
        toggle.textContent = '▼';
        toggle.onclick = () => {
          li.classList.toggle('collapsed');
          toggle.textContent = li.classList.contains('collapsed') ? '▶' : '▼';
        };
        li.appendChild(toggle);
      }

      const label = document.createElement('span');
      label.className = 'json-key';
      label.textContent = key + ': ';
      li.appendChild(label);

      if (isExpandable) {
        li.appendChild(createNode(value, `${path}.${key}`));
      } else {
        const valueSpan = document.createElement('span');
        valueSpan.className = `json-${typeof value}`;
        valueSpan.textContent = JSON.stringify(value);
        li.appendChild(valueSpan);
      }

      ul.appendChild(li);
    });

    return ul;
  }

  container.innerHTML = '';
  container.appendChild(createNode(data));
}

// JSON Diff comparison
function jsonDiff(obj1, obj2) {
  const changes = {
    added: {},
    deleted: {},
    modified: {}
  };

  // Find deleted and modified
  for (const key in obj1) {
    if (!(key in obj2)) {
      changes.deleted[key] = obj1[key];
    } else if (JSON.stringify(obj1[key]) !== JSON.stringify(obj2[key])) {
      changes.modified[key] = {
        old: obj1[key],
        new: obj2[key]
      };
    }
  }

  // Find added
  for (const key in obj2) {
    if (!(key in obj1)) {
      changes.added[key] = obj2[key];
    }
  }

  return changes;
}

// Usage
const before = {
  name: 'John',
  age: 30,
  city: 'New York'
};

const after = {
  name: 'John',
  age: 31,
  country: 'USA'
};

const diff = jsonDiff(before, after);
console.log(JSON.stringify(diff, null, 2));
/*
{
  "added": { "country": "USA" },
  "deleted": { "city": "New York" },
  "modified": { "age": { "old": 30, "new": 31 } }
}
*/

// Different diff strategies
const { diff } = require('deep-diff');

const obj1 = {
  user: { name: 'John', age: 30 },
  items: [1, 2, 3]
};

const obj2 = {
  user: { name: 'John', age: 31 },
  items: [1, 2, 3, 4]
};

// Deep diff
const differences = diff(obj1, obj2);
console.log('Differences:', differences);

// Path-based diff
differences.forEach(change => {
  console.log(`Path: ${change.path.join('.')}`);
  console.log(`Kind: ${change.kind}`); // N=new, D=deleted, E=edited, A=array
  console.log(`Value: ${JSON.stringify(change.rhs || change.lhs)}`);
});

// Recursive deep diff
function deepDiff(obj1, obj2, path = '') {
  const diffs = [];

  // Handle null/undefined
  if (obj1 == null || obj2 == null) {
    if (obj1 !== obj2) {
      diffs.push({ path, type: 'modified', from: obj1, to: obj2 });
    }
    return diffs;
  }

  // Handle different types
  if (typeof obj1 !== typeof obj2) {
    diffs.push({ path, type: 'type-change', from: obj1, to: obj2 });
    return diffs;
  }

  // Handle primitives
  if (typeof obj1 !== 'object') {
    if (obj1 !== obj2) {
      diffs.push({ path, type: 'modified', from: obj1, to: obj2 });
    }
    return diffs;
  }

  // Handle arrays
  if (Array.isArray(obj1) && Array.isArray(obj2)) {
    const maxLen = Math.max(obj1.length, obj2.length);
    for (let i = 0; i < maxLen; i++) {
      const itemPath = `${path}[${i}]`;
      if (i >= obj1.length) {
        diffs.push({ path: itemPath, type: 'added', value: obj2[i] });
      } else if (i >= obj2.length) {
        diffs.push({ path: itemPath, type: 'deleted', value: obj1[i] });
      } else {
        diffs.push(...deepDiff(obj1[i], obj2[i], itemPath));
      }
    }
    return diffs;
  }

  // Handle objects
  const allKeys = new Set([...Object.keys(obj1), ...Object.keys(obj2)]);

  allKeys.forEach(key => {
    const keyPath = path ? `${path}.${key}` : key;

    if (!(key in obj1)) {
      diffs.push({ path: keyPath, type: 'added', value: obj2[key] });
    } else if (!(key in obj2)) {
      diffs.push({ path: keyPath, type: 'deleted', value: obj1[key] });
    } else {
      diffs.push(...deepDiff(obj1[key], obj2[key], keyPath));
    }
  });

  return diffs;
}

// Escape JSON for embedding in HTML/JavaScript
function escapeJSON(json) {
  return JSON.stringify(json)
    .replace(/</g, '\\u003c')
    .replace(/>/g, '\\u003e')
    .replace(/&/g, '\\u0026')
    .replace(/'/g, '\\u0027');
}

// Example: Embed in HTML
const data = { message: '<script>alert("XSS")</script>' };
const escaped = escapeJSON(data);

const html = `
<div id="app">
  <script>
    const config = ${escaped};
  </script>
</div>
`;

// Safe embedding in template literal
const safeHTML = `
<button onclick='showData(${escapeJSON({ name: "John" })})'>
  Click Me
</button>
`;

// Unescape JSON string
function unescapeJSON(str) {
  return str
    .replace(/\\u003c/g, '<')
    .replace(/\\u003e/g, '>')
    .replace(/\\u0026/g, '&')
    .replace(/\\u0027/g, "'")
    .replace(/\\"/g, '"')
    .replace(/\\\\/g, '\\')
    .replace(/\\n/g, '\n')
    .replace(/\\r/g, '\r')
    .replace(/\\t/g, '\t');
}

// Example
const escaped = '{\"name\":\"John\",\"message\":\"Hello\\nWorld\"}';
const unescaped = unescapeJSON(escaped);
console.log(unescaped); // {"name":"John","message":"Hello\nWorld"}

// Parse unescaped JSON
const data = JSON.parse(unescaped);
console.log(data.message); // Hello (with newline) World

// JSONPath query examples
const jp = require('jsonpath');

const data = {
  store: {
    book: [
      { title: 'Book 1', author: 'Author A', price: 8.95 },
      { title: 'Book 2', author: 'Author B', price: 12.99 },
      { title: 'Book 3', author: 'Author A', price: 5.99 }
    ],
    bicycle: {
      color: 'red',
      price: 19.95
    }
  }
};

// All book titles
const titles = jp.query(data, '$.store.book[*].title');
console.log(titles); // ['Book 1', 'Book 2', 'Book 3']

// Books cheaper than $10
const cheap = jp.query(data, '$.store.book[?(@.price < 10)]');
console.log(cheap); // [Book 1, Book 3]

// All prices in the store
const prices = jp.query(data, '$..price');
console.log(prices); // [8.95, 12.99, 5.99, 19.95]

// All authors (recursive)
const authors = jp.query(data, '$..author');
console.log(authors); // ['Author A', 'Author B', 'Author A']

# jq command-line JSON processor

# Pretty print
echo '{"name":"John","age":30}' | jq '.'

# Extract field
echo '{"name":"John","age":30}' | jq '.name'
# Output: "John"

# Array operations
echo '[1,2,3,4,5]' | jq 'map(. * 2)'
# Output: [2,4,6,8,10]

# Filter array
echo '[{"name":"John","age":30},{"name":"Jane","age":25}]' | \
  jq '.[] | select(.age > 26)'
# Output: {"name":"John","age":30}

# Create new object
echo '{"first":"John","last":"Doe"}' | \
  jq '{name: (.first + " " + .last)}'
# Output: {"name":"John Doe"}

# Complex query
cat data.json | jq '.users[] | select(.active == true) | {name, email}'

// Advanced JSONPath patterns
const data = {
  users: [
    { id: 1, name: 'John', roles: ['admin', 'user'], active: true },
    { id: 2, name: 'Jane', roles: ['user'], active: false },
    { id: 3, name: 'Bob', roles: ['admin'], active: true }
  ]
};

// Filter with complex conditions
const activeAdmins = jp.query(
  data,
  '$.users[?(@.active && @.roles.indexOf("admin") >= 0)]'
);

// Get specific fields
const names = jp.query(data, '$.users[*].name');

// Recursive search
const allRoles = jp.query(data, '$..roles[*]');

// Parent references
const usersWithRoleCount = jp.nodes(data, '$.users[*]').map(node => ({
  ...node.value,
  roleCount: node.value.roles.length
}));

// JSON Schema definition and validation
const schema = {
  $schema: 'http://json-schema.org/draft-07/schema#',
  type: 'object',
  properties: {
    id: {
      type: 'integer',
      minimum: 1
    },
    name: {
      type: 'string',
      minLength: 1,
      maxLength: 100
    },
    email: {
      type: 'string',
      format: 'email'
    },
    age: {
      type: 'integer',
      minimum: 0,
      maximum: 150
    },
    roles: {
      type: 'array',
      items: {
        type: 'string',
        enum: ['admin', 'user', 'moderator']
      },
      minItems: 1,
      uniqueItems: true
    },
    metadata: {
      type: 'object',
      properties: {
        createdAt: { type: 'string', format: 'date-time' },
        updatedAt: { type: 'string', format: 'date-time' }
      },
      required: ['createdAt']
    }
  },
  required: ['id', 'name', 'email'],
  additionalProperties: false
};

// Validate data
const Ajv = require('ajv');
const ajv = new Ajv();
const validate = ajv.compile(schema);

const user = {
  id: 1,
  name: 'John Doe',
  email: '[email protected]',
  roles: ['admin', 'user']
};

if (validate(user)) {
  console.log('Valid!');
} else {
  console.log('Errors:', validate.errors);
}

// Generate JSON Schema from sample data
function generateSchema(data) {
  if (data === null) {
    return { type: 'null' };
  }

  if (Array.isArray(data)) {
    return {
      type: 'array',
      items: data.length > 0 ? generateSchema(data[0]) : {}
    };
  }

  const type = typeof data;

  if (type === 'object') {
    const properties = {};
    const required = [];

    for (const [key, value] of Object.entries(data)) {
      properties[key] = generateSchema(value);
      if (value !== null && value !== undefined) {
        required.push(key);
      }
    }

    return {
      type: 'object',
      properties,
      required
    };
  }

  return { type };
}

// Usage
const sampleData = {
  id: 1,
  name: 'John',
  tags: ['developer', 'javascript'],
  profile: {
    age: 30,
    city: 'New York'
  }
};

const schema = generateSchema(sampleData);
console.log(JSON.stringify(schema, null, 2));

// Sort JSON object keys
function sortJSONKeys(obj, recursive = true) {
  if (typeof obj !== 'object' || obj === null) {
    return obj;
  }

  if (Array.isArray(obj)) {
    return recursive ? obj.map(item => sortJSONKeys(item, true)) : obj;
  }

  return Object.keys(obj)
    .sort()
    .reduce((sorted, key) => {
      sorted[key] = recursive ? sortJSONKeys(obj[key], true) : obj[key];
      return sorted;
    }, {});
}

// Usage
const unsorted = {
  zebra: 'animal',
  apple: 'fruit',
  car: 'vehicle',
  nested: {
    zulu: 1,
    alpha: 2
  }
};

const sorted = sortJSONKeys(unsorted);
console.log(JSON.stringify(sorted, null, 2));
/*
{
  "apple": "fruit",
  "car": "vehicle",
  "nested": {
    "alpha": 2,
    "zulu": 1
  },
  "zebra": "animal"
}
*/

// Merge multiple JSON objects
function mergeJSON(...objects) {
  return objects.reduce((merged, obj) => {
    for (const [key, value] of Object.entries(obj)) {
      if (value && typeof value === 'object' && !Array.isArray(value)) {
        merged[key] = mergeJSON(merged[key] || {}, value);
      } else {
        merged[key] = value;
      }
    }
    return merged;
  }, {});
}

// Usage
const base = {
  name: 'App',
  config: {
    timeout: 3000,
    retries: 3
  }
};

const override = {
  config: {
    timeout: 5000,
    debug: true
  },
  version: '1.0.0'
};

const merged = mergeJSON(base, override);
console.log(JSON.stringify(merged, null, 2));
/*
{
  "name": "App",
  "config": {
    "timeout": 5000,
    "retries": 3,
    "debug": true
  },
  "version": "1.0.0"
}
*/

// API testing with JSON validation
const axios = require('axios');
const Ajv = require('ajv');

async function testAPI() {
  // Expected response schema
  const schema = {
    type: 'object',
    properties: {
      status: { type: 'string', enum: ['success', 'error'] },
      data: { type: 'object' },
      message: { type: 'string' }
    },
    required: ['status', 'data']
  };

  const ajv = new Ajv();
  const validate = ajv.compile(schema);

  try {
    const response = await axios.get('https://api.example.com/users/1');

    // Validate response
    if (!validate(response.data)) {
      console.error('Invalid API response:', validate.errors);
      return;
    }

    // Format for logging
    console.log('Response:', JSON.stringify(response.data, null, 2));

    // Compare with expected
    const expected = { status: 'success', data: { id: 1 } };
    const diff = jsonDiff(expected, response.data);

    if (Object.keys(diff.modified).length > 0) {
      console.warn('Unexpected changes:', diff);
    }
  } catch (error) {
    console.error('API Error:', error.message);
  }
}

// Generate API documentation from JSON schema
function generateAPIDocs(schema, endpoint) {
  const docs = {
    endpoint,
    method: 'POST',
    description: schema.description || '',
    requestBody: {
      contentType: 'application/json',
      schema: schema,
      example: generateExample(schema)
    },
    responses: {
      200: {
        description: 'Success',
        example: { status: 'success', data: {} }
      },
      400: {
        description: 'Validation Error',
        example: { status: 'error', errors: [] }
      }
    }
  };

  return docs;
}

function generateExample(schema) {
  if (schema.type === 'object') {
    const example = {};
    for (const [key, prop] of Object.entries(schema.properties || {})) {
      example[key] = generateExample(prop);
    }
    return example;
  }

  if (schema.type === 'array') {
    return [generateExample(schema.items || {})];
  }

  // Return example values by type
  const examples = {
    string: 'example',
    number: 123,
    integer: 123,
    boolean: true,
    null: null
  };

  return examples[schema.type] || null;
}

// Structured API error responses
class APIError {
  static badRequest(errors) {
    return {
      status: 'error',
      code: 'BAD_REQUEST',
      message: 'Invalid request data',
      errors: errors.map(e => ({
        field: e.field,
        message: e.message,
        code: e.code
      }))
    };
  }

  static validationError(validationErrors) {
    return {
      status: 'error',
      code: 'VALIDATION_ERROR',
      message: 'Request validation failed',
      errors: validationErrors
    };
  }

  static notFound(resource) {
    return {
      status: 'error',
      code: 'NOT_FOUND',
      message: `${resource} not found`
    };
  }
}

// Express middleware for error handling
app.use((err, req, res, next) => {
  if (err instanceof SyntaxError && 'body' in err) {
    // JSON parse error
    res.status(400).json({
      status: 'error',
      code: 'INVALID_JSON',
      message: 'Invalid JSON in request body',
      details: err.message
    });
  } else {
    next(err);
  }
});

// Development vs Production JSON handling
const isDevelopment = process.env.NODE_ENV === 'development';

// API response formatting
function formatResponse(data) {
  if (isDevelopment) {
    // Pretty-print in development
    return JSON.stringify(data, null, 2);
  } else {
    // Minified in production
    return JSON.stringify(data);
  }
}

// Configuration loading
function loadConfig() {
  const config = require('./config.json');

  if (isDevelopment) {
    // Validate and format in development
    console.log('Config:', JSON.stringify(config, null, 2));
    validateConfig(config);
  }

  return config;
}

// Error responses
function errorResponse(error) {
  if (isDevelopment) {
    return {
      error: error.message,
      stack: error.stack, // Include stack trace
      timestamp: new Date().toISOString()
    };
  } else {
    return {
      error: 'Internal server error', // Generic message
      code: error.code
    };
  }
}

// Automated JSON processing scripts

// Pre-commit hook: Validate and format JSON files
const fs = require('fs');
const glob = require('glob');

function validateJSONFiles() {
  const files = glob.sync('**/*.json', {
    ignore: ['node_modules/**', 'dist/**']
  });

  let hasErrors = false;

  files.forEach(file => {
    try {
      const content = fs.readFileSync(file, 'utf8');
      const parsed = JSON.parse(content);

      // Auto-format
      const formatted = JSON.stringify(parsed, null, 2) + '\n';

      if (content !== formatted) {
        console.log(`Formatting: ${file}`);
        fs.writeFileSync(file, formatted);
      }
    } catch (error) {
      console.error(`Error in ${file}: ${error.message}`);
      hasErrors = true;
    }
  });

  if (hasErrors) {
    process.exit(1);
  }
}

// CI/CD: Validate JSON schemas
function validateSchemas() {
  const Ajv = require('ajv');
  const ajv = new Ajv();

  const schemas = glob.sync('schemas/**/*.json');
  const data = glob.sync('data/**/*.json');

  schemas.forEach(schemaFile => {
    const schema = JSON.parse(fs.readFileSync(schemaFile, 'utf8'));
    const validate = ajv.compile(schema);

    data.forEach(dataFile => {
      const content = JSON.parse(fs.readFileSync(dataFile, 'utf8'));
      if (!validate(content)) {
        console.error(`Validation failed: ${dataFile}`);
        console.error(validate.errors);
        process.exit(1);
      }
    });
  });
}

// JSON debugging tips and tricks

// 1. Use console.table for arrays
const users = [
  { id: 1, name: 'John', age: 30 },
  { id: 2, name: 'Jane', age: 25 }
];
console.table(users);

// 2. Pretty-print with syntax highlighting
const data = { complex: { nested: { data: true } } };
console.log('%c' + JSON.stringify(data, null, 2), 'color: #0f0');

// 3. Circular reference detection
function detectCircular(obj, seen = new WeakSet()) {
  if (typeof obj === 'object' && obj !== null) {
    if (seen.has(obj)) {
      return true;
    }
    seen.add(obj);

    for (const value of Object.values(obj)) {
      if (detectCircular(value, seen)) {
        return true;
      }
    }
  }
  return false;
}

// 4. Safe JSON stringify with circular handling
function safeStringify(obj, indent = 2) {
  const seen = new WeakSet();
  return JSON.stringify(obj, (key, value) => {
    if (typeof value === 'object' && value !== null) {
      if (seen.has(value)) {
        return '[Circular]';
      }
      seen.add(value);
    }
    return value;
  }, indent);
}

// 5. Diff two JSON objects for debugging
function debugDiff(obj1, obj2) {
  const diff = jsonDiff(obj1, obj2);
  console.log('Added:', diff.added);
  console.log('Deleted:', diff.deleted);
  console.log('Modified:', diff.modified);
}

// 6. Trace JSON path to value
function findPath(obj, targetValue, currentPath = '$') {
  if (obj === targetValue) {
    return [currentPath];
  }

  if (typeof obj !== 'object' || obj === null) {
    return [];
  }

  const paths = [];

  for (const [key, value] of Object.entries(obj)) {
    const newPath = `${currentPath}.${key}`;
    paths.push(...findPath(value, targetValue, newPath));
  }

  return paths;
}