Python
Keep framework requirements in every agent edit
32 environments across 19 languages, with 64 advanced recipes. Inspect transaction boundaries, authorization, request races, queues and resource lifetime through actual source examples and captured Perch controls.
32 environments shown
Python
Django
Keep Django cancellation writes scoped to the authenticated tenant
Create a Django outbox event atomically with the order change
TypeScript
Next.js
Authorize a Next.js Server Action at the database write
Prevent private Next.js order responses from entering shared caches
JavaScript
Express
Reserve stock in Express with one conditional database update
Return the PostgreSQL client after every Express transaction outcome
Ruby
Rails
Serialize Rails stock reservations with an Active Record row lock
Reject stale Rails cancellation decisions with optimistic locking
PHP
Laravel
Dispatch Laravel order jobs only after the transaction commits
Use a conditional Laravel update to prevent overselling
Python
Flask
Keep Flask request connections from leaking on error paths
Deduplicate a signed Flask webhook inside its state transaction
JavaScript
Fastify
Keep Fastify permission hooks inside the protected plugin
Keep Fastify reservation and order writes on the same transaction client
TypeScript
Hono
Enforce Hono JWT permissions after verification and before mutation
Persist a Hono notification record before post-response dispatch
PHP
Symfony
Keep Symfony object authorization before the order write
Keep Symfony inventory and order writes on one Doctrine transaction
Java
Spring Boot
Keep Spring order confirmation and its outbox write under one proxy transaction
Require Spring method security before a scoped order mutation
Kotlin
Ktor
Apply backpressure to Ktor background work with a bounded coroutine channel
Preserve Kotlin coroutine cancellation in a Ktor service
Go
Gin
Keep Gin reservation and order creation on database/sql’s transaction handle
Keep Gin’s pooled context out of the background queue
Go
Echo
Prevent privileged-field binding in an Echo profile mutation
Carry Echo cancellation through to the database query
C#
ASP.NET Core
Authorize the loaded ASP.NET Core order before saving changes
Return a conflict when EF Core detects a stale order edit
Elixir
Phoenix
Keep Phoenix order and audit changes in one Ecto.Multi
Insert an Oban job in the same transaction as the Phoenix order change
JavaScript
React
Keep old React search responses from replacing the current query
Serialize and roll back an optimistic React cancellation
JavaScript
Vue
Cancel and invalidate Vue watcher requests before the next await
Dispose Vue realtime subscriptions when the owner disappears
TypeScript
Angular
Cancel obsolete Angular HttpClient searches with switchMap
Keep Angular form extras out of the profile mutation payload
TypeScript
SvelteKit
Authorize a SvelteKit form action before its conditional write
Keep SvelteKit private SSR responses out of shared caches
TypeScript
Nuxt
Keep Nuxt API mutations scoped to the server-verified session
Use Nuxt request-scoped state instead of a shared SSR ref
TypeScript
NestJS
Reject unlisted NestJS mutation fields at the validation pipe
Keep NestJS event persistence on the supplied TypeORM transaction manager
Rust
Axum
Keep Axum’s verified tenant inside the SQLx order update
Stop an Axum worker while it waits for queued input
Rust
Actix Web
Keep Actix order reads scoped by ReqData identity
Bound Actix import input before scheduling blocking work
C++
Qt
Protect Qt’s shared stock decision with one scoped mutex
Dispose Qt network replies after their completion signal
Swift
Vapor
Keep Vapor’s order and audit writes on the Fluent transaction database
Observe Swift task cancellation between bounded order-processing steps
Dart
Flutter
Reject stale Flutter search results after a newer query or disposal
Cancel Flutter timers and streams when the screen is disposed
R
Shiny
Check Shiny session authorization inside the write observer
Remove Shiny’s session-owned temporary files on session end
Scala
http4s
Release http4s response resources after success or decoding failure
Keep a doobie reservation and order insert in one transaction
Clojure
Ring
Keep Ring mutation permissions at the request handler
Release Clojure file resources when parsing an order fails
Lua
OpenResty
Protect OpenResty stock decisions across workers with a shared lock
Do not acknowledge OpenResty background work before timer admission
C
POSIX services
Preserve complete POSIX writes when appending an order record
Close a POSIX file descriptor even when synchronization fails
Turn a correction into a saved Perch rule
Each recipe gives your agent a concrete requirement, a focused check, and a repair/recheck workflow. Inspect the captured finding, adapt the example and regression tests, and commit the rule beside your code. The next agent session and CI can check the same requirement.
Published by Perch / Verglas LLC.