1use std::sync::Arc;
4
5use rustauth_core::db::User;
6use rustauth_core::error::RustAuthError;
7
8use time::OffsetDateTime;
9
10use super::{Invitation, Member, Organization, Team, TeamMember};
11
12#[derive(Clone, Default)]
13pub struct OrganizationHooks {
14 pub before_create_organization: Option<BeforeCreateOrganizationHook>,
15 pub after_create_organization: Option<AfterCreateOrganizationHook>,
16 pub before_update_organization: Option<BeforeUpdateOrganizationHook>,
17 pub after_update_organization: Option<AfterUpdateOrganizationHook>,
18 pub before_delete_organization: Option<BeforeDeleteOrganizationHook>,
19 pub after_delete_organization: Option<AfterDeleteOrganizationHook>,
20 pub before_add_member: Option<BeforeAddMemberHook>,
21 pub after_add_member: Option<AfterAddMemberHook>,
22 pub before_remove_member: Option<BeforeRemoveMemberHook>,
23 pub after_remove_member: Option<AfterRemoveMemberHook>,
24 pub before_update_member_role: Option<BeforeUpdateMemberRoleHook>,
25 pub after_update_member_role: Option<AfterUpdateMemberRoleHook>,
26 pub before_create_invitation: Option<BeforeCreateInvitationHook>,
27 pub after_create_invitation: Option<AfterCreateInvitationHook>,
28 pub before_accept_invitation: Option<BeforeAcceptInvitationHook>,
29 pub after_accept_invitation: Option<AfterAcceptInvitationHook>,
30 pub before_reject_invitation: Option<BeforeRejectInvitationHook>,
31 pub after_reject_invitation: Option<AfterRejectInvitationHook>,
32 pub before_cancel_invitation: Option<BeforeCancelInvitationHook>,
33 pub after_cancel_invitation: Option<AfterCancelInvitationHook>,
34 pub before_create_team: Option<BeforeCreateTeamHook>,
35 pub after_create_team: Option<AfterCreateTeamHook>,
36 pub before_update_team: Option<BeforeUpdateTeamHook>,
37 pub after_update_team: Option<AfterUpdateTeamHook>,
38 pub before_delete_team: Option<BeforeDeleteTeamHook>,
39 pub after_delete_team: Option<AfterDeleteTeamHook>,
40 pub before_add_team_member: Option<BeforeAddTeamMemberHook>,
41 pub after_add_team_member: Option<AfterAddTeamMemberHook>,
42 pub before_remove_team_member: Option<BeforeRemoveTeamMemberHook>,
43 pub after_remove_team_member: Option<AfterRemoveTeamMemberHook>,
44}
45
46pub type BeforeCreateOrganizationHook = Arc<
47 dyn Fn(&BeforeCreateOrganization) -> Result<OrganizationHookData, RustAuthError> + Send + Sync,
48>;
49pub type AfterCreateOrganizationHook =
50 Arc<dyn Fn(&AfterCreateOrganization) -> Result<(), RustAuthError> + Send + Sync>;
51pub type BeforeUpdateOrganizationHook = Arc<
52 dyn Fn(&BeforeUpdateOrganization) -> Result<OrganizationUpdateData, RustAuthError>
53 + Send
54 + Sync,
55>;
56pub type AfterUpdateOrganizationHook =
57 Arc<dyn Fn(&AfterUpdateOrganization) -> Result<(), RustAuthError> + Send + Sync>;
58pub type BeforeDeleteOrganizationHook =
59 Arc<dyn Fn(&BeforeDeleteOrganization) -> Result<(), RustAuthError> + Send + Sync>;
60pub type AfterDeleteOrganizationHook =
61 Arc<dyn Fn(&AfterDeleteOrganization) -> Result<(), RustAuthError> + Send + Sync>;
62pub type BeforeAddMemberHook =
63 Arc<dyn Fn(&BeforeAddMember) -> Result<MemberHookData, RustAuthError> + Send + Sync>;
64pub type AfterAddMemberHook =
65 Arc<dyn Fn(&AfterAddMember) -> Result<(), RustAuthError> + Send + Sync>;
66pub type BeforeRemoveMemberHook =
67 Arc<dyn Fn(&BeforeRemoveMember) -> Result<(), RustAuthError> + Send + Sync>;
68pub type AfterRemoveMemberHook =
69 Arc<dyn Fn(&AfterRemoveMember) -> Result<(), RustAuthError> + Send + Sync>;
70pub type BeforeUpdateMemberRoleHook = Arc<
71 dyn Fn(&BeforeUpdateMemberRole) -> Result<MemberRoleUpdateData, RustAuthError> + Send + Sync,
72>;
73pub type AfterUpdateMemberRoleHook =
74 Arc<dyn Fn(&AfterUpdateMemberRole) -> Result<(), RustAuthError> + Send + Sync>;
75pub type BeforeCreateInvitationHook =
76 Arc<dyn Fn(&BeforeCreateInvitation) -> Result<InvitationHookData, RustAuthError> + Send + Sync>;
77pub type AfterCreateInvitationHook =
78 Arc<dyn Fn(&AfterCreateInvitation) -> Result<(), RustAuthError> + Send + Sync>;
79pub type BeforeAcceptInvitationHook =
80 Arc<dyn Fn(&BeforeAcceptInvitation) -> Result<(), RustAuthError> + Send + Sync>;
81pub type AfterAcceptInvitationHook =
82 Arc<dyn Fn(&AfterAcceptInvitation) -> Result<(), RustAuthError> + Send + Sync>;
83pub type BeforeRejectInvitationHook =
84 Arc<dyn Fn(&BeforeRejectInvitation) -> Result<(), RustAuthError> + Send + Sync>;
85pub type AfterRejectInvitationHook =
86 Arc<dyn Fn(&AfterRejectInvitation) -> Result<(), RustAuthError> + Send + Sync>;
87pub type BeforeCancelInvitationHook =
88 Arc<dyn Fn(&BeforeCancelInvitation) -> Result<(), RustAuthError> + Send + Sync>;
89pub type AfterCancelInvitationHook =
90 Arc<dyn Fn(&AfterCancelInvitation) -> Result<(), RustAuthError> + Send + Sync>;
91pub type BeforeCreateTeamHook =
92 Arc<dyn Fn(&BeforeCreateTeam) -> Result<TeamHookData, RustAuthError> + Send + Sync>;
93pub type AfterCreateTeamHook =
94 Arc<dyn Fn(&AfterCreateTeam) -> Result<(), RustAuthError> + Send + Sync>;
95pub type BeforeUpdateTeamHook =
96 Arc<dyn Fn(&BeforeUpdateTeam) -> Result<TeamHookData, RustAuthError> + Send + Sync>;
97pub type AfterUpdateTeamHook =
98 Arc<dyn Fn(&AfterUpdateTeam) -> Result<(), RustAuthError> + Send + Sync>;
99pub type BeforeDeleteTeamHook =
100 Arc<dyn Fn(&BeforeDeleteTeam) -> Result<(), RustAuthError> + Send + Sync>;
101pub type AfterDeleteTeamHook =
102 Arc<dyn Fn(&AfterDeleteTeam) -> Result<(), RustAuthError> + Send + Sync>;
103pub type BeforeAddTeamMemberHook =
104 Arc<dyn Fn(&BeforeAddTeamMember) -> Result<TeamMemberHookData, RustAuthError> + Send + Sync>;
105pub type AfterAddTeamMemberHook =
106 Arc<dyn Fn(&AfterAddTeamMember) -> Result<(), RustAuthError> + Send + Sync>;
107pub type BeforeRemoveTeamMemberHook =
108 Arc<dyn Fn(&BeforeRemoveTeamMember) -> Result<(), RustAuthError> + Send + Sync>;
109pub type AfterRemoveTeamMemberHook =
110 Arc<dyn Fn(&AfterRemoveTeamMember) -> Result<(), RustAuthError> + Send + Sync>;
111
112#[derive(Debug, Clone)]
113pub struct BeforeCreateOrganization {
114 pub organization: OrganizationHookData,
115 pub user: User,
116}
117
118#[derive(Debug, Clone)]
119pub struct OrganizationHookData {
120 pub name: String,
121 pub slug: String,
122}
123
124#[derive(Debug, Clone)]
125pub struct AfterCreateOrganization {
126 pub organization: Organization,
127 pub member: Member,
128 pub user: User,
129}
130
131#[derive(Debug, Clone, Default)]
132pub struct OrganizationUpdateData {
133 pub name: Option<String>,
134 pub slug: Option<String>,
135 pub logo: Option<String>,
136 pub metadata: Option<serde_json::Value>,
137}
138
139#[derive(Debug, Clone)]
140pub struct BeforeUpdateOrganization {
141 pub organization: Organization,
142 pub user: User,
143 pub data: OrganizationUpdateData,
144}
145
146#[derive(Debug, Clone)]
147pub struct AfterUpdateOrganization {
148 pub organization: Organization,
149 pub user: User,
150}
151
152#[derive(Debug, Clone)]
153pub struct BeforeDeleteOrganization {
154 pub organization: Organization,
155 pub user: User,
156}
157
158#[derive(Debug, Clone)]
159pub struct AfterDeleteOrganization {
160 pub organization: Organization,
161 pub user: User,
162}
163
164#[derive(Debug, Clone)]
165pub struct BeforeAddMember {
166 pub organization: Organization,
167 pub user: User,
168 pub member: MemberHookData,
169}
170
171#[derive(Debug, Clone)]
172pub struct MemberHookData {
173 pub organization_id: String,
174 pub user_id: String,
175 pub role: String,
176}
177
178#[derive(Debug, Clone)]
179pub struct AfterAddMember {
180 pub organization: Organization,
181 pub member: Member,
182 pub user: User,
183}
184
185#[derive(Debug, Clone)]
186pub struct BeforeRemoveMember {
187 pub organization: Organization,
188 pub member: Member,
189 pub user: User,
190}
191
192#[derive(Debug, Clone)]
193pub struct AfterRemoveMember {
194 pub organization: Organization,
195 pub member: Member,
196 pub user: User,
197}
198
199#[derive(Debug, Clone)]
200pub struct MemberRoleUpdateData {
201 pub role: String,
202}
203
204#[derive(Debug, Clone)]
205pub struct BeforeUpdateMemberRole {
206 pub organization: Organization,
207 pub member: Member,
208 pub new_role: String,
209 pub user: User,
210}
211
212#[derive(Debug, Clone)]
213pub struct AfterUpdateMemberRole {
214 pub organization: Organization,
215 pub member: Member,
216 pub previous_role: String,
217 pub user: User,
218}
219
220#[derive(Debug, Clone)]
221pub struct InvitationHookData {
222 pub organization_id: String,
223 pub email: String,
224 pub role: String,
225 pub team_id: Option<String>,
226 pub inviter_id: String,
227 pub expires_at: OffsetDateTime,
228}
229
230#[derive(Debug, Clone)]
231pub struct BeforeCreateInvitation {
232 pub organization: Organization,
233 pub inviter: User,
234 pub invitation: InvitationHookData,
235}
236
237#[derive(Debug, Clone)]
238pub struct AfterCreateInvitation {
239 pub organization: Organization,
240 pub inviter: User,
241 pub invitation: Invitation,
242}
243
244#[derive(Debug, Clone)]
245pub struct BeforeAcceptInvitation {
246 pub organization: Organization,
247 pub invitation: Invitation,
248 pub user: User,
249}
250
251#[derive(Debug, Clone)]
252pub struct AfterAcceptInvitation {
253 pub organization: Organization,
254 pub invitation: Invitation,
255 pub member: Member,
256 pub user: User,
257}
258
259#[derive(Debug, Clone)]
260pub struct BeforeRejectInvitation {
261 pub organization: Organization,
262 pub invitation: Invitation,
263 pub user: User,
264}
265
266#[derive(Debug, Clone)]
267pub struct AfterRejectInvitation {
268 pub organization: Organization,
269 pub invitation: Invitation,
270 pub user: User,
271}
272
273#[derive(Debug, Clone)]
274pub struct BeforeCancelInvitation {
275 pub organization: Organization,
276 pub invitation: Invitation,
277 pub cancelled_by: User,
278}
279
280#[derive(Debug, Clone)]
281pub struct AfterCancelInvitation {
282 pub organization: Organization,
283 pub invitation: Invitation,
284 pub cancelled_by: User,
285}
286
287#[derive(Debug, Clone)]
288pub struct TeamHookData {
289 pub organization_id: String,
290 pub name: String,
291}
292
293#[derive(Debug, Clone)]
294pub struct BeforeCreateTeam {
295 pub organization: Organization,
296 pub team: TeamHookData,
297 pub user: User,
298}
299
300#[derive(Debug, Clone)]
301pub struct AfterCreateTeam {
302 pub organization: Organization,
303 pub team: Team,
304 pub user: User,
305}
306
307#[derive(Debug, Clone)]
308pub struct BeforeUpdateTeam {
309 pub organization: Organization,
310 pub team: Team,
311 pub updates: TeamHookData,
312 pub user: User,
313}
314
315#[derive(Debug, Clone)]
316pub struct AfterUpdateTeam {
317 pub organization: Organization,
318 pub team: Option<Team>,
319 pub user: User,
320}
321
322#[derive(Debug, Clone)]
323pub struct BeforeDeleteTeam {
324 pub organization: Organization,
325 pub team: Team,
326 pub user: User,
327}
328
329#[derive(Debug, Clone)]
330pub struct AfterDeleteTeam {
331 pub organization: Organization,
332 pub team: Team,
333 pub user: User,
334}
335
336#[derive(Debug, Clone)]
337pub struct TeamMemberHookData {
338 pub team_id: String,
339 pub user_id: String,
340}
341
342#[derive(Debug, Clone)]
343pub struct BeforeAddTeamMember {
344 pub organization: Organization,
345 pub team: Team,
346 pub team_member: TeamMemberHookData,
347 pub user: User,
348}
349
350#[derive(Debug, Clone)]
351pub struct AfterAddTeamMember {
352 pub organization: Organization,
353 pub team: Team,
354 pub team_member: TeamMember,
355 pub user: User,
356}
357
358#[derive(Debug, Clone)]
359pub struct BeforeRemoveTeamMember {
360 pub organization: Organization,
361 pub team: Team,
362 pub team_member: TeamMember,
363 pub user: User,
364}
365
366#[derive(Debug, Clone)]
367pub struct AfterRemoveTeamMember {
368 pub organization: Organization,
369 pub team: Team,
370 pub team_member: TeamMember,
371 pub user: User,
372}