Advanced Features

Advanced features for complex data generation scenarios.

Cross-Schema References

Reference fields from other schemas:

User:
  id: uuid
  name: name

Order:
  id: uuid
  user_id: reference(User, id)  # References User's id
  total: number(10..1000)

Benefits:

Maintain referential integrity
Generate related data sets
Test foreign key relationships

Custom Functions

Define custom generation logic:

# Register a custom function
FakeDataDSL.register_function(:generate_slug) do |context|
  name = context["name"] || "default"
  name.downcase.gsub(/\s+/, '-')
end

# Use in schema
User:
  name: name
  slug: custom(:generate_slug)

Function context:

Receives current generation context
Can access previously generated fields
Returns generated value

Streaming Generation

Generate large datasets efficiently:

schema = registry.schema('User')

# Stream records (lazy evaluation)
schema.generate_many_stream(1000).each do |record|
  # Process each record
  puts record
end

Benefits:

Memory efficient
Can process records as they're generated
Suitable for large datasets

Deterministic Generation

Use seeds for reproducible data:

# Set seed
FakeDataDSL.configure do |config|
  config.seed = 12345
end

# Generate (same seed = same data)
record1 = schema.generate
record2 = schema.generate
# record1 and record2 are deterministic

Use cases:

Reproducible tests
Debugging
Consistent demo data

Formula Fields

Compute values from other fields:

Order:
  quantity: number(1..10)
  unit_price: number(10..100)
  total: formula(quantity * unit_price)
  tax: formula(total * 0.08)
  grand_total: formula(total + tax)

Supported operations:

Arithmetic: +, -, *, /
Field references: price, quantity
Constants: 0.08, 100

Template Fields

String interpolation with field values:

User:
  first_name: first_name
  last_name: last_name
  greeting: template("Hello {first_name} {last_name}!")
  email_template: template("{first_name}.{last_name}@example.com")

Placeholders:

{field_name} - Replaced with field value
Supports multiple placeholders

Conditional Fields

Fields that depend on other fields:

User:
  is_admin: boolean
  admin_key: text if is_admin
  is_active: boolean
  deactivated_at: date if !is_active

Conditions:

if field_name - When field is truthy
if !field_name - When field is falsy

Uniqueness Constraints

Ensure unique values:

User:
  email: email unique
  username: username unique

Scope:

Per-schema generation
Per-Engine instance
Resets between runs

Resource Limits

Configure limits to prevent DoS:

FakeDataDSL.configure do |config|
  config.max_recursion = 10
  config.max_array_size = 1000
  config.max_text_length = 10000
  config.max_latency = 5000  # milliseconds
end

Observability

Add logging and metrics:

FakeDataDSL.configure do |config|
  config.logger = Logger.new(STDOUT)
  config.metrics_collector = MyMetricsCollector.new
  config.on_field_generated = proc do |schema, field, value|
    puts "Generated #{field} for #{schema}: #{value}"
  end
end