zod_rails 0.1.4

data/lib/tasks/zod_rails.rake

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+namespace :zod_rails do
+  desc "Generate Zod schemas for configured models"
+  task generate: :environment do
+    config = ZodRails.configuration
+    generator = ZodRails::Generator.new(output_dir: config.output_dir)
+
+    models = config.models.map(&:constantize)
+
+    if models.empty?
+      puts "No models configured. Add models to ZodRails.configure { |c| c.models = ['User', 'Article'] }"
+      exit 1
+    end
+
+    generated = generator.generate_all(models)
+    puts "Generated #{generated.size} schema file(s):"
+    generated.each { |f| puts "  - #{f}" }
+  end
+
+  desc "Generate Zod schema for a specific model"
+  task :generate_model, [:model_name] => :environment do |_t, args|
+    model_name = args[:model_name]
+    unless model_name
+      puts "Usage: rails zod_rails:generate_model[ModelName]"
+      exit 1
+    end
+
+    config = ZodRails.configuration
+    generator = ZodRails::Generator.new(output_dir: config.output_dir)
+
+    model_class = model_name.constantize
+    filename = generator.generate(model_class)
+    puts "Generated: #{filename}"
+  end
+end

data/lib/zod_rails/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ZodRails
+  class Configuration
+    attr_accessor :output_dir, :schema_suffix, :input_schema_suffix,
+                  :generate_input_schemas, :excluded_columns, :models
+
+    def initialize
+      @output_dir = "app/javascript/schemas"
+      @schema_suffix = "Schema"
+      @input_schema_suffix = "InputSchema"
+      @generate_input_schemas = true
+      @excluded_columns = %w[id created_at updated_at]
+      @models = []
+    end
+  end
+end

data/lib/zod_rails/generation/file_writer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module ZodRails
+  module Generation
+    class FileWriter
+      attr_reader :output_dir
+
+      def initialize(output_dir:)
+        @output_dir = output_dir
+      end
+
+      def write(filename:, content:)
+        full_path = File.join(output_dir, filename)
+        FileUtils.mkdir_p(File.dirname(full_path))
+        File.write(full_path, content)
+      end
+
+      def output_path_for(model_name)
+        parts = model_name.split("::")
+        filename = underscore(parts.pop)
+        path_parts = parts.map { |p| underscore(p) }
+        path_parts << "#{filename}.ts"
+        path_parts.join("/")
+      end
+
+      private
+
+      def underscore(str)
+        str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+    end
+  end
+end

data/lib/zod_rails/generation/schema_builder.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module Generation
+    class SchemaBuilder
+      attr_reader :inspector, :excluded_columns
+
+      def initialize(inspector, excluded_columns: [])
+        @inspector = inspector
+        @excluded_columns = excluded_columns.map(&:to_s)
+      end
+
+      def build(input_schema: false)
+        columns = input_schema ? filtered_columns : inspector.columns
+        fields = columns.map do |column|
+          field_definition(column, input_schema: input_schema)
+        end
+
+        "z.object({\n  #{fields.join(",\n  ")}\n})"
+      end
+
+      def schema_name(input_schema: false)
+        suffix = input_schema ? "InputSchema" : "Schema"
+        "#{inspector.model_name}#{suffix}"
+      end
+
+      private
+
+      def field_definition(column, input_schema:)
+        type_str = build_type_string(column, input_schema: input_schema)
+        "#{column.name}: #{type_str}"
+      end
+
+      def build_type_string(column, input_schema:)
+        if enum_column?(column.name)
+          build_enum_type(column, input_schema: input_schema)
+        else
+          build_regular_type(column, input_schema: input_schema)
+        end
+      end
+
+      def build_enum_type(column, input_schema:)
+        values = inspector.enums[column.name]
+        Mapping::EnumMapper.call(
+          values,
+          nullable: column.nullable,
+          input_schema: input_schema,
+          has_default: column.has_default
+        )
+      end
+
+      def build_regular_type(column, input_schema:)
+        validations = inspector.validations_for(column.name)
+        base_type = Mapping::TypeMapper.call(
+          column.type,
+          nullable: column.nullable,
+          input_schema: input_schema,
+          has_default: column.has_default
+        )
+
+        validation_chain = Mapping::ValidationMapper.call_all(validations, base_type: column.type)
+        insert_validation_chain(base_type, validation_chain)
+      end
+
+      def insert_validation_chain(base_type, validation_chain)
+        return base_type if validation_chain.empty?
+
+        if base_type.include?(".nullable()") || base_type.include?(".nullish()") || base_type.include?(".optional()")
+          suffix_match = base_type.match(/(\.(nullable|nullish|optional)\(\))$/)
+          if suffix_match
+            base_type.sub(suffix_match[0], "#{validation_chain}#{suffix_match[0]}")
+          else
+            "#{base_type}#{validation_chain}"
+          end
+        else
+          "#{base_type}#{validation_chain}"
+        end
+      end
+
+      def enum_column?(column_name)
+        inspector.enums.key?(column_name)
+      end
+
+      def filtered_columns
+        inspector.columns.reject { |col| excluded_columns.include?(col.name) }
+      end
+    end
+  end
+end

data/lib/zod_rails/generation/typescript_emitter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module Generation
+    class TypescriptEmitter
+      def emit(schema_name:, schema_body:)
+        type_name = derive_type_name(schema_name)
+
+        <<~TYPESCRIPT
+          import { z } from "zod";
+
+          export const #{schema_name} = #{schema_body};
+
+          export type #{type_name} = z.infer<typeof #{schema_name}>;
+        TYPESCRIPT
+      end
+
+      def emit_combined(response:, input:)
+        response_type = derive_type_name(response[:name])
+        input_type = derive_type_name(input[:name])
+
+        <<~TYPESCRIPT
+          import { z } from "zod";
+
+          export const #{response[:name]} = #{response[:body]};
+
+          export type #{response_type} = z.infer<typeof #{response[:name]}>;
+
+          export const #{input[:name]} = #{input[:body]};
+
+          export type #{input_type} = z.infer<typeof #{input[:name]}>;
+        TYPESCRIPT
+      end
+
+      private
+
+      def derive_type_name(schema_name)
+        schema_name.sub(/Schema$/, "").sub(/InputSchema$/, "Input")
+      end
+    end
+  end
+end

data/lib/zod_rails/generator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ZodRails
+  class Generator
+    attr_reader :output_dir, :file_writer, :emitter
+
+    def initialize(output_dir:)
+      @output_dir = output_dir
+      @file_writer = Generation::FileWriter.new(output_dir: output_dir)
+      @emitter = Generation::TypescriptEmitter.new
+    end
+
+    def generate(model_class)
+      inspector = Introspection::ModelInspector.new(model_class)
+      excluded = ZodRails.configuration.excluded_columns
+      builder = Generation::SchemaBuilder.new(inspector, excluded_columns: excluded)
+
+      response_schema = {
+        name: builder.schema_name,
+        body: builder.build
+      }
+
+      input_schema = {
+        name: builder.schema_name(input_schema: true),
+        body: builder.build(input_schema: true)
+      }
+
+      content = emitter.emit_combined(response: response_schema, input: input_schema)
+      filename = file_writer.output_path_for(inspector.model_name)
+
+      file_writer.write(filename: filename, content: content)
+      filename
+    end
+
+    def generate_all(model_classes)
+      model_classes.map { |klass| generate(klass) }
+    end
+  end
+end

data/lib/zod_rails/introspection/column_info.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module Introspection
+    class ColumnInfo
+      attr_reader :name, :type, :nullable, :has_default
+
+      def initialize(name:, type:, nullable:, has_default:)
+        @name = name
+        @type = type
+        @nullable = nullable
+        @has_default = has_default
+        freeze
+      end
+
+      def self.from_column(column)
+        new(
+          name: column.name,
+          type: column.type,
+          nullable: column.null,
+          has_default: !column.default.nil?
+        )
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          name == other.name &&
+          type == other.type &&
+          nullable == other.nullable &&
+          has_default == other.has_default
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, name, type, nullable, has_default].hash
+      end
+    end
+  end
+end

data/lib/zod_rails/introspection/model_inspector.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module Introspection
+    class ModelInspector
+      attr_reader :model_class
+
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      def columns
+        @columns ||= model_class.columns.map { |col| ColumnInfo.from_column(col) }
+      end
+
+      def validations_for(attribute)
+        attr_sym = attribute.to_sym
+        model_class.validators.each_with_object([]) do |validator, result|
+          next unless validator.attributes.include?(attr_sym)
+
+          result << ValidationInfo.from_validator(validator, attribute)
+        end
+      end
+
+      def enums
+        @enums ||= model_class.defined_enums
+      end
+
+      def model_name
+        model_class.name
+      end
+    end
+  end
+end

data/lib/zod_rails/introspection/validation_info.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module Introspection
+    class ValidationInfo
+      CONDITIONAL_KEYS = %i[if unless on].freeze
+
+      attr_reader :kind, :attribute, :options
+
+      def initialize(kind:, attribute:, options:, conditional:)
+        @kind = kind
+        @attribute = attribute
+        @options = options
+        @conditional = conditional
+        freeze
+      end
+
+      def self.from_validator(validator, attribute)
+        opts = validator.options.dup
+        conditional = CONDITIONAL_KEYS.any? { |key| opts.key?(key) }
+
+        new(
+          kind: validator.kind,
+          attribute: attribute,
+          options: opts.except(*CONDITIONAL_KEYS),
+          conditional: conditional
+        )
+      end
+
+      def conditional?
+        @conditional
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          kind == other.kind &&
+          attribute == other.attribute &&
+          options == other.options &&
+          conditional? == other.conditional?
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, kind, attribute, options, @conditional].hash
+      end
+    end
+  end
+end

data/lib/zod_rails/mapping/enum_mapper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module Mapping
+    class EnumMapper
+      def self.call(values, nullable: false, input_schema: false, has_default: false)
+        keys = values.keys.map { |k| "\"#{escape_quotes(k)}\"" }
+        base = "z.enum([#{keys.join(", ")}])"
+
+        suffix = determine_suffix(nullable: nullable, input_schema: input_schema, has_default: has_default)
+        "#{base}#{suffix}"
+      end
+
+      def self.escape_quotes(str)
+        str.to_s.gsub('"', '\\"')
+      end
+
+      def self.determine_suffix(nullable:, input_schema:, has_default:)
+        return "" unless nullable || has_default
+
+        if input_schema
+          nullable ? ".nullish()" : ".optional()"
+        else
+          nullable ? ".nullable()" : ""
+        end
+      end
+
+      private_class_method :escape_quotes, :determine_suffix
+    end
+  end
+end

data/lib/zod_rails/mapping/type_mapper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module Mapping
+    class TypeMapper
+      TYPE_MAP = {
+        string: "z.string()",
+        text: "z.string()",
+        integer: "z.int()",
+        bigint: "z.string()",
+        float: "z.number()",
+        decimal: "z.string()",
+        boolean: "z.boolean()",
+        date: "z.iso.date()",
+        datetime: "z.iso.datetime()",
+        time: "z.string()",
+        json: "z.json()",
+        jsonb: "z.json()",
+        uuid: "z.uuid()",
+        binary: "z.string()"
+      }.freeze
+
+      def self.call(type, nullable: false, input_schema: false, has_default: false)
+        base = TYPE_MAP.fetch(type.to_sym) do
+          ZodRails.logger.warn("ZodRails: Unknown type '#{type}', falling back to z.unknown()")
+          "z.unknown()"
+        end
+
+        suffix = determine_suffix(nullable: nullable, input_schema: input_schema, has_default: has_default)
+        "#{base}#{suffix}"
+      end
+
+      def self.determine_suffix(nullable:, input_schema:, has_default:)
+        return "" unless nullable || has_default
+
+        if input_schema
+          nullable ? ".nullish()" : ".optional()"
+        else
+          nullable ? ".nullable()" : ""
+        end
+      end
+
+      private_class_method :determine_suffix
+    end
+  end
+end

data/lib/zod_rails/mapping/validation_mapper.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module Mapping
+    class ValidationMapper
+      NUMERICALITY_MAP = {
+        greater_than: "gt",
+        greater_than_or_equal_to: "gte",
+        less_than: "lt",
+        less_than_or_equal_to: "lte"
+      }.freeze
+
+      def self.call(validation, base_type:)
+        return "" if validation.conditional?
+
+        case validation.kind
+        when :presence then map_presence(validation, base_type)
+        when :length then map_length(validation)
+        when :numericality then map_numericality(validation)
+        when :format then map_format(validation)
+        when :inclusion then map_inclusion(validation)
+        else ""
+        end
+      end
+
+      def self.call_all(validations, base_type:)
+        constraints = { min: nil, max: nil, length: nil, others: [] }
+
+        validations.each do |v|
+          collect_constraints(v, base_type, constraints)
+        end
+
+        build_chain(constraints)
+      end
+
+      def self.map_presence(_validation, base_type)
+        base_type == :string ? ".min(1)" : ""
+      end
+
+      def self.map_length(validation)
+        parts = []
+        opts = validation.options
+
+        if opts[:is]
+          parts << ".length(#{opts[:is]})"
+        else
+          parts << ".min(#{opts[:minimum]})" if opts[:minimum]
+          parts << ".max(#{opts[:maximum]})" if opts[:maximum]
+        end
+
+        parts.join
+      end
+
+      def self.map_numericality(validation)
+        validation.options.filter_map do |key, value|
+          method = NUMERICALITY_MAP[key]
+          ".#{method}(#{value})" if method
+        end.join
+      end
+
+      def self.map_format(validation)
+        regex = validation.options[:with]
+        return "" unless regex
+
+        js_pattern = convert_ruby_regex_to_js(regex)
+        ".regex(/#{js_pattern}/)"
+      end
+
+      def self.map_inclusion(validation)
+        values = validation.options[:in] || validation.options[:within]
+        return "" unless values.is_a?(Array)
+
+        ""
+      end
+
+      def self.convert_ruby_regex_to_js(regex)
+        pattern = regex.source
+        pattern = pattern.gsub("\\A", "^")
+        pattern.gsub(/\\z/i, "$")
+      end
+
+      def self.collect_constraints(validation, base_type, constraints)
+        return if validation.conditional?
+
+        case validation.kind
+        when :presence then handle_presence_constraint(base_type, constraints)
+        when :length then handle_length_constraint(validation, constraints)
+        when :numericality then handle_numericality_constraint(validation, constraints)
+        when :format then handle_format_constraint(validation, constraints)
+        when :inclusion then handle_inclusion_constraint(validation, constraints)
+        end
+      end
+
+      def self.handle_presence_constraint(base_type, constraints)
+        constraints[:min] = [constraints[:min] || 0, 1].max if base_type == :string
+      end
+
+      def self.handle_length_constraint(validation, constraints)
+        opts = validation.options
+        constraints[:length] = opts[:is] if opts[:is]
+        constraints[:min] = [constraints[:min] || 0, opts[:minimum]].max if opts[:minimum]
+        constraints[:max] = [constraints[:max] || Float::INFINITY, opts[:maximum]].min if opts[:maximum]
+      end
+
+      def self.handle_format_constraint(validation, constraints)
+        regex = validation.options[:with]
+        return unless regex
+
+        js_pattern = convert_ruby_regex_to_js(regex)
+        constraints[:others] << ".regex(/#{js_pattern}/)"
+      end
+
+      def self.build_chain(constraints)
+        parts = []
+
+        if constraints[:length]
+          parts << ".length(#{constraints[:length]})"
+        else
+          parts << ".min(#{constraints[:min]})" if constraints[:min]&.positive?
+          parts << ".max(#{constraints[:max].to_i})" if constraints[:max] && constraints[:max] != Float::INFINITY
+        end
+
+        parts.concat(constraints[:others])
+        parts.join
+      end
+
+      def self.handle_inclusion_constraint(validation, constraints)
+        values = validation.options[:in] || validation.options[:within]
+        return unless values
+
+        case values
+        when Range
+          if values.begin.is_a?(Numeric) && values.end.is_a?(Numeric)
+            constraints[:min] = [constraints[:min] || 0, values.begin].max
+            constraints[:max] = [constraints[:max] || Float::INFINITY, values.end].min
+          end
+        end
+      end
+
+      def self.handle_numericality_constraint(validation, constraints)
+        validation.options.each do |key, value|
+          if key == :in
+            apply_numeric_range(value, constraints)
+          elsif (method = NUMERICALITY_MAP[key])
+            constraints[:others] << ".#{method}(#{value})"
+          end
+        end
+      end
+
+      def self.apply_numeric_range(range, constraints)
+        return unless range.is_a?(Range) && range.begin.is_a?(Numeric) && range.end.is_a?(Numeric)
+
+        constraints[:min] = [constraints[:min] || 0, range.begin].max
+        constraints[:max] = [constraints[:max] || Float::INFINITY, range.end].min
+      end
+
+      private_class_method :map_presence, :map_length, :map_numericality, :map_format, :map_inclusion,
+                           :convert_ruby_regex_to_js, :collect_constraints, :build_chain,
+                           :handle_presence_constraint, :handle_length_constraint, :handle_format_constraint,
+                           :handle_inclusion_constraint, :handle_numericality_constraint, :apply_numeric_range
+    end
+  end
+end

data/lib/zod_rails/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module ZodRails
+  class Railtie < Rails::Railtie
+    railtie_name :zod_rails
+
+    rake_tasks do
+      load "tasks/zod_rails.rake"
+    end
+
+    initializer "zod_rails.configure" do
+      ZodRails.configure do |config|
+        config.output_dir ||= Rails.root.join("app/javascript/schemas").to_s
+      end
+    end
+  end
+end

data/lib/zod_rails/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ZodRails
+  VERSION = "0.1.4"
+end

data/lib/zod_rails.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "logger"
+require_relative "zod_rails/version"
+require_relative "zod_rails/configuration"
+require_relative "zod_rails/mapping/type_mapper"
+require_relative "zod_rails/mapping/validation_mapper"
+require_relative "zod_rails/mapping/enum_mapper"
+require_relative "zod_rails/introspection/column_info"
+require_relative "zod_rails/introspection/validation_info"
+require_relative "zod_rails/introspection/model_inspector"
+require_relative "zod_rails/generation/schema_builder"
+require_relative "zod_rails/generation/typescript_emitter"
+require_relative "zod_rails/generation/file_writer"
+require_relative "zod_rails/generator"
+require_relative "zod_rails/railtie" if defined?(Rails::Railtie)
+
+module ZodRails
+  class Error < StandardError; end
+
+  class << self
+    def logger
+      @logger ||= Logger.new($stdout, level: Logger::WARN)
+    end
+
+    attr_writer :logger
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end