typelizer 0.11.0 → 0.13.0

data/lib/typelizer/templates/route_runtime.ts

@@ -0,0 +1,109 @@
+export type Method = 'get' | 'post' | 'put' | 'patch' | 'delete'
+
+export type RouteDefinition<M extends Method> = {
+  url: string
+  method: M
+}
+
+export type RouteOptions = {
+  query?: Record<string, unknown>
+  anchor?: string
+}
+
+let baseUrl = ''
+let urlDefaults: Record<string, unknown> | (() => Record<string, unknown>) = {}
+
+export function setBaseUrl(url: string): void {
+  baseUrl = url.replace(/\/+$/, '')
+}
+
+export function setUrlDefaults(defaults: Record<string, unknown> | (() => Record<string, unknown>)): void {
+  urlDefaults = defaults
+}
+
+export function addUrlDefault(key: string, value: unknown): void {
+  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: string,
+  params: Record<string, unknown> | string | number,
+  options?: RouteOptions,
+): string {
+  const defaults = typeof urlDefaults === 'function' ? urlDefaults() : urlDefaults
+  let p: Record<string, unknown>
+
+  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: Record<string, unknown>, key: string): unknown {
+  if (key in params) return params[key]
+  return params[toCamelCase(key)]
+}
+
+function toCamelCase(key: string): string {
+  return key.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase())
+}
+
+function buildQuery(params: Record<string, unknown>, prefix?: string): string {
+  const parts: string[] = []
+  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 as Record<string, unknown>, k)
+      if (nested) parts.push(nested)
+    } else {
+      parts.push(`${k}=${encodeURIComponent(String(value))}`)
+    }
+  }
+  return parts.join('&')
+}

data/lib/typelizer/type_inference.rb

@@ -15,19 +15,27 @@ module Typelizer
       end
     end
 
+    def transform_properties(props)
+      return props unless config.properties_transformer
+
+      props = config.properties_transformer.call(props)
+      props.map do |prop|
+        next prop unless prop.type.is_a?(Shape)
+
+        prop.with(type: Shape.new(properties: transform_properties(prop.type.properties)))
+      end
+    end
+
     def infer_nested_property_types(prop)
-      return prop unless prop.nested_properties&.any?
+      return prop unless prop.type.is_a?(Shape)
 
-      typelizes = prop.nested_typelizes || {}
-      inferred = prop.nested_properties.map do |sub_prop|
-        dsl_type = typelizes[sub_prop.column_name.to_sym] || typelizes[sub_prop.name.to_sym]
+      inferred = prop.type.map_properties do |sub_prop|
         sub_prop
-          .then { |p| dsl_type&.any? ? p.with(**dsl_type) : apply_model_inference(p) }
+          .then { |p| p.type ? p : apply_model_inference(p) }
           .then { |p| apply_metadata(p) }
           .then { |p| infer_nested_property_types(p) }
       end
-
-      prop.with(nested_properties: inferred)
+      prop.with(type: inferred)
     end
 
     def model_class

data/lib/typelizer/type_parser.rb

@@ -23,6 +23,7 @@ module Typelizer
 
       def parse(type_def, **options)
         return options if type_def.nil?
+        return parse_shape(type_def, **options) if type_def.is_a?(Hash)
         return parse_array(type_def, **options) if type_def.is_a?(Array)
 
         type_str = type_def.to_s
@@ -49,8 +50,35 @@ module Typelizer
         type_str.end_with?("?", "[]")
       end
 
+      # Strips a trailing `?` from an attribute key, returning [clean_name, optional?].
+      def parse_key(name)
+        str = name.to_s
+        str.end_with?("?") ? [str.chomp("?").to_sym, true] : [name.to_sym, false]
+      end
+
+      def apply_optional_key(parsed, optional_from_key)
+        parsed[:optional] = true if optional_from_key && !parsed.key?(:optional)
+        parsed
+      end
+
       private
 
+      def parse_shape(hash, **options)
+        properties = hash.map do |name, value|
+          clean_name, optional_from_key = parse_key(name)
+
+          # parse_declaration returns Hash args verbatim (options-bag form); nested
+          # shapes need parse to dispatch back here and build a Shape.
+          parsed = value.is_a?(Hash) ? parse(value) : parse_declaration(value)
+          apply_optional_key(parsed, optional_from_key)
+
+          property_attrs = parsed.slice(*Property.members).tap { |h| h[:name] = clean_name }
+          Property.new(optional: false, nullable: false, multi: false, **property_attrs)
+        end
+
+        {type: Shape.new(properties: properties)}.merge(options)
+      end
+
       def parse_array(type_defs, **options)
         raise ArgumentError, "Empty array passed to typelize" if type_defs.empty?
 

data/lib/typelizer/version.rb

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

data/lib/typelizer/writer.rb

@@ -60,9 +60,9 @@ module Typelizer
     end
 
     def write_enums(enums)
-      fingerprint = [enums.map(&:fingerprint), config.properties_sort_order, config.prefer_double_quotes].inspect
+      fingerprint = [enums.map(&:fingerprint), config.properties_sort_order, config.prefer_double_quotes, config.enum_runtime].inspect
       write_file("Enums.ts", fingerprint) do
-        render_template("enums.ts.erb", enums: enums, sort_order: config.properties_sort_order, prefer_double_quotes: config.prefer_double_quotes)
+        render_template("enums.ts.erb", enums: enums, sort_order: config.properties_sort_order, prefer_double_quotes: config.prefer_double_quotes, enum_runtime: config.enum_runtime)
       end
     end
 
@@ -74,7 +74,7 @@ module Typelizer
         }
       ].inspect
       write_file("index.ts", fingerprint) do
-        render_template("index.ts.erb", interfaces: interfaces, enums: enums, index_dir: config.output_dir.to_s, imports_sort_order: config.imports_sort_order, prefer_double_quotes: config.prefer_double_quotes)
+        render_template("index.ts.erb", interfaces: interfaces, enums: enums, index_dir: config.output_dir.to_s, imports_sort_order: config.imports_sort_order, prefer_double_quotes: config.prefer_double_quotes, enum_runtime: config.enum_runtime)
       end
     end
 
@@ -88,7 +88,7 @@ module Typelizer
     def write_file(filename, fingerprint, output_dir: config.output_dir)
       output_file = File.join(output_dir, filename)
       existing_content = File.exist?(output_file) ? File.read(output_file) : nil
-      digest = render_template("fingerprint.ts.erb", fingerprint: fingerprint)
+      digest = render_template("fingerprint.erb", fingerprint: fingerprint)
 
       return output_file if existing_content&.start_with?(digest)
 

data/lib/typelizer.rb

@@ -2,6 +2,7 @@
 
 require_relative "typelizer/version"
 require_relative "typelizer/union_type_sorter"
+require_relative "typelizer/shape"
 require_relative "typelizer/property"
 require_relative "typelizer/model_plugins/auto"
 require_relative "typelizer/serializer_plugins/auto"
@@ -18,6 +19,9 @@ require_relative "typelizer/renderer"
 require_relative "typelizer/writer"
 require_relative "typelizer/openapi"
 require_relative "typelizer/generator"
+require_relative "typelizer/route_config"
+require_relative "typelizer/route_generator"
+require_relative "typelizer/route_writer"
 require_relative "typelizer/type_parser"
 require_relative "typelizer/dsl"
 
@@ -44,10 +48,14 @@ module Typelizer
     # writers
     def_delegators :configuration, :dirs=, :reject_class=, :listen=
 
+    # Is Typelizer active?
+    #
+    # Precedence: TYPELIZER env var > development? detection
     def enabled?
-      return false if ENV["DISABLE_TYPELIZER"] == "true" || ENV["DISABLE_TYPELIZER"] == "1"
+      val = ENV["TYPELIZER"]
+      return val == "true" || val == "1" if val
 
-      ENV["RAILS_ENV"] == "development" || ENV["RACK_ENV"] == "development" || ENV["DISABLE_TYPELIZER"] == "false"
+      development?
     end
 
     attr_accessor :logger
@@ -84,6 +92,12 @@ module Typelizer
 
     private
 
+    def development?
+      return Rails.env.development? if defined?(Rails) && Rails.respond_to?(:env)
+
+      ENV["RAILS_ENV"] == "development" || ENV["RACK_ENV"] == "development"
+    end
+
     def load_serializers
       dirs.flat_map { |dir| Dir["#{dir}/**/*.rb"] }.each { |file| require file }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typelizer
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Svyatoslav Kryukov
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
   name: benchmark
   requirement: !ruby/object:Gem::Requirement
@@ -62,6 +62,7 @@ files:
 - lib/typelizer/import_sorter.rb
 - lib/typelizer/interface.rb
 - lib/typelizer/listen.rb
+- lib/typelizer/middleware.rb
 - lib/typelizer/model_plugins/active_record.rb
 - lib/typelizer/model_plugins/auto.rb
 - lib/typelizer/model_plugins/poro.rb
@@ -70,6 +71,9 @@ files:
 - lib/typelizer/property_sorter.rb
 - lib/typelizer/railtie.rb
 - lib/typelizer/renderer.rb
+- lib/typelizer/route_config.rb
+- lib/typelizer/route_generator.rb
+- lib/typelizer/route_writer.rb
 - lib/typelizer/serializer_config_layer.rb
 - lib/typelizer/serializer_plugins/alba.rb
 - lib/typelizer/serializer_plugins/alba/block_attribute_collector.rb
@@ -79,13 +83,18 @@ files:
 - lib/typelizer/serializer_plugins/base.rb
 - lib/typelizer/serializer_plugins/oj_serializers.rb
 - lib/typelizer/serializer_plugins/panko.rb
+- lib/typelizer/shape.rb
 - lib/typelizer/templates/comment.ts.erb
 - lib/typelizer/templates/enums.ts.erb
-- lib/typelizer/templates/fingerprint.ts.erb
+- lib/typelizer/templates/fingerprint.erb
 - lib/typelizer/templates/index.ts.erb
 - lib/typelizer/templates/inheritance.ts.erb
 - lib/typelizer/templates/inline_type.ts.erb
 - lib/typelizer/templates/interface.ts.erb
+- lib/typelizer/templates/route_controller.erb
+- lib/typelizer/templates/route_index.erb
+- lib/typelizer/templates/route_runtime.js
+- lib/typelizer/templates/route_runtime.ts
 - lib/typelizer/type_inference.rb
 - lib/typelizer/type_parser.rb
 - lib/typelizer/union_type_sorter.rb