-

diff --git a/app/services/team_service.rb b/app/services/team_service.rb
index 87a28ad7ed..3cfd9a99bc 100644
--- a/app/services/team_service.rb
+++ b/app/services/team_service.rb
@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
-class TeamService
+module TeamService
   include C
 
-  Contract Team => Void
-  def initialize(team)
-    @team = team
-  end
-
   Contract KeywordArgs[:name => String, :owner => User] => Team
   public_class_method def self.create_team(name:, owner:)
     Team.transaction(:requires_new => true) do
@@ -18,96 +13,99 @@ class TeamService
   end
 
   Contract KeywordArgs[
+             :team => Team,
              :user => User,
              :role => ActiveRecordEnumKey[TeamMembership.roles],
              :status => ActiveRecordEnumKey[TeamMembership.statuses]
            ] => Void
-  public def add_user(user:, role:, status:)
+  public_class_method def self.add_user(user:, role:, status:)
     raise 'User is already a member of a team' if user.team.present?
     if role == 'owner'
-      raise 'Owner already exists' if @team.team_memberships.where(:role => 'owner').exists?
+      raise 'Owner already exists' if team.team_memberships.where(:role => 'owner').exists?
     end
-    @team.team_memberships.create!(:user => user, :role => role, :status => status)
+    team.team_memberships.create!(:user => user, :role => role, :status => status)
     _reset_user_associations(user)
   end
 
   # Anytime we're operating through the has_one associations on the
   # user, we need to invalidate the cache on user/team because the
   # return value of the has_one object is not an association
-  Contract User => Void
-  private def _reset_user_associations(user)
+  Contract KeywordArgs[:team => Team, :user => User] => Void
+  private_class_method def self._reset_user_associations(team:, user:)
     user.association(:team_membership).reset
     user.association(:team).reset
   end
 
   Contract Team => Void
-  private def _reset_team_associations(team)
+  private_class_method def self._reset_team_associations(team)
     # Is there a better way to achieve this?
     team.team_memberships.reset
     team.users.reset
   end
 
-  Contract User => Void
-  public def remove_user(user)
+  Contract KeywordArgs[:team => Team, :user => User] => Void
+  public_class_method def self.remove_user(team:, user:)
     _verify_user_is_member!(user)
     team_membership = user.team_membership
     raise 'Cannot remove owner' if team_membership.role == 'owner'
     team_membership.delete
-    _reset_team_associations(@team)
+    _reset_team_associations(team)
     _reset_user_associations(user)
   end
 
-  Contract User => Void
-  public def replace_owner(new_owner)
+  Contract KeywordArgs[:team => Team, :new_owner => User] => Void
+  public_class_method def self.replace_owner(team:, new_owner:)
     _verify_user_is_member!(new_owner)
-    current_owner = @team.owner
+    current_owner = team.owner
     TeamMembership.transaction(:requires_new => true) do
       current_owner.team_membership.update!(:role => 'member')
       new_owner.team_membership.update!(:role => 'owner')
     end
     _reset_user_associations(current_owner)
     _reset_user_associations(new_owner)
-    _reset_team_associations(@team)
+    _reset_team_associations(team)
   end
 
   Contract KeywordArgs[
+             :team => Team,
              :user => User,
              :to_role => ActiveRecordEnumKey[TeamMembership.roles],
            ] => Void
-  public def change_user_role(user:, to_role:)
+  public_class_method def self.change_user_role(team:, user:, to_role:)
     raise 'Cannot change to owner' if to_role == 'owner'
     _verify_user_is_member!(user)
     raise 'Cannot change role of owner' if user.team_membership.role == 'owner'
     user.team_membership.update!(:role => to_role)
     _reset_user_associations(user)
-    _reset_team_associations(@team)
+    _reset_team_associations(team)
   end
 
   Contract KeywordArgs[
+             :team => Team,
              :user => User,
              :to_status => ActiveRecordEnumKey[TeamMembership.statuses],
            ] => Void
-  public def change_user_status(user:, to_status:)
+  public_class_method def self.change_user_status(team:, user:, to_status:)
     _verify_user_is_member!(user)
     user.team_membership.update!(:status => to_status)
     _reset_user_associations(user)
-    _reset_team_associations(@team)
+    _reset_team_associations(team)
   end
 
   Contract None => Void
-  public def remove_all_users
+  public_class_method def self.remove_all_users
     time_now = Time.now
-    @team.team_memberships.update_all(:deleted_at => time_now, :updated_at => time_now)
+    team.team_memberships.update_all(:deleted_at => time_now, :updated_at => time_now)
   end
 
-  Contract None => Void
-  public def delete
-    raise 'Team still has members' if @team.team_memberships.exists?
-    @team.delete
+  Contract Team => Void
+  public_class_method def self.delete(team)
+    raise 'Team still has members' if team.team_memberships.exists?
+    team.delete
   end
 
-  Contract User => Void
-  private def _verify_user_is_member!(user)
-    raise 'User is not a member of team' if user.team != @team
+  Contract Team, User => Void
+  private_class_method def self._verify_user_is_member!(team, user)
+    raise 'User is not a member of team' if user.team != team
   end
 end