synthra 0.1.0

data/lib/synthra/webhook_simulator.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "openssl"
+
+module Synthra
+  # Webhook Simulation
+  #
+  # Simulate webhook deliveries for testing integrations with
+  # payment providers, notification services, and third-party APIs.
+  #
+  # @example Configure and send webhook
+  #   Synthra::WebhookSimulator.configure do |config|
+  #     config.endpoint = "http://localhost:3000/webhooks/stripe"
+  #     config.secret = "whsec_test123"
+  #   end
+  #
+  #   Synthra::WebhookSimulator.send(
+  #     "payment_intent.succeeded",
+  #     data: { amount: 2000, currency: "usd" }
+  #   )
+  #
+  module WebhookSimulator
+    class << self
+      attr_accessor :configuration
+
+      def configure
+        self.configuration ||= Configuration.new
+        yield(configuration) if block_given?
+        configuration
+      end
+
+      # Send a webhook
+      #
+      # @param event_type [String] event type (e.g., "payment_intent.succeeded")
+      # @param data [Hash] event data
+      # @param options [Hash] delivery options
+      # @option options [String] :endpoint override default endpoint
+      # @option options [String] :secret override default secret
+      # @option options [Integer] :delay delay in seconds before sending
+      # @option options [String] :schema schema to generate data from
+      # @option options [Hash] :headers additional headers
+      # @return [WebhookResult] delivery result
+      #
+      def send(event_type, data: nil, **options)
+        config = configuration || Configuration.new
+        endpoint = options[:endpoint] || config.endpoint
+        secret = options[:secret] || config.secret
+
+        raise ConfigurationError, "Endpoint not configured" unless endpoint
+
+        # Generate data from schema if specified
+        if options[:schema] && data.nil?
+          schema = Synthra.registry.schema(options[:schema].to_s)
+          data = schema.generate
+        end
+
+        # Build webhook payload
+        payload = build_payload(event_type, data, config)
+
+        # Handle delay
+        if options[:delay]
+          Thread.new do
+            sleep(options[:delay])
+            deliver(endpoint, payload, secret, options[:headers])
+          end
+          return WebhookResult.new(
+            success: true,
+            status: :scheduled,
+            message: "Webhook scheduled for delivery in #{options[:delay]}s"
+          )
+        end
+
+        # Deliver immediately
+        deliver(endpoint, payload, secret, options[:headers])
+      end
+
+      # Send webhook asynchronously
+      #
+      # @param event_type [String] event type
+      # @param options [Hash] options
+      # @return [Thread] delivery thread
+      #
+      def send_async(event_type, **options)
+        Thread.new { send(event_type, **options) }
+      end
+
+      # Simulate a sequence of webhooks
+      #
+      # @param events [Array<Hash>] list of events with delays
+      # @yield [result] for each delivered webhook
+      # @return [Array<WebhookResult>] results
+      #
+      # @example Simulate payment flow
+      #   WebhookSimulator.sequence([
+      #     { type: "payment_intent.created", delay: 0 },
+      #     { type: "payment_intent.processing", delay: 1 },
+      #     { type: "payment_intent.succeeded", delay: 2 }
+      #   ])
+      #
+      def sequence(events, &block)
+        results = []
+
+        events.each do |event|
+          sleep(event[:delay] || 0) if event[:delay]
+
+          result = send(
+            event[:type],
+            data: event[:data],
+            schema: event[:schema],
+            endpoint: event[:endpoint]
+          )
+
+          results << result
+          yield result if block_given?
+        end
+
+        results
+      end
+
+      # Register a webhook template
+      #
+      # @param name [Symbol] template name
+      # @param event_type [String] event type
+      # @param schema [String] schema for data
+      # @param options [Hash] default options
+      #
+      def register_template(name, event_type:, schema: nil, **options)
+        templates[name] = {
+          event_type: event_type,
+          schema: schema,
+          options: options
+        }
+      end
+
+      # Send webhook using template
+      #
+      # @param template_name [Symbol] registered template name
+      # @param overrides [Hash] data overrides
+      # @return [WebhookResult]
+      #
+      def from_template(template_name, **overrides)
+        template = templates[template_name]
+        raise ArgumentError, "Unknown template: #{template_name}" unless template
+
+        send(
+          template[:event_type],
+          schema: template[:schema],
+          **template[:options].merge(overrides)
+        )
+      end
+
+      # Templates registry
+      def templates
+        @templates ||= {}
+      end
+
+      private
+
+      def build_payload(event_type, data, config)
+        {
+          id: "evt_#{SecureRandom.hex(12)}",
+          type: event_type,
+          created: Time.now.to_i,
+          data: {
+            object: data || {}
+          },
+          livemode: false,
+          api_version: config.api_version
+        }
+      end
+
+      def deliver(endpoint, payload, secret, extra_headers)
+        uri = URI.parse(endpoint)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 10
+        http.read_timeout = 30
+
+        body = JSON.generate(payload)
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request["Content-Type"] = "application/json"
+        request["User-Agent"] = "Synthra-Webhook/1.0"
+
+        # Add signature if secret provided
+        if secret
+          timestamp = Time.now.to_i
+          signature = compute_signature(timestamp, body, secret)
+          request["Stripe-Signature"] = "t=#{timestamp},v1=#{signature}"
+        end
+
+        # Add extra headers
+        extra_headers&.each { |k, v| request[k] = v }
+
+        request.body = body
+
+        response = http.request(request)
+
+        WebhookResult.new(
+          success: response.code.to_i < 400,
+          status: response.code.to_i,
+          body: response.body,
+          payload: payload
+        )
+      rescue StandardError => e
+        WebhookResult.new(
+          success: false,
+          status: 0,
+          error: e.message,
+          payload: payload
+        )
+      end
+
+      def compute_signature(timestamp, payload, secret)
+        signed_payload = "#{timestamp}.#{payload}"
+        OpenSSL::HMAC.hexdigest("SHA256", secret, signed_payload)
+      end
+    end
+
+    # Configuration class
+    class Configuration
+      attr_accessor :endpoint, :secret, :api_version
+      attr_accessor :default_headers, :timeout
+
+      def initialize
+        @endpoint = nil
+        @secret = nil
+        @api_version = "2023-10-16"
+        @default_headers = {}
+        @timeout = 30
+      end
+    end
+
+    # Webhook delivery result
+    class WebhookResult
+      attr_reader :success, :status, :body, :error, :payload
+
+      def initialize(success:, status:, body: nil, error: nil, payload: nil, message: nil)
+        @success = success
+        @status = status
+        @body = body
+        @error = error
+        @payload = payload
+        @message = message
+      end
+
+      def success?
+        @success
+      end
+
+      def failed?
+        !@success
+      end
+
+      def to_h
+        {
+          success: @success,
+          status: @status,
+          body: @body,
+          error: @error
+        }
+      end
+    end
+
+    class ConfigurationError < StandardError; end
+
+    # Simulate Stripe webhooks
+    module Stripe
+      EVENTS = {
+        payment_succeeded: "payment_intent.succeeded",
+        payment_failed: "payment_intent.payment_failed",
+        subscription_created: "customer.subscription.created",
+        subscription_updated: "customer.subscription.updated",
+        subscription_deleted: "customer.subscription.deleted",
+        invoice_paid: "invoice.paid",
+        invoice_payment_failed: "invoice.payment_failed",
+        charge_succeeded: "charge.succeeded",
+        charge_refunded: "charge.refunded"
+      }.freeze
+
+      class << self
+        def payment_succeeded(amount:, currency: "usd", **options)
+          WebhookSimulator.send("payment_intent.succeeded", data: {
+            id: "pi_#{SecureRandom.hex(12)}",
+            object: "payment_intent",
+            amount: amount,
+            currency: currency,
+            status: "succeeded",
+            created: Time.now.to_i
+          }, **options)
+        end
+
+        def subscription_created(customer_id:, plan_id:, **options)
+          WebhookSimulator.send("customer.subscription.created", data: {
+            id: "sub_#{SecureRandom.hex(12)}",
+            object: "subscription",
+            customer: customer_id,
+            items: { data: [{ price: { id: plan_id } }] },
+            status: "active",
+            created: Time.now.to_i
+          }, **options)
+        end
+      end
+    end
+
+    # Simulate GitHub webhooks
+    module GitHub
+      EVENTS = {
+        push: "push",
+        pull_request: "pull_request",
+        issue: "issues",
+        release: "release"
+      }.freeze
+
+      class << self
+        def push(repo:, ref: "refs/heads/main", **options)
+          WebhookSimulator.send("push", data: {
+            ref: ref,
+            repository: { full_name: repo },
+            commits: [],
+            pusher: { name: "user", email: "user@example.com" }
+          }, **options)
+        end
+
+        def pull_request(repo:, action: "opened", **options)
+          WebhookSimulator.send("pull_request", data: {
+            action: action,
+            number: rand(1..1000),
+            repository: { full_name: repo },
+            pull_request: {
+              title: "Test PR",
+              state: action == "closed" ? "closed" : "open"
+            }
+          }, **options)
+        end
+      end
+    end
+  end
+end

data/lib/synthra.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+# =============================================================================
+# Synthra - Generate fake data from a human-friendly DSL
+# =============================================================================
+#
+# A Ruby gem for defining data schemas using a simple DSL and generating
+# realistic fake data with support for:
+#
+# - 50+ built-in types (uuid, name, email, etc.)
+# - Schema inheritance
+# - Cross-schema references
+# - Behaviors (latency, failure simulation)
+# - Multiple generation modes (random, edge, invalid, hostile)
+# - Export to multiple formats (TypeScript, Python, GraphQL, etc.)
+#
+# @example Basic usage
+#   schema = Synthra.load("schemas/user.dsl")
+#   user = schema.generate
+#
+# @author Synthra Contributors
+# @see https://github.com/talaatmagdyx/synthra
+#
+# =============================================================================
+
+require "zeitwerk"
+require "faker"
+require "json"
+require "securerandom"
+
+# Configure Zeitwerk autoloader
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "synthra" => "Synthra",
+  "dsl" => "DSL",
+  "rng" => "RNG",
+  "ast" => "AST",
+  "cli" => "CLI",
+  "lsp" => "LSP",
+  "repl" => "REPL",
+  "api" => "API"
+)
+
+# Ignore domain folders (manually loaded for flat namespace)
+IGNORED_DOMAIN_FOLDERS = %w[
+  address_location finance_banking technology_internet commerce_products
+  media_entertainment personal_names text_content health_medical travel
+  date_time crypto core
+].freeze
+
+# Ignore deprecated files and domain folders
+%w[
+  address_location_types finance_banking_types technology_internet_types
+  commerce_product_types media_entertainment_types personal_names_types
+  text_content_types datetime hash time
+].each { |f| loader.ignore("#{__dir__}/synthra/types/#{f}.rb") }
+
+IGNORED_DOMAIN_FOLDERS.each do |folder|
+  loader.ignore("#{__dir__}/synthra/types/#{folder}")
+end
+
+# Ignore manually loaded modules
+loader.ignore("#{__dir__}/synthra/utils")
+loader.ignore("#{__dir__}/synthra/validator")
+loader.ignore("#{__dir__}/synthra/lsp")
+loader.ignore("#{__dir__}/synthra/repl")
+loader.ignore("#{__dir__}/synthra/cli/commands")
+loader.ignore("#{__dir__}/synthra/types/hostile_payloads.rb")
+
+# Ignore new feature files (manually loaded)
+loader.ignore("#{__dir__}/synthra/api.rb")
+loader.ignore("#{__dir__}/synthra/type_definitions.rb")
+loader.ignore("#{__dir__}/synthra/config_file.rb")
+loader.ignore("#{__dir__}/synthra/schema_inheritance.rb")
+loader.ignore("#{__dir__}/synthra/factory_bot_integration.rb")
+loader.ignore("#{__dir__}/synthra/snapshot_testing.rb")
+loader.ignore("#{__dir__}/synthra/export/type_mapping.rb")
+loader.ignore("#{__dir__}/synthra/export/graphql.rb")
+
+# Ignore Phase 2 feature files (manually loaded)
+loader.ignore("#{__dir__}/synthra/rails_test_helper.rb")
+loader.ignore("#{__dir__}/synthra/mixin.rb")
+loader.ignore("#{__dir__}/synthra/relationships.rb")
+loader.ignore("#{__dir__}/synthra/schema_versioning.rb")
+loader.ignore("#{__dir__}/synthra/openapi_importer.rb")
+loader.ignore("#{__dir__}/synthra/database_seeder.rb")
+loader.ignore("#{__dir__}/synthra/live_preview.rb")
+loader.ignore("#{__dir__}/synthra/documentation_generator.rb")
+loader.ignore("#{__dir__}/synthra/deterministic_ids.rb")
+
+# Ignore Production-grade features (manually loaded)
+loader.ignore("#{__dir__}/synthra/export/protobuf.rb")
+loader.ignore("#{__dir__}/synthra/export/openapi.rb")
+loader.ignore("#{__dir__}/synthra/mock_server.rb")
+loader.ignore("#{__dir__}/synthra/contracts_registry.rb")
+loader.ignore("#{__dir__}/synthra/performance_mode.rb")
+loader.ignore("#{__dir__}/synthra/api_server.rb")
+
+# Ignore Rails-tier features (manually loaded)
+loader.ignore("#{__dir__}/synthra/engine.rb")
+loader.ignore("#{__dir__}/synthra/activerecord_inference.rb")
+loader.ignore("#{__dir__}/synthra/scenarios.rb")
+loader.ignore("#{__dir__}/synthra/personas.rb")
+loader.ignore("#{__dir__}/synthra/time_travel.rb")
+loader.ignore("#{__dir__}/synthra/quality_metrics.rb")
+loader.ignore("#{__dir__}/synthra/webhook_simulator.rb")
+loader.ignore("#{__dir__}/synthra/migration_generator.rb")
+loader.ignore("#{__dir__}/synthra/export/graphql_federation.rb")
+loader.ignore("#{__dir__}/synthra/export/terraform.rb")
+
+# Ignore Rails generators (loaded by Rails when available)
+loader.ignore("#{__dir__}/generators")
+
+# Ignore initializer and loader_config (loaded manually, not a class/module)
+loader.ignore("#{__dir__}/synthra/initializer.rb")
+loader.ignore("#{__dir__}/synthra/loader_config.rb")
+
+loader.setup
+
+# =============================================================================
+# Manual requires for organized modules
+# =============================================================================
+
+# Core utilities
+require_relative "synthra/utils/string_distance"
+require_relative "synthra/validator/path_validator"
+require_relative "synthra/validator/dsl_validator"
+
+# Export system
+require_relative "synthra/export"
+require_relative "synthra/export/type_mapping"
+
+# LSP and REPL
+require_relative "synthra/lsp/server"
+require_relative "synthra/repl/formatter"
+require_relative "synthra/repl/enhanced_repl"
+
+# Hostile payloads
+require_relative "synthra/types/hostile_payloads"
+
+# New features
+require_relative "synthra/api"
+require_relative "synthra/type_definitions"
+require_relative "synthra/config_file"
+require_relative "synthra/schema_inheritance"
+require_relative "synthra/factory_bot_integration"
+require_relative "synthra/snapshot_testing"
+
+# Phase 2 features
+require_relative "synthra/rails_test_helper"
+require_relative "synthra/mixin"
+require_relative "synthra/relationships"
+require_relative "synthra/schema_versioning"
+require_relative "synthra/openapi_importer"
+require_relative "synthra/database_seeder"
+require_relative "synthra/live_preview"
+require_relative "synthra/documentation_generator"
+require_relative "synthra/deterministic_ids"
+
+# Production-grade features
+require_relative "synthra/export/protobuf"
+require_relative "synthra/export/openapi"
+require_relative "synthra/mock_server"
+require_relative "synthra/contracts_registry"
+require_relative "synthra/performance_mode"
+require_relative "synthra/api_server"
+
+# Rails-tier features
+require_relative "synthra/time_travel"
+require_relative "synthra/scenarios"
+require_relative "synthra/personas"
+require_relative "synthra/quality_metrics"
+require_relative "synthra/webhook_simulator"
+require_relative "synthra/migration_generator"
+require_relative "synthra/export/graphql_federation"
+require_relative "synthra/export/terraform"
+
+# Rails Engine (only if Rails is available)
+# :nocov: — load-time, Rails-only. The gem's RSpec suite runs without Rails, so
+# Rails::Engine is never defined and this require block cannot execute under test.
+if defined?(Rails::Engine)
+  require_relative "synthra/engine"
+  require_relative "synthra/activerecord_inference"
+end
+# :nocov:
+
+# CLI command pattern
+require_relative "synthra/cli/commands/base"
+require_relative "synthra/cli/commands/validate"
+require_relative "synthra/cli/commands/lint"
+require_relative "synthra/cli/commands/generate"
+require_relative "synthra/cli/commands/export"
+require_relative "synthra/cli/commands/diff"
+require_relative "synthra/cli/commands/import"
+require_relative "synthra/cli/commands/docs"
+require_relative "synthra/cli/commands/live"
+require_relative "synthra/cli/commands/seed"
+
+# =============================================================================
+# Main Module
+# =============================================================================
+
+module Synthra
+  # Probability that an optional field will be included (80%)
+  OPTIONAL_FIELD_PRESENCE_RATE = 0.8
+
+  # Probability that a nullable field will be null (10%)
+  NULLABLE_FIELD_NULL_RATE = 0.1
+
+  # Maximum DSL file size to prevent DoS (10MB)
+  MAX_DSL_FILE_SIZE = 10 * 1024 * 1024
+
+  # Extend with API methods
+  extend API
+
+  class << self
+    # Load configuration from config file on first use
+    #
+    # @return [void]
+    #
+    def load_config_file!
+      @config_loaded ||= begin
+        ConfigFile.load_and_apply
+        true
+      end
+    end
+  end
+end
+
+# =============================================================================
+# Eager loading and initialization
+# =============================================================================
+
+# Eager load all autoloaded files
+loader.eager_load
+
+# Load domain folder type files
+IGNORED_DOMAIN_FOLDERS.each do |folder|
+  dir = File.join(__dir__, "synthra/types/#{folder}")
+  # :nocov: — load-time guard. Every listed domain folder ships with the gem, so
+  # the missing-directory (`next`) arm is never taken once the gem is installed.
+  next unless Dir.exist?(dir)
+  # :nocov:
+
+  Dir.glob(File.join(dir, "*.rb")).sort.each do |file|
+    require_relative file.sub(%r{^#{__dir__}/}, "")
+  end
+end
+
+# Register built-in types and behaviors
+Synthra.register_builtin_types!
+Synthra::Behaviors::Registry.register_builtins!
+
+# Auto-load config file if present
+# :nocov: — load-time, runs exactly once at require. Which arm is taken depends
+# on whether a config file is present in the boot CWD; it cannot be re-driven by
+# a unit test. (load_config_file! itself is covered directly in its own spec.)
+Synthra.load_config_file! if Synthra::ConfigFile.find_config_file
+# :nocov:

data/schemas/address.dsl

@@ -0,0 +1,16 @@
+# Address schema example
+Address:
+  street: text(10..100)
+  city: text(5..30)
+  state: text(2..20)
+  postal_code: postal_code(country: US)
+  country: country_code
+
+
+PostalCode:
+  postal_code: text(5..10)
+  country: country_code
+
+CountryCode:
+  country_code: text(2)
+

data/schemas/api_response.dsl

@@ -0,0 +1,8 @@
+# API response wrapper
+ApiResponse:
+  success: boolean(true:95%)
+  data?: User
+  error?: text if success
+  timestamp: timestamp
+  request_id: ulid
+

data/schemas/error_payload.dsl

@@ -0,0 +1,9 @@
+# Error response schema
+ErrorPayload:
+  error_code: text(3..10)
+  message: text(10..200)
+  details?: text(20..500)
+  timestamp: timestamp
+  request_id: ulid
+  path: url
+

data/schemas/order.dsl

@@ -0,0 +1,10 @@
+# Order schema with references
+Order:
+  id: uuid(unique: true)
+  user_id: Ref(User.id)
+  status: enum(pending, processing:30%, shipped:40%, delivered:25%, cancelled:5%)
+  total: money(range: 10..1000, currency: USD)
+  items: array(OrderItem, 1..5)
+  created_at: past_date(30d)
+  shipped_at?: future_date(7d) if status
+

data/schemas/order_item.dsl

@@ -0,0 +1,8 @@
+# Order item schema
+OrderItem:
+  id: uuid
+  product_name: text(5..50)
+  quantity: number(1..10)
+  unit_price: money(range: 1..500)
+  sku: text(8..12)
+

data/schemas/payment.dsl

@@ -0,0 +1,11 @@
+# Payment schema
+Payment:
+  id: uuid(unique: true)
+  order_id: Ref(Order.id)
+  amount: money
+  currency: currency
+  method: enum(credit_card:60%, debit_card:20%, paypal:15%, bank_transfer:5%)
+  status: enum(pending, completed:80%, failed:10%, refunded:10%)
+  processed_at?: timestamp
+  ip_address: ip
+

data/schemas/social_post.dsl

@@ -0,0 +1,13 @@
+# Social media post schema
+SocialPost:
+  id: ulid
+  author_id: uuid
+  content: text(10..280)
+  likes: number(0..10000)
+  shares: number(0..1000)
+  comments_count: number(0..500)
+  tags: array(text, 0..5)
+  media_url?: url
+  is_sponsored: boolean(true:10%)
+  created_at: past_date(30d)
+

data/schemas/user.dsl

@@ -0,0 +1,10 @@
+# User schema example
+User:
+  id: uuid(unique: true)
+  name: name
+  email: email
+  age?: number(18..80)
+  active: boolean(true:80%)
+  role: enum(user, admin:10%, moderator:20%)
+  created_at: past_date(2y)
+