typelizer 0.11.0 → 0.13.0

data/lib/typelizer/route_config.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Typelizer
+  RouteConfig = Struct.new(
+    :enabled,
+    :output_dir,
+    :include,
+    :exclude,
+    :camel_case,
+    :format,
+    keyword_init: true
+  )
+
+  class RouteConfig
+    def self.defaults
+      {
+        enabled: false,
+        output_dir: nil,
+        include: nil,
+        exclude: nil,
+        camel_case: true,
+        format: :ts
+      }
+    end
+
+    def ts?
+      format != :js
+    end
+
+    def js?
+      format == :js
+    end
+
+    def file_ext
+      js? ? "js" : "ts"
+    end
+
+    def self.build(**overrides)
+      new(**defaults.merge(overrides))
+    end
+
+    def output_dir
+      self[:output_dir] || begin
+        root_path = defined?(Rails) ? Rails.root : Pathname.pwd
+        js_root = defined?(ViteRuby) ? ViteRuby.config.source_code_dir : "app/javascript"
+        root_path.join(js_root, "routes")
+      end
+    end
+  end
+end

data/lib/typelizer/route_generator.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Typelizer
+  class RouteGenerator
+    FORMAT_SUFFIX = /\(\.:format\)$/
+
+    def self.call(**args)
+      new.call(**args)
+    end
+
+    def call(force: false, skip_check: false)
+      return [] if !skip_check && !(Typelizer.enabled? && config.enabled)
+
+      routes = collect_routes
+      return [] if routes.empty?
+
+      RouteWriter.new(config).call(routes, force: force)
+    end
+
+    private
+
+    def config
+      Typelizer.configuration.routes
+    end
+
+    def collect_routes
+      return [] unless defined?(Rails) && Rails.application
+
+      # Rails 8+ lazily loads routes
+      if Rails.application.respond_to?(:reload_routes_unless_loaded)
+        Rails.application.reload_routes_unless_loaded
+      end
+
+      name_by_action, name_by_path = build_name_lookups(Rails.application.routes.named_routes)
+
+      routes = Rails.application.routes.routes.flat_map do |route|
+        app = route.app.app
+        if app.is_a?(Class) && app < Rails::Engine
+          collect_engine_routes(route, app) || []
+        else
+          build_route_info(route, name_by_action, name_by_path)
+        end
+      end.compact
+
+      # Skip PUT where PATCH exists for the same route (Rails adds both for `resources`)
+      patch_keys = routes.select { |r| r[:verb] == "patch" }
+        .map { |r| [r[:controller], r[:action], r[:path]] }.to_set
+      routes.reject! { |r| r[:verb] == "put" && patch_keys.include?([r[:controller], r[:action], r[:path]]) }
+
+      if config.include
+        patterns = Array(config.include)
+        routes = routes.select { |r| patterns.any? { |p| r[:path].match?(p) } }
+      end
+      if config.exclude
+        patterns = Array(config.exclude)
+        routes = routes.reject { |r| patterns.any? { |p| r[:path].match?(p) } }
+      end
+
+      routes
+    end
+
+    def build_name_lookups(named_routes, path_prefix: "", name_prefix: "")
+      name_by_action = {}
+      name_by_path = {}
+
+      named_routes.each do |name, route|
+        controller = route.requirements[:controller]
+        action = route.requirements[:action]
+        next unless controller && action
+
+        path = path_prefix + strip_format(route.path.spec.to_s)
+        prefixed_name = "#{name_prefix}#{name}"
+        name_by_action[[controller, action]] = prefixed_name
+        name_by_path[[controller, path]] = prefixed_name
+      end
+
+      [name_by_action, name_by_path]
+    end
+
+    def strip_format(path)
+      path.sub(FORMAT_SUFFIX, "")
+    end
+
+    def build_route_info(route, name_by_action, name_by_path)
+      controller = route.requirements[:controller]
+      action = route.requirements[:action]
+
+      path = strip_format(route.path.spec.to_s)
+
+      if controller.present? && action.present?
+        has_own_name = !!route.name
+        name = route.name || name_by_action[[controller, action]]
+        name ||= name_by_path[[controller, path]] ? action : nil
+      elsif route.name.present?
+        has_own_name = true
+        name = route.name.to_s
+        controller = "_routes"
+        action = name
+      end
+
+      return unless name
+
+      verb = extract_verb(route)
+      return unless verb
+
+      required_parts = route.required_parts.map(&:to_s)
+      optional_parts = (route.path.optional_names || []).map(&:to_s) - ["format"]
+
+      {
+        name: name,
+        named: has_own_name || !!name_by_action[[controller, action]],
+        controller: controller,
+        action: action,
+        verb: verb,
+        path: path,
+        required_parts: required_parts,
+        optional_parts: optional_parts
+      }
+    end
+
+    def collect_engine_routes(mount_route, engine)
+      mount_prefix = mount_route.path.spec.to_s
+      engine_name = mount_route.name
+      return unless engine_name
+
+      name_by_action, name_by_path = build_name_lookups(
+        engine.routes.named_routes,
+        path_prefix: mount_prefix,
+        name_prefix: "#{engine_name}_"
+      )
+
+      engine.routes.routes.filter_map do |engine_route|
+        info = build_route_info(engine_route, name_by_action, name_by_path)
+        next unless info
+        info[:path] = mount_prefix + info[:path]
+        info
+      end
+    end
+
+    def extract_verb(route)
+      verb = route.verb
+      return nil if verb.blank?
+
+      verb.split("|").first&.strip&.downcase
+    end
+  end
+end

data/lib/typelizer/route_writer.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Typelizer
+  class RouteWriter
+    def initialize(config)
+      @config = config
+      @template_cache = {}
+    end
+
+    def call(routes, force:)
+      FileUtils.rm_rf(config.output_dir) if force
+
+      written_files = []
+
+      controllers = routes.group_by { |r| r[:controller] }
+      named = build_named_routes(routes, controllers)
+
+      controllers.each do |controller, controller_routes|
+        written_files << write_controller(controller, controller_routes)
+      end
+
+      written_files << write_index(controllers, named)
+
+      written_files << write_runtime
+
+      cleanup_stale_files(written_files) unless force
+
+      Typelizer.logger.debug("Generated #{written_files.size} route files in #{config.output_dir}")
+
+      written_files
+    end
+
+    private
+
+    attr_reader :config, :template_cache
+
+    def write_controller(controller, routes)
+      ctrl_path = controller_filename(controller)
+      filename = "#{ctrl_path}.#{config.file_ext}"
+
+      prepared_routes = routes.map do |route|
+        key = route_key(route, routes)
+
+        required = route[:required_parts].map { |p| camelize_key(p) }
+        optional = route[:optional_parts].map { |p| camelize_key(p) }
+        single_required = required.size == 1 && optional.empty?
+
+        route.merge(
+          key: key,
+          required_params: required,
+          optional_params: optional,
+          single_required: single_required
+        )
+      end
+
+      runtime_import = (ctrl_path.count("/") > 0) ? "#{"../" * ctrl_path.count("/")}runtime" : "./runtime"
+      content = render_template("route_controller.erb", ts: config.ts?, routes: prepared_routes, runtime_import: runtime_import)
+
+      write_file(filename, content) do
+        content
+      end
+    end
+
+    def write_index(controllers, named)
+      entries = controllers.map do |controller, _routes|
+        {
+          namespace: controller_namespace_name(controller),
+          file: controller_filename(controller)
+        }
+      end.sort_by { |e| e[:namespace] }
+
+      sorted_named = named.sort_by { |n| n[:export_name] }
+      content = render_template("route_index.erb", entries: entries, named_routes: sorted_named)
+
+      write_file("index.#{config.file_ext}", content) do
+        content
+      end
+    end
+
+    RUNTIME_TEMPLATES = {
+      "ts" => File.read(File.join(__dir__, "templates/route_runtime.ts")),
+      "js" => File.read(File.join(__dir__, "templates/route_runtime.js"))
+    }.freeze
+
+    def write_runtime
+      content = RUNTIME_TEMPLATES.fetch(config.file_ext)
+
+      write_file("runtime.#{config.file_ext}", content) do
+        content
+      end
+    end
+
+    def write_file(filename, fingerprint)
+      output_file = File.join(config.output_dir, filename)
+      digest = render_template("fingerprint.erb", fingerprint: fingerprint)
+
+      existing_header = begin
+        File.read(output_file, digest.bytesize)
+      rescue
+        nil
+      end
+      return output_file if existing_header == digest
+
+      content = yield
+
+      FileUtils.mkdir_p(File.dirname(output_file))
+
+      File.write(output_file, digest + content)
+      output_file
+    end
+
+    def cleanup_stale_files(written_files)
+      existing_files = Dir[File.join(config.output_dir, "**/*.#{config.file_ext}")]
+      stale_files = existing_files - written_files
+
+      File.delete(*stale_files) unless stale_files.empty?
+    end
+
+    def render_template(template, **context)
+      template_cache[template] ||= Renderer.new(template)
+      template_cache[template].call(**context)
+    end
+
+    def build_named_routes(routes, controllers)
+      controller_namespaces = controllers.keys.map { |c| controller_namespace_name(c) }.to_set
+
+      routes.filter_map do |route|
+        next unless route[:named]
+        export_name = camelize_key(route[:name])
+        next if controller_namespaces.include?(export_name)
+
+        ctrl_routes = controllers[route[:controller]]
+        key = route_key(route, ctrl_routes)
+        controller_var = "_#{controller_namespace_name(route[:controller])}"
+
+        {
+          export_name: export_name,
+          key: key,
+          controller_file: controller_filename(route[:controller]),
+          controller_var: controller_var
+        }
+      end
+    end
+
+    def route_key(route, controller_routes)
+      collides = controller_routes.count { |r| r[:action] == route[:action] } > 1
+      camelize_key(collides ? route[:name] : route[:action])
+    end
+
+    def camelize_key(key)
+      config.camel_case ? key.camelize(:lower) : key
+    end
+
+    def controller_filename(controller)
+      @controller_filenames ||= {}
+      @controller_filenames[controller] ||= begin
+        parts = controller.split("/")
+        parts.map!(&:camelize)
+        parts[-1] = "#{parts[-1]}Controller"
+        parts.join("/")
+      end
+    end
+
+    def controller_namespace_name(controller)
+      name = controller.tr("/", "_")
+      camelize_key(name)
+    end
+  end
+end

data/lib/typelizer/serializer_plugins/alba/trait_interface.rb

@@ -29,6 +29,7 @@ module Typelizer
         @properties ||= begin
           props, typelizes = plugin.trait_properties(trait_name)
           props = infer_types(props, typelizes)
+          props = transform_properties(props)
           PropertySorter.sort(props, config.properties_sort_order)
         end
       end
@@ -37,7 +38,7 @@ module Typelizer
 
       def infer_types(props, typelizes)
         props.map do |prop|
-          dsl_type = typelizes[prop.column_name.to_sym] || typelizes[prop.name.to_sym]
+          dsl_type = prop.lookup_in(typelizes)
           prop
             .then { |p| dsl_type&.any? ? p.with(**dsl_type) : apply_model_inference(p) }
             .then { |p| apply_metadata(p) }

data/lib/typelizer/serializer_plugins/alba.rb

@@ -47,7 +47,6 @@ module Typelizer
         trait_block = traits[trait_name]
         return [], {} unless trait_block
 
-        # Create a collector to capture attributes defined in the trait block
         collector = BlockAttributeCollector.new
         collector.instance_exec(&trait_block)
 
@@ -76,16 +75,13 @@ module Typelizer
           )
         when BlockAttributeCollector::BlockNestedAttribute
           prop_name = has_transform_key?(serializer) ? fetch_key(serializer, name) : name
-          nested_props, nested_typelizes = collect_nested_block(attr.block)
           Property.new(
             name: prop_name,
-            type: nil,
+            type: Shape.new(properties: collect_nested_block(attr.block)),
             optional: false,
             nullable: false,
             multi: false,
-            column_name: name,
-            nested_properties: nested_props,
-            nested_typelizes: nested_typelizes
+            column_name: name
           )
         else
           build_property(name, attr)
@@ -179,16 +175,13 @@ module Typelizer
           )
         when ::Alba::NestedAttribute
           block = attr.instance_variable_get(:@block)
-          nested_props, nested_typelizes = collect_nested_block(block)
           Property.new(
             name: name,
-            type: nil,
+            type: Shape.new(properties: collect_nested_block(block)),
             optional: false,
             nullable: false,
             multi: false,
             column_name: column_name,
-            nested_properties: nested_props,
-            nested_typelizes: nested_typelizes,
             **options
           )
         when ::Alba::ConditionalAttribute
@@ -217,13 +210,14 @@ module Typelizer
       def collect_nested_block(block)
         collector = BlockAttributeCollector.new
         collector.instance_exec(&block)
+        typelizes = collector.collected_typelizes
 
-        props = collector.collected_attributes.map do |attr_name, attr|
+        collector.collected_attributes.map do |attr_name, attr|
           attr_name_str = attr_name.is_a?(Symbol) ? attr_name.name : attr_name
-          build_collected_property(attr_name_str, attr)
+          prop = build_collected_property(attr_name_str, attr)
+          override = prop.lookup_in(typelizes)
+          override&.any? ? prop.with(**override) : prop
         end
-
-        [props, collector.collected_typelizes]
       end
     end
   end

data/lib/typelizer/shape.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Typelizer
+  class Shape
+    attr_reader :properties
+
+    def initialize(properties:)
+      @properties = properties.freeze
+      @fingerprint = ["Shape", properties.map(&:fingerprint)].freeze
+      @hash = @fingerprint.hash
+      freeze
+    end
+
+    def map_properties
+      self.class.new(properties: properties.map { |p| yield p })
+    end
+
+    def render(sort_order: :none, prefer_double_quotes: false)
+      inner = properties.map { |p|
+        (p.render(sort_order: sort_order, prefer_double_quotes: prefer_double_quotes) + ";")
+          .gsub(/^/, "  ")
+      }.join("\n")
+      "{\n#{inner}\n}"
+    end
+
+    alias_method :to_s, :render
+
+    attr_reader :fingerprint, :hash
+
+    def ==(other)
+      other.is_a?(Shape) && fingerprint == other.fingerprint
+    end
+    alias_method :eql?, :==
+
+    def inspect
+      "<Typelizer::Shape properties=#{properties.inspect}>"
+    end
+  end
+end

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

@@ -1,3 +1,6 @@
 <%- enums.each do |property| -%>
 export <%= property.enum_definition(sort_order: sort_order, prefer_double_quotes: prefer_double_quotes) %>;
+<%- if enum_runtime -%>
+export <%= property.enum_runtime_definition(sort_order: sort_order, prefer_double_quotes: prefer_double_quotes) %>;
+<%- end -%>
 <%- end -%>

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

@@ -1,6 +1,7 @@
 <%- if enums.any? -%>
 <%- enums_path = prefer_double_quotes ? '"./Enums"' : "'./Enums'" -%>
-export type { <%= ImportSorter.sort(enums.map(&:enum_type_name), imports_sort_order).join(", ") %> } from <%= enums_path %>
+<%- enum_keyword = enum_runtime ? "export" : "export type" -%>
+<%= enum_keyword %> { <%= ImportSorter.sort(enums.map(&:enum_type_name), imports_sort_order).join(", ") %> } from <%= enums_path %>
 <%- end -%>
 <%- interfaces.each do |interface| -%>
 <%- sorted_traits = ImportSorter.sort(interface.trait_interfaces.map(&:name), interface.config.imports_sort_order) -%>

data/lib/typelizer/templates/route_controller.erb

@@ -0,0 +1,36 @@
+<%- if ts -%>
+import type { RouteDefinition, RouteOptions } from '<%= runtime_import %>'
+<%- end -%>
+import { buildUrl } from '<%= runtime_import %>'
+
+export default {
+<%- routes.each_with_index do |route, idx| -%>
+<%= "\n" if idx > 0 -%>
+<%- parts = route[:required_params].map { |p| "#{p}#{ts ? ": string | number" : ""}" } -%>
+<%- parts += route[:optional_params].map { |p| "#{p}#{ts ? "?: string | number" : ""}" } -%>
+<%- has_params = parts.any? -%>
+  /** <%= route[:verb].upcase %> <%= route[:path] %> */
+<%- if has_params -%>
+<%- if ts -%>
+  <%= route[:key] %>: (
+    params: { <%= parts.join('; ') %> }<%= " | string | number" if route[:single_required] %>,
+    options?: RouteOptions,
+  ): RouteDefinition<<%= "'#{route[:verb]}'" %>> => ({
+<%- else -%>
+  <%= route[:key] %>: (params, options) => ({
+<%- end -%>
+    url: buildUrl('<%= route[:path] %>', params, options),
+    method: '<%= route[:verb] %>',
+  }),
+<%- else -%>
+<%- if ts -%>
+  <%= route[:key] %>: (options?: RouteOptions): RouteDefinition<<%= "'#{route[:verb]}'" %>> => ({
+<%- else -%>
+  <%= route[:key] %>: (options) => ({
+<%- end -%>
+    url: buildUrl('<%= route[:path] %>', {}, options),
+    method: '<%= route[:verb] %>',
+  }),
+<%- end -%>
+<%- end -%>
+}

data/lib/typelizer/templates/route_index.erb

@@ -0,0 +1,14 @@
+<%- entries.each do |entry| -%>
+export { default as <%= entry[:namespace] %> } from './<%= entry[:file] %>'
+<%- end -%>
+<%- if named_routes.any? -%>
+<%- controllers = named_routes.group_by { |r| r[:controller_file] } -%>
+
+<%- controllers.each do |file, routes| -%>
+import <%= routes.first[:controller_var] %> from './<%= file %>'
+<%- end -%>
+
+<%- named_routes.each do |route| -%>
+export const <%= route[:export_name] %> = <%= route[:controller_var] %>.<%= route[:key] %>
+<%- end -%>
+<%- end -%>

data/lib/typelizer/templates/route_runtime.js

@@ -0,0 +1,97 @@
+let baseUrl = ''
+let urlDefaults = {}
+
+export function setBaseUrl(url) {
+  baseUrl = url.replace(/\/+$/, '')
+}
+
+export function setUrlDefaults(defaults) {
+  urlDefaults = defaults
+}
+
+export function addUrlDefault(key, value) {
+  const current = typeof urlDefaults === 'function' ? urlDefaults : { ...urlDefaults }
+  if (typeof current === 'function') {
+    const fn = current
+    urlDefaults = () => ({ ...fn(), [key]: value })
+  } else {
+    current[key] = value
+    urlDefaults = current
+  }
+}
+
+export function buildUrl(
+  template,
+  params,
+  options,
+) {
+  const defaults = typeof urlDefaults === 'function' ? urlDefaults() : urlDefaults
+  let p
+
+  if (typeof params === 'string' || typeof params === 'number') {
+    const key = template.match(/[:*](\w+)/)?.[1]
+    p = key ? { ...defaults, [key]: params } : { ...defaults }
+  } else {
+    p = { ...defaults, ...params }
+  }
+
+  // Optional segments: fill or remove
+  let url = template.replace(/\(\/:?(\w+)\)/g, (_, key) => {
+    const val = getParam(p, key)
+    if (val != null) return `/${encodeURIComponent(String(val))}`
+    return ''
+  })
+
+  // Glob params
+  url = url.replace(/\*(\w+)/g, (match, key) => {
+    const val = getParam(p, key)
+    if (val == null) return match
+    return Array.isArray(val) ? encodeURI(val.map(String).join('/')) : encodeURI(String(val))
+  })
+
+  // Required params
+  url = url.replace(/:(\w+)/g, (match, key) => {
+    const val = getParam(p, key)
+    if (val != null) return encodeURIComponent(String(val))
+    return match
+  })
+
+  // Query string
+  if (options?.query) {
+    const qs = buildQuery(options.query)
+    if (qs) url += `?${qs}`
+  }
+
+  // Anchor
+  if (options?.anchor) url += `#${options.anchor}`
+
+  return baseUrl + url
+}
+
+// Accepts both snake_case and camelCase param keys by looking up
+// the snake_case key from the URL template, then its camelCase equivalent.
+function getParam(params, key) {
+  if (key in params) return params[key]
+  return params[toCamelCase(key)]
+}
+
+function toCamelCase(key) {
+  return key.replace(/_([a-z])/g, (_, c) => c.toUpperCase())
+}
+
+function buildQuery(params, prefix) {
+  const parts = []
+  for (const [key, value] of Object.entries(params)) {
+    const k = prefix ? `${prefix}[${key}]` : key
+    if (value === null || value === undefined) continue
+    if (Array.isArray(value)) {
+      value.forEach(v => parts.push(`${k}[]=${encodeURIComponent(String(v))}`))
+    } else if (typeof value === 'object') {
+      const nested = buildQuery(value, k)
+      if (nested) parts.push(nested)
+    } else {
+      parts.push(`${k}=${encodeURIComponent(String(value))}`)
+    }
+  }
+  return parts.join('&')
+}