zod_rails 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abcbdb41173e1bb789719ff85fbf595a619daf0cdb08ec260e0532601af9db96
-  data.tar.gz: 5649df9de3c18bd6d81347e12f23552d75420c8a5b5166d9d325797162ec0196
+  metadata.gz: 2d23bb8daf103c59a7cb41cd7eff8a7e2346ab19171228283ab990214e7aa1a6
+  data.tar.gz: 22b5712ffa475a57026411d6e9f2345e42a56999f3efc5f2e7ee8b63a3d39449
 SHA512:
-  metadata.gz: 281121330df0dbbb626d99103db9ad4a63c8691a850f0419fb58f3de42bb3fc6be44d1b404473ae46830b8ea66dabad1e195b0e980a6b68888f4f026a607d24e
-  data.tar.gz: dff40d3630dd26e743db6b48472c906fc416ad5a5bf7503340f6708eaf5105a6e13dd96dd6042a78437a232b01d6e2ff3ed6a4a85938f0cf3a609f2a200a5d17
+  metadata.gz: 18f8e43a66304819f9d0e14a50822c2c869a79da08c54772d2775f6393b590f55f156774f7404003ce2a169654138b83d4e136d4ce581be558100651136a03c6
+  data.tar.gz: 9ecd30fe73d9a791e9642be2895308becd45752c9d1e84435e9a82be7a882c8a6bd80b307e0629d7d96c4c2ef873907da064478d03f908febb50aa4d32884309

data/CHANGELOG.md

@@ -0,0 +1,55 @@
+# Changelog
+
+All notable changes to ZodRails are documented here.
+
+## Unreleased
+
+## 0.3.1 - 2026-08-03
+
+### Upgrade Notes
+
+- Regenerate committed schemas after upgrading if your models contain PostgreSQL arrays, adapter-reported `:bigint`
+  columns, or `time` columns. Their generated wire schemas now match Rails payload shapes more closely.
+
+### Fixed
+
+- Generate `z.array(...)` schemas for PostgreSQL array columns, with inclusion constraints on elements and
+  presence, length, default, and nullability constraints on the outer array.
+- Map adapter-reported `:bigint` columns to the JSON number shape emitted by Rails.
+- Validate Rails `time` payloads as ISO datetimes with timezone-offset support.
+
+### Changed
+
+- Run a generated-schema runtime contract against the pinned Zod version in CI.
+
+## 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

@@ -112,26 +112,31 @@ end
 | Rails/DB Type | Zod Type |
 |---------------|----------|
 | `string`, `text` | `z.string()` |
-| `integer` | `z.int()` |
+| `integer`, `bigint` | `z.int()` |
 | `float` | `z.number()` |
-| `bigint` | `z.string()` (avoids JS `Number` overflow) |
 | `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()` |
+| `time` | `z.iso.datetime({ offset: true })` |
 | `binary` | `z.string()` |
 | `enum` | `z.enum([...])` |
 
+PostgreSQL array columns wrap the element mapping with `z.array(...)`. Nullability and input optionality apply to the
+array itself, so a nullable `string[]` becomes `z.array(z.string()).nullable()`, while a non-null array with a database
+default becomes `z.array(z.string())` in the response schema and `z.array(z.string()).optional()` in the input schema.
+Rails inclusion validators on array attributes constrain each element, so `inclusion: { in: %w[a b] }` produces an
+element enum inside the array.
+
 ## Validation Mappings
 
 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)` |
@@ -139,8 +144,8 @@ 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/)` (preserves `/i` case-insensitivity) |
-| `inclusion: { in: n..m }` (Range) | `.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)]))` |
 
@@ -149,7 +154,7 @@ ZodRails introspects your model validations and maps them to Zod constraints:
 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.
+- `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.
 
@@ -175,20 +180,20 @@ 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()
@@ -266,6 +271,8 @@ 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:
@@ -340,6 +347,20 @@ 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. Rails emits integer and bigint attributes as JSON numbers, so
+ZodRails maps both to `z.int()`. Zod intentionally rejects integers outside JavaScript's safe integer range; serialize
+large identifiers as strings and provide an application-owned schema when values can exceed that range. Decimal values
+map to strings to preserve `BigDecimal` precision. Review generated schemas when using custom serializers,
+adapter-specific types, or custom ActiveRecord types.
+
+PostgreSQL permits null elements and multidimensional values without exposing either constraint through ordinary
+column metadata. ZodRails currently generates one-dimensional arrays with non-null elements. Use an application-owned
+schema when a column intentionally stores null elements or nested arrays.
+
 ### 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:
@@ -372,8 +393,13 @@ After checking out the repo:
 ```bash
 bundle install
 bundle exec rspec
+bun install --frozen-lockfile
+bun run test:contracts
 ```
 
+The Bun contract test generates a TypeScript schema and parses representative Rails payload values with the pinned Zod
+version. This complements the Ruby unit and golden tests by exercising the generated code at runtime.
+
 ## Contributing
 
 1. Fork it

data/lib/zod_rails/generation/file_writer.rb

@@ -23,8 +23,9 @@ module ZodRails
         File.write(full_path, final)
       end
 
-      def preview(filename:, content:) # rubocop:disable Lint/UnusedMethodArgument
-        content
+      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)

data/lib/zod_rails/generation/schema_builder.rb

@@ -5,12 +5,15 @@ module ZodRails
     class SchemaBuilder
       STRING_TYPES = %i[string text].freeze
       NULLABILITY_SUFFIX_RE = /(\.(?:nullable|nullish|optional)\(\))\z/
+      TYPESCRIPT_IDENTIFIER_RE = /\A[$A-Z_a-z][$\w]*\z/
 
-      attr_reader :inspector, :excluded_columns
+      attr_reader :inspector, :excluded_columns, :schema_suffix, :input_schema_suffix
 
-      def initialize(inspector, excluded_columns: [])
+      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)
@@ -23,32 +26,42 @@ module ZodRails
       end
 
       def schema_name(input_schema: false)
-        suffix = input_schema ? "InputSchema" : "Schema"
-        "#{inspector.model_name.gsub("::", "")}#{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)
-        elsif (values = string_array_inclusion_values(column))
-          build_inclusion_enum_type(column, values, 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 string_array_inclusion_values(column)
-        return nil unless STRING_TYPES.include?(column.type)
+      def string_array_inclusion(column, validations)
+        return nil if column.array || !STRING_TYPES.include?(column.type)
 
-        inclusion = inspector.validations_for(column.name).find { |v| string_array_inclusion?(v) }
-        inclusion&.options&.[](:in)
+        validations.find { |validation| string_array_inclusion?(validation) }
       end
 
       def string_array_inclusion?(validation)
@@ -58,35 +71,42 @@ module ZodRails
         values.is_a?(Array) && !values.empty? && values.all? { |x| x.is_a?(String) }
       end
 
-      def build_inclusion_enum_type(column, values, input_schema:)
+      def build_inclusion_enum_type(column, inclusion, validations, input_schema:)
+        remaining = validations.reject { |validation| validation.equal?(inclusion) }
         Mapping::EnumMapper.call(
-          values,
-          nullable: column.nullable,
+          inclusion.options[:in],
+          validation_chain: Mapping::ValidationMapper.call_all(remaining, base_type: :string, array: column.array),
+          nullable: nullable?(column, validations),
           input_schema: input_schema,
-          has_default: column.has_default
+          has_default: column.has_default,
+          array: column.array
         )
       end
 
-      def build_enum_type(column, input_schema:)
+      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, array: column.array),
+          nullable: nullable?(column, validations),
           input_schema: input_schema,
-          has_default: column.has_default
+          has_default: column.has_default,
+          array: column.array,
+          element_validation_chain: array_element_validation_chain(column, validations)
         )
       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
+          has_default: column.has_default,
+          array: column.array,
+          element_validation_chain: array_element_validation_chain(column, validations)
         )
 
-        validation_chain = Mapping::ValidationMapper.call_all(validations, base_type: column.type)
+        validation_chain = Mapping::ValidationMapper.call_all(validations, base_type: column.type, array: column.array)
         insert_validation_chain(base_type, validation_chain)
       end
 
@@ -104,6 +124,20 @@ 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 array_element_validation_chain(column, validations)
+        return "" unless column.array
+
+        element_validations = validations.select { |validation| validation.kind == :inclusion }
+        Mapping::ValidationMapper.call_all(element_validations, base_type: column.type)
+      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

@@ -18,27 +18,32 @@ module ZodRails
 
     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
       }
-
-      input_schema = {
-        name: builder.schema_name(input_schema: true),
-        body: builder.build(input_schema: true)
-      }
-
-      content = emitter.emit_combined(response: response_schema, input: input_schema)
-      filename = file_writer.output_path_for(inspector.model_name)
-
-      { filename: filename, content: content }
+      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)
-      files = model_classes.map { |klass| generate(klass) }
+      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
@@ -59,6 +64,25 @@ module ZodRails
 
     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
+
+      emitter.emit_combined(response: response, input: input)
+    end
+
     def run_post_generate_command
       cmd = ZodRails.configuration.post_generate_command
       return if cmd.nil? || cmd.to_s.strip.empty?

data/lib/zod_rails/introspection/column_info.rb

@@ -3,13 +3,14 @@
 module ZodRails
   module Introspection
     class ColumnInfo
-      attr_reader :name, :type, :nullable, :has_default
+      attr_reader :name, :type, :nullable, :has_default, :array
 
-      def initialize(name:, type:, nullable:, has_default:)
+      def initialize(name:, type:, nullable:, has_default:, array: false)
         @name = name
         @type = type
         @nullable = nullable
         @has_default = has_default
+        @array = array
         freeze
       end
 
@@ -18,7 +19,9 @@ 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?),
+          array: column.respond_to?(:array?) && column.array?
         )
       end
 
@@ -27,12 +30,13 @@ module ZodRails
           name == other.name &&
           type == other.type &&
           nullable == other.nullable &&
-          has_default == other.has_default
+          has_default == other.has_default &&
+          array == other.array
       end
       alias eql? ==
 
       def hash
-        [self.class, name, type, nullable, has_default].hash
+        [self.class, name, type, nullable, has_default, array].hash
       end
     end
   end

data/lib/zod_rails/mapping/enum_mapper.rb

@@ -3,17 +3,28 @@
 module ZodRails
   module Mapping
     class EnumMapper
-      def self.call(values, nullable: false, input_schema: false, has_default: false)
+      def self.call(values, nullable: false, input_schema: false, array: false, **options)
+        has_default = options.fetch(:has_default, false)
+        validation_chain = options.fetch(:validation_chain, "")
+        element_validation_chain = options.fetch(:element_validation_chain, "")
         names = values.is_a?(Hash) ? values.keys : values
-        quoted = names.map { |k| "\"#{escape_quotes(k)}\"" }
-        base = "z.enum([#{quoted.join(", ")}])"
+        quoted = names.map { |name| JSON.generate(name.to_s) }
+        enum = "z.enum([#{quoted.join(", ")}])"
+        base = if array
+                 array_schema(enum, element_validation_chain, validation_chain)
+               elsif validation_chain.empty?
+                 enum
+               else
+                 "z.string()#{validation_chain}.pipe(#{enum})"
+               end
 
         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('"', '\\"')
+      def self.array_schema(enum, element_validation_chain, array_validation_chain)
+        element = element_validation_chain.empty? ? enum : "z.string()#{element_validation_chain}.pipe(#{enum})"
+        "z.array(#{element})#{array_validation_chain}"
       end
 
       def self.determine_suffix(nullable:, input_schema:, has_default:)
@@ -26,7 +37,7 @@ module ZodRails
         end
       end
 
-      private_class_method :escape_quotes, :determine_suffix
+      private_class_method :array_schema, :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

@@ -7,24 +7,29 @@ module ZodRails
         string: "z.string()",
         text: "z.string()",
         integer: "z.int()",
-        bigint: "z.string()",
+        bigint: "z.int()",
         float: "z.number()",
         decimal: "z.string()",
         boolean: "z.boolean()",
         date: "z.iso.date()",
-        datetime: "z.iso.datetime()",
-        time: "z.string()",
+        datetime: "z.iso.datetime({ offset: true })",
+        timestamp: "z.iso.datetime({ offset: true })",
+        time: "z.iso.datetime({ offset: true })",
         json: "z.json()",
         jsonb: "z.json()",
         uuid: "z.uuid()",
         binary: "z.string()"
       }.freeze
 
-      def self.call(type, nullable: false, input_schema: false, has_default: false)
+      def self.call(type, nullable: false, input_schema: false, array: false, **options)
+        has_default = options.fetch(:has_default, false)
+        element_validation_chain = options.fetch(:element_validation_chain, "")
         base = TYPE_MAP.fetch(type.to_sym) do
           ZodRails.logger.warn("ZodRails: Unknown type '#{type}', falling back to z.unknown()")
           "z.unknown()"
         end
+        base = "#{base}#{element_validation_chain}"
+        base = "z.array(#{base})" if array
 
         suffix = determine_suffix(nullable: nullable, input_schema: input_schema, has_default: has_default)
         "#{base}#{suffix}"

data/lib/zod_rails/mapping/validation_mapper.rb

@@ -13,35 +13,37 @@ module ZodRails
       NUMERIC_ZOD_TYPES = %i[integer float].freeze
       STRING_ZOD_TYPES = %i[string text].freeze
 
-      def self.call(validation, base_type:)
-        return "" if validation.conditional?
+      def self.call(validation, base_type:, array: false)
+        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, base_type)
+        when :presence then map_presence(validation, base_type, array)
+        when :length then map_length(validation, base_type, array)
+        when :numericality then map_numericality(validation, base_type, array)
+        when :format then map_format(validation, base_type, array)
+        when :inclusion then map_inclusion(validation, base_type, array)
         else ""
         end
       end
 
-      def self.call_all(validations, base_type:)
+      def self.call_all(validations, base_type:, array: false)
         constraints = { min: nil, max: nil, length: nil, others: [] }
 
         validations.each do |v|
-          collect_constraints(v, base_type, constraints)
+          collect_constraints(v, base_type, constraints, array)
         end
 
         build_chain(constraints)
       end
 
-      def self.map_presence(_validation, base_type)
-        STRING_ZOD_TYPES.include?(base_type) ? ".min(1)" : ""
+      def self.map_presence(_validation, base_type, array)
+        return ".min(1)" if array
+
+        STRING_ZOD_TYPES.include?(base_type) ? ".min(1)#{presence_suffix}" : ""
       end
 
-      def self.map_length(validation, base_type)
-        return "" unless STRING_ZOD_TYPES.include?(base_type)
+      def self.map_length(validation, base_type, array)
+        return "" unless array || STRING_ZOD_TYPES.include?(base_type)
 
         parts = []
         opts = validation.options
@@ -56,26 +58,27 @@ module ZodRails
         parts.join
       end
 
-      def self.map_numericality(validation, base_type)
-        return "" unless NUMERIC_ZOD_TYPES.include?(base_type)
+      def self.map_numericality(validation, base_type, array)
+        return "" if array || !NUMERIC_ZOD_TYPES.include?(base_type)
 
         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
 
-      def self.map_format(validation, base_type)
-        return "" unless STRING_ZOD_TYPES.include?(base_type)
+      def self.map_format(validation, base_type, array)
+        return "" if array || !STRING_ZOD_TYPES.include?(base_type)
 
         regex = validation.options[:with]
         return "" unless regex
 
-        js_pattern = convert_ruby_regex_to_js(regex)
-        ".regex(/#{js_pattern}/#{regex_flags_for(regex)})"
+        RegexpMapper.call(regex)&.then { |expression| ".regex(#{expression})" } || ""
       end
 
-      def self.map_inclusion(validation, base_type)
+      def self.map_inclusion(validation, base_type, array)
+        return "" if array
+
         values = validation.options[:in] || validation.options[:within]
         return "" unless values.is_a?(Array)
 
@@ -101,51 +104,47 @@ module ZodRails
       end
 
       def self.build_string_enum_suffix(values)
-        quoted = values.map { |v| %("#{escape_quotes(v)}") }.join(", ")
+        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.escape_quotes(str)
-        str.to_s.gsub('"', '\\"')
-      end
-
-      def self.convert_ruby_regex_to_js(regex)
-        pattern = regex.source
-        pattern = pattern.gsub("\\A", "^")
-        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?
+      def self.collect_constraints(validation, base_type, constraints, array)
+        return if validation.conditional? || no_op_presence?(validation)
+        return collect_array_constraints(validation, base_type, constraints) if array
 
         case validation.kind
-        when :presence then handle_presence_constraint(base_type, constraints)
-        when :length then handle_length_constraint(validation, base_type, constraints)
+        when :presence then handle_presence_constraint(base_type, constraints, false)
+        when :length then handle_length_constraint(validation, base_type, constraints, false)
         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, 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)
+      def self.collect_array_constraints(validation, base_type, constraints)
+        case validation.kind
+        when :presence then handle_presence_constraint(base_type, constraints, true)
+        when :length then handle_length_constraint(validation, base_type, constraints, true)
+        end
       end
 
-      def self.handle_length_constraint(validation, base_type, constraints)
-        return unless STRING_ZOD_TYPES.include?(base_type)
+      def self.handle_presence_constraint(base_type, constraints, array)
+        return unless array || STRING_ZOD_TYPES.include?(base_type)
+
+        constraints[:min] = [constraints[:min] || 0, 1].max
+        constraints[:others] << presence_suffix unless array
+      end
+
+      def self.handle_length_constraint(validation, base_type, constraints, array)
+        return unless array || STRING_ZOD_TYPES.include?(base_type)
 
         opts = validation.options
         constraints[:length] = opts[:is] if opts[:is]
@@ -159,8 +158,8 @@ module ZodRails
         regex = validation.options[:with]
         return unless regex
 
-        js_pattern = convert_ruby_regex_to_js(regex)
-        constraints[:others] << ".regex(/#{js_pattern}/#{regex_flags_for(regex)})"
+        expression = RegexpMapper.call(regex)
+        constraints[:others] << ".regex(#{expression})" if expression
       end
 
       def self.build_chain(constraints)
@@ -169,7 +168,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
 
@@ -181,16 +180,15 @@ module ZodRails
         values = validation.options[:in] || validation.options[:within]
 
         case values
-        when Range then apply_range_inclusion(values, constraints)
+        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, constraints)
-        return unless range.begin.is_a?(Numeric) && range.end.is_a?(Numeric)
+      def self.apply_range_inclusion(range, base_type, constraints)
+        return unless NUMERIC_ZOD_TYPES.include?(base_type)
 
-        constraints[:min] = [constraints[:min] || 0, range.begin].max
-        constraints[:max] = [constraints[:max] || Float::INFINITY, range.end].min
+        apply_numeric_range(range, constraints)
       end
 
       def self.apply_array_inclusion(values, base_type, constraints)
@@ -204,27 +202,40 @@ module ZodRails
         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[:min] = [constraints[:min] || 0, range.begin].max
-        constraints[:max] = [constraints[:max] || Float::INFINITY, range.end].min
+        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
+
+      def self.no_op_presence?(validation) = validation.kind == :presence && validation.options[:allow_blank]
+
       private_class_method :map_presence, :map_length, :map_numericality, :map_format, :map_inclusion,
                            :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,
+                           :build_numeric_literal_suffix, :collect_constraints, :collect_array_constraints,
+                           :build_chain,
                            :handle_presence_constraint, :handle_length_constraint, :handle_format_constraint,
                            :handle_inclusion_constraint, :apply_range_inclusion, :apply_array_inclusion,
-                           :handle_numericality_constraint, :apply_numeric_range
+                           :handle_numericality_constraint, :apply_numeric_range, :presence_suffix, :static_number?,
+                           :no_op_presence?
     end
   end
 end

data/lib/zod_rails/model_resolver.rb

@@ -5,14 +5,38 @@ module ZodRails
     def self.resolve(names)
       resolved = []
       missing = []
+      invalid = []
 
       names.each do |name|
-        resolved << Object.const_get(name)
-      rescue NameError
+        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 }
+      { 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.2.0"
+  VERSION = "0.3.1"
 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"

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.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Matt Kelly
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-27 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,20 +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,93 +0,0 @@
-# frozen_string_literal: true
-
-namespace :zod_rails do
-  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)
-
-    if config.models.empty?
-      puts "No models configured. Add models to ZodRails.configure { |c| c.models = ['User', 'Article'] }"
-      exit 1
-    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}" }
-      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"
-  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)
-
-    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