rbs_activerecord 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b56f18a5772a23292e3ae455e90f9e6d4deff43a1f1d89b0df9f80d67489218a
-  data.tar.gz: 698af6fa420f68d4068effe5aa65fb474656b89afa18118c0dc76d70f83d937f
+  metadata.gz: 78a25f0014350c5542d7b2ed8eeb226c736c8f3416432261413e26f84b7d5877
+  data.tar.gz: 92684a1a6ac24afc2bcf1fe160ab6bf391f0ada8bd75ae337360c01d36891114
 SHA512:
-  metadata.gz: 0e50032631a3a6f95d34de4decb79d49d673409f3d1196c670c364307ecf1f2506d05edc1fe3ee321fc80e1f643853d0d895276b75bec4545808f1788f1019da
-  data.tar.gz: 23152212c926367241ad8e29b38ebe2b8861b8b046df7b1dff3314b49e5a84bacc1aaa70529094e8b7767e4e61d178e829dbe5b14b93ed7f7656d209eea229cd
+  metadata.gz: 680a2e88d185d9a7c26d124ed5b6f0240233f4199006f4eb85e1639b25abb2925fa6ac6dd623c4d25f7777eea947a137357c05e274f3d8ac02c88ee9a01e2acc
+  data.tar.gz: db219887c854a4f412e0d5c1ba7713dc2425c45d985e9bb9fd5872424d51a84c17d8b843db400273fe7c47baa35e690fc2fe8ca2d45bfce2cdfeaf3e0aaf13b7

data/.claude/hooks/claude-code-web-session-start.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+set -eu
+
+if [ "${CLAUDE_CODE_REMOTE:-}" = "true" ]; then
+  eval "$(rbenv init - bash)"
+
+  # Set the latest installed Ruby version as the global default
+  rbenv global `rbenv versions --bare | sort -rV | head -1`
+
+  echo 'eval "$(rbenv init - bash)"' >> "$CLAUDE_ENV_FILE"
+  echo 'export RUBYOPT="-rcgi"' >> "$CLAUDE_ENV_FILE"
+  RUBYOPT="-rcgi" bundle install
+  bundle exec rbs collection install --frozen
+fi

data/.claude/hooks/pre-commit-check.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+
+# Hook input is JSON from stdin
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.tool_name')
+command=$(echo "$input" | jq -r '.tool_input.command // ""')
+
+# Only run for git commit commands
+if [[ "$tool_name" != "Bash" ]] || [[ ! "$command" =~ git[[:space:]]+(commit|cherry-pick|merge|rebase) ]]; then
+    exit 0
+fi
+
+cd "$CLAUDE_PROJECT_DIR" || exit 1
+
+if [ "${CLAUDE_CODE_REMOTE:-}" = "true" ]; then
+  eval "$(rbenv init - bash)"
+fi
+
+echo "Running pre-commit checks..." >&2
+
+# Regenerate RBS from scratch so that files orphaned by deleted lib/ sources are dropped too
+if ! bundle exec rake rbs:regenerate >&2; then
+    echo "Error: RBS generation failed" >&2
+    exit 2
+fi
+
+# True when $command stages the whole of sig/ itself, which the check below cannot see because
+# this hook runs first. Staging only part of sig/ does not count - the rest still drops out.
+stages_sig() {
+    local segment tokens token stages_everything pathspec_given
+
+    while IFS= read -r segment; do
+        segment=${segment//[\"\']/}
+        read -ra tokens <<<"${segment#*add}"
+        stages_everything=0
+        pathspec_given=0
+
+        for token in "${tokens[@]}"; do
+            case "$token" in
+                --) ;;
+                -*A*|--all) stages_everything=1 ;;
+                -*) ;;
+                .|./|sig|sig/|./sig|./sig/) return 0 ;;
+                *) pathspec_given=1 ;;
+            esac
+        done
+
+        # -A alone stages every path; given a pathspec it stages that path only
+        [ "$stages_everything" = 1 ] && [ "$pathspec_given" = 0 ] && return 0
+    done < <(grep -oE '(^|[;&|(])[[:space:]]*git[[:space:]]+add[^;&|(]*' <<<"$command")
+
+    return 1
+}
+
+# Stop rather than let the RBS just regenerated above drop out of the commit unnoticed
+if [[ "$command" =~ git[[:space:]]+commit([[:space:]]|$) ]] && ! stages_sig; then
+    unstaged_sig=$(git status --porcelain --untracked-files=all -- sig/ | awk 'substr($0, 2, 1) != " "')
+
+    if [ -n "$unstaged_sig" ]; then
+        echo "Error: sig/ has changes that are not staged:" >&2
+        echo "$unstaged_sig" >&2
+        echo "Run 'git add sig/' and commit again." >&2
+        exit 2
+    fi
+fi
+
+if ! bundle exec rake >&2; then
+    echo "Error: rake checks failed" >&2
+    exit 2
+fi
+
+echo "All checks passed!" >&2
+exit 0

data/.claude/hooks/protect-sig-files.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# Prevents direct editing of auto-generated RBS type definition files.
+# Type definitions in the project's own sig/ are managed by PostToolUse hooks.
+# Hand-written stubs for third-party gems under sig/gems/ are exempt.
+
+# Hook input is JSON from stdin
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.tool_name // ""')
+
+# Block Write/Edit operations on sig/ files
+if [[ "$tool_name" == "Write" || "$tool_name" == "Edit" ]]; then
+    file_path=$(echo "$input" | jq -r '.tool_input.file_path // ""')
+
+    # Judge the path relative to the project root: only the sig/ there is
+    # generated. A sig/ nested elsewhere is hand-written and stays editable.
+    project_root="${CLAUDE_PROJECT_DIR:-$PWD}"
+    rel_path="${file_path#"${project_root}/"}"
+
+    if [[ "$rel_path" == sig/gems/* ]]; then
+        exit 0
+    fi
+
+    if [[ "$rel_path" == sig/* ]]; then
+        echo "❌ ERROR: Direct editing of generated sig/ files is not allowed." >&2
+        echo "📝 This repository's own types are generated: fix the inline RBS comments in the .rb file." >&2
+        echo "💡 Hand-written files are allowed only under sig/gems/ (stubs for third-party gems)." >&2
+        exit 2
+    fi
+fi
+
+# Block manual rbs-inline execution
+if [[ "$tool_name" == "Bash" ]]; then
+    command=$(echo "$input" | jq -r '.tool_input.command // ""')
+
+    # Match rbs-inline only at a command position, not as an argument.
+    rbs_inline_re=$'(^|[;&|(\n])[[:space:]]*(bundle[[:space:]]+exec[[:space:]]+)?([^[:space:]]*/)?rbs-inline([[:space:]]|[;&|)]|$)'
+
+    if [[ "$command" =~ $rbs_inline_re ]]; then
+        echo "❌ ERROR: Manual rbs-inline execution is not allowed." >&2
+        echo "🔄 Type definitions are auto-generated by hooks." >&2
+        exit 2
+    fi
+fi
+
+exit 0

data/.claude/hooks/rbs-inline.sh

@@ -0,0 +1,95 @@
+#!/bin/bash
+
+# Hook input is JSON from stdin
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.tool_name')
+
+cd "$CLAUDE_PROJECT_DIR" || exit 1
+
+if [ "${CLAUDE_CODE_REMOTE:-}" = "true" ]; then
+  eval "$(rbenv init - bash)"
+fi
+
+# Handle Edit or Write tools
+if [[ "$tool_name" == "Edit" || "$tool_name" == "Write" ]]; then
+    file_path=$(echo "$input" | jq -r '.tool_input.file_path // ""')
+
+    if [[ ! "$file_path" =~ \.rb$ ]]; then
+        exit 0
+    fi
+
+    if [[ ! "$file_path" =~ /lib/ ]]; then
+        exit 0
+    fi
+
+    echo "Running rbs-inline for $file_path..." >&2
+
+    if ! bundle exec rbs-inline --opt-out --output=sig/ "$file_path" >&2; then
+        echo "Warning: RBS generation failed for $file_path" >&2
+        exit 0
+    fi
+
+    echo "RBS generation completed." >&2
+    exit 0
+fi
+
+# Handle Bash tool for mv command
+if [[ "$tool_name" == "Bash" ]]; then
+    command=$(echo "$input" | jq -r '.tool_input.command // ""')
+
+    # Check if this is a mv command
+    if [[ ! "$command" =~ ^[[:space:]]*(mv|git\ mv)[[:space:]] ]]; then
+        exit 0
+    fi
+
+    # Extract source and destination paths from mv command
+    paths=$(echo "$command" | sed -E 's/^[[:space:]]*(git[[:space:]]+)?mv[[:space:]]+//')
+
+    source_path=$(echo "$paths" | awk '{print $1}')
+    dest_path=$(echo "$paths" | awk '{print $2}')
+
+    # Check if source was a .rb file in lib/
+    if [[ ! "$source_path" =~ \.rb$ ]] || [[ ! "$source_path" =~ lib/ ]]; then
+        exit 0
+    fi
+
+    echo "Detected mv of Ruby file in lib/: $source_path -> $dest_path" >&2
+
+    # Calculate the corresponding .rbs file path for the source
+    source_rbs=$(echo "$source_path" | sed -E 's|^(.*/)?lib/|sig/|; s|\.rb$|.rbs|')
+
+    # Remove the old .rbs file if it exists
+    if [[ -f "$source_rbs" ]]; then
+        echo "Removing old RBS file: $source_rbs" >&2
+        rm -f "$source_rbs"
+    fi
+
+    # Determine the new .rb file path
+    if [[ -d "$dest_path" ]]; then
+        dest_file="$dest_path/$(basename "$source_path")"
+    else
+        dest_file="$dest_path"
+    fi
+
+    # Check if the destination is in lib/
+    if [[ ! "$dest_file" =~ lib/ ]]; then
+        echo "Destination is not in lib/, skipping RBS generation" >&2
+        exit 0
+    fi
+
+    # Generate RBS for the new file
+    if [[ -f "$dest_file" ]]; then
+        echo "Running rbs-inline for $dest_file..." >&2
+
+        if ! bundle exec rbs-inline --opt-out --output=sig/ "$dest_file" >&2; then
+            echo "Warning: RBS generation failed for $dest_file" >&2
+            exit 0
+        fi
+
+        echo "RBS generation completed." >&2
+    fi
+
+    exit 0
+fi
+
+exit 0

data/.claude/hooks/self-review.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+#
+# PreToolUse hook: review code before `git commit`.
+#
+# Fires before a Bash `git commit` command and blocks the first commit attempt
+# for a given change-set, asking Claude to review the code before committing.
+# The review uses the `self-review` skill when available, and falls back to the
+# bundled `code-review` skill otherwise — so the hook works even in projects
+# that don't ship the custom self-review skill.
+#
+# A per-change-set marker (keyed by a hash of the diff, stored under .git/)
+# prevents an infinite block loop: once a change-set has been surfaced for
+# review, the matching commit is allowed through. If the review leads to fixes,
+# the diff changes, so the new state is reviewed once more before it commits.
+#
+
+set -euo pipefail
+
+# Read JSON input from stdin
+input=$(cat)
+
+tool_name=$(echo "$input" | jq -r '.tool_name // empty')
+command=$(echo "$input" | jq -r '.tool_input.command // empty')
+
+# Only gate the Bash tool running a git commit.
+if [[ "$tool_name" != "Bash" ]]; then
+  exit 0
+fi
+# Match `git commit`, or `git -C <path> commit`.
+commit_re='git[[:space:]]+(-C[[:space:]]+[^[:space:]]+[[:space:]]+)?commit'
+if [[ ! "$command" =~ $commit_re ]]; then
+  exit 0
+fi
+
+# If the command targets a specific repo via `git -C <path>`, operate there too.
+work_dir="."
+if [[ "$command" =~ git[[:space:]]+-C[[:space:]]+([^[:space:]]+) ]]; then
+  work_dir="${BASH_REMATCH[1]}"
+fi
+
+# Not a git repo → nothing to do.
+git_dir=$(git -C "$work_dir" rev-parse --absolute-git-dir 2>/dev/null || true)
+if [[ -z "$git_dir" ]]; then
+  exit 0
+fi
+
+# Hash what will be committed. `git status --porcelain` is included so a commit
+# that only adds untracked files isn't mistaken for empty; `git diff HEAD` adds
+# tracked content. On the first commit there is no HEAD, so use the working state.
+if git -C "$work_dir" rev-parse --verify HEAD >/dev/null 2>&1; then
+  changeset=$(git -C "$work_dir" status --porcelain; git -C "$work_dir" diff HEAD)
+else
+  changeset=$(git -C "$work_dir" status --porcelain; git -C "$work_dir" diff; git -C "$work_dir" diff --cached)
+fi
+
+# Nothing to review (e.g. a message-only `--amend`) → let it proceed.
+if [[ -z "$changeset" ]]; then
+  exit 0
+fi
+
+hash=$(printf '%s' "$changeset" | git hash-object --stdin)
+state_file="$git_dir/self-review-reviewed"
+
+# Already surfaced for review → allow the commit.
+if [[ -f "$state_file" ]] && grep -qxF "$hash" "$state_file"; then
+  exit 0
+fi
+
+# Record this change-set and block once to force a review first.
+echo "$hash" >> "$state_file"
+
+review_prompt='SELF-REVIEW REQUIRED before committing. Review the changes that are
+about to be committed BEFORE running git commit again:
+
+- If the `self-review` skill is available, invoke it (Skill tool, skill "self-review").
+- Otherwise, run the bundled `/code-review` skill on the working diff.
+
+Judge each finding the review returns rather than fixing it on sight. Weigh what the review
+attached to it — how it graded the point, the basis it gave — and decide whether acting on it
+is worth it. Where you skip a finding, say so; do not drop it silently. Where the choice needs
+a requirement or an intent you do not have, leave it to the user. Once every fix you judged
+necessary is in, review again; when nothing you judged worth fixing is left, run the same git
+commit command again to proceed — it will be allowed through.'
+
+jq -n --arg reason "$review_prompt" '{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": $reason
+  }
+}'
+
+exit 0

data/.claude/settings.json

@@ -0,0 +1,58 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/protect-sig-files.sh",
+            "timeout": 5000
+          }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/pre-commit-check.sh",
+            "timeout": 300000
+          }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/self-review.sh",
+            "timeout": 10000
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/claude-code-web-session-start.sh"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/rbs-inline.sh",
+            "timeout": 60000
+          }
+        ]
+      }
+    ]
+  }
+}

data/.rubocop.yml

@@ -1,24 +1,48 @@
+# NOTE: Rules are sorted in ASCII order.
+
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.2
+  TargetRubyVersion: 3.3
 
 plugins:
+  - rubocop-instance_variable_access
+  - rubocop-numbered-params
   - rubocop-rake
+  - rubocop-rbs_inline
   - rubocop-rspec
+  - rubocop-rspec-unused-let
 
+# Layout
 Layout/LeadingCommentSpace:
   AllowRBSInlineAnnotation: true
   AllowSteepAnnotation: true
 
+Layout/LineLength:
+  Max: 120
+
+# Metrics
+Metrics/AbcSize:
+  Max: 20
+
 Metrics/BlockLength:
   Exclude:
     - "spec/**/*.rb"
 
+Metrics/ClassLength:
+  Max: 200
+
 Metrics/MethodLength:
   Max: 30
 
+# RSpec
 RSpec/ExampleLength:
-  Max: 20
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/MultipleMemoizedHelpers:
+  Max: 10
 
 RSpec/NamedSubject:
   Enabled: false
@@ -26,15 +50,28 @@ RSpec/NamedSubject:
 RSpec/NestedGroups:
   Max: 5
 
-RSpec/MultipleExpectations:
+# Style
+Style/AccessorGrouping:
   Enabled: false
 
-RSpec/MultipleMemoizedHelpers:
-  Max: 10
+Style/CommentedKeyword:
+  Enabled: false
 
 Style/Documentation:
   Enabled: false
 
+Style/HashSyntax:
+  EnforcedShorthandSyntax: always
+
+Style/RbsInline:
+  Mode: opt_out
+
+Style/RbsInline/MissingTypeAnnotation:
+  EnforcedStyle: doc_style_and_return_annotation
+
+Style/RbsInline/RedundantTypeAnnotation:
+  EnforcedStyle: doc_style_and_return_annotation
+
 Style/RedundantFormat:
   Enabled: false
 

data/.vscode/settings.json

@@ -25,7 +25,9 @@
         "requireds",
         "rmtree",
         "rubocop",
+        "rubygems",
         "Takeshi",
-        "tasklib"
+        "tasklib",
+        "tk0miya"
     ]
 }

data/Rakefile

@@ -1,15 +1,43 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
 
-task default: :rubocop
+task default: :ci
+
+task ci: %i[rubocop spec steep rbs:validate]
 
 namespace :rbs do
-  desc "Generate RBS files"
-  task :generate do
-    sh "rbs-inline", "--opt-out", "--output=sig", "lib"
+  # sig/gems holds hand-written types for external gems, so it is never regenerated
+  kept = ->(path) { path == "sig/gems" || path.start_with?("sig/gems/") }
+
+  desc "Install RBS collection"
+  task :install do
+    sh "bundle exec rbs collection install --frozen"
+  end
+
+  desc "Regenerate all RBS files under sig/ from scratch (run manually after editing lib/)"
+  task :regenerate do
+    Dir.glob("sig/**/*.rbs").reject(&kept).each { rm _1 }
+
+    sh "bundle exec rbs-inline --opt-out --output=sig lib"
+
+    # Drop the directories the deletion above left empty, deepest first
+    dirs = Dir.glob("sig/**/*").select { File.directory?(_1) }
+    dirs.reject(&kept).sort.reverse_each { rmdir _1 if Dir.empty?(_1) }
+  end
+
+  desc "Validate RBS files"
+  task validate: "rbs:install" do
+    sh "bundle exec rbs -Isig validate"
   end
 end
+
+desc "Run steep type check"
+task steep: "rbs:install" do
+  sh "bundle exec steep check"
+end

data/lib/generators/rbs_activerecord/install_generator.rb

@@ -4,7 +4,7 @@ require "rails"
 
 module RbsActiverecord
   class InstallGenerator < Rails::Generators::Base
-    def create_raketask
+    def create_raketask #: void
       create_file "lib/tasks/rbs_activerecord.rake", <<~RUBY
         # frozen_string_literal: true
 

data/lib/rbs_activerecord/generator/active_storage/instance_methods.rb

@@ -23,13 +23,14 @@ module RbsActiverecord
 
         def attachments #: Hash[String, untyped]
           if model.klass.respond_to?(:attachment_reflections)
-            model.klass.attachment_reflections # steep:ignore
+            model.klass.attachment_reflections
           else
             {}
           end
         end
 
         # @rbs name: String
+        # @rbs reflection: untyped
         def attachment(name, reflection) #: String
           case reflection.macro
           when :has_one_attached

data/lib/rbs_activerecord/generator/active_storage/scopes.rb

@@ -23,7 +23,7 @@ module RbsActiverecord
 
         def attachments #: Hash[String, untyped]
           if model.klass.respond_to?(:attachment_reflections)
-            model.klass.attachment_reflections # steep:ignore
+            model.klass.attachment_reflections
           else
             {}
           end

data/lib/rbs_activerecord/generator/associations.rb

@@ -25,7 +25,7 @@ module RbsActiverecord
 
       private
 
-      def has_many #: String  # rubocop:disable Naming/PredicateName
+      def has_many #: String # rubocop:disable Naming/PredicatePrefix
         model.reflect_on_all_associations(:has_many).map do |assoc|
           assoc_name = assoc.name.to_s
           klass_name = "::#{assoc.klass.name}"
@@ -41,7 +41,7 @@ module RbsActiverecord
         end.join("\n")
       end
 
-      def has_one #: String  # rubocop:disable Naming/PredicateName
+      def has_one #: String # rubocop:disable Naming/PredicatePrefix
         model.reflect_on_all_associations(:has_one).map do |assoc|
           type = "::#{assoc.klass.name}"
           optional = "#{type}?"
@@ -85,7 +85,7 @@ module RbsActiverecord
       def polymorphic_owner_types(assoc) #: String  # rubocop:disable Metrics/AbcSize
         table_name = model.klass.name.to_s.tableize.to_sym
         owners = ActiveRecord::Base.descendants.select do |klass|
-          klass.reflect_on_all_associations.any? { |a| a.name == table_name && a.options[:as] == assoc.name }
+          klass.reflect_on_all_associations.any? { _1.name == table_name && _1.options[:as] == assoc.name }
         end
 
         if owners.empty?
@@ -98,7 +98,7 @@ module RbsActiverecord
         end
       end
 
-      def has_and_belongs_to_many #: String  # rubocop:disable Naming/PredicateName
+      def has_and_belongs_to_many #: String # rubocop:disable Naming/PredicatePrefix
         model.reflect_on_all_associations(:has_and_belongs_to_many).map do |assoc|
           assoc_name = assoc.name.to_s
           klass_name = assoc.klass.name

data/lib/rbs_activerecord/generator/attributes.rb

@@ -18,7 +18,7 @@ module RbsActiverecord
       def generate #: String
         <<~RBS
           module GeneratedAttributeMethods
-            #{model.columns.map { |c| column(c) }.join("\n")}
+            #{model.columns.map { column(_1) }.join("\n")}
             #{attributes.map { |name, type| attribute(name, type) }.join("\n")}
             #{model.attribute_aliases.map { |from, to| alias_method(from, to) }.join("\n")}
           end
@@ -27,15 +27,17 @@ module RbsActiverecord
 
       private
 
+      # @rbs col: untyped
       def column(col) #: String  # rubocop:disable Metrics/AbcSize
         type = sql_type_to_class(col.type)
         optional = "#{type}?"
         column_type = col.null ? optional : type
+        writer_type = writer_type_for(col.type, nullable: col.null)
 
         <<~RBS
           #{"%a{pure}" if pure_accessors}
           def #{col.name}: () -> #{column_type}
-          def #{col.name}=: (#{column_type}) -> #{column_type}
+          def #{col.name}=: (#{writer_type}) -> #{writer_type}
           def #{col.name}?: () -> bool
           def #{col.name}_changed?: () -> bool
           def #{col.name}_change: () -> [#{optional}, #{optional}]
@@ -57,7 +59,7 @@ module RbsActiverecord
 
       def attributes #: Hash[String, untyped]
         model.attribute_types.filter_map do |name, type|
-          [name, type] if model.columns.none? { |col| col.name == name }
+          [name, type] if model.columns.none? { _1.name == name }
         end.to_h
       end
 
@@ -65,13 +67,32 @@ module RbsActiverecord
       # @rbs type: untyped
       def attribute(name, type) #: String
         column_type = sql_type_to_class(type.type)
+        writer_type = writer_type_for(type.type, nullable: false)
 
         <<~RBS
           def #{name}: () -> #{column_type}
-          def #{name}=: (#{column_type}) -> #{column_type}
+          def #{name}=: (#{writer_type}) -> #{writer_type}
         RBS
       end
 
+      # The type accepted by the attribute writer.
+      # It is wider than the reader type for the types ActiveRecord casts on assignment.
+      #
+      # @rbs type: Symbol
+      # @rbs nullable: bool
+      def writer_type_for(type, nullable:) #: String
+        writer_type = case type
+                      when :datetime
+                        # A datetime attribute also accepts ::Time and converts it to ::ActiveSupport::TimeWithZone
+                        "(::ActiveSupport::TimeWithZone | ::Time)"
+                      else
+                        sql_type_to_class(type)
+                      end
+        nullable ? "#{writer_type}?" : writer_type
+      end
+
+      # @rbs from: untyped
+      # @rbs to: untyped
       def alias_method(from, to) #: String
         <<~RBS
           alias #{from} #{to}