typelizer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2a3d9ee492a8abe52368f76b6312cb8dea42c1321d45f9555e69ad7165c660bf
+  data.tar.gz: b3327bfeebc1bae33772bd3a4ddeec312583fbc9345da5e2ca16e992f845331b
+SHA512:
+  metadata.gz: 43771cbcdbc2ae8952abe2af958b434a1e2cf8caaa639fab7ea477be64000e7b9c4e7d83fec13c94b3ab26ac65efbae4dfab47bd3e6976e345c0b2516e95bf40
+  data.tar.gz: 0450a22f5189a079f7747f2c8c2d1b01445143d5a1cbdadf34d3be17ef7056b2f28ce27d880b3950d87d69e34a166481742a1d16a8fce5b9906c130b3c18f378

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog],
+and this project adheres to [Semantic Versioning].
+
+## [Unreleased]
+
+## [0.1.0] - 2024-08-02
+
+- Initial release ([@skryukov])
+
+[@skryukov]: https://github.com/skryukov
+
+[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/skryukov/typelizer/commits/v0.1.0
+
+[Keep a Changelog]: https://keepachangelog.com/en/1.0.0/
+[Semantic Versioning]: https://semver.org/spec/v2.0.0.html

data/README.md

@@ -0,0 +1,253 @@
+# Typelizer
+
+[![Gem Version](https://badge.fury.io/rb/typelizer.svg)](https://rubygems.org/gems/typelizer)
+
+Typelizer is a Ruby gem that automatically generates TypeScript interfaces from your Ruby serializers, bridging the gap between your Ruby backend and TypeScript frontend. It supports multiple serializer libraries and provides a flexible configuration system, making it easier to maintain type consistency across your full-stack application.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Basic Setup](#basic-setup)
+  - [Manual Typing](#manual-typing)
+  - [TypeScript Integration](#typescript-integration)
+  - [Manual Generation](#manual-generation)
+  - [Automatic Generation in Development](#automatic-generation-in-development)
+- [Configuration](#configuration)
+  - [Global Configuration](#global-configuration)
+  - [Config Options](#config-options)
+  - [Per-Serializer Configuration](#per-serializer-configuration)
+- [Credits](#credits)
+- [License](#license)
+
+<a href="https://evilmartians.com/?utm_source=typelizer&utm_campaign=project_page">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Built by Evil Martians" width="236" height="54">
+</a>
+
+## Features
+
+- Automatic TypeScript interface generation
+- Support for multiple serializer libraries (`Alba`, `ActiveModel::Serializer`, `Oj::Serializer`)
+- File watching and automatic regeneration in development
+
+## Installation
+
+To install Typelizer, add the following line to your `Gemfile` and run `bundle install`:
+
+```ruby
+gem "typelizer"
+```
+
+## Usage
+
+### Basic Setup
+
+Include the Typelizer DSL in your serializers:
+
+```ruby
+class ApplicationResource
+  include Alba::Resource 
+  include Typelizer::DSL
+end
+
+class PostResource < ApplicationResource
+  attributes :id, :title, :body
+  
+  has_one :author, serializer: AuthorResource
+end
+
+class AuthorResource < ApplicationResource
+  # specify the model to infer types from (optional)
+  typelize_from User
+  
+  attributes :id, :name
+end
+```
+
+Typelizer will automatically generate TypeScript interfaces based on your serializer definitions using information from your models.
+
+### Manual Typing
+
+You can manually specify TypeScript types in your serializers:
+
+```ruby
+class PostResource < ApplicationResource
+  attributes :id, :title, :body, :published_at
+
+  typelize "string"
+  attribute :author_name do |post|
+    post.author.name
+  end
+end
+```
+
+### TypeScript Integration
+
+Typelizer generates TypeScript interfaces in the specified output directory:
+
+```typescript
+// app/javascript/types/serializers/Post.ts
+export interface Post {
+  id: number;
+  title: string;
+  body: string;
+  published_at: string | null;
+  author_name: string;
+}
+```
+
+All generated interfaces are automatically imported in a single file:
+
+```typescript
+// app/javascript/types/serializers/index.ts
+export * from "./post";
+export * from "./author";
+```
+
+We recommend importing this file in a central location:
+
+```typescript
+// app/javascript/types/index.ts
+import "@/types/serializers";
+// Custom types can be added here
+// ...
+```
+
+With such a setup, you can import all generated interfaces in your TypeScript files:
+
+```typescript
+import { Post } from "@/types";
+```
+
+This setup also allows you to use custom types in your serializers:
+
+```ruby
+class PostWithMetaResource < ApplicationResource
+  attributes :id, :title
+  typelize "PostMeta"
+  attribute :meta do |post|
+    { likes: post.likes, comments: post.comments }
+  end
+end
+```
+
+```typescript
+// app/javascript/types/serializers/PostWithMeta.ts
+
+import { PostMeta } from "@/types";
+
+export interface Post {
+  id: number;
+  title: string;
+  meta: PostMeta;
+}
+```
+
+The `"@/types"` import path is configurable:
+
+```ruby
+Typelizer.configure do |config|
+  config.types_import_path = "@/types";
+end
+```
+
+See the [Configuration](#configuration) section for more options.
+
+### Manual Generation
+
+To manually generate TypeScript interfaces:
+
+```
+$ rails typelizer:generate
+```
+
+### Automatic Generation in Development
+
+When [Listen](https://github.com/guard/listen) is installed, Typelizer automatically watches for changes and regenerates interfaces in development mode. You can disable this behavior:
+
+```ruby
+Typelizer.listen = false
+```
+
+## Configuration
+
+### Global Configuration
+
+Typelizer provides several global configuration options:
+
+```ruby
+# Directories to search for serializers:
+Typelizer.dirs = [Rails.root.join("app", "resources"), Rails.root.join("app", "serializers")]
+# Reject specific classes from being typelized:
+Typelizer.reject_class = ->(serializer:) { false }
+# Logger for debugging:
+Typelizer.logger = Logger.new($stdout, level: :info)
+# Force enable or disable file watching with Listen:
+Typelizer.listen = nil
+```
+
+### Config Options
+
+`Typelizer::Config` offers fine-grained control over the gem's behavior. Here's a list of available options:
+
+```ruby
+Typelizer.configure do |config|
+  # Determines how serializer names are mapped to TypeScript interface names
+  config.serializer_name_mapper = ->(serializer) { ... }
+
+  # Maps serializers to their corresponding model classes
+  config.serializer_model_mapper = ->(serializer) { ... }
+
+  # Custom transformation for generated properties
+  config.properties_transformer = ->(properties) { ... }
+
+  # Plugin for model type inference (default: ModelPlugins::ActiveRecord)
+  config.model_plugin = Typelizer::ModelPlugins::ActiveRecord
+
+  # Plugin for serializer parsing (default: SerializerPlugins::Auto)
+  config.serializer_plugin = Typelizer::SerializerPlugins::Auto
+
+  # Additional configurations for specific plugins
+  config.plugin_configs = { alba: { ts_mapper: {...} } }
+
+  # Custom DB to TypeScript type mapping
+  config.type_mapping = config.type_mapping.merge(jsonb: "Record<string, undefined>", ... )
+
+  # Strategy for handling null values (:nullable, :optional, or :nullable_and_optional)
+  config.null_strategy = :nullable
+
+  # Directory where TypeScript interfaces will be generated
+  config.output_dir = Rails.root.join("app/javascript/types/serializers")
+
+  # Import path for generated types in TypeScript files
+  # (e.g., `import { MyType } from "@/types"`)
+  config.types_import_path = "@/types"
+
+  # List of type names that should be considered global in TypeScript
+  # (i.e. not prefixed with the import path)
+  config.types_global << %w[Array Date Record File FileList]
+end
+```
+
+### Per-Serializer Configuration
+
+You can also configure Typelizer on a per-serializer basis:
+
+```ruby
+class PostResource < ApplicationResource
+  typelizer_config do |config|
+    config.type_mapping = config.type_mapping.merge(jsonb: "Record<string, undefined>", ... )
+    config.null_strategy = :nullable
+    # ...
+  end
+end
+```
+
+## Credits
+
+Typelizer is inspired by [types_from_serializers](https://github.com/ElMassimo/types_from_serializers).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/tasks/generate.rake

@@ -0,0 +1,18 @@
+namespace :typelizer do
+  desc "Generate TypeScript interfaces from serializers"
+  task generate: :environment do
+    require "benchmark"
+
+    ENV["TYPELIZER"] = "true"
+
+    puts "Generating TypeScript interfaces..."
+    serializers = []
+    time = Benchmark.realtime do
+      serializers = Typelizer::Generator.call
+    end
+
+    puts "Finished in #{time} seconds"
+    puts "Found #{serializers.size} serializers:"
+    puts serializers.map { |s| "\t#{s.name}" }.join("\n")
+  end
+end

data/lib/typelizer/config.rb

@@ -0,0 +1,75 @@
+module Typelizer
+  TYPE_MAPPING = {
+    boolean: :boolean,
+    date: :string,
+    datetime: :string,
+    decimal: :number,
+    integer: :number,
+    string: :string,
+    text: :string,
+    citext: :string
+  }.tap do |types|
+    types.default = :unknown
+  end
+
+  class Config < Struct.new(
+    :serializer_name_mapper,
+    :serializer_model_mapper,
+    :properties_transformer,
+    :model_plugin,
+    :serializer_plugin,
+    :plugin_configs,
+    :type_mapping,
+    :null_strategy,
+    :output_dir,
+    :types_import_path,
+    :types_global,
+    keyword_init: true
+  ) do
+    class << self
+      def instance
+        @instance ||= new(
+          serializer_name_mapper: ->(serializer) { serializer.name.ends_with?("Serializer") ? serializer.name.delete_suffix("Serializer") : serializer.name.delete_suffix("Resource") },
+          serializer_model_mapper: ->(serializer) do
+            base_class = serializer_name_mapper.call(serializer)
+            Object.const_get(base_class) if Object.const_defined?(base_class)
+          end,
+
+          model_plugin: ModelPlugins::ActiveRecord,
+          serializer_plugin: SerializerPlugins::Auto,
+          plugin_configs: {},
+
+          type_mapping: TYPE_MAPPING,
+          null_strategy: :nullable,
+
+          output_dir: js_root.join("types/serializers"),
+
+          types_import_path: "@/types",
+          types_global: %w[Array Date Record File FileList],
+
+          properties_transformer: nil
+        )
+      end
+
+      private
+
+      def js_root
+        root_path = defined?(Rails) ? Rails.root : Pathname.pwd
+        js_root = defined?(ViteRuby) ? ViteRuby.config.source_code_dir : "app/javascript"
+        root_path.join(js_root)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        Typelizer.respond_to?(name) ||
+          instance.respond_to?(name, include_private)
+      end
+
+      def method_missing(method, *args, &block)
+        return Typelizer.send(method, *args, &block) if Typelizer.respond_to?(method)
+
+        instance.send(method, *args, &block)
+      end
+    end
+  end
+  end
+end

data/lib/typelizer/dsl.rb

@@ -0,0 +1,89 @@
+module Typelizer
+  module DSL
+    # typelize_from Model
+    # typelize attribute_name: ["string", "Date", optional: true, nullable: true, multi: true]
+
+    def self.included(base)
+      Typelizer.base_classes << base.to_s
+      base.extend(ClassMethods)
+    end
+
+    def self.extended(base)
+      Typelizer.base_classes << base.to_s
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def typelizer_config
+        @typelizer_config ||=
+          begin
+            parent_config = superclass.respond_to?(:typelizer_config) ? superclass.typelizer_config : Config
+            Config.new(parent_config.to_h.transform_values(&:dup))
+          end
+        yield @typelizer_config if block_given?
+        @typelizer_config
+      end
+
+      def typelizer_interface
+        @typelizer_interface ||= Interface.new(serializer: self)
+      end
+
+      # save association of serializer to model
+      def typelize_from(model)
+        return unless Typelizer.enabled?
+
+        define_singleton_method(:_typelizer_model_name) { model }
+      end
+
+      # save association of serializer attributes to type
+      # can be invoked multiple times
+      def typelize(type = nil, type_params = {}, **attributes)
+        if type
+          @keyless_type = [type, type_params.merge(attributes)]
+        else
+          assign_type_information(:_typelizer_attributes, attributes)
+        end
+      end
+
+      attr_accessor :keyless_type
+
+      def typelize_meta(**attributes)
+        assign_type_information(:_typelizer_meta_attributes, attributes)
+      end
+
+      private
+
+      def assign_type_information(attribute_name, attributes)
+        return unless Typelizer.enabled?
+
+        instance_variable = "@#{attribute_name}"
+
+        unless instance_variable_get(instance_variable)
+          instance_variable_set(instance_variable, {})
+        end
+
+        unless respond_to?(attribute_name)
+          define_singleton_method(attribute_name) do
+            result = instance_variable_get(instance_variable)
+            if superclass.respond_to?(attribute_name)
+              result.merge(superclass.send(attribute_name))
+            else
+              result
+            end
+          end
+        end
+
+        attributes.each do |name, attrs|
+          next unless name
+
+          attrs = [attrs] if attrs && !attrs.is_a?(Array)
+          options = attrs.last.is_a?(Hash) ? attrs.pop : {}
+
+          options[:type] = attrs.join(" | ") if attrs.any?
+          instance_variable_get(instance_variable)[name.to_sym] ||= {}
+          instance_variable_get(instance_variable)[name.to_sym].merge!(options)
+        end
+      end
+    end
+  end
+end

data/lib/typelizer/generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Typelizer
+  class Generator
+    def self.call
+      new.call
+    end
+
+    def initialize(config = Typelizer::Config)
+      @config = config
+      @writer = Writer.new
+    end
+
+    attr_reader :config, :writer
+
+    def call(force: false)
+      return unless Typelizer.enabled?
+
+      read_serializers
+
+      interfaces = target_serializers.map(&:typelizer_interface).reject(&:empty?)
+      writer.call(interfaces, force: force)
+
+      interfaces
+    end
+
+    private
+
+    def target_serializers
+      base_classes = Typelizer.base_classes.filter_map do |base_class|
+        Object.const_get(base_class) if Object.const_defined?(base_class)
+      end.tap do |base_classes|
+        raise ArgumentError, "Please ensure all your serializers include Typelizer::DSL." if base_classes.none?
+      end
+
+      (base_classes + base_classes.flat_map(&:descendants)).uniq.sort_by(&:name)
+        .reject { |serializer| Typelizer.reject_class.call(serializer: serializer) }
+    end
+
+    def read_serializers(files = nil)
+      files ||= Typelizer.dirs.flat_map { |dir| Dir["#{dir}/**/*.rb"] }
+
+      files.each do |file|
+        trace = TracePoint.new(:call) do |tp|
+          begin
+            next unless tp.self.respond_to?(:typelizer_interface) && !tp.self.send(:respond_to_missing?, :typelizer_interface, false)
+          rescue WeakRef::RefError
+            next
+          end
+          serializer_plugin = tp.self.typelizer_interface.serializer_plugin
+
+          if tp.callee_id.in?(serializer_plugin.methods_to_typelize)
+            type, attrs = tp.self.keyless_type
+            name = tp.binding.local_variable_get(:name) if tp.binding.local_variable_defined?(:name)
+            tp.self.typelize(**serializer_plugin.typelize_method_transform(method: tp.callee_id, binding: tp.binding, name: name, type: type, attrs: attrs || {}))
+            tp.self.keyless_type = nil
+          end
+        end
+
+        trace.enable
+        require file
+        trace.disable
+      end
+    end
+  end
+end

data/lib/typelizer/interface.rb

@@ -0,0 +1,101 @@
+module Typelizer
+  class Interface
+    attr_reader :serializer, :serializer_plugin
+
+    def config
+      serializer.typelizer_config
+    end
+
+    def initialize(serializer:)
+      @serializer = serializer
+      @serializer_plugin = config.serializer_plugin.new(serializer: serializer, config: config)
+    end
+
+    def name
+      config.serializer_name_mapper.call(serializer).tr_s(":", "")
+    end
+
+    def filename
+      name.gsub("::", "/")
+    end
+
+    def root_key
+      serializer_plugin.root_key
+    end
+
+    def empty?
+      meta_fields.empty? && properties.empty?
+    end
+
+    def meta_fields
+      @meta_fields ||= begin
+        props = serializer_plugin.meta_fields || []
+        props = infer_types(props, :_typelizer_meta_attributes)
+        props = config.properties_transformer.call(props) if config.properties_transformer
+        props
+      end
+    end
+
+    def properties
+      @properties ||= begin
+        props = serializer_plugin.properties
+        props = infer_types(props)
+        props = config.properties_transformer.call(props) if config.properties_transformer
+        props
+      end
+    end
+
+    def imports
+      association_serializers, attribute_types = properties.filter_map(&:type)
+        .uniq
+        .partition { |type| type.is_a?(Interface) }
+
+      serializer_types = association_serializers
+        .filter_map { |interface| interface.name if interface.name != name }
+
+      custom_type_imports = attribute_types
+        .flat_map { |type| extract_typescript_types(type.to_s) }
+        .uniq
+        .reject { |type| global_type?(type) }
+
+      custom_type_imports + serializer_types
+    end
+
+    def inspect
+      "<#{self.class.name} #{name} properties=#{properties.inspect}>"
+    end
+
+    private
+
+    def extract_typescript_types(type)
+      type.split(/[<>\[\],\s|]+/)
+    end
+
+    def global_type?(type)
+      type[0] == type[0].downcase || config.types_global.include?(type)
+    end
+
+    def infer_types(props, hash_name = :_typelizer_attributes)
+      props.map do |prop|
+        if serializer.respond_to?(hash_name)
+          dsl_type = serializer.public_send(hash_name)[prop.name.to_sym]
+          next Property.new(prop.to_h.merge(dsl_type)) if dsl_type&.any?
+        end
+
+        model_plugin.infer_types(prop)
+      end
+    end
+
+    def model_class
+      return serializer._typelizer_model_name if serializer.respond_to?(:_typelizer_model_name)
+
+      config.serializer_model_mapper.call(serializer)
+    rescue NameError
+      nil
+    end
+
+    def model_plugin
+      @model_plugin ||= config.model_plugin.new(model_class: model_class, config: config)
+    end
+  end
+end

data/lib/typelizer/listen.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module Listen
+    class << self
+      attr_accessor :started
+
+      def call(
+        run_on_start: true,
+        options: {},
+        &block
+      )
+        return if started
+        return unless Typelizer.enabled?
+
+        @block = block
+        @generator = Typelizer::Generator.new
+
+        gem "listen"
+        require "listen"
+
+        self.started = true
+
+        locales_dirs = Typelizer.dirs.filter(&:exist?).map { |path| File.expand_path(path) }
+
+        relative_paths = locales_dirs.map { |path| relative_path(path) }
+
+        debug("Watching #{relative_paths.inspect}")
+
+        listener(locales_dirs.map(&:to_s), options).start
+        @generator.call if run_on_start
+      end
+
+      def relative_path(path)
+        root_path = defined?(Rails) ? Rails.root : Pathname.pwd
+        Pathname.new(path).relative_path_from(root_path).to_s
+      end
+
+      def debug(message)
+        Typelizer.logger.debug(message)
+      end
+
+      def listener(paths, options)
+        ::Listen.to(*paths, options) do |changed, added, removed|
+          changes = compute_changes(paths, changed, added, removed)
+
+          next unless changes.any?
+
+          debug(changes.map { |key, value| "#{key}=#{value.inspect}" }.join(", "))
+
+          @block.call
+        end
+      end
+
+      def compute_changes(paths, changed, added, removed)
+        paths = paths.map { |path| relative_path(path) }
+
+        {
+          changed: included_on_watched_paths(paths, changed),
+          added: included_on_watched_paths(paths, added),
+          removed: included_on_watched_paths(paths, removed)
+        }.select { |_k, v| v.any? }
+      end
+
+      def included_on_watched_paths(paths, changes)
+        changes.map { |change| relative_path(change) }.select do |change|
+          paths.any? { |path| change.start_with?(path) }
+        end
+      end
+    end
+  end
+end

data/lib/typelizer/model_plugins/active_record.rb

@@ -0,0 +1,34 @@
+module Typelizer
+  module ModelPlugins
+    class ActiveRecord
+      def initialize(model_class:, config:)
+        @columns_hash = model_class&.columns_hash || {}
+        @config = config
+      end
+
+      attr_reader :columns_hash, :config
+
+      def infer_types(prop)
+        column = columns_hash[prop.column_name.to_s]
+        return prop unless column
+
+        prop.multi = !!column.try(:array)
+        case config.null_strategy
+        when :nullable
+          prop.nullable = column.null
+        when :optional
+          prop.optional = column.null
+        when :nullable_and_optional
+          prop.nullable = column.null
+          prop.optional = column.null
+        else
+          raise "Unknown null strategy: #{config.null_strategy}"
+        end
+
+        prop.type = @config.type_mapping[column.type]
+
+        prop
+      end
+    end
+  end
+end

data/lib/typelizer/property.rb

@@ -0,0 +1,26 @@
+module Typelizer
+  Property = Struct.new(
+    :name, :type, :optional, :nullable,
+    :multi, :column_name,
+    keyword_init: true
+  ) do
+    def inspect
+      props = to_h.merge(type: type_name).map { |k, v| "#{k}=#{v.inspect}" }.join(" ")
+      "<#{self.class.name} #{props}>"
+    end
+
+    def to_s
+      type_str = type_name
+      type_str = "Array<#{type_str}>" if multi
+      type_str = "#{type_str} | null" if nullable
+
+      "#{name}#{"?" if optional}: #{type_str}"
+    end
+
+    private
+
+    def type_name
+      type.respond_to?(:name) ? type.name : type || "unknown"
+    end
+  end
+end

data/lib/typelizer/railtie.rb

@@ -0,0 +1,35 @@
+module Typelizer
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/generate.rake"
+    end
+
+    initializer "typelizer.configure" do
+      Typelizer.configure do |c|
+        c.dirs = [
+          Rails.root.join("app", "resources"),
+          Rails.root.join("app", "serializers")
+        ]
+      end
+    end
+
+    initializer "typelizer.generate" do |app|
+      next unless Typelizer.enabled?
+
+      generator = Typelizer::Generator.new
+
+      if Typelizer.listen == true || Gem.loaded_specs["listen"] && Typelizer.listen != false
+        require_relative "listen"
+        app.config.after_initialize do
+          Typelizer::Listen.call do
+            Rails.application.reloader.reload!
+          end
+        end
+      end
+
+      app.config.to_prepare do
+        generator.call
+      end
+    end
+  end
+end

data/lib/typelizer/serializer_plugins/alba.rb

@@ -0,0 +1,120 @@
+require_relative "base"
+
+module Typelizer
+  module SerializerPlugins
+    class Alba < Base
+      ALBA_TS_MAPPER = {
+        "String" => {type: :string},
+        "Integer" => {type: :number},
+        "Boolean" => {type: :boolean},
+        "ArrayOfString" => {type: :string, multi: true},
+        "ArrayOfInteger" => {type: :number, multi: true}
+      }
+
+      def properties
+        serializer._attributes.map do |name, attr|
+          build_property(name, attr)
+        end
+      end
+
+      def methods_to_typelize
+        [
+          :association, :one, :has_one,
+          :many, :has_many,
+          :attributes, :attribute,
+          :nested_attribute, :nested,
+          :meta
+        ]
+      end
+
+      def typelize_method_transform(method:, name:, binding:, type:, attrs:)
+        return {name => [type, attrs.merge(multi: true)]} if [:many, :has_many].include?(method)
+
+        super
+      end
+
+      def root_key
+        serializer.new({}).send(:_key)
+      end
+
+      def meta_fields
+        return nil unless serializer._meta
+
+        name = serializer._meta.first
+        [
+          build_property(name, name)
+        ]
+      end
+
+      private
+
+      def build_property(name, attr, **options)
+        case attr
+        when Symbol
+          Property.new(
+            name: name,
+            type: nil,
+            optional: false,
+            nullable: false,
+            multi: false,
+            column_name: name,
+            **options
+          )
+        when Proc
+          Property.new(
+            name: name,
+            type: nil,
+            optional: false,
+            nullable: false,
+            multi: false,
+            column_name: nil,
+            **options
+          )
+        when ::Alba::Association
+          resource = attr.instance_variable_get(:@resource)
+          Property.new(
+            name: name,
+            type: Interface.new(serializer: resource),
+            optional: false,
+            nullable: false,
+            multi: false, # we override this in typelize_method_transform
+            column_name: name,
+            **options
+          )
+        when ::Alba::TypedAttribute
+          alba_type = attr.instance_variable_get(:@type)
+          Property.new(
+            name: name,
+            optional: false,
+            # not sure if that's a good default tbh
+            nullable: !alba_type.instance_variable_get(:@auto_convert),
+            multi: false,
+            column_name: name,
+            **ts_mapper[alba_type.name.to_s],
+            **options
+          )
+        when ::Alba::NestedAttribute
+          Property.new(
+            name: name,
+            type: nil,
+            optional: false,
+            nullable: false,
+            multi: false,
+            column_name: nil,
+            **options
+          )
+        when ::Alba::ConditionalAttribute
+          build_property(name, attr.instance_variable_get(:@body), optional: true)
+        else
+          raise ArgumentError, "Unsupported attribute type: #{attr.class}"
+        end
+      end
+
+      private
+
+      def ts_mapper
+        config.plugin_configs.dig(:alba, :ts_mapper) || ALBA_TS_MAPPER
+      end
+    end
+  end
+end

data/lib/typelizer/serializer_plugins/ams.rb

@@ -0,0 +1,33 @@
+require_relative "base"
+
+module Typelizer
+  module SerializerPlugins
+    class AMS < Base
+      def methods_to_typelize
+        [
+          :has_many, :has_one, :belongs_to,
+          :attribute, :attributes
+        ]
+      end
+
+      def typelize_method_transform(method:, name:, binding:, type:, attrs:)
+        return {binding.local_variable_get(:attr) => [type, attrs]} if method == :attribute
+
+        super
+      end
+
+      def properties
+        serializer._attributes_data.merge(serializer._reflections).flat_map do |key, association|
+          type = association.options[:serializer] ? Interface.new(serializer: association.options[:serializer]) : nil
+          Property.new(
+            name: key.to_s,
+            type: type,
+            optional: association.options.key?(:if) || association.options.key?(:unless),
+            multi: association.respond_to?(:collection?) && association.collection?,
+            column_name: association.name.to_s
+          )
+        end
+      end
+    end
+  end
+end

data/lib/typelizer/serializer_plugins/auto.rb

@@ -0,0 +1,24 @@
+module Typelizer
+  module SerializerPlugins
+    module Auto
+      class << self
+        def new(serializer:, config:)
+          plugin(serializer).new(serializer: serializer, config: config)
+        end
+
+        def plugin(serializer)
+          if defined?(::Oj::Serializer) && serializer.ancestors.include?(::Oj::Serializer)
+            OjSerializers
+          elsif defined?(::Alba) && serializer.ancestors.include?(::Alba::Resource)
+            Alba
+          elsif defined?(ActiveModel::Serializer) && serializer.ancestors.include?(ActiveModel::Serializer)
+            AMS
+          else
+            raise "Can't guess serializer plugin for #{serializer}. " \
+                    "Please specify it with `config.serializer_plugin`."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/typelizer/serializer_plugins/base.rb

@@ -0,0 +1,34 @@
+module Typelizer
+  module SerializerPlugins
+    class Base
+      def initialize(serializer:, config:)
+        @serializer = serializer
+        @config = config
+      end
+
+      def root_key
+        nil
+      end
+
+      def meta_fields
+        nil
+      end
+
+      def typelize_method_transform(method:, name:, binding:, type:, attrs:)
+        {name => [type, attrs]}
+      end
+
+      def methods_to_typelize
+        []
+      end
+
+      def properties
+        []
+      end
+
+      private
+
+      attr_reader :serializer, :config
+    end
+  end
+end

data/lib/typelizer/serializer_plugins/oj_serializers.rb

@@ -0,0 +1,33 @@
+require_relative "base"
+
+module Typelizer
+  module SerializerPlugins
+    class OjSerializers < Base
+      def methods_to_typelize
+        [
+          :has_many, :has_one, :belongs_to,
+          :flat_one, :attribute, :attributes
+        ]
+      end
+
+      def properties
+        serializer._attributes
+          .flat_map do |key, options|
+            if options[:association] == :flat
+              Interface.new(serializer: options.fetch(:serializer)).properties
+            else
+              type = options[:serializer] ? Interface.new(serializer: options[:serializer]) : options[:type]
+              Property.new(
+                name: key,
+                type: type,
+                optional: options[:optional] || options.key?(:if),
+                nullable: options[:nullable],
+                multi: options[:association] == :many,
+                column_name: options.fetch(:value_from)
+              )
+            end
+          end
+      end
+    end
+  end
+end

data/lib/typelizer/templates/fingerprint.ts.erb

@@ -0,0 +1,3 @@
+// Typelizer digest <%= Digest::MD5.hexdigest(fingerprint) %>
+//
+// DO NOT MODIFY: This file was automatically generated by Typelizer.

data/lib/typelizer/templates/index.ts.erb

@@ -0,0 +1,3 @@
+<%- interfaces.each do |interface| -%>
+export type { default as <%= interface.name %> } from './<%= interface.filename %>'
+<%- end -%>

data/lib/typelizer/templates/interface.ts.erb

@@ -0,0 +1,26 @@
+<%- if interface.imports.any? -%>
+import type {<%= interface.imports.join(", ") %>} from '<%= interface.config.types_import_path %>'
+<%- end -%>
+
+<%- if interface.root_key -%>
+type <%= interface.name %>Data = {
+<%- interface.properties.each do |property| -%>
+  <%= property %>;
+<%- end -%>
+}
+
+type <%= interface.name %> = {
+  <%= interface.root_key %>: <%= interface.name %>Data;
+<%- interface.meta_fields&.each do |property| -%>
+  <%= property %>;
+<%- end -%>
+}
+<%- else -%>
+type <%= interface.name %> = {
+<%- interface.properties.each do |property| -%>
+  <%= property %>;
+<%- end -%>
+}
+<%- end -%>
+
+export default <%= interface.name %>;

data/lib/typelizer/version.rb

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

data/lib/typelizer/writer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "erb"
+
+module Typelizer
+  class Writer
+    def initialize
+      @template_cache = {}
+      @config = Config
+    end
+
+    attr_reader :config, :template_cache
+
+    def call(interfaces, force:)
+      cleanup_output_dir if force
+
+      written_files = interfaces.map { |interface| write_interface(interface) }
+      written_files << write_index(interfaces)
+
+      existing_files = Dir[File.join(config.output_dir, "**/*.ts")]
+      files_to_delete = existing_files - written_files
+
+      File.delete(*files_to_delete) unless files_to_delete.empty?
+    end
+
+    private
+
+    def write_index(interfaces)
+      write_file("index.ts", interfaces.map(&:filename).join) do
+        render_template("index.ts.erb", interfaces: interfaces)
+      end
+    end
+
+    def write_interface(interface)
+      write_file("#{interface.filename}.ts", interface.inspect) do
+        render_template("interface.ts.erb", interface: interface)
+      end
+    end
+
+    def write_file(filename, fingerprint)
+      output_file = File.join(config.output_dir, filename)
+      existing_content = File.exist?(output_file) ? File.read(output_file) : nil
+      digest = render_template("fingerprint.ts.erb", fingerprint: fingerprint)
+
+      return output_file if existing_content&.start_with?(digest)
+
+      content = yield
+
+      FileUtils.mkdir_p(File.dirname(output_file))
+
+      File.write(output_file, digest + content)
+      output_file
+    end
+
+    def render_template(template, **context)
+      template_cache[template] ||= ERB.new(File.read(File.join(File.dirname(__FILE__), "templates/#{template}")), trim_mode: "-")
+      template_cache[template].result_with_hash(context)
+    end
+
+    def cleanup_output_dir
+      FileUtils.rm_rf(config.output_dir)
+    end
+  end
+end

data/lib/typelizer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "typelizer/version"
+require_relative "typelizer/config"
+require_relative "typelizer/property"
+require_relative "typelizer/interface"
+require_relative "typelizer/writer"
+require_relative "typelizer/generator"
+
+require_relative "typelizer/dsl"
+
+require_relative "typelizer/serializer_plugins/auto"
+require_relative "typelizer/serializer_plugins/oj_serializers"
+require_relative "typelizer/serializer_plugins/alba"
+require_relative "typelizer/serializer_plugins/ams"
+
+require_relative "typelizer/model_plugins/active_record"
+
+require_relative "typelizer/railtie" if defined?(Rails)
+
+module Typelizer
+  class << self
+    def enabled?
+      ENV["RAILS_ENV"] == "development" || ENV["RACK_ENV"] == "development" || ENV["TYPELIZER"] == "true"
+    end
+
+    attr_accessor :dirs
+    attr_accessor :reject_class
+    attr_accessor :logger
+    attr_accessor :listen
+
+    # @private
+    attr_reader :base_classes
+
+    def configure
+      yield Config
+    end
+
+    private
+
+    attr_writer :base_classes
+  end
+
+  # Set in the Railtie
+  self.dirs = []
+  self.reject_class = ->(serializer:) { false }
+  self.logger = Logger.new($stdout, level: :info)
+  self.listen = nil
+
+  self.base_classes = Set.new
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: typelizer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Svyatoslav Kryukov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+description: A TypeScript type generator for Ruby serializers.
+email:
+- me@skryukov.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/tasks/generate.rake
+- lib/typelizer.rb
+- lib/typelizer/config.rb
+- lib/typelizer/dsl.rb
+- lib/typelizer/generator.rb
+- lib/typelizer/interface.rb
+- lib/typelizer/listen.rb
+- lib/typelizer/model_plugins/active_record.rb
+- lib/typelizer/property.rb
+- lib/typelizer/railtie.rb
+- lib/typelizer/serializer_plugins/alba.rb
+- lib/typelizer/serializer_plugins/ams.rb
+- lib/typelizer/serializer_plugins/auto.rb
+- lib/typelizer/serializer_plugins/base.rb
+- lib/typelizer/serializer_plugins/oj_serializers.rb
+- lib/typelizer/templates/fingerprint.ts.erb
+- lib/typelizer/templates/index.ts.erb
+- lib/typelizer/templates/interface.ts.erb
+- lib/typelizer/version.rb
+- lib/typelizer/writer.rb
+homepage: https://github.com/skryukov/typelizer
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/skryukov/typelizer/issues
+  changelog_uri: https://github.com/skryukov/typelizer/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/skryukov/typelizer/blob/main/README.md
+  homepage_uri: https://github.com/skryukov/typelizer
+  source_code_uri: https://github.com/skryukov/typelizer
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.7
+signing_key:
+specification_version: 4
+summary: A TypeScript type generator for Ruby serializers.
+test_files: []