mochitype 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7832035805b331f4ce0e845f3104c4f0356f24489c9c649374778fc6196f3618
+  data.tar.gz: 4664df36000c2773999da7eec7b11889ab5e03eeed8836d92ee27494ee104672
+SHA512:
+  metadata.gz: dcc0c4a00a8eb1f7c239d00e39dd839e664fda815ead297c13a444cda25b0ea2c8c6ef8181f3bf4ebc6eaa150555aa5a9ef290511db89717a30da9e587596092
+  data.tar.gz: 118f4b24547826d9bfec06a0e49da2e7c9012c3495b70919ffda5fc867683565b69221d47b23cd3845bcfece8a3c8514ed4ed7666fdfec5bf2f97877e41d29e0

data/README.md

@@ -0,0 +1,215 @@
+# Mochitype
+
+For Ruby on Rails apps that have a Typescript frontend, your left with few options to ensure your Typescript types are correct.
+
+You either manually create Typescript interfaces or manually write Zod for runtime checks.
+
+Mochitype turns your `T::Struct` classes into Zod types, allowing your frontend and backend to share a common type definition. This gives you:
+
+- Typescript interfaces in sync with the backend with Zod infer.
+- Runtime type checking with Zod.
+- A typed interface using Sorbet for building your JSON payload.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mochitype'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install mochitype
+
+## Usage
+
+1. Configure the
+
+```
+Mochitype.configure do |config|
+  config.watch_path = "app/mochitypes"
+  config.output_path = "app/javascript/__generated__/mochitypes"
+end
+Mochitype.start_watcher!
+```
+
+2. When your Rails app starts in development, it'll watch all files in `watch_path` - each time a file is added, modified, or deleted, it'll update the corresponding TypeScript file in `output_path`.
+
+3. Since your Ruby classes are T::Structs, you can also DRY up your rendering logic.
+
+```ruby
+# before
+class UsersController < ApplicationController
+  def index
+    @users = User.all
+    render json: @users
+  end
+end
+
+# after
+class UsersController < ApplicationController
+  def index
+    # has access to helpers
+    render Mochiviews::Users::Index.render(
+      users: User.all,
+    )
+  end
+end
+
+class Mochiviews::Users::Index < T::Struct
+  class User < T::Struct
+    const :id, Integer
+    const :name, String
+  end
+
+  const :users, T::Array[Mochiviews::Users::Index::User]
+
+  sig { params(users: T::Array[User]).returns(Mochiviews::Users::Index) }
+  def self.render(users:)
+    Mochiviews::Users::Index.new(
+        users: users.map do |user|
+          User.new(
+            id: user.id,
+            name: user.name,
+          )
+        end
+    )
+  end
+end
+
+# Mochiviews::Users::Index is automatically converted to Zod
+# app/javascript/__generated__/mochitypes/users/index.ts
+export const UsersIndexSchema = z.object({
+  users: z.array(z.object({
+    id: z.number(),
+    name: z.string(),
+  })),
+});
+
+export type UsersIndex = z.infer<typeof UsersIndexSchema>;
+```
+
+Now if you change UsersController#index to return something different, it'll update the corresponding TypeScript file. Your backend and frontend are always in sync!
+
+## Using Mochitype::View for Rendering
+
+The `Mochitype::View` module provides a simple way to make your `T::Struct` classes renderable in Rails controllers. When you include this module, your struct gains two methods:
+
+- `render_in(view_context)` - Serializes the struct to JSON
+- `format` - Returns `:json` to indicate the response format
+
+### Basic Usage
+
+Include `Mochitype::View` in any `T::Struct` class:
+
+```ruby
+class UserResponse < T::Struct
+  include Mochitype::View
+
+  const :id, Integer
+  const :name, String
+  const :email, String
+end
+```
+
+Then use it directly in your controllers:
+
+```ruby
+class UsersController < ApplicationController
+  def show
+    user = User.find(params[:id])
+    response = UserResponse.new(id: user.id, name: user.name, email: user.email)
+
+    render response
+  end
+end
+```
+
+### Advanced Example with Nested Structs
+
+```ruby
+module API
+  module Users
+    class IndexResponse < T::Struct
+      include Mochitype::View
+
+      class UserSummary < T::Struct
+        const :id, Integer
+        const :name, String
+        const :avatar_url, T.nilable(String)
+      end
+
+      const :users, T::Array[UserSummary]
+      const :total_count, Integer
+      const :page, Integer
+
+      sig { params(users: T::Array[User], page: Integer).returns(IndexResponse) }
+      def self.from_users(users:, page:)
+        new(
+          users:
+            users.map do |user|
+              UserSummary.new(id: user.id, name: user.name, avatar_url: user.avatar_url)
+            end,
+          total_count: users.size,
+          page: page,
+        )
+      end
+    end
+  end
+end
+
+# In your controller:
+class API::UsersController < ApplicationController
+  def index
+    users = User.page(params[:page])
+    render API::Users::IndexResponse.from_users(users: users, page: params[:page].to_i)
+  end
+end
+```
+
+### Benefits
+
+1. **Type Safety**: Your responses are type-checked by Sorbet at the Ruby level
+2. **Automatic TS Generation**: The corresponding TypeScript types are automatically generated
+3. **Clean Controllers**: Separates response structure from controller logic
+4. **Reusable**: Response classes can be shared across multiple endpoints
+
+### What Gets Generated
+
+For the examples above, Mochitype will automatically generate TypeScript types like:
+
+```typescript
+// __generated__/mochitypes/user_response.ts
+export const UserResponse = z.object({
+  id: z.number(),
+  name: z.string(),
+  email: z.string(),
+});
+
+export type TUserResponse = z.infer<typeof UserResponse>;
+```
+
+This keeps your frontend types perfectly in sync with your backend responses!
+
+## Limitations
+
+- Currently only works with T::Structs, T::Enum, and standard Ruby types like String, Integer, etc. If your struct has a field that's a custom class, it will be marked as `unknown`
+- Since we're using the Prism parser, it requires Ruby 3.3.5+
+- It does not de-dupe types across files. For example, if you have MyStruct and reference MyOtherStruct, both of those Typescript files will contain TS on MyOtherStruct.
+
+## Development
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/mochitype.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/mochitype/configuration.rb

@@ -0,0 +1,39 @@
+# typed: true
+require 'sorbet-runtime'
+
+module Mochitype
+  class Configuration
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_accessor :watch_path
+
+    sig { returns(String) }
+    attr_accessor :output_path
+
+    sig { void }
+    def initialize
+      @watch_path = T.let('app/mochitypes/', String) # default path for Sorbet files
+      @output_path = T.let('app/javascript/__generated__/mochitypes', String) # default path for TypeScript output
+    end
+  end
+
+  class << self
+    extend T::Sig
+
+    sig { returns(Configuration) }
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    sig { params(blk: T.proc.params(config: Configuration).void).void }
+    def configure(&blk)
+      yield(configuration)
+    end
+
+    sig { void }
+    def start_watcher!
+      Mochitype::FileWatcher.start
+    end
+  end
+end

data/lib/mochitype/convertible_class.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+# Data container that contains all the properties that can be turned into a TypeScript file for a class.
+# The class must either be a T::Enum or T::Struct
+class ConvertibleClass < T::Struct
+  extend T::Sig
+
+  const :klass, Class
+  prop :props, T::Hash[String, String], default: {}
+  prop :inner_classes, T::Array[ConvertibleClass], default: []
+
+  # Currently not used.
+  TS_TYPE_SUFFIX = ''
+  TS_ENUM_SUFFIX = ''
+
+  # The name of the type in the generated Typescript file.
+  # This is the name of the Zod definition.
+  sig { returns(String) }
+  def typescript_name
+    js_name = klass.name.demodulize
+    klass < T::Enum ? "#{js_name}#{TS_ENUM_SUFFIX}" : "#{js_name}#{TS_TYPE_SUFFIX}"
+  end
+
+  # The name of the TypeScript type alias
+  sig { returns(String) }
+  def typescript_type_name
+    js_name = klass.to_s.gsub('::', '')
+    # For very short class names (3 chars or less), use just the class name
+    # Otherwise, use T prefix + the typescript_name
+    if js_name.length <= 3
+      js_name
+    else
+      "T#{typescript_name}"
+    end
+  end
+end

data/lib/mochitype/convertible_property.rb

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mochitype
+  class ConvertibleProperty < T::Struct
+    const :zod_definition, String
+    const :discovered_classes, T::Array[Class], default: []
+  end
+end

data/lib/mochitype/file_watcher.rb

@@ -0,0 +1,144 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mochitype
+  class FileWatcher
+    class << self
+      extend T::Sig
+
+      attr_reader :listener, :mutex
+
+      # Logger that works with or without Rails
+      sig { returns(T.untyped) }
+      def logger
+        defined?(Rails) && Rails.logger ? Rails.logger : Logger.new($stdout)
+      end
+
+      # Performs a full sweep of the watched Ruby type directory and the generated TypeScript output directory.
+      #
+      # - For every Ruby file under the configured `watch_path`, determines the expected TypeScript output path.
+      # - Deletes any orphaned TypeScript files in the output directory that do not have a corresponding Ruby source file.
+      # - Generates TypeScript files for any Ruby files that are missing outputs.
+      #
+      # This method is typically called on Rails boot in development to ensure the generated TypeScript
+      # is in sync with the Ruby source files, and to clean up any stale outputs.
+      #
+      # Logs actions and errors using Rails.logger (or stdout in headless mode).
+      sig { void }
+      def sweep
+        begin
+          ts_base = Mochitype.configuration.output_path
+
+          # Build expected TS paths from all Ruby files.
+          ruby_files = Dir.glob("#{Mochitype.configuration.watch_path}/**/*.rb")
+          expected_ts = {}
+          ruby_files.each do |rb_file|
+            ts_path = TypeConverter.determine_output_path(rb_file)
+            expected_ts[ts_path] = rb_file
+          end
+
+          # Delete orphan TS files (those without a corresponding Ruby file).
+          Dir
+            .glob("#{ts_base}/**/*.ts")
+            .each do |ts_file|
+              begin
+                next if expected_ts.key?(ts_file)
+                File.delete(ts_file)
+                logger.info "Mochitype: Removed orphan TypeScript file #{ts_file}"
+              rescue => e
+                logger.error "Mochitype: Error removing orphan TypeScript file #{ts_file}: #{e.message}"
+              end
+            end
+
+          # Generate missing TS files for Ruby files without outputs.
+          ruby_files.each do |rb_file|
+            begin
+              ts_path = TypeConverter.determine_output_path(rb_file)
+              next if File.exist?(ts_path)
+              TypeConverter.convert_file(rb_file)
+              logger.info "Mochitype: Generated missing TypeScript for #{rb_file}"
+            rescue => e
+              logger.error "Mochitype: Error generating TypeScript for #{rb_file}: #{e.message}"
+            end
+          end
+        rescue => e
+          logger.error "Mochitype: Initial sweep failed: #{e.message}"
+        end
+      end
+
+      sig { void }
+      def start
+        return unless Rails.env.development?
+        return if @listener # Already started
+
+        @mutex = Mutex.new
+
+        path =
+          (
+            if Rails.root
+              Rails.root.join(Mochitype.configuration.watch_path)
+            else
+              Mochitype.configuration.watch_path
+            end
+          )
+        FileUtils.mkdir_p(path) unless File.directory?(path)
+
+        # Initial conversion of all existing files
+        @mutex.synchronize do
+          Dir
+            .glob("#{path}/**/*.rb")
+            .each do |file|
+              begin
+                TypeConverter.convert_file(file)
+                logger.info "Mochitype: Successfully converted #{file} to TypeScript"
+              rescue StandardError => e
+                logger.error "Mochitype: Error converting #{file}"
+                logger.error "  #{e.class}: #{e.message}"
+                logger.error "  #{e.backtrace.first(3).join("\n  ")}" if e.backtrace
+              end
+            end
+        end
+
+        @listener =
+          Listen.to(path, only: /\.rb$/) do |modified, added, removed|
+            @mutex.synchronize do
+              handle_file_changes(modified, added, removed)
+            end
+          end
+
+        @listener.start
+        Kernel.puts "Mochitype starting: Watching for Sorbet struct changes in #{path}"
+        Kernel.puts "* #{Dir.glob("#{path}/**/*.rb").count} file(s) in #{path}"
+        Kernel.puts "* #{Dir.glob("#{Mochitype.configuration.output_path}/**/*.ts").count} generated TS file(s) in #{Mochitype.configuration.output_path}"
+
+        # Run sweep synchronously after initial conversion
+        @mutex.synchronize { sweep }
+      end
+
+      sig { params(modified: T::Array[String], added: T::Array[String], removed: T::Array[String]).void }
+      def handle_file_changes(modified, added, removed)
+        (modified + added).each do |file|
+          begin
+            TypeConverter.convert_file(file)
+            logger.info "Mochitype: Successfully converted #{file} to TypeScript"
+          rescue StandardError => e
+            logger.error "Mochitype: Error converting #{file}"
+            logger.error "  #{e.class}: #{e.message}"
+            logger.error "  #{e.backtrace.first(3).join("\n  ")}" if e.backtrace
+          end
+        end
+
+        removed.each do |file|
+          begin
+            ts_file = TypeConverter.determine_output_path(file)
+            File.delete(ts_file) if File.exist?(ts_file)
+            logger.info "Mochitype: Removed TypeScript file for #{file}"
+          rescue StandardError => e
+            logger.error "Mochitype: Error removing TypeScript file for #{file}"
+            logger.error "  #{e.class}: #{e.message}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mochitype/railtie.rb

@@ -0,0 +1,25 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mochitype
+  class Railtie < Rails::Railtie
+    extend T::Sig
+
+    # NOTE: (overload119) Temporarily removed so that the developer can choose to invoke the thread.
+    # This gives more flexibility during adoption.
+    #
+    # Start the file watcher after all initializers have run
+    # This ensures the user's configuration in config/initializers/mochitype.rb has been loaded
+    initializer 'mochitype.start_watcher', after: :load_config_initializers do
+      if Rails.env.development?
+        Rails.application.config.after_initialize do
+          # Mochitype.start_watcher!
+        end
+      end
+    end
+
+    rake_tasks do
+      load 'tasks/mochitype.rake'
+    end
+  end
+end

data/lib/mochitype/reflection_type_converter.rb

@@ -0,0 +1,310 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mochitype
+  class ReflectionTypeConverter
+    extend T::Sig
+
+    SORBET_TYPESCRIPT_MAPPING = {
+      String => 'z.string()',
+      Integer => 'z.number()',
+      Float => 'z.number()',
+      Numeric => 'z.number()',
+    }
+
+    sig { params(file_path: String).void }
+    def initialize(file_path)
+      @file_path = file_path
+    end
+
+    # Entrypoint to generate the Typescript file content from the main struct that's being converted.
+    sig { returns(String) }
+    def build_typescript_file
+      buffer = String.new("/**\n")
+      buffer << "/* This file is generated by Mochitype. Do not edit it by hand.\n"
+      buffer << "/**/\n\n"
+      buffer << "import { z } from 'zod';\n\n"
+
+      # Track classes that have already been written to avoid duplicates
+      @written_classes = T.let(Set.new, T::Set[Class])
+      buffer << convertible_class_to_typescript(root_convertible_class)
+      buffer.strip!
+      buffer << "\n"
+    end
+
+    sig { params(convertible_class: ConvertibleClass).returns(String) }
+    def convertible_class_to_typescript(convertible_class)
+      buffer = String.new
+
+      # Skip if this class has already been written
+      @written_classes ||= Set.new
+      return buffer if @written_classes.include?(convertible_class.klass)
+
+      # Mark this class as being written
+      @written_classes.add(convertible_class.klass)
+
+      if convertible_class.klass < T::Enum
+        values = T.unsafe(convertible_class.klass).values.map(&:serialize).map { "'#{_1}'" }
+        buffer << "export const #{convertible_class.typescript_name} = z.enum([#{values.join(', ')}]);\n\n"
+      elsif convertible_class.klass < T::Struct
+        # Populate the properties.
+        properties = {}
+        inner_classes = T.let([], T::Array[ConvertibleClass])
+        T
+          .cast(convertible_class.klass, T.class_of(T::Struct))
+          .props
+          .each do |property_name, data|
+            convertible_property = write_prop(data)
+            properties[property_name.to_s] = convertible_property.zod_definition
+            inner_classes +=
+              convertible_property.discovered_classes.map do |klass|
+                ConvertibleClass.new(klass: klass)
+              end
+          end
+
+        convertible_class.props = properties
+        convertible_class.inner_classes = inner_classes
+
+        # Before adding this convertible class into the TypeScript file, we have to make sure all of
+        # its dependencies are added first.
+        convertible_class.inner_classes.each do |inner_class|
+          buffer << convertible_class_to_typescript(inner_class)
+        end
+
+        buffer << "export const #{convertible_class.typescript_name} = z.object({\n"
+        buffer << convertible_class.props.map { |name, type| "  #{name}: #{type}" }.join(",\n")
+        buffer << "\n});\n\n"
+      else
+        raise NotImplementedError, "Unknown type: #{convertible_class.klass}"
+      end
+
+      buffer << "export type #{convertible_class.typescript_type_name} = z.infer<typeof #{convertible_class.typescript_name}>;\n\n"
+      buffer
+    end
+
+    sig { returns(ConvertibleClass) }
+    def root_convertible_class
+      klass_name = extract_main_klass
+      klass = klass_name.constantize
+
+      # Accept both T::Struct and T::Enum
+      unless (klass.is_a?(Class) && (klass < T::Struct || klass < T::Enum))
+        raise TypeError, "Expected T::Struct or T::Enum, got #{klass}"
+      end
+
+      ConvertibleClass.new(klass: klass)
+    end
+
+    # Computes the Typescript-property of a T::Struct.
+    # @param data A `const` or `prop` property definition from a T::Struct.
+    sig { params(data: T::Hash[Symbol, T.untyped]).returns(ConvertibleProperty) }
+    def write_prop(data)
+      is_nilable = data[:_tnilable]
+
+      result =
+        case data[:type].class.to_s
+        # Handle special Sorbet types that should map to z.unknown()
+        when 'T::Types::Untyped'
+          ConvertibleProperty.new(zod_definition: 'z.unknown()', discovered_classes: [])
+        when 'T::Types::Intersection'
+          # T.all - intersection types are not representable in Zod
+          ConvertibleProperty.new(zod_definition: 'z.unknown()', discovered_classes: [])
+        when 'T::Types::ClassOf'
+          # T.class_of - represents a class itself, not an instance
+          ConvertibleProperty.new(zod_definition: 'z.unknown()', discovered_classes: [])
+        when 'T::Types::AttachedClass'
+          # T.attached_class - used in module mixins
+          ConvertibleProperty.new(zod_definition: 'z.unknown()', discovered_classes: [])
+        when 'T::Types::NoReturn'
+          # T.noreturn - function never returns
+          ConvertibleProperty.new(zod_definition: 'z.unknown()', discovered_classes: [])
+        when 'T::Types::TypedArray', 'T::Types::TypedArray::Untyped'
+          inner_type = data[:type].type
+          inner_type_convertible_property = instance_of_class_to_convertible_property(inner_type)
+
+          ConvertibleProperty.new(
+            zod_definition: "z.array(#{inner_type_convertible_property.zod_definition})",
+            discovered_classes: inner_type_convertible_property.discovered_classes,
+          )
+        when 'T::Private::Types::SimplePairUnion'
+          first_value = data[:type].types[0].raw_type
+          second_value = data[:type].types[1].raw_type
+          if [first_value, second_value].to_set == [TrueClass, FalseClass].to_set
+            ConvertibleProperty.new(zod_definition: 'z.boolean()', discovered_classes: [])
+          else
+            fv = simple_class_to_typescript(first_value)
+            sv = simple_class_to_typescript(second_value)
+
+            ConvertibleProperty.new(
+              zod_definition: "z.union([#{fv.zod_definition}, #{sv.zod_definition}])",
+              discovered_classes: (fv.discovered_classes + sv.discovered_classes).uniq,
+            )
+          end
+        when 'T::Types::TypedHash'
+          key_type = data[:type].keys
+          value_type = data[:type].values
+
+          key_convertible_property = instance_of_class_to_convertible_property(key_type)
+          value_convertible_property = instance_of_class_to_convertible_property(value_type)
+
+          ConvertibleProperty.new(
+            zod_definition:
+              "z.record(#{key_convertible_property.zod_definition}, #{value_convertible_property.zod_definition})",
+            discovered_classes: [],
+          )
+        when 'T::Types::Union'
+          union_types = data[:type].types.map(&:raw_type)
+          properties = union_types.map { |union_type| simple_class_to_typescript(union_type) }
+
+          values = properties.map(&:zod_definition)
+          discovered_classes = properties.flat_map(&:discovered_classes).uniq
+
+          ConvertibleProperty.new(
+            zod_definition: "z.union([#{values.join(',')}])",
+            discovered_classes: discovered_classes,
+          )
+        else
+          simple_class_to_typescript(data[:type])
+        end
+
+      # Add .nullable() if the type is nilable
+      if is_nilable
+        ConvertibleProperty.new(
+          zod_definition: "#{result.zod_definition}.nullable()",
+          discovered_classes: result.discovered_classes,
+        )
+      else
+        result
+      end
+    end
+
+    sig { params(instance: T.untyped).returns(ConvertibleProperty) }
+    def instance_of_class_to_convertible_property(instance)
+      # Handle special Sorbet types
+      case instance.class.to_s
+      when 'T::Types::Untyped'
+        return ConvertibleProperty.new(zod_definition: 'z.unknown()', discovered_classes: [])
+      when 'T::Types::Intersection'
+        return ConvertibleProperty.new(zod_definition: 'z.unknown()', discovered_classes: [])
+      when 'T::Types::ClassOf'
+        return ConvertibleProperty.new(zod_definition: 'z.unknown()', discovered_classes: [])
+      when 'T::Types::AttachedClass'
+        return ConvertibleProperty.new(zod_definition: 'z.unknown()', discovered_classes: [])
+      when 'T::Types::NoReturn'
+        return ConvertibleProperty.new(zod_definition: 'z.unknown()', discovered_classes: [])
+      end
+
+      if instance.is_a?(T::Types::Simple)
+        simple_class_to_typescript(instance.raw_type)
+      elsif instance.is_a?(T::Types::TypedArray)
+        inner_type = instance.type
+        inner_type_convertible_property = instance_of_class_to_convertible_property(inner_type)
+
+        ConvertibleProperty.new(
+          zod_definition: "z.array(#{inner_type_convertible_property.zod_definition})",
+          discovered_classes: inner_type_convertible_property.discovered_classes,
+        )
+      elsif instance.is_a?(T::Types::TypedHash)
+        key_type = instance.keys
+        value_type = instance.values
+
+        key_convertible_property = instance_of_class_to_convertible_property(key_type)
+        value_convertible_property = instance_of_class_to_convertible_property(value_type)
+
+        ConvertibleProperty.new(
+          zod_definition:
+            "z.record(#{key_convertible_property.zod_definition}, #{value_convertible_property.zod_definition})",
+          discovered_classes: [],
+        )
+      elsif instance.is_a?(T::Types::Union)
+        union_types = instance.types.map(&:raw_type)
+        if union_types.to_set == [TrueClass, FalseClass].to_set
+          ConvertibleProperty.new(zod_definition: 'z.boolean()', discovered_classes: [])
+        else
+          properties = union_types.map { |union_type| simple_class_to_typescript(union_type) }
+          values = properties.map(&:zod_definition)
+          discovered_classes = properties.flat_map(&:discovered_classes).uniq
+
+          ConvertibleProperty.new(
+            zod_definition: "z.union([#{values.join(', ')}])",
+            discovered_classes: discovered_classes,
+          )
+        end
+      else
+        ConvertibleProperty.new(zod_definition: 'z.unknown()')
+      end
+    end
+
+    sig { params(klass: T.untyped).returns(ConvertibleProperty) }
+    def simple_class_to_typescript(klass)
+      # Check if klass is a Class first, since < operator only works on classes
+      if klass.is_a?(Class)
+        case
+        when klass < T::Struct
+          inner_klass = ConvertibleClass.new(klass: klass)
+          ConvertibleProperty.new(
+            zod_definition: inner_klass.typescript_name,
+            discovered_classes: [klass],
+          )
+        when klass < T::Enum
+          inner_klass = ConvertibleClass.new(klass: klass)
+          ConvertibleProperty.new(
+            zod_definition: inner_klass.typescript_name,
+            discovered_classes: [klass],
+          )
+        when SORBET_TYPESCRIPT_MAPPING.key?(klass)
+          ConvertibleProperty.new(zod_definition: SORBET_TYPESCRIPT_MAPPING[klass])
+        else
+          ConvertibleProperty.new(zod_definition: 'z.unknown()')
+        end
+      else
+        ConvertibleProperty.new(zod_definition: 'z.unknown()')
+      end
+    end
+
+    # Reads the Ruby file and extracts the primary class being converted.
+    # This assumes that every has a single Module or Class declaration, otherwise only the last is considered.
+    # @return a namespaced class name
+    sig { returns(String) }
+    def extract_main_klass
+      ast = Prism.parse(File.read(@file_path))
+
+      struct_class_name = T.let(nil, T.nilable(String))
+      enum_class_name = T.let(nil, T.nilable(String))
+      module_names = T.let([], T::Array[String])
+
+      # Recursively traverse modules but stop at classes to avoid nested classes
+      find_main_class =
+        lambda do |nodes, modules|
+          nodes.each do |node|
+            if node.is_a?(Prism::ModuleNode)
+              # Traverse into modules recursively
+              module_body = node.body
+              if module_body.is_a?(Prism::StatementsNode)
+                find_main_class.call(module_body.body, modules + [node.name.to_s])
+              end
+            elsif node.is_a?(Prism::ClassNode)
+              parent = node.superclass
+              if parent.is_a?(Prism::ConstantPathNode)
+                if parent.full_name == 'T::Struct'
+                  # Keep updating to get the LAST struct at any level
+                  # But DON'T traverse into class bodies (to avoid nested classes)
+                  struct_class_name = node.name.to_s
+                  module_names = modules
+                elsif parent.full_name == 'T::Enum' && struct_class_name.nil?
+                  enum_class_name = node.name.to_s
+                  module_names = modules if module_names.empty?
+                end
+              end
+            end
+          end
+        end
+
+      find_main_class.call(ast.value.statements.body, [])
+
+      # Prefer struct over enum
+      class_name = struct_class_name || enum_class_name
+      [*module_names, T.must(class_name)].compact.join('::')
+    end
+  end
+end

data/lib/mochitype/ruby_type_utils.rb

@@ -0,0 +1,24 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mochitype
+  class RubyTypeUtils
+    class << self
+      extend T::Sig
+
+      sig { params(statement_node: Prism::Node).returns(T::Boolean) }
+      def struct_call_node?(statement_node)
+        return false unless statement_node.is_a?(Prism::CallNode)
+        receiver = statement_node.receiver
+        receiver.is_a?(Prism::ConstantPathNode) && receiver.full_name == 'T::Struct'
+      end
+
+      sig { params(statement_node: Prism::Node).returns(T::Boolean) }
+      def enum_call_node?(statement_node)
+        return false unless statement_node.is_a?(Prism::CallNode)
+        receiver = statement_node.receiver
+        receiver.is_a?(Prism::ConstantPathNode) && receiver.full_name == 'T::Enum'
+      end
+    end
+  end
+end

data/lib/mochitype/type_converter.rb

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative 'reflection_type_converter.rb'
+
+module Mochitype
+  class TypeConverter < ReflectionTypeConverter
+    class << self
+      extend T::Sig
+
+      sig { params(in_filepath: String, out_filepath: String).void }
+      def write_converted_file(in_filepath:, out_filepath:)
+        File.write(out_filepath, new(in_filepath).build_typescript_file)
+      end
+
+      sig { params(file_path: String).returns(T.nilable(String)) }
+      def convert_file(file_path)
+        output_filepath = determine_output_path(file_path)
+        FileUtils.mkdir_p(File.dirname(output_filepath))
+        write_converted_file(in_filepath: file_path, out_filepath: output_filepath)
+        output_filepath
+      end
+
+      sig { params(file_path: String).returns(String) }
+      def determine_output_path(file_path)
+        base_path =
+          if defined?(Rails) && Rails.root
+            Rails.root.join(Mochitype.configuration.output_path)
+          else
+            Mochitype.configuration.output_path
+          end
+
+        relative_path = file_path.sub(/.*#{Mochitype.configuration.watch_path}/, '')
+        File.join(base_path, relative_path.sub('.rb', '.ts'))
+      end
+    end
+  end
+end

data/lib/mochitype/type_data.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mochitype
+  class ConvertibleStruct < T::Struct
+    extend T::Sig
+
+    const :name, String
+    const :props, T::Hash[String, String]
+    const :type, T.nilable(String)
+
+    sig { returns(String) }
+    def typescript_name
+      "#{name}Schema"
+    end
+  end
+end

data/lib/mochitype/typescript_utils.rb

@@ -0,0 +1,25 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mochitype
+  class TypescriptUtils
+    class << self
+      extend T::Sig
+
+      def plain_ruby_class_to_typescript_type(node)
+        case T.unsafe(node).name.to_s
+        when 'String'
+          'z.string()'
+        when 'Integer', 'Numeric', 'Float'
+          'z.number()'
+        else
+          "#{T.unsafe(node).name}Schema"
+        end
+      end
+
+      def number_type?(class_name)
+        %w[Integer Numeric Float].include?(class_name)
+      end
+    end
+  end
+end

data/lib/mochitype/version.rb

@@ -0,0 +1,3 @@
+module Mochitype
+  VERSION = '0.3.0'
+end

data/lib/mochitype/view.rb

@@ -0,0 +1,18 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mochitype
+  module View
+    extend T::Sig
+
+    sig { params(view_context: ActionView::Base).returns(String) }
+    def render_in(view_context)
+      serialize.to_json
+    end
+
+    sig { returns(Symbol) }
+    def format
+      :json
+    end
+  end
+end

data/lib/mochitype.rb

@@ -0,0 +1,31 @@
+# Core dependencies
+require 'rails'
+require 'listen'
+require 'prism'
+require 'sorbet-runtime'
+
+require 'mochitype/version'
+require 'mochitype/configuration'
+require 'mochitype/ruby_type_utils'
+
+require 'mochitype/convertible_property'
+require 'mochitype/convertible_class'
+require 'mochitype/type_converter'
+require 'mochitype/reflection_type_converter'
+
+require 'mochitype/view'
+require 'mochitype/file_watcher'
+require 'mochitype/railtie' if defined?(Rails)
+
+module Mochitype
+  class Error < StandardError
+  end
+
+  module ViewHelper
+    def mochitype_render(*args, **kwargs)
+      # Your custom rendering logic will go here
+      # This method will be available in all Rails views
+      'Placeholder for custom rendering logic'
+    end
+  end
+end

data/lib/tasks/mochitype.rake

@@ -0,0 +1,33 @@
+# typed: true
+# frozen_string_literal: true
+
+namespace :mochitype do
+  desc 'Generate TypeScript types from Ruby Sorbet definitions'
+  task generate: :environment do
+    require 'mochitype'
+
+    watch_path = Mochitype.configuration.watch_path
+    output_path = Mochitype.configuration.output_path
+
+    puts "Mochitype: Scanning #{watch_path} for Ruby type definitions..."
+
+    # Find all .rb files in watch_path
+    files = Dir.glob(File.join(watch_path, '**', '*.rb'))
+
+    if files.empty?
+      puts "No Ruby files found in #{watch_path}"
+      next
+    end
+
+    converted_count = 0
+    files.each do |file_path|
+      output_file = Mochitype::TypeConverter.convert_file(file_path)
+      if output_file
+        puts "Generated #{output_file}"
+        converted_count += 1
+      end
+    end
+
+    puts "Successfully generated #{converted_count} TypeScript file(s) in #{output_path}"
+  end
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: mochitype
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Your Name
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.11094
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.11094
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Rails view helper that provides custom rendering functionality
+email:
+- your.email@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/mochitype.rb
+- lib/mochitype/configuration.rb
+- lib/mochitype/convertible_class.rb
+- lib/mochitype/convertible_property.rb
+- lib/mochitype/file_watcher.rb
+- lib/mochitype/railtie.rb
+- lib/mochitype/reflection_type_converter.rb
+- lib/mochitype/ruby_type_utils.rb
+- lib/mochitype/type_converter.rb
+- lib/mochitype/type_data.rb
+- lib/mochitype/typescript_utils.rb
+- lib/mochitype/version.rb
+- lib/mochitype/view.rb
+- lib/tasks/mochitype.rake
+homepage: https://github.com/username/mochitype
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/username/mochitype
+  source_code_uri: https://github.com/username/mochitype
+  changelog_uri: https://github.com/username/mochitype/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Custom rendering helper for Rails applications
+test_files: []