zodra 0.1.0

data/lib/zodra/type_deriver.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Zodra
+  class TypeDeriver
+    def initialize(source_definition, pick: nil, omit: nil, partial: false)
+      raise ArgumentError, 'Cannot use both :pick and :omit' if pick && omit
+      raise ArgumentError, 'Source must be an object type' unless source_definition.object?
+
+      @source = source_definition
+      @pick = pick&.map(&:to_sym)
+      @omit = omit&.map(&:to_sym)
+      @partial = partial
+    end
+
+    def apply(target_definition)
+      selected_attributes.each do |name, attribute|
+        copy_attribute(target_definition, name, attribute, optional: @partial && !attribute.optional?)
+      end
+    end
+
+    private
+
+    def copy_attribute(target, name, attribute, optional: false)
+      target.add_attribute(name,
+                           type: attribute.type,
+                           optional: optional || attribute.optional?,
+                           nullable: attribute.nullable?,
+                           format: attribute.format,
+                           default: attribute.default,
+                           min: attribute.min,
+                           max: attribute.max,
+                           enum: attribute.enum,
+                           of: attribute.of,
+                           reference_name: attribute.reference_name)
+    end
+
+    def selected_attributes
+      attributes = @source.attributes
+
+      if @pick
+        unknown = @pick - attributes.keys
+        raise ArgumentError, "Unknown attributes #{unknown.inspect} for type :#{@source.name}" if unknown.any?
+
+        attributes.slice(*@pick)
+      elsif @omit
+        unknown = @omit - attributes.keys
+        raise ArgumentError, "Unknown attributes #{unknown.inspect} for type :#{@source.name}" if unknown.any?
+
+        attributes.except(*@omit)
+      else
+        attributes
+      end
+    end
+  end
+end

data/lib/zodra/type_registry.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Zodra
+  class TypeRegistry
+    include Enumerable
+
+    def self.global
+      @global ||= new
+    end
+
+    def initialize
+      @store = {}
+    end
+
+    def register(name, kind:, **)
+      name = name.to_sym
+      raise DuplicateTypeError, "Type :#{name} is already registered" if @store.key?(name)
+
+      @store[name] = Definition.new(name:, kind:, **)
+    end
+
+    def find(name)
+      @store[name.to_sym]
+    end
+
+    def find!(name)
+      @store.fetch(name.to_sym) { raise KeyError, "Type :#{name} is not registered" }
+    end
+
+    def exists?(name)
+      @store.key?(name.to_sym)
+    end
+
+    def each(&)
+      @store.each_value(&)
+    end
+
+    def clear!
+      @store.clear
+    end
+  end
+end

data/lib/zodra/union_builder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Zodra
+  class UnionBuilder
+    def initialize(definition)
+      @definition = definition
+    end
+
+    def variant(tag, &block)
+      variant_builder = VariantBuilder.new
+      variant_builder.instance_eval(&block) if block
+      @definition.add_variant(tag, attributes: variant_builder.attributes)
+    end
+  end
+end

data/lib/zodra/variant.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Zodra
+  class Variant
+    attr_reader :tag, :attributes
+
+    def initialize(tag:, attributes: {})
+      @tag = tag.to_sym
+      @attributes = attributes
+    end
+  end
+end

data/lib/zodra/variant_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Zodra
+  class VariantBuilder
+    attr_reader :attributes
+
+    PRIMITIVES = TypeBuilder::PRIMITIVES
+
+    def initialize
+      @attributes = {}
+    end
+
+    PRIMITIVES.each do |primitive_type|
+      define_method(primitive_type) do |name, **options|
+        @attributes[name.to_sym] = Attribute.new(name:, type: primitive_type, **options)
+      end
+
+      define_method(:"#{primitive_type}?") do |name, **options|
+        @attributes[name.to_sym] = Attribute.new(name:, type: primitive_type, optional: true, **options)
+      end
+    end
+  end
+end

data/lib/zodra/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Zodra
+  VERSION = '0.1.0'
+end

data/lib/zodra.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+require 'active_support/core_ext/string/inflections'
+
+module Zodra
+  class Error < StandardError; end
+  class DuplicateTypeError < Error; end
+  class ConfigurationError < Error; end
+
+  class ParamsError < Error
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+      super('Params validation failed')
+    end
+  end
+
+  class << self
+    def logger
+      @logger || (defined?(Rails) ? Rails.logger : nil)
+    end
+
+    attr_writer :logger
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def type(name, from: nil, pick: nil, omit: nil, partial: false, &block)
+      definition = TypeRegistry.global.register(name, kind: :object)
+
+      if from
+        source = TypeRegistry.global.find!(from)
+        TypeDeriver.new(source, pick:, omit:, partial:).apply(definition)
+      end
+
+      TypeBuilder.new(definition).instance_eval(&block) if block
+      definition
+    end
+
+    def enum(name, values:)
+      TypeRegistry.global.register(name, kind: :enum, values:)
+    end
+
+    def union(name, discriminator:, &block)
+      definition = TypeRegistry.global.register(name, kind: :union, discriminator:)
+      UnionBuilder.new(definition).instance_eval(&block) if block
+      definition
+    end
+
+    def contract(name, &block)
+      contract = ContractRegistry.global.register(name)
+      ContractBuilder.new(contract).instance_eval(&block) if block
+      contract
+    end
+
+    def api(base_path, &block)
+      api_definition = ApiRegistry.global.register(base_path)
+      ApiBuilder.new(api_definition).instance_eval(&block) if block
+      api_definition
+    end
+
+    def scalar(name, base:, &coercer)
+      ScalarRegistry.global.register(name, base:, coercer:)
+    end
+
+    def load_definitions!
+      return unless defined?(Rails)
+
+      ScalarRegistry.global.clear!
+      TypeRegistry.global.clear!
+      ContractRegistry.global.clear!
+      ApiRegistry.global.clear!
+
+      load_definition_dir(Rails.root.join('app/types'))
+      load_definition_dir(Rails.root.join('app/contracts'))
+      load_definition_dir(Rails.root.join('config/apis'))
+
+      resolve_routes!
+    end
+
+    def resolve_routes!
+      ApiRegistry.global.each do |api_definition|
+        api_definition.resources.each do |resource|
+          resolve_resource_routes(resource, api_definition.base_path)
+        end
+      end
+    end
+
+    private
+
+    def load_definition_dir(path)
+      Dir[path.join('**/*.rb')].each { |file| load(file) }
+    end
+
+    def resolve_resource_routes(resource, base_path, parent_param: nil)
+      segment = resource.name.to_s
+      resource_path = parent_param ? "#{base_path}/#{parent_param}/#{segment}" : "#{base_path}/#{segment}"
+
+      contract = ContractRegistry.global.find(resource.contract_name)
+
+      if contract
+        resource.crud_actions.each do |action_name|
+          action = contract.find_action(action_name)
+          next unless action
+
+          crud = Resource::CRUD_ACTIONS[action_name]
+          action.http_method = crud[:http_method]
+          action.path = crud[:member] ? "#{resource_path}/:id" : resource_path
+        end
+
+        resource.custom_actions.each do |custom|
+          action = contract.find_action(custom[:name])
+          next unless action
+
+          action.http_method = custom[:http_method]
+          action.path = custom[:member] ? "#{resource_path}/:id/#{custom[:name]}" : "#{resource_path}/#{custom[:name]}"
+        end
+      end
+
+      resource.children.each do |child|
+        child_parent_param = resource.singular? ? nil : ":#{resource.name.to_s.singularize}_id"
+        resolve_resource_routes(child, resource_path, parent_param: child_parent_param)
+      end
+    end
+
+    def setup_autoload
+      @loader = Zeitwerk::Loader.for_gem.tap do |loader|
+        loader.inflector.inflect('dsl' => 'DSL')
+        loader.ignore("#{__dir__}/generators")
+        loader.ignore("#{__dir__}/zodra/tasks")
+        loader.ignore("#{__dir__}/zodra/railtie.rb")
+        loader.setup
+      end
+    end
+  end
+
+  setup_autoload
+
+  require 'zodra/railtie' if defined?(Rails::Railtie)
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: zodra
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Zodra Contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Define types once in Ruby DSL, generate TypeScript interfaces and Zod
+  schemas for runtime validation on both ends.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- lib/generators/zodra/install_generator.rb
+- lib/generators/zodra/templates/initializer.rb.tt
+- lib/zodra.rb
+- lib/zodra/action.rb
+- lib/zodra/action_builder.rb
+- lib/zodra/api_builder.rb
+- lib/zodra/api_definition.rb
+- lib/zodra/api_registry.rb
+- lib/zodra/attribute.rb
+- lib/zodra/configuration.rb
+- lib/zodra/contract.rb
+- lib/zodra/contract_builder.rb
+- lib/zodra/contract_registry.rb
+- lib/zodra/controller.rb
+- lib/zodra/definition.rb
+- lib/zodra/export.rb
+- lib/zodra/export/contract_mapper.rb
+- lib/zodra/export/surface_resolver.rb
+- lib/zodra/export/type_analysis.rb
+- lib/zodra/export/type_script_mapper.rb
+- lib/zodra/export/writer.rb
+- lib/zodra/export/zod_mapper.rb
+- lib/zodra/params_coercer.rb
+- lib/zodra/params_parser.rb
+- lib/zodra/params_validator.rb
+- lib/zodra/railtie.rb
+- lib/zodra/resource.rb
+- lib/zodra/resource_builder.rb
+- lib/zodra/response_serializer.rb
+- lib/zodra/route_helper.rb
+- lib/zodra/router.rb
+- lib/zodra/scalar_registry.rb
+- lib/zodra/scalar_type.rb
+- lib/zodra/tasks/zodra.rake
+- lib/zodra/type_builder.rb
+- lib/zodra/type_deriver.rb
+- lib/zodra/type_registry.rb
+- lib/zodra/union_builder.rb
+- lib/zodra/variant.rb
+- lib/zodra/variant_builder.rb
+- lib/zodra/version.rb
+homepage: https://github.com/supostat/zodra
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/supostat/zodra
+  source_code_uri: https://github.com/supostat/zodra
+  changelog_uri: https://github.com/supostat/zodra/blob/main/gem/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'End-to-end type system for Rails: DSL → TypeScript + Zod'
+test_files: []