anchor.diff:      let fieldDef = Define.Field("a", String, fun _ dt -> dt.c)
       ctx.FieldExecuteMap.SetExecute("Data", fieldDef)
       next ctx
  +
  +// After the schema has been compiled, inject a fake variable "foo" to every input object
  +let postCompileMiddleware (schema : ISchema) (next : ISchema -> unit) =
  +    schema.TypeMap.ToSeq()
  +    |> Seq.iter(fun (n, def) ->
  +                    match def with
  +                    | InputObject iobj ->
  +                        iobj.Fields
  +                        |> Array.iter(fun f -> f.ExecuteInput <- (fun value vars -> f.ExecuteInput value (Map.add "foo" (upcast 1) vars)))
  +                    | _ -> ())
  +    next schema
   
   // On the planning phase, we watch the time needed to do the operation
   let planningMiddleware (ctx : PlanningContext) (next : PlanningContext -> ExecutionPlan) =
  
positive.code:             a
              b
              c
          }
      }"""
  
  
negative.code: let middleware =
      { new IExecutorMiddleware with
          member __.CompileSchema = Some compileMiddleware
          member __.PostCompileSchema = Some postCompileMiddleware
          member __.PlanOperation = Some planningMiddleware
          member __.ExecuteOperationAsync = Some executionMiddleware }
  
  