gem 'synthra'

require 'synthra'

# Load and generate
schema = Synthra.load('schemas/user.dsl')
user = schema.generate

# Output:
# {
#   "id" => "550e8400-e29b-41d4-a716-446655440000",
#   "name" => "John Smith",
#   "email" => "john.smith@example.com",
#   "age" => 34,
#   "active" => true,
#   "role" => "user",
#   "created_at" => "2024-06-15"
# }

# Generate multiple records
users = schema.generate_many(100)

# Generate with seed for reproducibility
user = schema.generate(seed: 12345)

begin
  data = schema.generate
rescue Synthra::Errors::SimulatedFailure
  puts "Service unavailable"
rescue Synthra::Errors::SimulatedError => e
  puts "HTTP #{e.status_code}"
end

schema.generate(mode: :random)   # Realistic data
schema.generate(mode: :edge)     # Edge cases
schema.generate(mode: :invalid)   # Invalid data
schema.generate(mode: :hostile)   # Security testing
schema.generate(mode: :mixed)    # Comprehensive testing

# From file
schema = Synthra.load('schemas/user.dsl')

# From string
schema = Synthra.parse(<<~DSL)
  User:
    id: uuid
    name: name
DSL

# Multiple schemas
registry = Synthra::Registry.new
registry.load_dir('schemas/')
user_schema = registry.schema('User')

# Single record
data = schema.generate

# With options
data = schema.generate(
  seed: 12345,           # Reproducibility
  mode: :edge,           # Generation mode
  registry: registry     # For cross-references
)

# Multiple records
records = schema.generate_many(100)

# Streaming (memory-efficient)
schema.generate_stream(count: 1_000_000).each do |record|
  process(record)
end

Synthra.register_type(:ssn) do |rng, context, args, mode|
  "#{rng.int(100, 999)}-#{rng.int(10, 99)}-#{rng.int(1000, 9999)}"
end

Synthra.register_function(:full_name) do |context|
  "#{context['first_name']} #{context['last_name']}"
end

# Schema exports
Synthra.to_typescript(schema)
Synthra.to_python(schema, style: :pydantic)
Synthra.to_json_schema(schema)
Synthra.to_sql(schema, dialect: :postgresql)
Synthra.to_graphql(schema)  # NEW: GraphQL SDL

# Data exports
Synthra.to_json(schema, count: 100)
Synthra.to_csv(schema, count: 1000)
Synthra.to_sql_insert(schema, count: 100, dialect: :mysql)
Synthra.to_yaml(schema, count: 50)
Synthra.to_xml(schema, count: 20)

# Auto-file export
Synthra.export_to_file(:typescript, schema, output_dir: "./types")
# => "./types/user.ts"

# Install and compile (one-time setup)
# 1. Install Rust: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# 2. gem install rb_sys
# 3. bundle exec rake compile

# Generate 10 million records in ~3 seconds
schema.generate_to_file(10_000_000, "users.jsonl")

# Or use engine: :native option
users = schema.generate_many(100_000, engine: :native, seed: 42)

# Default (2 threads)
schema.generate_to_file(10_000_000, "users.jsonl")

# Use 4 threads
schema.generate_to_file(10_000_000, "users.jsonl", threads: 4)

# Use all cores (fastest for single job)
schema.generate_to_file(10_000_000, "users.jsonl", threads: 0)

# English (fast mode)
schema.generate_to_file(1_000_000, "users.jsonl", locale: "en")

# Japanese names
schema.generate_to_file(1_000_000, "users.jsonl", locale: "ja_jp")

# French names
schema.generate_to_file(1_000_000, "users.jsonl", locale: "fr_fr")

require 'synthra'
include Synthra::PropertyTesting

RSpec.describe "User Registration" do
  it "accepts all valid users" do
    verify_property("User", count: 1000) do |user_data|
      user = User.create(user_data)
      expect(user).to be_valid
      expect(user.save).to be_truthy
    end
  end

  it "validates email format" do
    verify_property("User", count: 100) do |user_data|
      email = user_data["email"]
      expect(email).to match(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i)
    end
  end
end

# Generate hostile data
schema.generate(mode: :hostile)

# CLI
synthra generate User --mode hostile

# Test API endpoint with hostile inputs
hostile_data = schema.generate_many(1000, mode: :hostile)
hostile_data.each do |payload|
  response = post("/api/users", payload)
  expect(response.status).to eq(400) # Should reject hostile input
end

# Define a factory using a Synthra schema
Synthra.define_factory(:user, schema: "User") do
  trait(:admin) do
    role { "admin" }
  end

  trait(:with_address) do
    address { Synthra.generate("Address") }
  end
end

# Use in tests
create(:user)                         # Standard user
create(:user, :admin)                 # Admin user
create(:user, :admin, :with_address)  # Admin with address
create(:user, name: "Custom Name")    # Override fields

# In spec_helper.rb
RSpec.configure do |config|
  config.include Synthra::FactoryBotIntegration::RSpec
end

# In tests
describe "User Registration" do
  it "creates a valid user" do
    user_data = fake_data_build(:user)
    # or: user_data = build_fake_data(:user)
    
    expect(User.create(user_data)).to be_valid
  end
end

require 'synthra/snapshot_testing'

RSpec.describe "Schema Snapshots" do
  include Synthra::SnapshotTesting

  # Test individual schema
  it "User generates stable output" do
    schema = Synthra.load("schemas/user.dsl")
    expect_snapshot(schema, seed: 42)
  end

  # Test all schemas
  Synthra.each_schema do |schema|
    it "#{schema.name} generates stable output" do
      expect(schema.generate(seed: 42)).to match_snapshot(schema.name)
    end
  end
end

# Generate all snapshots
Synthra::SnapshotTesting.generate_all_snapshots(registry, seed: 42)

# Verify all snapshots match
mismatches = Synthra::SnapshotTesting.verify_all_snapshots(registry, seed: 42)
puts "Mismatched schemas: #{mismatches}" if mismatches.any?

# Load from custom path
Synthra::ConfigFile.load_and_apply("custom/path.yml")

# Load with specific environment
Synthra::ConfigFile.load_and_apply("config.yml", env: "staging")

# test/test_helper.rb
require 'synthra/rails_test_helper'

class ActiveSupport::TestCase
  include Synthra::RailsTestHelper
end

# In your tests
class UserTest < ActiveSupport::TestCase
  test "validates email format" do
    user = generate_for_test(User)
    assert user.valid?
  end
  
  test "with overrides" do
    user = generate_for_test(User, :valid, email: "test@example.com")
    assert_equal "test@example.com", user.email
  end
  
  test "generate multiple" do
    users = generate_many_for_test(User, 10)
    assert_equal 10, users.length
  end
end

# Pre-registered mixins
Synthra::CommonMixins.register_all!

# Available mixins:
# - Timestamps: created_at, updated_at
# - SoftDelete: deleted_at
# - Auditable: created_by, updated_by
# - Sluggable: slug
# - Publishable: published_at, published

# Ruby API
importer = Synthra::OpenAPIImporter.new("openapi.yaml")
schemas = importer.import_to_directory("schemas/")
# Creates user.dsl, product.dsl, etc.

# Deterministic UUIDs
Synthra::DeterministicIds.uuid(variant: "user", index: 0, seed: 42)
# => "f47ac10b-58cc-4372-a567-0e02b2c3d479" (always the same)

# Short IDs (like YouTube)
Synthra::DeterministicIds.short_id(variant: "video", index: 0)
# => "dQw4w9WgXcQ"

# Integer IDs
Synthra::DeterministicIds.integer(variant: "order", max: 1_000_000)

# URL slugs
Synthra::DeterministicIds.slug(words: 3)
# => "alpha-baker-charlie"

# Batch generation
Synthra::DeterministicIds.batch(100, type: :uuid, variant: "user")

Synthra.seed_database(truncate: true) do
  create User, count: 100
  create Order, count: 500        # Links to Users automatically
  create OrderItem, count: 2000   # Links to Orders automatically
end

# Parse versioned schema names
Synthra::SchemaVersioning.parse_version("User@v2")
# => { name: "User", version: "v2" }

# Register migrations
Synthra::SchemaVersioning::Registry.register(
  from: "User@v1",
  to: "User@v2",
  changes: { added: ["avatar"], removed: ["legacy_field"] }
)

# Find migration path
Synthra::SchemaVersioning::Registry.migration_path("User@v1", "User@v3")
# => [["User@v1", "User@v2"], ["User@v2", "User@v3"]]

Synthra.configure do |config|
  # Default generation mode
  config.default_mode = :random
  
  # Resource limits
  config.limits.max_latency_ms = 10_000
  config.limits.max_recursion = 10
  config.limits.max_array_size = 1000
  config.limits.max_text_length = 10_000
end

# Start server programmatically
Synthra::APIServer.start(
  schema_dir: "schemas/",
  port: 3000,
  auth: { type: :api_key, keys: ["secret123"] },
  rate_limit: 100,  # requests per minute
  enable_caching: true
)

# Use as Rack middleware
# config.ru
run Synthra::APIServer.rack_app(schema_dir: "schemas/")

exporter = Synthra::Export::OpenAPI.new(registry,
  title: "My Data API",
  version: "1.0.0",
  server_url: "https://api.example.com"
)

# Export as YAML
spec_yaml = exporter.export

# Export as JSON
spec_json = exporter.export_as(:json)

# Start mock server
Synthra::MockServer.start(
  schema_dir: "schemas/",
  port: 3000,
  recording: true,           # Enable recording
  recordings_dir: "mocks/",  # Save recordings here
  cors: true,
  default_mode: :random
)

registry = Synthra::ContractsRegistry.new("contracts/")

# Publish
registry.publish("User", version: "1.0.0", schema: schema, changelog: "Initial")

# Deprecate
registry.deprecate("User", version: "1.0.0", sunset_date: Date.new(2026, 6, 1))

# Check compatibility
result = registry.compatible?("User", "1.0.0", "2.0.0")
if result[:breaking]
  puts "Breaking changes: #{result[:changes]}"
end

# Validate current schema against contract
registry.validate("User", version: "1.0.0", schema: current_schema)

# Generate with progress callback
records = Synthra::PerformanceMode.generate(schema, count: 1_000_000) do |progress|
  puts "#{progress[:current]} / #{progress[:total]} (#{progress[:rate]} rec/s)"
end

# Stream to file (memory efficient)
Synthra::PerformanceMode.to_file(
  schema,
  count: 10_000_000,
  output: "users.ndjson",
  format: :ndjson
) do |progress|
  puts "ETA: #{progress[:eta]}s"
end

# Benchmark
results = Synthra::PerformanceMode.benchmark(schema, counts: [1000, 10_000, 100_000])
# => { 1000 => { elapsed: 0.05, rate: 20000, memory_mb: 2.5 }, ... }

# System capabilities
Synthra::PerformanceMode.system_info
# => { cpu_cores: 8, optimal_threads: 7, native_available: true, ... }