zodra 0.1.0

data/lib/zodra/export/surface_resolver.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Zodra
+  module Export
+    class SurfaceResolver
+      def self.call(definitions, contracts)
+        return definitions if contracts.empty?
+
+        new(definitions, contracts).resolve
+      end
+
+      def initialize(definitions, contracts)
+        @definitions_by_name = definitions.to_h { |d| [d.name, d] }
+        @contracts = contracts
+      end
+
+      def resolve
+        reachable = expand_dependencies(collect_seed_types)
+        @definitions_by_name.values.select { |d| reachable.include?(d.name) }
+      end
+
+      private
+
+      def collect_seed_types
+        names = Set.new
+
+        @contracts.each do |contract|
+          contract.actions.each_value do |action|
+            names << action.response_type if action.response_type
+            collect_attribute_references(action.params, names)
+            collect_attribute_references(action.response_definition, names) unless action.response_type
+          end
+        end
+
+        names
+      end
+
+      def expand_dependencies(seed_names)
+        visited = Set.new
+        queue = seed_names.to_a
+
+        while (name = queue.shift)
+          next if visited.include?(name)
+
+          visited << name
+          definition = @definitions_by_name[name]
+          next unless definition
+
+          collect_definition_dependencies(definition).each do |dep|
+            queue << dep unless visited.include?(dep)
+          end
+        end
+
+        visited
+      end
+
+      def collect_definition_dependencies(definition)
+        deps = Set.new
+        definition.attributes.each_value { |attr| add_dependency(attr, deps) }
+        definition.variants.each do |variant|
+          variant.attributes.each_value { |attr| add_dependency(attr, deps) }
+        end
+        deps
+      end
+
+      def collect_attribute_references(definition, names)
+        definition.attributes.each_value { |attr| add_dependency(attr, names) }
+      end
+
+      def add_dependency(attribute, set)
+        dep = attribute.dependency_name
+        set << dep if dep
+      end
+    end
+  end
+end

data/lib/zodra/export/type_analysis.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Zodra
+  module Export
+    class TypeAnalysis
+      Result = Data.define(:sorted, :cycles)
+
+      def self.call(definitions)
+        new(definitions).analyze
+      end
+
+      def initialize(definitions)
+        @definitions_by_name = definitions.to_h { |d| [d.name, d] }
+        @graph = build_graph
+      end
+
+      def analyze
+        cycles = detect_cycles
+        sorted = topological_sort(cycles)
+        Result.new(sorted:, cycles:)
+      end
+
+      private
+
+      def build_graph
+        @definitions_by_name.each_with_object({}) do |(name, definition), graph|
+          graph[name] = collect_dependencies(definition)
+        end
+      end
+
+      def collect_dependencies(definition)
+        deps = Set.new
+
+        definition.attributes.each_value do |attr|
+          dep = attr.dependency_name
+          deps << dep if dep && @definitions_by_name.key?(dep)
+        end
+
+        definition.variants.each do |variant|
+          variant.attributes.each_value do |attr|
+            dep = attr.dependency_name
+            deps << dep if dep && @definitions_by_name.key?(dep)
+          end
+        end
+
+        deps
+      end
+
+      # Tarjan's SCC algorithm — detects strongly connected components
+      def detect_cycles
+        @index_counter = 0
+        @stack = []
+        @indices = {}
+        @lowlinks = {}
+        @on_stack = Set.new
+        cycles = Set.new
+
+        @graph.each_key do |name|
+          tarjan(name, cycles) unless @indices.key?(name)
+        end
+
+        cycles
+      end
+
+      def tarjan(name, cycles)
+        @indices[name] = @index_counter
+        @lowlinks[name] = @index_counter
+        @index_counter += 1
+        @stack.push(name)
+        @on_stack << name
+
+        @graph[name].each do |dep|
+          if !@indices.key?(dep)
+            tarjan(dep, cycles)
+            @lowlinks[name] = [@lowlinks[name], @lowlinks[dep]].min
+          elsif @on_stack.include?(dep)
+            @lowlinks[name] = [@lowlinks[name], @indices[dep]].min
+          end
+        end
+
+        return unless @lowlinks[name] == @indices[name]
+
+        component = []
+        loop do
+          node = @stack.pop
+          @on_stack.delete(node)
+          component << node
+          break if node == name
+        end
+
+        return unless component.size > 1 || @graph[name].include?(name)
+
+        component.each { |n| cycles << n }
+      end
+
+      # Kahn's algorithm with reversed edges — dependencies come before dependents
+      def topological_sort(cycles)
+        in_degree = Hash.new(0)
+        reverse_adjacency = {}
+
+        @graph.each_key do |name|
+          reverse_adjacency[name] ||= []
+        end
+
+        @graph.each do |name, deps|
+          deps.each do |dep|
+            next if cycles.include?(name) && cycles.include?(dep)
+
+            reverse_adjacency[dep] ||= []
+            reverse_adjacency[dep] << name
+            in_degree[name] += 1
+          end
+        end
+
+        queue = @graph.keys.select { |n| in_degree[n].zero? }
+        sorted = []
+
+        while (name = queue.shift)
+          sorted << name
+          reverse_adjacency[name]&.each do |dependent|
+            in_degree[dependent] -= 1
+            queue << dependent if in_degree[dependent].zero?
+          end
+        end
+
+        remaining = @graph.keys - sorted
+        sorted.concat(remaining)
+
+        sorted.filter_map { |name| @definitions_by_name[name] }
+      end
+    end
+  end
+end

data/lib/zodra/export/type_script_mapper.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Zodra
+  module Export
+    class TypeScriptMapper
+      PRIMITIVE_MAP = {
+        string: 'string',
+        integer: 'number',
+        decimal: 'number',
+        number: 'number',
+        boolean: 'boolean',
+        datetime: 'string',
+        date: 'string',
+        uuid: 'string',
+        binary: 'string'
+      }.freeze
+
+      def initialize(key_format: :keep)
+        @key_format = key_format
+      end
+
+      def map_definition(definition)
+        case definition.kind
+        when :object then map_object(definition)
+        when :enum then map_enum(definition)
+        when :union then map_union(definition)
+        end
+      end
+
+      def map_definitions(definitions, cycles: Set.new)
+        definitions.map { |definition| map_definition(definition) }.join("\n\n")
+      end
+
+      def map_contract(contract)
+        params_output = map_contract_params(contract)
+        descriptor_output = map_contract_descriptor(contract)
+        [params_output, descriptor_output].compact.reject(&:empty?).join("\n\n")
+      end
+
+      def map_contracts(contracts)
+        contracts.map { |contract| map_contract(contract) }.join("\n\n")
+      end
+
+      private
+
+      def map_object(definition)
+        properties = definition.attributes.values.map { |attr| map_property(attr) }
+        "export interface #{pascal_case(definition.name)} {\n#{properties.join("\n")}\n}"
+      end
+
+      def map_enum(definition)
+        values = definition.values.map { |value| "'#{value}'" }.join(' | ')
+        "export type #{pascal_case(definition.name)} = #{values};"
+      end
+
+      def map_union(definition)
+        variants = definition.variants.map { |variant| map_variant(variant, definition.discriminator) }
+        "export type #{pascal_case(definition.name)} =\n#{variants.join("\n")};"
+      end
+
+      def map_variant(variant, discriminator)
+        discriminator_key = transform_key(discriminator)
+        properties = variant.attributes.values.map do |attr|
+          "#{transform_key(attr.name)}: #{map_type(attr)}"
+        end
+        all_properties = ["#{discriminator_key}: '#{variant.tag}'"] + properties
+        "  | { #{all_properties.join('; ')} }"
+      end
+
+      def map_property(attribute)
+        key = transform_key(attribute.name)
+        optional_marker = attribute.optional? ? '?' : ''
+        type_string = map_type(attribute)
+        type_string = [type_string, 'null'].sort.join(' | ') if attribute.nullable?
+        "  #{key}#{optional_marker}: #{type_string};"
+      end
+
+      def map_type(attribute)
+        if attribute.enum
+          attribute.enum.map { |v| "'#{v}'" }.join(' | ')
+        elsif attribute.reference?
+          pascal_case(attribute.reference_name)
+        elsif attribute.array?
+          "#{pascal_case(attribute.of)}[]"
+        else
+          resolve_primitive_type(attribute.type)
+        end
+      end
+
+      def transform_key(key)
+        key_string = key.to_s
+        case @key_format
+        when :camel then camel_case(key_string)
+        when :pascal then pascal_case_string(key_string)
+        else key_string
+        end
+      end
+
+      def map_contract_params(contract)
+        contract.actions.values.map do |action|
+          params_name = :"#{action.name}_#{contract.name}_params"
+          renamed = Definition.new(name: params_name, kind: :object)
+          action.params.attributes.each { |key, attr| renamed.attributes[key] = attr }
+          map_object(renamed)
+        end.join("\n\n")
+      end
+
+      def map_contract_descriptor(contract)
+        name = pascal_case(contract.name)
+        return "export interface #{name}Contract {}" if contract.actions.empty?
+
+        entries = contract.actions.values.map do |action|
+          params_type = "#{pascal_case(action.name)}#{name}Params"
+          parts = ["method: '#{action.http_method.to_s.upcase}'", "path: '#{action.path}'", "params: #{params_type}"]
+          parts << "response: #{pascal_case(action.response_type)}" if action.response_type
+          "  #{action.name}: { #{parts.join('; ')} };"
+        end
+
+        "export interface #{name}Contract {\n#{entries.join("\n")}\n}"
+      end
+
+      def resolve_primitive_type(type)
+        PRIMITIVE_MAP.fetch(type) do
+          scalar = ScalarRegistry.global.find(type)
+          scalar ? PRIMITIVE_MAP.fetch(scalar.base, 'unknown') : 'unknown'
+        end
+      end
+
+      def pascal_case(name)
+        name.to_s.split('_').map(&:capitalize).join
+      end
+
+      def pascal_case_string(string)
+        string.split('_').map(&:capitalize).join
+      end
+
+      def camel_case(string)
+        parts = string.split('_')
+        parts.first + parts[1..].map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/zodra/export/writer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Zodra
+  module Export
+    class Writer
+      HEADER = '// Auto-generated by Zodra — DO NOT EDIT'
+
+      FORMATS = {
+        zod: 'schemas.ts',
+        typescript: 'types.ts'
+      }.freeze
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def write(format)
+        content = Export.generate(format,
+                                  key_format: @configuration.key_format,
+                                  zod_import: @configuration.zod_import)
+
+        write_file(FORMATS.fetch(format), content)
+      end
+
+      def write_contracts
+        content = Export.generate_contracts
+        return if content.empty?
+
+        write_file('contracts.ts', content)
+      end
+
+      def write_all
+        paths = FORMATS.keys.map { |format| write(format) }
+        contracts_path = write_contracts
+        paths << contracts_path if contracts_path
+        paths
+      end
+
+      private
+
+      def write_file(filename, content)
+        FileUtils.mkdir_p(@configuration.output_path)
+        filepath = File.join(@configuration.output_path, filename)
+        File.write(filepath, "#{HEADER}\n#{content}\n")
+        filepath
+      end
+    end
+  end
+end

data/lib/zodra/export/zod_mapper.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Zodra
+  module Export
+    class ZodMapper
+      PRIMITIVE_MAP = {
+        string: 'z.string()',
+        integer: 'z.number().int()',
+        decimal: 'z.number()',
+        number: 'z.number()',
+        boolean: 'z.boolean()',
+        datetime: 'z.iso.datetime()',
+        date: 'z.iso.date()',
+        uuid: 'z.uuid()',
+        binary: 'z.string()'
+      }.freeze
+
+      def initialize(key_format: :keep)
+        @key_format = key_format
+      end
+
+      def map_definition(definition, lazy: false)
+        case definition.kind
+        when :object then map_object(definition, lazy:)
+        when :enum then map_enum(definition)
+        when :union then map_union(definition, lazy:)
+        end
+      end
+
+      def map_definitions(definitions, cycles: Set.new)
+        definitions.map { |definition| map_definition(definition, lazy: cycles.include?(definition.name)) }.join("\n\n")
+      end
+
+      def map_contract(contract)
+        params_output = map_contract_params(contract)
+        error_types_output = map_contract_error_types(contract)
+        descriptor_output = map_contract_descriptor(contract)
+        [params_output, error_types_output, descriptor_output].compact.reject(&:empty?).join("\n\n")
+      end
+
+      def map_contracts(contracts)
+        contracts.map { |contract| map_contract(contract) }.join("\n\n")
+      end
+
+      private
+
+      def map_object(definition, lazy: false)
+        name = pascal_case(definition.name)
+        properties = definition.attributes.values.map { |attr| "  #{map_property(attr)}," }
+        body = "z.object({\n#{properties.join("\n")}\n})"
+
+        if lazy
+          "export const #{name}Schema: z.ZodType<#{name}> = z.lazy(() => #{body});"
+        else
+          "export const #{name}Schema = #{body};"
+        end
+      end
+
+      def map_enum(definition)
+        values = definition.values.map { |value| "'#{value}'" }.join(', ')
+        "export const #{pascal_case(definition.name)}Schema = z.enum([#{values}]);"
+      end
+
+      def map_union(definition, lazy: false)
+        name = pascal_case(definition.name)
+        discriminator_key = transform_key(definition.discriminator)
+        variants = definition.variants.map { |variant| map_variant(variant, discriminator_key) }
+        indent = '  '
+        body = "z.discriminatedUnion('#{discriminator_key}', [\n" \
+               "#{variants.map { |v| "#{indent}#{v}" }.join(",\n")},\n])"
+
+        if lazy
+          "export const #{name}Schema: z.ZodType<#{name}> = z.lazy(() => #{body});"
+        else
+          "export const #{name}Schema = #{body};"
+        end
+      end
+
+      def map_variant(variant, discriminator_key)
+        properties = variant.attributes.values.map { |attr| "#{transform_key(attr.name)}: #{map_zod_type(attr)}" }
+        all_properties = ["#{discriminator_key}: z.literal('#{variant.tag}')"] + properties
+        "z.object({ #{all_properties.join(', ')} })"
+      end
+
+      def map_property(attribute)
+        key = transform_key(attribute.name)
+        "#{key}: #{map_zod_type(attribute)}"
+      end
+
+      def map_zod_type(attribute)
+        base = resolve_base_type(attribute)
+        base = apply_constraints(base, attribute)
+        apply_modifiers(base, attribute)
+      end
+
+      def resolve_base_type(attribute)
+        if attribute.enum
+          values = attribute.enum.map { |v| "'#{v}'" }.join(', ')
+          "z.enum([#{values}])"
+        elsif attribute.reference?
+          "#{pascal_case(attribute.reference_name)}Schema"
+        elsif attribute.array?
+          "z.array(#{pascal_case(attribute.of)}Schema)"
+        else
+          resolve_primitive_type(attribute.type)
+        end
+      end
+
+      def apply_constraints(base, attribute)
+        base = "#{base}.min(#{attribute.min})" if attribute.min
+        base = "#{base}.max(#{attribute.max})" if attribute.max
+        base
+      end
+
+      def apply_modifiers(base, attribute)
+        base = "#{base}.default(#{format_default(attribute.default)})" unless attribute.default.nil?
+        base = "#{base}.nullable()" if attribute.nullable?
+        base = "#{base}.optional()" if attribute.optional?
+        base
+      end
+
+      def format_default(value)
+        case value
+        when String then "'#{value}'"
+        when Symbol then "'#{value}'"
+        else value
+        end
+      end
+
+      def transform_key(key)
+        key_string = key.to_s
+        case @key_format
+        when :camel then camel_case(key_string)
+        when :pascal then pascal_case(key_string)
+        else key_string
+        end
+      end
+
+      def map_contract_params(contract)
+        contract.actions.values.map do |action|
+          params_name = :"#{action.name}_#{contract.name}_params"
+          renamed = Definition.new(name: params_name, kind: :object)
+          action.params.attributes.each { |key, attr| renamed.attributes[key] = attr }
+          map_object(renamed)
+        end.join("\n\n")
+      end
+
+      def map_contract_error_types(contract)
+        parts = contract.actions.values.filter_map do |action|
+          next if action.errors.empty?
+
+          action_name = pascal_case(action.name)
+          contract_name = pascal_case(contract.name)
+
+          codes = action.errors.values.map { |e| "'#{e[:code]}'" }.join(' | ')
+          "export type #{action_name}#{contract_name}BusinessError = { code: #{codes}; message: string };"
+        end
+
+        parts.join("\n\n")
+      end
+
+      def map_contract_descriptor(contract)
+        name = pascal_case(contract.name)
+        return "export const #{name}Contract = {} as const;" if contract.actions.empty?
+
+        entries = contract.actions.values.map do |action|
+          params_schema = "#{pascal_case(action.name)}#{name}ParamsSchema"
+          parts = ["method: '#{action.http_method.to_s.upcase}' as const", "path: '#{action.path}' as const",
+                   "params: #{params_schema}"]
+          parts << "response: #{pascal_case(action.response_type)}Schema" if action.response_type
+          if action.errors.any?
+            error_entries = action.errors.values.map do |e|
+              "{ code: '#{e[:code]}' as const, status: #{e[:status]} as const }"
+            end
+            parts << "errors: [#{error_entries.join(', ')}] as const"
+          end
+          "  #{action.name}: { #{parts.join(', ')} }"
+        end
+
+        "export const #{name}Contract = {\n#{entries.join(",\n")},\n} as const;"
+      end
+
+      def resolve_primitive_type(type)
+        PRIMITIVE_MAP.fetch(type) do
+          scalar = ScalarRegistry.global.find(type)
+          scalar ? PRIMITIVE_MAP.fetch(scalar.base, 'z.unknown()') : 'z.unknown()'
+        end
+      end
+
+      def pascal_case(name)
+        name.to_s.split('_').map(&:capitalize).join
+      end
+
+      def camel_case(string)
+        parts = string.split('_')
+        parts.first + parts[1..].map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/zodra/export.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Zodra
+  module Export
+    MAPPERS = {
+      typescript: TypeScriptMapper,
+      zod: ZodMapper
+    }.freeze
+
+    def self.generate(format, key_format: :camel, zod_import: 'zod')
+      mapper_class = MAPPERS.fetch(format) do
+        raise ConfigurationError, "Unknown export format: #{format}. Available: #{MAPPERS.keys.join(', ')}"
+      end
+
+      mapper = mapper_class.new(key_format:)
+      contracts = ContractRegistry.global.to_a
+
+      definitions = SurfaceResolver.call(TypeRegistry.global.to_a, contracts)
+      analysis = TypeAnalysis.call(definitions)
+
+      parts = []
+      parts << "import { z } from '#{zod_import}';" if format == :zod
+      parts << mapper.map_definitions(analysis.sorted, cycles: analysis.cycles)
+      parts << mapper.map_contracts(contracts) unless contracts.empty?
+      parts.reject(&:empty?).join("\n\n")
+    end
+
+    def self.generate_contracts
+      contracts = ContractRegistry.global.to_a
+      api_definitions = ApiRegistry.global.to_a
+
+      ContractMapper.new(api_definitions, contracts).generate
+    end
+  end
+end