zod_rails 0.1.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3bbdef55113e82c23ae843f93fb14074b05799036856202bc615028373993c1
-  data.tar.gz: b638454c118e1f666b971769492f5787bf4e7d20bc736dbac106b77d80689bc2
+  metadata.gz: f8e1e956f2954b2200c39a4b467529911806337883bd2674b31b7a271ef560a8
+  data.tar.gz: 681139d70905f6c34ee190f629f437e015a2eb1313a76940d42b0eaf6a8ffabe
 SHA512:
-  metadata.gz: 16e639e56112401f8ffbab59263642fd0c244f5a08be5ed17b8d68eb185e7f6294d849596378eef24123f65ef4b2a79bb2e9dd71e1970154ad616288b334b8b3
-  data.tar.gz: 11adc59ed2fbab1da351ab6981ce9de6ff3830c8491e40ebe8ccc31eb5d0f9fd93ef148da41a803d8767f0be6d4f72412c640c755c4793ec4ee161a10b6fcbb5
+  metadata.gz: 30a4ce819ee99ac5bcdd83e482c16cd2029136af74e6e64c04a03960c8640991cef144eab6562eb431a0205c655c857687e78f023ffe66aaa9d8c53a953a7b1e
+  data.tar.gz: 7744055379a755592beadb1010992deeba5ef0fac4d0ea5719bd67d98191264d9671d0a4ee6806e2c62a7e97e0a69997d0bd8f80eca7ed6002c52d59ae7c236c

data/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+All notable changes to ZodRails are documented here.
+
+## Unreleased
+
+## 0.3.0 - 2026-08-03
+
+### Upgrade Notes
+
+- Regenerate committed schemas after upgrading. Presence, range, regular-expression, and datetime output has changed
+  to more closely match Rails behavior.
+- `schema_suffix`, `input_schema_suffix`, and `generate_input_schemas` now take effect. Applications that configured
+  these previously ignored options will see the configured output for the first time.
+- Configured model names must resolve to concrete ActiveRecord models; nonmodels and abstract models now produce a
+  targeted configuration error.
+
+### Fixed
+
+- Honor custom schema suffixes and `generate_input_schemas`.
+- Generate safe TypeScript for unusual column names, enum values, and regular expressions.
+- Preserve negative, zero, exclusive, beginless, and endless numeric range bounds.
+- Match Rails presence semantics for whitespace-only strings and required nullable columns.
+- Accept ISO datetimes with timezone offsets and detect database expression defaults.
+- Keep preserved custom blocks from causing false drift reports.
+- Detect output filename collisions before writing files.
+
+### Changed
+
+- Declare ActiveRecord and Railties as runtime dependencies.
+- Reject configured constants that are not concrete ActiveRecord models.
+- Skip dynamic numericality constraints and Ruby extended-mode regular expressions instead of emitting invalid TypeScript.
+
+## 0.2.0
+
+- Added response and input schema generation, enums, validation mapping, namespaced models, drift detection,
+  custom block preservation, dry runs, and formatter integration.

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
 
@@ -117,7 +118,7 @@ end
 | `decimal` | `z.string()` (preserves `BigDecimal` precision) |
 | `boolean` | `z.boolean()` |
 | `date` | `z.iso.date()` |
-| `datetime`, `timestamp` | `z.iso.datetime()` |
+| `datetime`, `timestamp` | `z.iso.datetime({ offset: true })` |
 | `json`, `jsonb` | `z.json()` |
 | `uuid` | `z.uuid()` |
 | `time` | `z.string()` |
@@ -130,7 +131,7 @@ ZodRails introspects your model validations and maps them to Zod constraints:
 
 | Rails Validation | Zod Constraint |
 |------------------|----------------|
-| `presence: true` | `.min(1)` for string/text columns |
+| `presence: true` | `.min(1).refine(...)` for string/text columns, including whitespace-only rejection |
 | `length: { minimum: n }` | `.min(n)` |
 | `length: { maximum: n }` | `.max(n)` |
 | `length: { is: n }` | `.length(n)` |
@@ -138,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(new RegExp(...))` with safe escaping and compatible flags |
+| `inclusion: { in: n..m }` (Range) | `.gte(n).lte(m)`; exclusive and open-ended bounds are preserved |
+| `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 restricts the result with `z.enum(["pending", "approved"])`. Other compatible validators on the attribute are retained before the enum restriction.
+
+If you mix both (`enum` macro AND a separate `inclusion` validator on the same column), the `enum` macro wins.
 
 ## Generated Output Example
 
@@ -152,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
 ```
 
@@ -162,20 +175,22 @@ import { z } from "zod";
 
 export const UserSchema = z.object({
   id: z.int(),
-  email: z.string().min(1).regex(/^[^@\s]+@[^@\s]+$/),
-  name: z.string().min(2).max(100),
+  email: z.string().min(1).refine((value) => value.trim().length > 0).regex(new RegExp("^[^@\\s]+@[^@\\s]+$")),
+  name: z.string().min(2).max(100).refine((value) => value.trim().length > 0),
   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()
+  created_at: z.iso.datetime({ offset: true }),
+  updated_at: z.iso.datetime({ offset: true })
 });
 
 export type User = z.infer<typeof UserSchema>;
 
 export const UserInputSchema = z.object({
-  email: z.string().min(1).regex(/^[^@\s]+@[^@\s]+$/),
-  name: z.string().min(2).max(100),
+  email: z.string().min(1).refine((value) => value.trim().length > 0).regex(new RegExp("^[^@\\s]+@[^@\\s]+$")),
+  name: z.string().min(2).max(100).refine((value) => value.trim().length > 0),
   age: z.int().gt(0).lt(150).nullish(),
+  status: z.enum(["pending", "active", "suspended"]),
   role: z.enum(["member", "admin", "moderator"]).optional()
 });
 
@@ -197,6 +212,62 @@ ZodRails generates two schema variants:
 - Uses `.optional()` for columns with database 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.
+
+Because `zod_rails:check` compares generated bytes, a formatter that rewrites those bytes can report drift. Prefer a formatter configuration that accepts the generated style, or run the same deterministic formatter before checking committed files.
+
 ## Integrating with Forms
 
 ZodRails pairs well with form libraries that support Zod:
@@ -235,10 +306,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
 
@@ -264,6 +342,28 @@ 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.
 
+### Serialization and validation limits
+
+ZodRails generates a useful static approximation of database columns and unconditional model validations. It cannot reproduce validations that require database access, another attribute, or runtime model state. Conditional and context-specific validations, dynamic numericality values, uniqueness, and unsupported Ruby regular-expression modes are skipped.
+
+The generated wire types must match your serializers. In particular, `bigint` and `decimal` map to strings to avoid JavaScript precision loss; configure your API serializer to emit strings for those attributes. Review generated schemas when using adapter-specific or custom ActiveRecord 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/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,14 @@ 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:)
+        full_path = File.join(output_dir, filename)
+        File.exist?(full_path) ? splice_custom_blocks(content, File.read(full_path)) : content
       end
 
       def output_path_for(model_name)
@@ -27,6 +38,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,11 +3,17 @@
 module ZodRails
   module Generation
     class SchemaBuilder
-      attr_reader :inspector, :excluded_columns
+      STRING_TYPES = %i[string text].freeze
+      NULLABILITY_SUFFIX_RE = /(\.(?:nullable|nullish|optional)\(\))\z/
+      TYPESCRIPT_IDENTIFIER_RE = /\A[$A-Z_a-z][$\w]*\z/
 
-      def initialize(inspector, excluded_columns: [])
+      attr_reader :inspector, :excluded_columns, :schema_suffix, :input_schema_suffix
+
+      def initialize(inspector, excluded_columns: [], schema_suffix: "Schema", input_schema_suffix: "InputSchema")
         @inspector = inspector
         @excluded_columns = excluded_columns.map(&:to_s)
+        @schema_suffix = schema_suffix
+        @input_schema_suffix = input_schema_suffix
       end
 
       def build(input_schema: false)
@@ -20,40 +26,77 @@ module ZodRails
       end
 
       def schema_name(input_schema: false)
-        suffix = input_schema ? "InputSchema" : "Schema"
-        "#{inspector.model_name}#{suffix}"
+        suffix = input_schema ? input_schema_suffix : schema_suffix
+        name = "#{inspector.model_name.gsub("::", "")}#{suffix}"
+        return name if name.match?(TYPESCRIPT_IDENTIFIER_RE)
+
+        raise ZodRails::Error, "Invalid TypeScript schema name: #{name.inspect}"
+      end
+
+      def type_name(input_schema: false)
+        name = inspector.model_name.gsub("::", "")
+        input_schema ? "#{name}Input" : name
       end
 
       private
 
       def field_definition(column, input_schema:)
         type_str = build_type_string(column, input_schema: input_schema)
-        "#{column.name}: #{type_str}"
+        key = column.name.match?(TYPESCRIPT_IDENTIFIER_RE) ? column.name : JSON.generate(column.name)
+        "#{key}: #{type_str}"
       end
 
       def build_type_string(column, input_schema:)
+        validations = inspector.validations_for(column.name)
+
         if enum_column?(column.name)
-          build_enum_type(column, input_schema: input_schema)
+          build_enum_type(column, validations, input_schema: input_schema)
+        elsif (inclusion = string_array_inclusion(column, validations))
+          build_inclusion_enum_type(column, inclusion, validations, input_schema: input_schema)
         else
-          build_regular_type(column, input_schema: input_schema)
+          build_regular_type(column, validations, input_schema: input_schema)
         end
       end
 
-      def build_enum_type(column, input_schema:)
+      def string_array_inclusion(column, validations)
+        return nil unless STRING_TYPES.include?(column.type)
+
+        validations.find { |validation| string_array_inclusion?(validation) }
+      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, inclusion, validations, input_schema:)
+        remaining = validations.reject { |validation| validation.equal?(inclusion) }
+        Mapping::EnumMapper.call(
+          inclusion.options[:in],
+          validation_chain: Mapping::ValidationMapper.call_all(remaining, base_type: :string),
+          nullable: nullable?(column, validations),
+          input_schema: input_schema,
+          has_default: column.has_default
+        )
+      end
+
+      def build_enum_type(column, validations, input_schema:)
         values = inspector.enums[column.name]
         Mapping::EnumMapper.call(
           values,
-          nullable: column.nullable,
+          validation_chain: Mapping::ValidationMapper.call_all(validations, base_type: :string),
+          nullable: nullable?(column, validations),
           input_schema: input_schema,
           has_default: column.has_default
         )
       end
 
-      def build_regular_type(column, input_schema:)
-        validations = inspector.validations_for(column.name)
+      def build_regular_type(column, validations, input_schema:)
         base_type = Mapping::TypeMapper.call(
           column.type,
-          nullable: column.nullable,
+          nullable: nullable?(column, validations),
           input_schema: input_schema,
           has_default: column.has_default
         )
@@ -65,13 +108,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
@@ -81,6 +119,13 @@ module ZodRails
         inspector.enums.key?(column_name)
       end
 
+      def nullable?(column, validations)
+        column.nullable && validations.none? do |validation|
+          validation.kind == :presence && !validation.conditional? &&
+            !validation.options[:allow_nil] && !validation.options[:allow_blank]
+        end
+      end
+
       def filtered_columns
         inspector.columns.reject { |col| excluded_columns.include?(col.name) }
       end

data/lib/zod_rails/generation/typescript_emitter.rb

@@ -3,8 +3,8 @@
 module ZodRails
   module Generation
     class TypescriptEmitter
-      def emit(schema_name:, schema_body:)
-        type_name = derive_type_name(schema_name)
+      def emit(schema_name:, schema_body:, type_name: nil)
+        type_name ||= derive_type_name(schema_name)
 
         <<~TYPESCRIPT
           import { z } from "zod";
@@ -16,8 +16,8 @@ module ZodRails
       end
 
       def emit_combined(response:, input:)
-        response_type = derive_type_name(response[:name])
-        input_type = derive_type_name(input[:name])
+        response_type = response[:type_name] || derive_type_name(response[:name])
+        input_type = input[:type_name] || derive_type_name(input[:name])
 
         <<~TYPESCRIPT
           import { z } from "zod";
@@ -35,7 +35,7 @@ module ZodRails
       private
 
       def derive_type_name(schema_name)
-        schema_name.sub(/Schema$/, "").sub(/InputSchema$/, "Input")
+        schema_name.sub(/InputSchema$/, "Input").sub(/Schema$/, "")
       end
     end
   end

data/lib/zod_rails/generator.rb

@@ -11,29 +11,88 @@ 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)
+      config = ZodRails.configuration
+      builder = Generation::SchemaBuilder.new(
+        inspector,
+        excluded_columns: config.excluded_columns,
+        schema_suffix: config.schema_suffix,
+        input_schema_suffix: config.input_schema_suffix
+      )
 
       response_schema = {
         name: builder.schema_name,
+        type_name: builder.type_name,
         body: builder.build
       }
+      content = emit_content(builder, response_schema, generate_input: config.generate_input_schemas)
+      { filename: file_writer.output_path_for(inspector.model_name), content: content }
+    end
+
+    def generate_all(model_classes)
+      targets = model_classes.map { |klass| generate_content(klass) }
+      duplicate = targets.group_by { |target| target[:filename] }.find { |_filename, matches| matches.size > 1 }
+      raise ZodRails::Error, "Output filename collision: #{duplicate.first}" if duplicate
+
+      files = targets.map do |target|
+        file_writer.write(filename: target[:filename], content: target[:content])
+        target[:filename]
+      end
+      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])
 
-      input_schema = {
+        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 emit_content(builder, response, generate_input:)
+      unless generate_input
+        return emitter.emit(
+          schema_name: response[:name], schema_body: response[:body], type_name: response[:type_name]
+        )
+      end
+
+      input = {
         name: builder.schema_name(input_schema: true),
+        type_name: builder.type_name(input_schema: true),
         body: builder.build(input_schema: true)
       }
+      if input[:name] == response[:name]
+        raise ZodRails::Error, "Response and input schemas have the same export name: #{input[:name]}"
+      end
 
-      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
+      emitter.emit_combined(response: response, input: input)
     end
 
-    def generate_all(model_classes)
-      model_classes.map { |klass| generate(klass) }
+    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/introspection/column_info.rb

@@ -18,7 +18,8 @@ module ZodRails
           name: column.name,
           type: column.type,
           nullable: column.null,
-          has_default: !column.default.nil?
+          has_default: !column.default.nil? ||
+            (column.respond_to?(:default_function) && !column.default_function.nil?)
         )
       end
 

data/lib/zod_rails/mapping/enum_mapper.rb

@@ -3,18 +3,16 @@
 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(", ")}])"
+      def self.call(values, nullable: false, input_schema: false, has_default: false, validation_chain: "")
+        names = values.is_a?(Hash) ? values.keys : values
+        quoted = names.map { |name| JSON.generate(name.to_s) }
+        enum = "z.enum([#{quoted.join(", ")}])"
+        base = validation_chain.empty? ? enum : "z.string()#{validation_chain}.pipe(#{enum})"
 
         suffix = determine_suffix(nullable: nullable, input_schema: input_schema, has_default: has_default)
         "#{base}#{suffix}"
       end
 
-      def self.escape_quotes(str)
-        str.to_s.gsub('"', '\\"')
-      end
-
       def self.determine_suffix(nullable:, input_schema:, has_default:)
         return "" unless nullable || has_default
 
@@ -25,7 +23,7 @@ module ZodRails
         end
       end
 
-      private_class_method :escape_quotes, :determine_suffix
+      private_class_method :determine_suffix
     end
   end
 end

data/lib/zod_rails/mapping/regexp_mapper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module Mapping
+    class RegexpMapper
+      UNSUPPORTED_TOKENS = %w[\\K \\R (?> (?~].freeze
+
+      def self.call(regex)
+        if unsupported?(regex)
+          ZodRails.logger.warn("ZodRails: Skipping regexp with Ruby-only semantics: #{regex.inspect}")
+          return nil
+        end
+
+        pattern = regex.source
+                       .gsub("\\A", "^")
+                       .gsub("\\z", "(?![\\s\\S])")
+                       .gsub("\\Z", "(?=(?:\\n)?(?![\\s\\S]))")
+        flags = flags_for(regex)
+        args = [JSON.generate(pattern), (JSON.generate(flags) unless flags.empty?)].compact
+        "new RegExp(#{args.join(", ")})"
+      end
+
+      def self.flags_for(regex)
+        flags = +""
+        flags << "i" if regex.options.anybits?(Regexp::IGNORECASE)
+        flags << "s" if regex.options.anybits?(Regexp::MULTILINE)
+        flags
+      end
+
+      def self.unsupported?(regex)
+        regex.options.anybits?(Regexp::EXTENDED) || UNSUPPORTED_TOKENS.any? { |token| regex.source.include?(token) }
+      end
+      private_class_method :flags_for, :unsupported?
+    end
+  end
+end

data/lib/zod_rails/mapping/type_mapper.rb

@@ -12,7 +12,8 @@ module ZodRails
         decimal: "z.string()",
         boolean: "z.boolean()",
         date: "z.iso.date()",
-        datetime: "z.iso.datetime()",
+        datetime: "z.iso.datetime({ offset: true })",
+        timestamp: "z.iso.datetime({ offset: true })",
         time: "z.string()",
         json: "z.json()",
         jsonb: "z.json()",

data/lib/zod_rails/mapping/validation_mapper.rb

@@ -14,14 +14,14 @@ module ZodRails
       STRING_ZOD_TYPES = %i[string text].freeze
 
       def self.call(validation, base_type:)
-        return "" if validation.conditional?
+        return "" if validation.conditional? || no_op_presence?(validation)
 
         case validation.kind
         when :presence then map_presence(validation, base_type)
         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
@@ -37,7 +37,7 @@ module ZodRails
       end
 
       def self.map_presence(_validation, base_type)
-        STRING_ZOD_TYPES.include?(base_type) ? ".min(1)" : ""
+        STRING_ZOD_TYPES.include?(base_type) ? ".min(1)#{presence_suffix}" : ""
       end
 
       def self.map_length(validation, base_type)
@@ -61,7 +61,7 @@ module ZodRails
 
         validation.options.filter_map do |key, value|
           method = NUMERICALITY_MAP[key]
-          ".#{method}(#{value})" if method
+          ".#{method}(#{value})" if method && static_number?(value)
         end.join
       end
 
@@ -71,37 +71,64 @@ module ZodRails
         regex = validation.options[:with]
         return "" unless regex
 
-        js_pattern = convert_ruby_regex_to_js(regex)
-        ".regex(/#{js_pattern}/)"
+        RegexpMapper.call(regex)&.then { |expression| ".regex(#{expression})" } || ""
       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.convert_ruby_regex_to_js(regex)
-        pattern = regex.source
-        pattern = pattern.gsub("\\A", "^")
-        pattern.gsub(/\\z/i, "$")
+      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 { |value| JSON.generate(value) }.join(", ")
+        ".pipe(z.enum([#{quoted}]))"
+      end
+
+      def self.build_numeric_literal_suffix(values)
+        return nil unless values.all? { |value| static_number?(value) }
+        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.collect_constraints(validation, base_type, constraints)
-        return if validation.conditional?
+        return if validation.conditional? || no_op_presence?(validation)
 
         case validation.kind
         when :presence then handle_presence_constraint(base_type, constraints)
         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
 
       def self.handle_presence_constraint(base_type, constraints)
-        constraints[:min] = [constraints[:min] || 0, 1].max if STRING_ZOD_TYPES.include?(base_type)
+        return unless STRING_ZOD_TYPES.include?(base_type)
+
+        constraints[:min] = [constraints[:min] || 0, 1].max
+        constraints[:others] << presence_suffix
       end
 
       def self.handle_length_constraint(validation, base_type, constraints)
@@ -119,8 +146,8 @@ module ZodRails
         regex = validation.options[:with]
         return unless regex
 
-        js_pattern = convert_ruby_regex_to_js(regex)
-        constraints[:others] << ".regex(/#{js_pattern}/)"
+        expression = RegexpMapper.call(regex)
+        constraints[:others] << ".regex(#{expression})" if expression
       end
 
       def self.build_chain(constraints)
@@ -129,7 +156,7 @@ module ZodRails
         if constraints[:length]
           parts << ".length(#{constraints[:length]})"
         else
-          parts << ".min(#{constraints[:min]})" if constraints[:min]&.positive?
+          parts << ".min(#{constraints[:min]})" unless constraints[:min].nil?
           parts << ".max(#{constraints[:max].to_i})" if constraints[:max] && constraints[:max] != Float::INFINITY
         end
 
@@ -137,42 +164,67 @@ 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, base_type, constraints)
+        when Array then apply_array_inclusion(values, base_type, constraints)
         end
       end
 
+      def self.apply_range_inclusion(range, base_type, constraints)
+        return unless NUMERIC_ZOD_TYPES.include?(base_type)
+
+        apply_numeric_range(range, constraints)
+      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)
 
         validation.options.each do |key, value|
           if key == :in
             apply_numeric_range(value, constraints)
-          elsif (method = NUMERICALITY_MAP[key])
+          elsif (method = NUMERICALITY_MAP[key]) && static_number?(value)
             constraints[:others] << ".#{method}(#{value})"
           end
         end
       end
 
       def self.apply_numeric_range(range, constraints)
-        return unless range.is_a?(Range) && range.begin.is_a?(Numeric) && range.end.is_a?(Numeric)
+        return unless range.is_a?(Range)
+
+        constraints[:others] << ".gte(#{range.begin})" if static_number?(range.begin)
+        return unless static_number?(range.end)
+
+        constraints[:others] << ".#{range.exclude_end? ? "lt" : "lte"}(#{range.end})"
+      end
+
+      def self.presence_suffix
+        '.refine((value) => value.trim().length > 0, { message: "can\'t be blank" })'
+      end
+
+      def self.static_number?(value)
+        value.is_a?(Numeric) && (!value.respond_to?(:finite?) || value.finite?)
+      end
 
-        constraints[:min] = [constraints[:min] || 0, range.begin].max
-        constraints[:max] = [constraints[:max] || Float::INFINITY, range.end].min
+      def self.no_op_presence?(validation)
+        validation.kind == :presence && validation.options[:allow_blank]
       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, :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, :presence_suffix, :static_number?,
+                           :no_op_presence?
     end
   end
 end

data/lib/zod_rails/model_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ZodRails
+  module ModelResolver
+    def self.resolve(names)
+      resolved = []
+      missing = []
+      invalid = []
+
+      names.each do |name|
+        model = resolve_constant(name)
+        if active_record_model?(model)
+          resolved << model
+        else
+          invalid << name
+        end
+      rescue NameError => e
+        raise unless missing_constant?(e, name)
+
+        missing << name
+      end
+
+      { resolved: resolved, missing: missing, invalid: invalid }
+    end
+
+    def self.resolve_constant(name)
+      name.split("::").reject(&:empty?).reduce(Object) do |namespace, constant_name|
+        namespace.const_get(constant_name, false)
+      end
+    end
+
+    def self.active_record_model?(constant)
+      constant.is_a?(Class) && constant < ActiveRecord::Base && !constant.abstract_class?
+    end
+
+    def self.missing_constant?(error, requested_name)
+      requested_name.split("::").include?(error.name.to_s)
+    end
+
+    private_class_method :resolve_constant, :active_record_model?, :missing_constant?
+  end
+end

data/lib/zod_rails/version.rb

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

data/lib/zod_rails.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 require "logger"
+require "json"
+require "active_record"
 require_relative "zod_rails/version"
 require_relative "zod_rails/configuration"
 require_relative "zod_rails/mapping/type_mapper"
+require_relative "zod_rails/mapping/regexp_mapper"
 require_relative "zod_rails/mapping/validation_mapper"
 require_relative "zod_rails/mapping/enum_mapper"
 require_relative "zod_rails/introspection/column_info"
@@ -12,6 +15,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)
 

data/sig/zod_rails.rbs

@@ -1,4 +1,38 @@
 module ZodRails
   VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+
+  class Error < StandardError
+  end
+
+  def self.logger: () -> Logger
+  def self.logger=: (Logger) -> Logger
+  def self.configuration: () -> Configuration
+  def self.configure: [A] () { (Configuration) -> A } -> A
+  def self.reset_configuration!: () -> Configuration
+
+  class Configuration
+    attr_accessor output_dir: String
+    attr_accessor schema_suffix: String
+    attr_accessor input_schema_suffix: String
+    attr_accessor generate_input_schemas: bool
+    attr_accessor excluded_columns: Array[String]
+    attr_accessor models: Array[String]
+    attr_accessor post_generate_command: String?
+
+    def initialize: () -> void
+  end
+
+  class Generator
+    attr_reader output_dir: String
+
+    def initialize: (output_dir: String) -> void
+    def generate: (singleton(ActiveRecord::Base)) -> String
+    def generate_content: (singleton(ActiveRecord::Base)) -> Hash[Symbol, String]
+    def generate_all: (Array[singleton(ActiveRecord::Base)]) -> Array[String]
+    def check: (Array[singleton(ActiveRecord::Base)]) -> Array[Hash[Symbol, String | Symbol]]
+  end
+
+  module ModelResolver
+    def self.resolve: (Array[String]) -> Hash[Symbol, Array[untyped]]
+  end
 end

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: zod_rails
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Matt Kelly
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-17 00:00:00.000000000 Z
+date: 2026-08-03 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +44,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 description: Ruby gem that introspects ActiveRecord models and generates TypeScript
   files with Zod schemas for type-safe frontend validation
 email:
@@ -32,12 +72,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/ci.yml"
-- ".github/workflows/release.yml"
+- CHANGELOG.md
 - LICENSE
 - README.md
-- Rakefile
-- lib/tasks/zod_rails.rake
 - lib/zod_rails.rb
 - lib/zod_rails/configuration.rb
 - lib/zod_rails/generation/file_writer.rb
@@ -48,19 +85,20 @@ files:
 - lib/zod_rails/introspection/model_inspector.rb
 - lib/zod_rails/introspection/validation_info.rb
 - lib/zod_rails/mapping/enum_mapper.rb
+- lib/zod_rails/mapping/regexp_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
-- zod_rails.png
 homepage: https://github.com/mathisto/zod_rails
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/mathisto/zod_rails
   source_code_uri: https://github.com/mathisto/zod_rails
-  changelog_uri: https://github.com/mathisto/zod_rails/blob/main/CHANGELOG.md
+  changelog_uri: https://github.com/mathisto/zod_rails/blob/trunk/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []

data/.github/workflows/ci.yml

@@ -1,32 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [trunk]
-  pull_request:
-    branches: [trunk]
-  workflow_call:
-
-jobs:
-  test:
-    name: Ruby ${{ matrix.ruby-version }}
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby-version: ['3.2', '3.3', '3.4']
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Ruby ${{ matrix.ruby-version }}
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby-version }}
-          bundler-cache: true
-
-      - name: Run tests
-        run: bundle exec rspec --format documentation
-
-      - name: Run linter
-        run: bundle exec rubocop --parallel

data/.github/workflows/release.yml

@@ -1,33 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - "v*"
-
-jobs:
-  test:
-    uses: ./.github/workflows/ci.yml
-
-  release:
-    needs: test
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: write
-      id-token: write
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: "3.3"
-          bundler-cache: true
-
-      - name: Build gem
-        run: gem build *.gemspec
-
-      - name: Publish to RubyGems
-        uses: rubygems/release-gem@v1

data/Rakefile

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
-task default: %i[spec rubocop]

data/lib/tasks/zod_rails.rake

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-namespace :zod_rails do
-  desc "Generate Zod schemas for configured models"
-  task generate: :environment do
-    config = ZodRails.configuration
-    generator = ZodRails::Generator.new(output_dir: config.output_dir)
-
-    models = config.models.map(&:constantize)
-
-    if 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}" }
-  end
-
-  desc "Generate Zod schema for a specific model"
-  task :generate_model, [:model_name] => :environment do |_t, args|
-    model_name = args[:model_name]
-    unless model_name
-      puts "Usage: rails zod_rails:generate_model[ModelName]"
-      exit 1
-    end
-
-    config = ZodRails.configuration
-    generator = ZodRails::Generator.new(output_dir: config.output_dir)
-
-    model_class = model_name.constantize
-    filename = generator.generate(model_class)
-    puts "Generated: #{filename}"
-  end
-end