synthra 0.1.0

data/lib/generators/synthra/install_generator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Synthra
+  module Generators
+    # Rails generator for setting up Synthra in a Rails application
+    #
+    # @example Install Synthra
+    #   rails generate synthra:install
+    #
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Sets up Synthra for your Rails application"
+
+      def create_config_file
+        template "synthra.yml", "config/synthra.yml"
+      end
+
+      def create_schemas_directory
+        empty_directory "schemas"
+        template "user.dsl", "schemas/user.dsl"
+        template "api_response.dsl", "schemas/api_response.dsl"
+      end
+
+      def create_generated_directory
+        empty_directory "generated"
+        empty_directory "generated/types"
+        empty_directory "generated/mocks"
+        empty_directory "generated/docs"
+        
+        create_file "generated/.gitkeep"
+        create_file "generated/types/.gitkeep"
+        create_file "generated/mocks/.gitkeep"
+        create_file "generated/docs/.gitkeep"
+      end
+
+      def create_rspec_support
+        return unless File.exist?("spec/spec_helper.rb")
+        
+        template "synthra_support.rb", "spec/support/synthra.rb"
+      end
+
+      def create_rake_tasks
+        template "fake_data.rake", "lib/tasks/fake_data.rake"
+      end
+
+      def add_gitignore_entries
+        append_to_file ".gitignore", <<~GITIGNORE
+
+          # Synthra generated files
+          /generated/types/*
+          /generated/mocks/*
+          /generated/docs/*
+          !/generated/*/.gitkeep
+        GITIGNORE
+      end
+
+      def show_readme
+        say ""
+        say "=" * 60, :green
+        say "  Synthra installed successfully! 🎉", :green
+        say "=" * 60, :green
+        say ""
+        say "Next steps:", :yellow
+        say ""
+        say "  1. Edit your schemas in schemas/"
+        say "  2. Generate TypeScript types:"
+        say "       rails fake_data:types", :cyan
+        say ""
+        say "  3. Generate mock data:"
+        say "       rails fake_data:mocks", :cyan
+        say ""
+        say "  4. Start live preview server:"
+        say "       rails fake_data:live", :cyan
+        say ""
+        say "  5. Run schema linter:"
+        say "       rails fake_data:lint", :cyan
+        say ""
+        say "Documentation: https://github.com/talaatmagdyx/synthra"
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/synthra/templates/api_response.dsl

@@ -0,0 +1,15 @@
+# API Response Schema
+# Use this for simulating API responses with behaviors
+
+APIResponse:
+  @latency 50..200ms        # Simulate network latency
+  @failure 2%               # 2% chance of failure
+  
+  success: boolean(true:95%)
+  data: object
+  meta:
+    page: number(1..100)
+    per_page: const(20)
+    total: number(0..10000)
+  timestamp: now
+  request_id: uuid

data/lib/generators/synthra/templates/fake_data.rake

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# Synthra Rake Tasks
+# Generated by: rails generate synthra:install
+
+namespace :fake_data do
+  desc "Generate TypeScript types from schemas"
+  task types: :environment do
+    require "synthra"
+    
+    output_file = "generated/types/api.ts"
+    
+    puts "📝 Generating TypeScript types..."
+    system("synthra export --all -d schemas -f typescript -o #{output_file}")
+    puts "✅ Generated: #{output_file}"
+  end
+
+  desc "Generate mock JSON data"
+  task mocks: :environment do
+    require "synthra"
+    
+    registry = Synthra::Registry.new
+    registry.load_dir("schemas")
+    
+    puts "📦 Generating mock data..."
+    
+    registry.names.each do |name|
+      schema = registry.schema(name)
+      output_file = "generated/mocks/#{name.downcase}.json"
+      
+      data = schema.generate_many(50, seed: 42)
+      File.write(output_file, JSON.pretty_generate(data))
+      
+      puts "   ✅ #{output_file} (50 records)"
+    end
+    
+    puts "✅ Mock generation complete!"
+  end
+
+  desc "Generate HTML documentation"
+  task docs: :environment do
+    require "synthra"
+    
+    puts "📚 Generating documentation..."
+    system("synthra docs schemas/ --output generated/docs/")
+    puts "✅ Documentation generated: generated/docs/index.html"
+  end
+
+  desc "Start live preview server"
+  task live: :environment do
+    require "synthra"
+    
+    port = ENV.fetch("PORT", 4567)
+    puts "🚀 Starting live preview server on http://localhost:#{port}"
+    exec("synthra live schemas/ --port #{port}")
+  end
+
+  desc "Lint schemas for errors"
+  task lint: :environment do
+    require "synthra"
+    
+    puts "🔍 Linting schemas..."
+    system("synthra lint schemas/ --strict")
+  end
+
+  desc "Seed database with fake data"
+  task seed: :environment do
+    require "synthra"
+    
+    count = ENV.fetch("COUNT", 100).to_i
+    
+    puts "🌱 Seeding database with #{count} records per schema..."
+    
+    Synthra.seed_database do
+      # Add your models here:
+      # create User, count: count
+      # create Product, count: count * 5
+      # create Order, count: count * 10
+    end
+    
+    puts "✅ Database seeded!"
+  end
+
+  desc "Generate all outputs (types, mocks, docs)"
+  task all: [:types, :mocks, :docs] do
+    puts ""
+    puts "🎉 All outputs generated!"
+    puts ""
+    puts "   TypeScript types: generated/types/api.ts"
+    puts "   Mock data:        generated/mocks/"
+    puts "   Documentation:    generated/docs/index.html"
+  end
+
+  desc "Watch schemas for changes and regenerate"
+  task watch: :environment do
+    require "synthra"
+    
+    puts "👁  Watching schemas/ for changes..."
+    puts "   Press Ctrl+C to stop"
+    
+    last_mtime = Dir.glob("schemas/*.dsl").map { |f| File.mtime(f) }.max
+    
+    loop do
+      sleep 1
+      current_mtime = Dir.glob("schemas/*.dsl").map { |f| File.mtime(f) }.max rescue nil
+      
+      if current_mtime && last_mtime && current_mtime > last_mtime
+        puts "♻️  Changes detected, regenerating..."
+        Rake::Task["fake_data:all"].execute
+        last_mtime = current_mtime
+      end
+    end
+  rescue Interrupt
+    puts "\n👋 Stopped watching"
+  end
+end

data/lib/generators/synthra/templates/synthra.yml

@@ -0,0 +1,31 @@
+# Synthra Configuration
+# https://github.com/talaatmagdyx/synthra
+
+# Default generation mode: random, edge, invalid, hostile, mixed
+default_mode: random
+
+# Maximum retries for unique field generation
+max_unique_retries: 1000
+
+# Resource limits
+limits:
+  max_array_size: 100
+  max_recursion: 5
+  max_text_length: 10000
+  max_latency_ms: 5000
+
+# Environment-specific overrides
+test:
+  default_mode: edge      # Use edge cases in tests
+  seed: 42                # Deterministic output for CI
+
+development:
+  default_mode: random
+
+staging:
+  default_mode: random
+  seed: 12345             # Consistent staging data
+
+production:
+  # Production should NOT use this gem
+  # Keep this section empty or commented out

data/lib/generators/synthra/templates/synthra_support.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Synthra RSpec Support
+# Generated by: rails generate synthra:install
+
+require "synthra"
+require "synthra/rails_test_helper"
+require "synthra/snapshot_testing"
+
+RSpec.configure do |config|
+  # Include test helpers
+  config.include Synthra::RailsTestHelper
+  config.include Synthra::SnapshotTesting
+
+  # Load schemas once before the test suite
+  config.before(:suite) do
+    Synthra.configure_test_helper!
+  end
+end

data/lib/generators/synthra/templates/user.dsl

@@ -0,0 +1,11 @@
+# User Schema
+# Edit this file to match your User model
+
+User:
+  id: uuid(unique: true)
+  email: email(unique: true)
+  name: name
+  role: enum(admin, user, guest)
+  active: boolean(true:90%)
+  created_at: timestamp
+  updated_at: timestamp

data/lib/synthra/activerecord_inference.rb

@@ -0,0 +1,394 @@
+# frozen_string_literal: true
+
+module Synthra
+  # ActiveRecord Schema Inference
+  #
+  # Automatically generates DSL schemas from ActiveRecord models by
+  # analyzing column types, validations, and associations.
+  #
+  # @example Infer schema from model
+  #   schema = Synthra::ActiveRecordInference.infer(User)
+  #   schema.generate
+  #
+  # @example Discover all models
+  #   Synthra::ActiveRecordInference.discover_all!
+  #
+  # @example Export inferred schema to DSL file
+  #   Synthra::ActiveRecordInference.export(User, "schemas/user.dsl")
+  #
+  class ActiveRecordInference
+    # Column type to Synthra type mapping
+    COLUMN_TYPE_MAP = {
+      # Strings
+      string: "text",
+      text: "paragraph",
+      citext: "text",
+
+      # Numbers
+      integer: "number",
+      bigint: "number",
+      smallint: "number",
+      float: "float",
+      decimal: "money",
+      numeric: "money",
+
+      # Boolean
+      boolean: "boolean",
+
+      # Date/Time
+      date: "date",
+      datetime: "timestamp",
+      timestamp: "timestamp",
+      time: "time",
+
+      # Binary
+      binary: "binary",
+      blob: "binary",
+
+      # Special
+      uuid: "uuid",
+      json: "object",
+      jsonb: "object",
+      hstore: "object",
+      array: "array(text)"
+    }.freeze
+
+    # Column name patterns for smart type inference
+    NAME_PATTERNS = {
+      /\Aemail\z/i => "email",
+      /email/i => "email",
+      /\Aphone\z/i => "phone",
+      /phone|mobile|cell/i => "phone",
+      /\Aurl\z/i => "url",
+      /url|website|link|href/i => "url",
+      /\Aname\z/i => "name",
+      /first_name/i => "first_name",
+      /last_name/i => "last_name",
+      /full_name/i => "full_name",
+      /username/i => "username",
+      /password/i => "password",
+      /\Aaddress\z/i => "address",
+      /street/i => "street",
+      /city/i => "city",
+      /state|province/i => "state",
+      /country/i => "country",
+      /zip|postal/i => "postal_code",
+      /latitude|lat\z/i => "latitude",
+      /longitude|lng|lon\z/i => "longitude",
+      /ip_address|ip\z/i => "ip",
+      /user_agent/i => "user_agent",
+      /color/i => "hex_color",
+      /avatar|image|photo|picture/i => "url",
+      /title/i => "sentence",
+      /description|bio|about/i => "paragraph",
+      /slug/i => "slug",
+      /token|secret|api_key/i => "uuid",
+      /amount|price|cost|total/i => "money",
+      /count|quantity|qty/i => "number(1..100)",
+      /age/i => "number(1..120)",
+      /ssn/i => "ssn",
+      /credit_card|card_number/i => "credit_card",
+      /company|organization/i => "company",
+      /job_title|position/i => "job_title"
+    }.freeze
+
+    class << self
+      # Infer schema from an ActiveRecord model
+      #
+      # @param model [Class] ActiveRecord model class
+      # @param options [Hash] inference options
+      # @option options [Boolean] :include_associations include associations
+      # @option options [Boolean] :include_validations infer from validations
+      # @option options [Array<String>] :skip_columns columns to skip
+      # @return [Schema] generated schema
+      #
+      def infer(model, **options)
+        options = {
+          include_associations: true,
+          include_validations: true,
+          skip_columns: %w[id created_at updated_at]
+        }.merge(options)
+
+        builder = SchemaBuilder.new(model.name)
+
+        # Process columns
+        model.columns.each do |column|
+          next if options[:skip_columns].include?(column.name)
+
+          field_type = infer_column_type(column, model, options)
+          field_options = infer_field_options(column, model, options)
+
+          builder.add_field(column.name, field_type, **field_options)
+        end
+
+        # Process associations
+        if options[:include_associations]
+          model.reflect_on_all_associations.each do |assoc|
+            process_association(builder, assoc)
+          end
+        end
+
+        # Process validations
+        if options[:include_validations]
+          process_validations(builder, model)
+        end
+
+        builder.build
+      end
+
+      # Discover and infer schemas for all ActiveRecord models
+      #
+      # @param options [Hash] inference options
+      # @return [Array<Schema>] list of generated schemas
+      #
+      def discover_all!(**options)
+        # Ensure models are loaded
+        Rails.application.eager_load! if defined?(Rails) && Rails.env.development?
+
+        schemas = []
+
+        ActiveRecord::Base.descendants.each do |model|
+          next if model.abstract_class?
+          next if model.name.nil?
+          next if model.name.start_with?("ActiveRecord::")
+          next if model.name.start_with?("HABTM_")
+
+          begin
+            schema = infer(model, **options)
+            Synthra.registry.register_schema(model.name, schema)
+            schemas << schema
+          rescue StandardError => e
+            warn "[Synthra] Could not infer #{model.name}: #{e.message}"
+          end
+        end
+
+        schemas
+      end
+
+      # Export inferred schema to a DSL file
+      #
+      # @param model [Class] ActiveRecord model class
+      # @param path [String] output file path
+      # @param options [Hash] inference options
+      # @return [String] generated DSL content
+      #
+      def export(model, path = nil, **options)
+        schema = infer(model, **options)
+        dsl_content = schema_to_dsl(schema)
+
+        if path
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, dsl_content)
+        end
+
+        dsl_content
+      end
+
+      # Export all discovered models to DSL files
+      #
+      # @param output_dir [String] output directory
+      # @param options [Hash] inference options
+      #
+      def export_all(output_dir = "db/schemas", **options)
+        FileUtils.mkdir_p(output_dir)
+
+        discover_all!(**options).each do |schema|
+          filename = schema.name.underscore + ".dsl"
+          path = File.join(output_dir, filename)
+          dsl_content = schema_to_dsl(schema)
+          File.write(path, dsl_content)
+        end
+      end
+
+      private
+
+      def infer_column_type(column, model, options)
+        # First, check name patterns
+        NAME_PATTERNS.each do |pattern, type|
+          return type if column.name.match?(pattern)
+        end
+
+        # Check for enums
+        if model.defined_enums.key?(column.name)
+          values = model.defined_enums[column.name].keys
+          return "enum(#{values.join(', ')})"
+        end
+
+        # Check validations for format hints
+        if options[:include_validations]
+          type_from_validations = infer_from_validations(column, model)
+          return type_from_validations if type_from_validations
+        end
+
+        # Fall back to column type mapping
+        COLUMN_TYPE_MAP[column.type] || "text"
+      end
+
+      def infer_field_options(column, model, _options)
+        opts = {}
+
+        # Check nullability
+        opts[:nullable] = column.null
+
+        # Check default value
+        opts[:default] = column.default if column.default
+
+        # Check for unique constraint
+        if model.validators_on(column.name).any? { |v| v.is_a?(ActiveRecord::Validations::UniquenessValidator) }
+          opts[:unique] = true
+        end
+
+        opts
+      end
+
+      def process_association(builder, assoc)
+        case assoc.macro
+        when :belongs_to
+          # Add foreign key reference
+          fk_column = assoc.foreign_key
+          unless builder.has_field?(fk_column)
+            ref_type = "Ref(#{assoc.class_name}.id)"
+            builder.add_field(fk_column, ref_type, optional: assoc.options[:optional])
+          end
+
+        when :has_one
+          # Record the relationship for potential use
+          builder.add_relationship(:has_one, assoc.name, assoc.class_name)
+
+        when :has_many
+          # Record the relationship
+          builder.add_relationship(:has_many, assoc.name, assoc.class_name)
+        end
+      end
+
+      def process_validations(builder, model)
+        model.validators.each do |validator|
+          validator.attributes.each do |attr|
+            case validator
+            when ActiveModel::Validations::PresenceValidator
+              builder.set_required(attr.to_s)
+
+            when ActiveModel::Validations::LengthValidator
+              if validator.options[:maximum]
+                builder.set_max_length(attr.to_s, validator.options[:maximum])
+              end
+              if validator.options[:minimum]
+                builder.set_min_length(attr.to_s, validator.options[:minimum])
+              end
+
+            when ActiveModel::Validations::InclusionValidator
+              if validator.options[:in].is_a?(Array)
+                values = validator.options[:in]
+                builder.update_type(attr.to_s, "enum(#{values.join(', ')})")
+              end
+
+            when ActiveModel::Validations::NumericalityValidator
+              opts = validator.options
+              if opts[:greater_than_or_equal_to] && opts[:less_than_or_equal_to]
+                min = opts[:greater_than_or_equal_to]
+                max = opts[:less_than_or_equal_to]
+                builder.update_type(attr.to_s, "number(#{min}..#{max})")
+              end
+            end
+          end
+        end
+      end
+
+      def infer_from_validations(column, model)
+        model.validators_on(column.name).each do |validator|
+          case validator
+          when ActiveModel::Validations::FormatValidator
+            pattern = validator.options[:with]
+            return "email" if pattern.to_s.include?("@")
+            return "url" if pattern.to_s.include?("http")
+
+          when ActiveModel::Validations::InclusionValidator
+            if validator.options[:in].is_a?(Array)
+              values = validator.options[:in]
+              return "enum(#{values.join(', ')})"
+            end
+          end
+        end
+
+        nil
+      end
+
+      def schema_to_dsl(schema)
+        lines = ["#{schema.name}:"]
+
+        schema.fields.each do |field|
+          optional_marker = field.optional? ? "?" : ""
+          lines << "  #{field.name}#{optional_marker}: #{field.type_name}"
+        end
+
+        lines.join("\n")
+      end
+    end
+
+    # Internal schema builder
+    class SchemaBuilder
+      def initialize(name)
+        @name = name
+        @fields = {}
+        @relationships = []
+      end
+
+      def add_field(name, type, **options)
+        @fields[name] = {
+          type: type,
+          options: options
+        }
+      end
+
+      def has_field?(name)
+        @fields.key?(name)
+      end
+
+      def update_type(name, type)
+        @fields[name][:type] = type if @fields[name]
+      end
+
+      def set_required(name)
+        @fields[name][:options][:optional] = false if @fields[name]
+      end
+
+      def set_max_length(name, max)
+        return unless @fields[name]
+
+        current_type = @fields[name][:type]
+        if current_type == "text"
+          @fields[name][:type] = "text(1..#{max})"
+        end
+      end
+
+      def set_min_length(name, min)
+        return unless @fields[name]
+
+        current_type = @fields[name][:type]
+        if current_type.start_with?("text")
+          max = current_type.match(/\.\.(\d+)/)&.[](1) || 255
+          @fields[name][:type] = "text(#{min}..#{max})"
+        end
+      end
+
+      def add_relationship(type, name, target)
+        @relationships << { type: type, name: name, target: target }
+      end
+
+      def build
+        # Create DSL string
+        dsl_lines = ["#{@name}:"]
+
+        @fields.each do |name, config|
+          optional = config[:options][:optional] ? "?" : ""
+          dsl_lines << "  #{name}#{optional}: #{config[:type]}"
+        end
+
+        dsl_string = dsl_lines.join("\n")
+
+        # Parse and return schema
+        Synthra::Parser.parse(dsl_string).first
+      end
+    end
+  end
+end