;; How many queries does /api/books actually fire?
(trace/detect-n+1
  (trace/trace-sql
    (lw/run-as "member1"
      (.getBooks (lw/bean "bookController")))))
;; => {:total-queries 481, :suspicious-queries [{...} {:count 200} ...]}

;; Convert any Java object to a Clojure map — works for both plain JavaBeans and
;; Java records (DTOs). Use this instead of clojure.core/bean, which silently
;; returns {} for records (no error, just missing fields).
(lw/bean->map some-dto)
;; => {:totalBooks 200, :totalAuthors 30, ...}

;; What repos are registered?
(lw/find-beans-matching ".*Repository.*")
;; => ("bookRepository" "authorRepository" "reviewRepository" ...)

;; All registered bean names
(lw/bean-names)
;; => ("bookRepository" "authorRepository" ... "dataSource" ...)

;; All beans of a given type
(lw/beans-of-type javax.sql.DataSource)
;; => [{:name "dataSource", :bean #object[HikariDataSource ...]}]

;; What DB URL is the app actually talking to?
(lw/props-matching "spring\\.datasource\\.url")
;; => {"spring.datasource.url" "jdbc:postgresql://localhost:32808/test"}

;; Runtime environment summary + primary DataSource details
(lw/info)
;; => {:spring-boot "4.0.1", :spring "7.0.2", :hibernate "7.2.0.Final", :java "25", ...
;;     :datasource {:db-product "PostgreSQL 16.9"
;;                  :jdbc-url "jdbc:postgresql://localhost:5432/myapp"
;;                  :db-user "app" :driver "PostgreSQL JDBC Driver 42.7.8"
;;                  :pool-name "HikariPool-1" :pool-size-max 10}}

;; Wiring of a single bean — what it injects and what injects it
(lw/bean-deps "bookService")
;; => {:bean         "bookService"
;;     :class        "com.example.BookService"
;;     :dependencies ["bookRepository"]
;;     :dependents   ["adminController" "bookController"]}

;; App-level wiring graph — defaults to your own classes only (auto-detected via @SpringBootApplication)
(lw/all-bean-deps)
;; => [{:bean "adminService", :class "com.example.AdminService", :dependencies [...], :dependents [...]} ...]

;; Find high-fan-out coupling candidates
(->> (lw/all-bean-deps)
     (sort-by #(count (:dependencies %)) >)
     (take 10)
     (mapv #(select-keys % [:bean :class :dependencies])))

;; Include Spring infrastructure beans too
(lw/all-bean-deps :app-only false)

;; CLI shorthands
;; lw-bean-deps bookService
;; lw-all-bean-deps

;; @Transactional surface of a single bean
(lw/bean-tx "bookService")
;; => {:bean "bookService" :class "com.example.BookService"
;;     :methods [{:method "archiveBook" :propagation :required :read-only false ...}
;;               {:method "getAllBooks"  :propagation :required :read-only true  ...}]}

;; All app-level beans with transactional methods (auto-filtered via @SpringBootApplication)
(lw/all-bean-tx)

;; Smell check: reads not marked read-only
(->> (lw/all-bean-tx)
     (mapcat (fn [b] (map #(assoc % :bean (:bean b)) (:methods b))))
     (filter #(and (not (:read-only %))
                   (re-find #"(?i)^(get|find|list|count|search|fetch)" (:method %)))))

;; CLI shorthands
;; lw-bean-tx bookService
;; lw-all-bean-tx

;; Raw SQL through the live DataSource — always cap results
(lw/in-readonly-tx
  (q/sql "SELECT id, title FROM book LIMIT 5"))
;; => [{:id 1, :title "All the King's Men"} ...]

;; Repository calls — always page, never call .findAll without a Pageable
(lw/in-readonly-tx
  (->> (.findAll (lw/bean "bookRepository")
                 (org.springframework.data.domain.PageRequest/of 0 3))
       .getContent
       (mapv #(select-keys (clojure.core/bean %) [:id :title :isbn]))))
;; => [{:id 1, :title "All the King's Men", :isbn "979-0-925405-37-0"} ...]

;; Mutations roll back automatically — safe to experiment
(lw/in-tx
  (.save (lw/bean "bookRepository") ...)
  (.count (lw/bean "bookRepository")))
;; => 201  (and then silently rolled back)

;; ✅ Preferred: vector form — [username role1 role2 ...]
(lw/run-as ["repl-user" "ROLE_MEMBER"]
  (.getBookById (lw/bean "bookController") 25))

;; Multiple roles
(lw/run-as ["repl-user" "ROLE_ADMIN" "ROLE_MEMBER"]
  (.getStats (lw/bean "adminController")))

;; ⚠️ Plain string form — only grants ROLE_USER + ROLE_ADMIN
;; Will throw AuthorizationDeniedException for MEMBER/VIEWER-gated endpoints
(lw/run-as "admin"
  (.getBookById (lw/bean "bookController") 25))

;; See every SQL a call fires — wrap it and look
(trace/trace-sql
  (lw/in-readonly-tx
    (.count (lw/bean "bookRepository"))))
;; => {:result 200, :count 1, :duration-ms 8,
;;     :queries [{:sql "select count(*) from book b1_0", :caller "..."}]}

;; Detect N+1 automatically
(trace/detect-n+1
  (trace/trace-sql
    (lw/run-as "member1"
      (.getBooks (lw/bean "bookController")))))
;; => {:total-queries 481,
;;     :suspicious-queries [{:sql "select ... from book_genre ...", :count 200}
;;                          {:sql "select ... from review ...",     :count 200}
;;                          {:sql "select ... from library_member", :count 50}
;;                          {:sql "select ... from author ...",     :count 30}]}

;; For @Async / CompletableFuture — capture SQL across all threads
(trace/trace-sql-global
  (lw/run-as "member1"
    (.getBooksByGenreAsync (lw/bean "bookService") 1)))
;; => {:result [...], :count 12, :queries [...]}

;; See what @Query methods exist on a repo
(hq/list-queries "bookRepository")
;; => ({:method "findAllWithAuthorAndGenres",
;;      :jpql "SELECT DISTINCT b FROM Book b JOIN FETCH b.author LEFT JOIN FETCH b.genres"}
;;     {:method "findByGenreId", ...} ...)

;; Swap to a candidate fix
(hq/hot-swap-query! "bookRepository" "findAllWithAuthorAndGenres"
  "SELECT DISTINCT b FROM Book b JOIN FETCH b.author
   LEFT JOIN FETCH b.genres LEFT JOIN FETCH b.reviews")

;; Verify — does the query count drop?
(trace/trace-sql
  (lw/run-as "member1"
    (.getBooks (lw/bean "bookController"))))

;; Restore when done — don't leave swapped queries hanging
(hq/reset-all!)
;; => [["bookRepository" "findAllWithAuthorAndGenres"]]

;; Check watcher status
(qw/status)
;; => {:running? true, :disk-state-size 8}

;; After recompiling in your IDE — watcher fires automatically:
;; [query-watcher] detected change: bookRepository#findAllWithAuthorAndGenres
;; [hot-queries] watcher re-swapped ✓

;; All HTTP endpoints — auth, param sources, and required/optional flags
(->> (intro/list-endpoints)
     (filter #(re-find #"books" (str (:paths %))))
     (mapv #(select-keys % [:paths :methods :handler-method :pre-authorize :required-roles :parameters])))
;; => [{:paths ["/api/books"], :methods ["GET"],
;;      :handler-method "getBooks", :pre-authorize "hasRole('MEMBER')",
;;      :required-roles ["MEMBER"], :parameters []}
;;     {:paths ["/api/books/{id}"], :methods ["GET"],
;;      :handler-method "getBookById", :required-roles ["MEMBER"],
;;      :parameters [{:name nil, :type "java.lang.Long", :source :path, :required true}]}]

;; All Hibernate-managed entities
(map :name (intro/list-entities))
;; => ("Author" "Book" "Genre" "LoanRecord" "LibraryMember" "Review")

;; Entity schema for one entity — straight from Hibernate's live metamodel
(intro/inspect-entity "Book")
;; => {:table-name "book",
;;     :identifier {:name "id", :columns ["id"], :type "long"},
;;     :properties [{:name "title", :columns ["title"], :type "string", :is-association false,
;;                   :constraints ["@NotBlank" "@Size(min=0,max=255)"]} ...]}

;; Full domain model in one call — great for ER diagrams
(intro/inspect-all-entities)
;; => {"Book"   {:table-name "book", :identifier {...}, :properties [...]}
;;     "Author" {:table-name "author", ...}
;;     ...}

;; Execute any JPQL via the live EntityManager — returns plain Clojure maps
(jpa/jpa-query "SELECT b FROM Book b ORDER BY b.id" :page 0 :page-size 5)
;; => [{:id 1, :title "All the King's Men", :author {:id 6, ...}, :genres "<lazy>"} ...]

;; Scalar projections with AS aliases become named keys
(jpa/jpa-query
  "SELECT b.title AS title, COUNT(lr) AS loans
   FROM Book b JOIN b.loanRecords lr
   GROUP BY b.id, b.title ORDER BY COUNT(lr) DESC"
  :page-size 5)
;; => [{:title "Vanity Fair", :loans 7} ...]

;; Invoke a controller method under a live SecurityContext
;; and serialize with the exact same Jackson ObjectMapper Spring MVC uses
(mvc/serialize
  (lw/run-as ["repl-user" "ROLE_MEMBER"]
    (.getBooks (lw/bean "bookController")))
  :limit 3)
;; => ^{:total 200, :returned 3, :content-size 51529, :content-size-gzip 8299}
;;    [{"id" 1, "title" "All the King's Men", ...} ...]

(q/diff-entity "Book" 100
  (fn [] (.archiveBook (lw/bean "bookService") (long 100))))
;; => {:before  {:archived false, :archivedAt nil, :availableCopies 5,
;;               :title "A Handful of Dust", ...}
;;     :after   {:archived true,  :archivedAt "2026-03-28T16:16:20", :availableCopies 5}
;;     :changed {:archived   [false true]
;;               :archivedAt [nil "2026-03-28T16:16:20"]}}

;; Simple entity — no required FKs, just scalar fields
(faker/build-entity "Author")
;; => #object[Author ... {:firstName "Evelyn", :lastName "Hartwell",
;;            :birthYear 1923, :nationality "Montenegrins"}]

;; Let Livewire resolve the full dependency chain automatically
(faker/build-entity "Book" {:auto-deps? true :persist? true})

;; Speculative pattern: persist + rollback — get a real DB-assigned id without leaving data behind
(let [review (faker/build-entity "Review" {:auto-deps? true :persist? true :rollback? true})]
  ;; Call your rating service with a real id — nothing persists after this block
  (.computeAverageRating (lw/bean "ratingService") (.getId review)))

;; Returns every scalar field with its Java type and generated value, plus the repo bean name
(faker/build-test-recipe "Review")
;; => {:Review {:repo "reviewRepository"
;;              :fields {:rating     {:type "short"         :value 5}
;;                       :comment    {:type "string"        :value "A remarkable journey..."}
;;                       :reviewedAt {:type "LocalDateTime" :value #object[LocalDateTime ...]}}}
;;     :Book   {:repo "bookRepository"
;;              :fields {:title {:type "string" :value "The Midnight Crisis"} ...}}
;;     ...}

;; CLI
;; lw-build-test-recipe Review

(lw/repo-entity "bookRepository")
;; => {:bean "bookRepository" :entity "Book" :entity-fqn "com.example.domain.Book" :id-type "Long"}

(lw/all-repo-entities)
;; => [{:bean "authorRepository" :entity "Author" :entity-fqn "..." :id-type "Long"} ...]

;; CLI
;; lw-repo-entity bookRepository
;; lw-all-repo-entities

(faker/available?)  ;; => true

;; CLI
;; lw-build-entity Review '{:auto-deps? true :persist? true :rollback? true}'

;; Which endpoints call bookRepository/findAll, directly or via services?
(cg/blast-radius "bookRepository" "findAll")
;; => {:target   {:bean "bookRepository" :method "findAll"}
;;     :affected [{:bean "bookService"    :method "getAllBooks"      :depth 1 :entry-point nil}
;;                {:bean "bookController" :method "getBooks"         :depth 2
;;                 :entry-point {:type :http-endpoint :paths ["/api/books"] :http-methods ["GET"]
;;                               :pre-authorize "hasRole('MEMBER')"}}
;;                {:bean "bookStatsReporter" :method "reportNightlyStats" :depth 2
;;                 :entry-point {:type :scheduler :cron "0 0 2 * * *"}}]
;;     :warnings ["Method name 'findAll' matched multiple signatures — all overloads are included"]}

;; What breaks if I change bookService/archiveBook?
(cg/blast-radius "bookService" "archiveBook")

;; All methods at once — per-method {method → {:callers [...]}} map
;; Methods with empty :callers have no known entry points
(cg/blast-radius "bookService" "*" :per-method? true)

;; CLI
;; lw-blast-radius bookRepository findAll
;; lw-blast-radius bookService archiveBook
;; lw-blast-radius-all bookService        ← per-method map, one command

(cg/dead-methods "bookService")
;; => {:bean              "bookService"
;;     :dead              []          ; no callers anywhere — true dead code
;;     :internal-only     [{:method "archiveBook" :intra-callers ["adminHelper"]} ...]
;;     :reachable-count   4
;;     :dead-count        0
;;     :internal-only-count 1
;;     :warnings          ["2 @EventListener beans detected — ..."]}

(cg/method-dep-map "adminService")
;; => {:bean "adminService"
;;     :methods [{:method "getSystemStats"
;;                :deps   ["authorRepository" "bookRepository" "reviewRepository" ...]
;;                :orchestrator? false}
;;               {:method "getTop10MostLoanedBooks"
;;                :deps   ["bookRepository"]
;;                :orchestrator? false}]
;;     :dep-frequency [{:dep "bookRepository" :used-by-count 2 :methods [...]} ...]
;;     :unaccounted-deps []}

;; Add intra-class call direction for split planning
(cg/method-dep-map "adminService" :intra-calls? true)   ; which siblings does each method call?
(cg/method-dep-map "adminService" :callers? true)        ; which siblings call each method?

;; CLI
;; lw-method-dep-map adminService

(cg/method-dep-clusters "memberService")
;; => {:clusters [{:id 0 :methods ["getActiveLoansForMember"]
;;                 :exclusive-deps ["loanRecordRepository"] :shared-deps [] :intra-call-violations []}
;;                {:id 1 :methods ["getAllMembers" "getMemberById"]
;;                 :exclusive-deps ["libraryMemberRepository"] :shared-deps [] :intra-call-violations []}]
;;     :orchestrators [] :dep-free [] :shared-deps-summary [] :unaccounted-deps []}

;; CLI
;; lw-method-dep-clusters memberService
;; lw-method-dep-clusters adminService --expand-private