zod_rails 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8657a14c01a80ca02ca7802858fa13095d3386b49e52a0a5f221f2d6efd8dc20
-  data.tar.gz: 5e51b264468b0267a00f4c32f64dd2a6bca0f054bea798b3c5b10e987ce63438
+  metadata.gz: abcbdb41173e1bb789719ff85fbf595a619daf0cdb08ec260e0532601af9db96
+  data.tar.gz: 5649df9de3c18bd6d81347e12f23552d75420c8a5b5166d9d325797162ec0196
 SHA512:
-  metadata.gz: f817791d90ab6eb88ba1ece45e8b00a815afffd7d55c3958e249dd6319ade7c400a621a47838191f3cd3f52c9c7ab4b4ebdfbb5b9544eab5738f715f9cbf6135
-  data.tar.gz: e058c4c1931f8947379f60baa0f37c1f0a10a17da4ea8db261ede5cdf2f3b6f3d7b5b4019ec35553e6a3fd60b56af1f9975032b4250aafd62ee7fd3b11c303fe
+  metadata.gz: 281121330df0dbbb626d99103db9ad4a63c8691a850f0419fb58f3de42bb3fc6be44d1b404473ae46830b8ea66dabad1e195b0e980a6b68888f4f026a607d24e
+  data.tar.gz: dff40d3630dd26e743db6b48472c906fc416ad5a5bf7503340f6708eaf5105a6e13dd96dd6042a78437a232b01d6e2ff3ed6a4a85938f0cf3a609f2a200a5d17

data/README.md

@@ -92,6 +92,7 @@ const formData = UserInputSchema.parse(formValues);
 | `input_schema_suffix` | `InputSchema` | Suffix for input schemas (e.g., `UserInputSchema`) |
 | `generate_input_schemas` | `true` | Whether to generate input schemas |
 | `excluded_columns` | `["id", "created_at", "updated_at"]` | Columns to exclude from input schemas |
+| `post_generate_command` | `nil` | Shell command to run after a successful generation (e.g., your formatter) |
 
 ### Full Configuration Example
 
@@ -120,6 +121,8 @@ end
 | `datetime`, `timestamp` | `z.iso.datetime()` |
 | `json`, `jsonb` | `z.json()` |
 | `uuid` | `z.uuid()` |
+| `time` | `z.string()` |
+| `binary` | `z.string()` |
 | `enum` | `z.enum([...])` |
 
 ## Validation Mappings
@@ -128,7 +131,7 @@ ZodRails introspects your model validations and maps them to Zod constraints:
 
 | Rails Validation | Zod Constraint |
 |------------------|----------------|
-| `presence: true` | `.min(1)` for strings |
+| `presence: true` | `.min(1)` for string/text columns |
 | `length: { minimum: n }` | `.min(n)` |
 | `length: { maximum: n }` | `.max(n)` |
 | `length: { is: n }` | `.length(n)` |
@@ -136,8 +139,19 @@ ZodRails introspects your model validations and maps them to Zod constraints:
 | `numericality: { greater_than_or_equal_to: n }` | `.gte(n)` |
 | `numericality: { less_than: n }` | `.lt(n)` |
 | `numericality: { less_than_or_equal_to: n }` | `.lte(n)` |
-| `format: { with: /regex/ }` | `.regex(/regex/)` |
-| `inclusion: { in: n..m }` | `.min(n).max(m)` |
+| `format: { with: /regex/ }` | `.regex(/regex/)` (preserves `/i` case-insensitivity) |
+| `inclusion: { in: n..m }` (Range) | `.min(n).max(m)` |
+| `inclusion: { in: %w[a b c] }` (Array, string column) | `z.enum(["a", "b", "c"])` as the base type |
+| `inclusion: { in: [1, 5, 10] }` (Array, integer column) | `.pipe(z.union([z.literal(1), z.literal(5), z.literal(10)]))` |
+
+### `inclusion` vs. Rails `enum`
+
+The Rails `enum` macro and a string column with `validates :foo, inclusion: { in: %w[...] }` both end up as `z.enum([...])` in the generated TypeScript:
+
+- `enum :role, { member: 0, admin: 1 }` introspects through ActiveRecord's `defined_enums` and emits `z.enum(["member", "admin"])`.
+- `validates :decision, inclusion: { in: %w[pending approved] }` on a string column is detected by `SchemaBuilder` and produces `z.enum(["pending", "approved"])` as the base type. `presence: true` becomes redundant once the values are restricted, so it's dropped from the chain.
+
+If you mix both (`enum` macro AND a separate `inclusion` validator on the same column), the `enum` macro wins.
 
 ## Generated Output Example
 
@@ -150,6 +164,7 @@ class User < ApplicationRecord
   validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
   validates :name, presence: true, length: { minimum: 2, maximum: 100 }
   validates :age, numericality: { greater_than: 0, less_than: 150 }, allow_nil: true
+  validates :status, inclusion: { in: %w[pending active suspended] }
 end
 ```
 
@@ -160,9 +175,10 @@ import { z } from "zod";
 
 export const UserSchema = z.object({
   id: z.int(),
-  email: z.string().min(1).regex(/\A[^@\s]+@[^@\s]+\z/),
+  email: z.string().min(1).regex(/^[^@\s]+@[^@\s]+$/),
   name: z.string().min(2).max(100),
   age: z.int().gt(0).lt(150).nullable(),
+  status: z.enum(["pending", "active", "suspended"]),
   role: z.enum(["member", "admin", "moderator"]),
   created_at: z.iso.datetime(),
   updated_at: z.iso.datetime()
@@ -171,9 +187,10 @@ export const UserSchema = z.object({
 export type User = z.infer<typeof UserSchema>;
 
 export const UserInputSchema = z.object({
-  email: z.string().min(1).regex(/\A[^@\s]+@[^@\s]+\z/),
+  email: z.string().min(1).regex(/^[^@\s]+@[^@\s]+$/),
   name: z.string().min(2).max(100),
   age: z.int().gt(0).lt(150).nullish(),
+  status: z.enum(["pending", "active", "suspended"]),
   role: z.enum(["member", "admin", "moderator"]).optional()
 });
 
@@ -193,7 +210,61 @@ ZodRails generates two schema variants:
 - Represents data for form submission
 - Excludes configured columns (defaults: `id`, `created_at`, `updated_at`)
 - Uses `.optional()` for columns with database defaults
-- Uses `.nullish()` for nullable columns without defaults
+- Uses `.nullish()` for nullable columns (accepts both `null` and `undefined`)
+
+## Preserving Hand-Written Code
+
+The generator overwrites files in `output_dir` on every run. If you want to keep hand-written schemas, types, or imports next to the generated ones, wrap them in sentinel comments — the writer will preserve anything between the markers verbatim across regens.
+
+Two block markers are recognized per file:
+
+```typescript
+import { z } from "zod";
+
+// ZOD_RAILS:CUSTOM:IMPORTS:BEGIN
+import { customValidator } from "./shared";
+// ZOD_RAILS:CUSTOM:IMPORTS:END
+
+export const ArticleSchema = z.object({ /* generated */ });
+
+export type Article = z.infer<typeof ArticleSchema>;
+
+// ZOD_RAILS:CUSTOM:BEGIN
+export const ArticleResponseSchema = z.object({
+  article: ArticleSchema,
+  meta: z.object({ count: z.int() }),
+});
+// ZOD_RAILS:CUSTOM:END
+```
+
+- **Imports block** lives right after the `import { z } from "zod";` line. Use it for any external imports your custom code needs.
+- **Tail block** lives at the end of the file. Use it for additional schemas, response wrappers, helper types, etc.
+
+Both blocks are optional. If you don't add them, the file is overwritten as before. Hand-edits *outside* the markers will still be lost on regen — wrap them, or move them to a separate file.
+
+## Drift Detection in CI
+
+`bin/rails zod_rails:check` regenerates schemas in memory and compares them against the files on disk. Exits 0 if everything is up to date, 1 with a list of out-of-date files otherwise. Wire it into your CI to catch the case where someone updated a model but forgot to regenerate:
+
+```yaml
+- name: Check Zod schemas are up to date
+  run: bin/rails zod_rails:check
+```
+
+For local iteration, `DRY_RUN=1 bin/rails zod_rails:generate` prints the same drift list without writing anything.
+
+## Formatter Integration
+
+If your TypeScript project runs prettier, biome, or a similar formatter with conventions that differ from the gem's output (single quotes, trailing commas, line width…), set `post_generate_command` and the gem will hand off to your formatter after a successful generation:
+
+```ruby
+ZodRails.configure do |config|
+  config.post_generate_command =
+    "bun run prettier --write 'app/javascript/schemas/**/*.ts'"
+end
+```
+
+The command runs with your project's working directory. A nonzero exit raises `ZodRails::Error` so CI catches misconfiguration, and the generated files are still written before the formatter runs.
 
 ## Integrating with Forms
 
@@ -233,10 +304,17 @@ async function fetchUser(id: number): Promise<User> {
 
 ## CI/CD Integration
 
-Add schema generation to your build process to catch type mismatches early:
+Use `zod_rails:check` to catch missed regenerations:
 
 ```yaml
 # .github/workflows/ci.yml
+- name: Check Zod schemas are up to date
+  run: bin/rails zod_rails:check
+```
+
+This works whether or not the generated schemas are committed to the same repo. If they are committed, the older `git diff --exit-code` approach also works:
+
+```yaml
 - name: Generate Zod schemas
   run: bin/rails zod_rails:generate
 
@@ -262,6 +340,22 @@ Ensure validations are defined on the model class, not in concerns that might no
 
 For custom types not in the mapping table, ZodRails falls back to `z.unknown()`. Open an issue if you need support for additional types.
 
+### Misconfigured model names
+
+A typo in `config.models` no longer raises an `uninitialized constant` backtrace. The generator collects every unresolvable name and prints them all in one report:
+
+```
+ZodRails: 2 model(s) in config.models could not be loaded:
+  - Useer
+  - Postt
+
+Check the model names in config/initializers/zod_rails.rb.
+```
+
+### Namespaced models
+
+A model like `Admin::User` writes to `admin/user.ts` and exports `AdminUserSchema` / `AdminUser` (the namespace separator is collapsed for the TypeScript identifier — `::` is not valid in a TS identifier).
+
 ## Releasing
 
 1. Bump the version in `lib/zod_rails/version.rb`

data/lib/tasks/zod_rails.rake

@@ -1,21 +1,73 @@
 # frozen_string_literal: true
 
 namespace :zod_rails do
-  desc "Generate Zod schemas for configured models"
+  desc "Generate Zod schemas for configured models (DRY_RUN=1 to preview only)"
   task generate: :environment do
     config = ZodRails.configuration
     generator = ZodRails::Generator.new(output_dir: config.output_dir)
 
-    models = config.models.map(&:constantize)
-
-    if models.empty?
+    if config.models.empty?
       puts "No models configured. Add models to ZodRails.configure { |c| c.models = ['User', 'Article'] }"
       exit 1
     end
 
-    generated = generator.generate_all(models)
-    puts "Generated #{generated.size} schema file(s):"
-    generated.each { |f| puts "  - #{f}" }
+    resolution = ZodRails::ModelResolver.resolve(config.models)
+
+    unless resolution[:missing].empty?
+      puts "ZodRails: #{resolution[:missing].size} model(s) in config.models could not be loaded:"
+      resolution[:missing].each { |m| puts "  - #{m}" }
+      puts ""
+      puts "Check the model names in config/initializers/zod_rails.rb."
+      exit 1
+    end
+
+    models = resolution[:resolved]
+
+    if ENV["DRY_RUN"] == "1"
+      drift = generator.check(models)
+      if drift.empty?
+        puts "ZodRails (dry run): no changes."
+      else
+        puts "ZodRails (dry run): would update #{drift.size} file(s):"
+        drift.each { |d| puts "  - #{d[:filename]} (#{d[:status]})" }
+      end
+    else
+      generated = generator.generate_all(models)
+      puts "Generated #{generated.size} schema file(s):"
+      generated.each { |f| puts "  - #{f}" }
+    end
+  end
+
+  desc "Check whether generated schemas match the current models (exits nonzero on drift)"
+  task check: :environment do
+    config = ZodRails.configuration
+    generator = ZodRails::Generator.new(output_dir: config.output_dir)
+
+    if config.models.empty?
+      puts "No models configured. Nothing to check."
+      exit 0
+    end
+
+    resolution = ZodRails::ModelResolver.resolve(config.models)
+
+    unless resolution[:missing].empty?
+      puts "ZodRails: #{resolution[:missing].size} model(s) in config.models could not be loaded:"
+      resolution[:missing].each { |m| puts "  - #{m}" }
+      exit 1
+    end
+
+    drift = generator.check(resolution[:resolved])
+
+    if drift.empty?
+      puts "ZodRails: generated schemas are up to date."
+      exit 0
+    end
+
+    puts "ZodRails: #{drift.size} file(s) out of date:"
+    drift.each { |d| puts "  - #{d[:filename]} (#{d[:status]})" }
+    puts ""
+    puts "Run `bin/rails zod_rails:generate` to update."
+    exit 1
   end
 
   desc "Generate Zod schema for a specific model"
@@ -29,8 +81,13 @@ namespace :zod_rails do
     config = ZodRails.configuration
     generator = ZodRails::Generator.new(output_dir: config.output_dir)
 
-    model_class = model_name.constantize
-    filename = generator.generate(model_class)
+    resolution = ZodRails::ModelResolver.resolve([model_name])
+    if resolution[:missing].any?
+      puts "ZodRails: model '#{model_name}' could not be loaded. Check the spelling."
+      exit 1
+    end
+
+    filename = generator.generate(resolution[:resolved].first)
     puts "Generated: #{filename}"
   end
 end

data/lib/zod_rails/configuration.rb

@@ -3,7 +3,8 @@
 module ZodRails
   class Configuration
     attr_accessor :output_dir, :schema_suffix, :input_schema_suffix,
-                  :generate_input_schemas, :excluded_columns, :models
+                  :generate_input_schemas, :excluded_columns, :models,
+                  :post_generate_command
 
     def initialize
       @output_dir = "app/javascript/schemas"
@@ -12,6 +13,7 @@ module ZodRails
       @generate_input_schemas = true
       @excluded_columns = %w[id created_at updated_at]
       @models = []
+      @post_generate_command = nil
     end
   end
 end

data/lib/zod_rails/generation/file_writer.rb

@@ -5,6 +5,10 @@ require "fileutils"
 module ZodRails
   module Generation
     class FileWriter
+      IMPORTS_BLOCK_RE = %r{^// ZOD_RAILS:CUSTOM:IMPORTS:BEGIN\n.*?^// ZOD_RAILS:CUSTOM:IMPORTS:END\n}m
+      TAIL_BLOCK_RE = %r{^// ZOD_RAILS:CUSTOM:BEGIN\n.*?^// ZOD_RAILS:CUSTOM:END\n}m
+      ZOD_IMPORT_RE = /^(import \{ z \} from "zod";\n)/
+
       attr_reader :output_dir
 
       def initialize(output_dir:)
@@ -14,7 +18,13 @@ module ZodRails
       def write(filename:, content:)
         full_path = File.join(output_dir, filename)
         FileUtils.mkdir_p(File.dirname(full_path))
-        File.write(full_path, content)
+
+        final = File.exist?(full_path) ? splice_custom_blocks(content, File.read(full_path)) : content
+        File.write(full_path, final)
+      end
+
+      def preview(filename:, content:) # rubocop:disable Lint/UnusedMethodArgument
+        content
       end
 
       def output_path_for(model_name)
@@ -27,6 +37,24 @@ module ZodRails
 
       private
 
+      def splice_custom_blocks(new_content, existing)
+        imports = existing[IMPORTS_BLOCK_RE]
+        tail = existing[TAIL_BLOCK_RE]
+
+        result = new_content
+        result = insert_imports_block(result, imports) if imports
+        result = append_tail_block(result, tail) if tail
+        result
+      end
+
+      def insert_imports_block(content, imports_block)
+        content.sub(ZOD_IMPORT_RE, "\\1\n#{imports_block}")
+      end
+
+      def append_tail_block(content, tail_block)
+        "#{content.rstrip}\n\n#{tail_block}"
+      end
+
       def underscore(str)
         str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
            .gsub(/([a-z\d])([A-Z])/, '\1_\2')

data/lib/zod_rails/generation/schema_builder.rb

@@ -3,6 +3,9 @@
 module ZodRails
   module Generation
     class SchemaBuilder
+      STRING_TYPES = %i[string text].freeze
+      NULLABILITY_SUFFIX_RE = /(\.(?:nullable|nullish|optional)\(\))\z/
+
       attr_reader :inspector, :excluded_columns
 
       def initialize(inspector, excluded_columns: [])
@@ -21,7 +24,7 @@ module ZodRails
 
       def schema_name(input_schema: false)
         suffix = input_schema ? "InputSchema" : "Schema"
-        "#{inspector.model_name}#{suffix}"
+        "#{inspector.model_name.gsub("::", "")}#{suffix}"
       end
 
       private
@@ -34,11 +37,36 @@ module ZodRails
       def build_type_string(column, input_schema:)
         if enum_column?(column.name)
           build_enum_type(column, input_schema: input_schema)
+        elsif (values = string_array_inclusion_values(column))
+          build_inclusion_enum_type(column, values, input_schema: input_schema)
         else
           build_regular_type(column, input_schema: input_schema)
         end
       end
 
+      def string_array_inclusion_values(column)
+        return nil unless STRING_TYPES.include?(column.type)
+
+        inclusion = inspector.validations_for(column.name).find { |v| string_array_inclusion?(v) }
+        inclusion&.options&.[](:in)
+      end
+
+      def string_array_inclusion?(validation)
+        return false unless validation.kind == :inclusion && !validation.conditional?
+
+        values = validation.options[:in]
+        values.is_a?(Array) && !values.empty? && values.all? { |x| x.is_a?(String) }
+      end
+
+      def build_inclusion_enum_type(column, values, input_schema:)
+        Mapping::EnumMapper.call(
+          values,
+          nullable: column.nullable,
+          input_schema: input_schema,
+          has_default: column.has_default
+        )
+      end
+
       def build_enum_type(column, input_schema:)
         values = inspector.enums[column.name]
         Mapping::EnumMapper.call(
@@ -65,13 +93,8 @@ module ZodRails
       def insert_validation_chain(base_type, validation_chain)
         return base_type if validation_chain.empty?
 
-        if base_type.include?(".nullable()") || base_type.include?(".nullish()") || base_type.include?(".optional()")
-          suffix_match = base_type.match(/(\.(nullable|nullish|optional)\(\))$/)
-          if suffix_match
-            base_type.sub(suffix_match[0], "#{validation_chain}#{suffix_match[0]}")
-          else
-            "#{base_type}#{validation_chain}"
-          end
+        if (match = base_type.match(NULLABILITY_SUFFIX_RE))
+          base_type.sub(NULLABILITY_SUFFIX_RE, "#{validation_chain}#{match[0]}")
         else
           "#{base_type}#{validation_chain}"
         end

data/lib/zod_rails/generator.rb

@@ -11,6 +11,12 @@ module ZodRails
     end
 
     def generate(model_class)
+      result = generate_content(model_class)
+      file_writer.write(filename: result[:filename], content: result[:content])
+      result[:filename]
+    end
+
+    def generate_content(model_class)
       inspector = Introspection::ModelInspector.new(model_class)
       excluded = ZodRails.configuration.excluded_columns
       builder = Generation::SchemaBuilder.new(inspector, excluded_columns: excluded)
@@ -28,12 +34,41 @@ module ZodRails
       content = emitter.emit_combined(response: response_schema, input: input_schema)
       filename = file_writer.output_path_for(inspector.model_name)
 
-      file_writer.write(filename: filename, content: content)
-      filename
+      { filename: filename, content: content }
     end
 
     def generate_all(model_classes)
-      model_classes.map { |klass| generate(klass) }
+      files = model_classes.map { |klass| generate(klass) }
+      run_post_generate_command
+      files
+    end
+
+    def check(model_classes)
+      model_classes.each_with_object([]) do |klass, drift|
+        target = generate_content(klass)
+        full_path = File.join(output_dir, target[:filename])
+        expected = file_writer.preview(filename: target[:filename], content: target[:content])
+
+        if !File.exist?(full_path)
+          drift << { filename: target[:filename], status: :missing }
+        elsif File.read(full_path) != expected
+          drift << { filename: target[:filename], status: :drifted }
+        end
+      end
+    end
+
+    private
+
+    def run_post_generate_command
+      cmd = ZodRails.configuration.post_generate_command
+      return if cmd.nil? || cmd.to_s.strip.empty?
+
+      ok = system(cmd)
+      return if ok
+
+      exit_status = Process.last_status&.exitstatus
+      raise ZodRails::Error,
+            "post_generate_command failed (exit #{exit_status}): #{cmd}"
     end
   end
 end

data/lib/zod_rails/mapping/enum_mapper.rb

@@ -4,8 +4,9 @@ module ZodRails
   module Mapping
     class EnumMapper
       def self.call(values, nullable: false, input_schema: false, has_default: false)
-        keys = values.keys.map { |k| "\"#{escape_quotes(k)}\"" }
-        base = "z.enum([#{keys.join(", ")}])"
+        names = values.is_a?(Hash) ? values.keys : values
+        quoted = names.map { |k| "\"#{escape_quotes(k)}\"" }
+        base = "z.enum([#{quoted.join(", ")}])"
 
         suffix = determine_suffix(nullable: nullable, input_schema: input_schema, has_default: has_default)
         "#{base}#{suffix}"

data/lib/zod_rails/mapping/validation_mapper.rb

@@ -21,7 +21,7 @@ module ZodRails
         when :length then map_length(validation, base_type)
         when :numericality then map_numericality(validation, base_type)
         when :format then map_format(validation, base_type)
-        when :inclusion then map_inclusion(validation)
+        when :inclusion then map_inclusion(validation, base_type)
         else ""
         end
       end
@@ -72,14 +72,48 @@ module ZodRails
         return "" unless regex
 
         js_pattern = convert_ruby_regex_to_js(regex)
-        ".regex(/#{js_pattern}/)"
+        ".regex(/#{js_pattern}/#{regex_flags_for(regex)})"
       end
 
-      def self.map_inclusion(validation)
+      def self.map_inclusion(validation, base_type)
         values = validation.options[:in] || validation.options[:within]
         return "" unless values.is_a?(Array)
 
-        ""
+        build_array_inclusion_suffix(values, base_type) || ""
+      end
+
+      def self.build_array_inclusion_suffix(values, base_type)
+        return nil if values.empty?
+
+        if string_array_for_string_type?(values, base_type)
+          build_string_enum_suffix(values)
+        elsif numeric_array_for_numeric_type?(values, base_type)
+          build_numeric_literal_suffix(values)
+        end
+      end
+
+      def self.string_array_for_string_type?(values, base_type)
+        STRING_ZOD_TYPES.include?(base_type) && values.all? { |v| v.is_a?(String) }
+      end
+
+      def self.numeric_array_for_numeric_type?(values, base_type)
+        NUMERIC_ZOD_TYPES.include?(base_type) && values.all? { |v| v.is_a?(Numeric) }
+      end
+
+      def self.build_string_enum_suffix(values)
+        quoted = values.map { |v| %("#{escape_quotes(v)}") }.join(", ")
+        ".pipe(z.enum([#{quoted}]))"
+      end
+
+      def self.build_numeric_literal_suffix(values)
+        return ".pipe(z.literal(#{values.first}))" if values.length == 1
+
+        literals = values.map { |v| "z.literal(#{v})" }.join(", ")
+        ".pipe(z.union([#{literals}]))"
+      end
+
+      def self.escape_quotes(str)
+        str.to_s.gsub('"', '\\"')
       end
 
       def self.convert_ruby_regex_to_js(regex)
@@ -88,6 +122,12 @@ module ZodRails
         pattern.gsub(/\\z/i, "$")
       end
 
+      def self.regex_flags_for(regex)
+        flags = +""
+        flags << "i" if regex.options.anybits?(Regexp::IGNORECASE)
+        flags
+      end
+
       def self.collect_constraints(validation, base_type, constraints)
         return if validation.conditional?
 
@@ -96,7 +136,7 @@ module ZodRails
         when :length then handle_length_constraint(validation, base_type, constraints)
         when :numericality then handle_numericality_constraint(validation, base_type, constraints)
         when :format then handle_format_constraint(validation, base_type, constraints)
-        when :inclusion then handle_inclusion_constraint(validation, constraints)
+        when :inclusion then handle_inclusion_constraint(validation, base_type, constraints)
         end
       end
 
@@ -120,7 +160,7 @@ module ZodRails
         return unless regex
 
         js_pattern = convert_ruby_regex_to_js(regex)
-        constraints[:others] << ".regex(/#{js_pattern}/)"
+        constraints[:others] << ".regex(/#{js_pattern}/#{regex_flags_for(regex)})"
       end
 
       def self.build_chain(constraints)
@@ -137,19 +177,27 @@ module ZodRails
         parts.join
       end
 
-      def self.handle_inclusion_constraint(validation, constraints)
+      def self.handle_inclusion_constraint(validation, base_type, constraints)
         values = validation.options[:in] || validation.options[:within]
-        return unless values
 
         case values
-        when Range
-          if values.begin.is_a?(Numeric) && values.end.is_a?(Numeric)
-            constraints[:min] = [constraints[:min] || 0, values.begin].max
-            constraints[:max] = [constraints[:max] || Float::INFINITY, values.end].min
-          end
+        when Range then apply_range_inclusion(values, constraints)
+        when Array then apply_array_inclusion(values, base_type, constraints)
         end
       end
 
+      def self.apply_range_inclusion(range, constraints)
+        return unless range.begin.is_a?(Numeric) && range.end.is_a?(Numeric)
+
+        constraints[:min] = [constraints[:min] || 0, range.begin].max
+        constraints[:max] = [constraints[:max] || Float::INFINITY, range.end].min
+      end
+
+      def self.apply_array_inclusion(values, base_type, constraints)
+        suffix = build_array_inclusion_suffix(values, base_type)
+        constraints[:others] << suffix if suffix
+      end
+
       def self.handle_numericality_constraint(validation, base_type, constraints)
         return unless NUMERIC_ZOD_TYPES.include?(base_type)
 
@@ -170,9 +218,13 @@ module ZodRails
       end
 
       private_class_method :map_presence, :map_length, :map_numericality, :map_format, :map_inclusion,
-                           :convert_ruby_regex_to_js, :collect_constraints, :build_chain,
+                           :build_array_inclusion_suffix, :string_array_for_string_type?,
+                           :numeric_array_for_numeric_type?, :build_string_enum_suffix,
+                           :build_numeric_literal_suffix, :escape_quotes,
+                           :convert_ruby_regex_to_js, :regex_flags_for, :collect_constraints, :build_chain,
                            :handle_presence_constraint, :handle_length_constraint, :handle_format_constraint,
-                           :handle_inclusion_constraint, :handle_numericality_constraint, :apply_numeric_range
+                           :handle_inclusion_constraint, :apply_range_inclusion, :apply_array_inclusion,
+                           :handle_numericality_constraint, :apply_numeric_range
     end
   end
 end

data/lib/zod_rails/model_resolver.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module ModelResolver
+    def self.resolve(names)
+      resolved = []
+      missing = []
+
+      names.each do |name|
+        resolved << Object.const_get(name)
+      rescue NameError
+        missing << name
+      end
+
+      { resolved: resolved, missing: missing }
+    end
+  end
+end

data/lib/zod_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ZodRails
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

data/lib/zod_rails.rb

@@ -12,6 +12,7 @@ require_relative "zod_rails/introspection/model_inspector"
 require_relative "zod_rails/generation/schema_builder"
 require_relative "zod_rails/generation/typescript_emitter"
 require_relative "zod_rails/generation/file_writer"
+require_relative "zod_rails/model_resolver"
 require_relative "zod_rails/generator"
 require_relative "zod_rails/railtie" if defined?(Rails::Railtie)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zod_rails
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Matt Kelly
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-17 00:00:00.000000000 Z
+date: 2026-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -50,6 +50,7 @@ files:
 - lib/zod_rails/mapping/enum_mapper.rb
 - lib/zod_rails/mapping/type_mapper.rb
 - lib/zod_rails/mapping/validation_mapper.rb
+- lib/zod_rails/model_resolver.rb
 - lib/zod_rails/railtie.rb
 - lib/zod_rails/version.rb
 - sig/zod_rails.rbs