Advanced Patterns

JSSON isn’t just for simple key-value pairs. Its features can be combined to solve complex configuration challenges. Here are some advanced patterns to supercharge your workflow.

Clean Configuration with Variables

Avoid repetition and magic numbers by using variables (:=). Variables are scoped and don’t appear in the final output.

JSSON
JSON Output

// Define constants
base_url := "https://api.example.com"
timeout := 5000
retries := 3

// Environment configuration
production {
url = base_url
timeout = timeout
retry_count = retries
}

staging {
url = "https://staging.example.com"
timeout = timeout
retry_count = retries
}

{
"production": {
  "url": "https://api.example.com",
  "timeout": 5000,
  "retry_count": 3
},
"staging": {
  "url": "https://staging.example.com",
  "timeout": 5000,
  "retry_count": 3
}
}

🧪 Test Data Generation

Need to generate thousands of records for load testing? JSSON’s ranges and string concatenation make it trivial.

Generating Dates

Combine numeric ranges with string concatenation to generate calendar dates:

JSSON
JSON Output

test_data [
template { date, event }

map (row) = {
  date = "2025-01-" + row.day
  event = "Login Attempt"
  status = "Success"
}

// Generate dates from 1 to 31
1..31
]

{
"test_data": [
  {
    "date": "2025-01-1",
    "event": "Login Attempt",
    "status": "Success"
  },
  // ... up to 31
  {
    "date": "2025-01-31",
    "event": "Login Attempt",
    "status": "Success"
  }
]
}

Generating User Accounts

Create realistic user profiles by zipping ranges and using templates:

JSSON
JSON Output

users [
template { id, department }

map (u) = {
  id = u.id
  username = "user_" + u.id
  email = "user_" + u.id + "@company.com"
  dept = u.department
  role = "employee"
}

// Generate 5 users for Engineering
100..104, Engineering

// Generate 5 users for Sales
200..204, Sales
]

{
"users": [
  {
    "id": 100,
    "username": "user_100",
    "email": "user_100@company.com",
    "dept": "Engineering",
    "role": "employee"
  },
  // ...
  {
    "id": 204,
    "username": "user_204",
    "email": "user_204@company.com",
    "dept": "Sales",
    "role": "employee"
  }
]
}

🌍 Environment Management

Manage multiple environments (Dev, Staging, Prod) cleanly using the Base + Overlay pattern with include.

1. Base Configuration (`base.jsson`)

Define the common settings shared across all environments.

app {
  name = "MyApp"
  version = "1.0.0"
  retry_attempts = 3
}

database {
  driver = "postgres"
  pool_size = 10
}

2. Environment Overlays (`prod.jsson`)

Include the base config and override only what changes.

include "base.jsson"

// Override database settings for production
database {
  host = "prod-db.aws.com"
  pool_size = 100  // Higher pool size for prod
}

// Add prod-specific settings
logging {
  level = "error"
  format = "json"
}

Why this works: JSSON’s include merges the included file into the current scope. If you redefine a key (like database), JSSON merges the new properties into the existing object, allowing for granular overrides.

🏷️ Dynamic Resource Naming

Enforce naming conventions automatically using the map clause. This ensures consistency across your infrastructure configuration.

JSSON
JSON Output

resources [
template { name, type, region }

map (res) = {
  // Auto-generate standardized ID: type-name-region
  id = res.type + "-" + res.name + "-" + res.region

  // Pass through original fields
  name = res.name
  type = res.type
  region = res.region

  // Add default tags
  tags {
    managed_by = "jsson"
    env = "production"
  }
}

"web-server", ec2, "us-east-1"
"db-primary", rds, "us-west-2"
"cache-cluster", redis, "eu-central-1"
]

{
"resources": [
  {
    "id": "ec2-web-server-us-east-1",
    "name": "web-server",
    "type": "ec2",
    "region": "us-east-1",
    "tags": { "managed_by": "jsson", "env": "production" }
  },
  {
    "id": "rds-db-primary-us-west-2",
    "name": "db-primary",
    "type": "rds",
    "region": "us-west-2",
    "tags": { "managed_by": "jsson", "env": "production" }
  },
  {
    "id": "redis-cache-cluster-eu-central-1",
    "name": "cache-cluster",
    "type": "redis",
    "region": "eu-central-1",
    "tags": { "managed_by": "jsson", "env": "production" }
  }
]
}

🔢 Matrix Generation

Since v0.0.5, JSSON supports nested map() transformations, making matrix generation trivial!

// Generate a 3x3 grid using nested maps
grid = (1..3 map (y) = (1..3 map (x) = {
x = x
y = y
}))

{
"grid": [
  [
    { "x": 1, "y": 1 },
    { "x": 2, "y": 1 },
    { "x": 3, "y": 1 }
  ],
  [
    { "x": 1, "y": 2 },
    { "x": 2, "y": 2 },
    { "x": 3, "y": 2 }
  ],
  [
    { "x": 1, "y": 3 },
    { "x": 2, "y": 3 },
    { "x": 3, "y": 3 }
  ]
]
}

Numeric Matrix

Generate a multiplication table or any numeric matrix:

JSSON
JSON Output

// Multiplication table
multiplicationTable = (1..5 map (row) = (1..5 map (col) = row * col))

// Simple numeric grid
matrix = (0..2 map (row) = (0..2 map (col) = row * 3 + col))

{
"multiplicationTable": [
  [1, 2, 3, 4, 5],
  [2, 4, 6, 8, 10],
  [3, 6, 9, 12, 15],
  [4, 8, 12, 16, 20],
  [5, 10, 15, 20, 25]
],
"matrix": [
  [0, 1, 2],
  [3, 4, 5],
  [6, 7, 8]
]
}

Combinatorial Product Catalog

Create all combinations of product variants:

JSSON
JSON Output

// All size/color combinations
products = (["S", "M", "L", "XL"] map (size) = (
["red", "blue", "green", "black"] map (color) = {
  size = size
  color = color
  sku = size + "-" + color
  price = 29.99
}
))

{
"products": [
  [
    { "size": "S", "color": "red", "sku": "S-red", "price": 29.99 },
    { "size": "S", "color": "blue", "sku": "S-blue", "price": 29.99 },
    { "size": "S", "color": "green", "sku": "S-green", "price": 29.99 },
    { "size": "S", "color": "black", "sku": "S-black", "price": 29.99 }
  ],
  [
    { "size": "M", "color": "red", "sku": "M-red", "price": 29.99 },
    // ... and so on for M, L, XL
  ]
]
}

Advanced: Chess Board

Generate a complete chess board with coordinates:

chessBoard = (["a", "b", "c", "d", "e", "f", "g", "h"] map (file) = (
1..8 map (rank) = {
  square = file + rank
  file = file
  rank = rank
  color = (rank % 2) == 0 ? "white" : "black"
}
))

Pro Tip: Nested maps unlock infinite possibilities for matrix-like data structures. Combine with ranges for explosive data generation!