Organization

import { betterAuth } from "better-auth";
import { organization } from "better-auth/plugins";

export const auth = betterAuth({
  plugins: [
    organization({
      organizationHooks: {
        // 조직 생성 훅
        beforeCreateOrganization: async ({ organization, user }) => {
          // 조직이 생성되기 전에 사용자 정의 로직 실행
          // 선택적으로 조직 데이터 수정
          return {
            data: {
              ...organization,
              metadata: {
                customField: "value",
              },
            },
          };
        },

        afterCreateOrganization: async ({ organization, member, user }) => {
          // 조직이 생성된 후 사용자 정의 로직 실행
          // 예: 기본 리소스 생성, 알림 전송
          await setupDefaultResources(organization.id);
        },

        // 조직 업데이트 훅
        beforeUpdateOrganization: async ({ organization, user, member }) => {
          // 업데이트 검증, 비즈니스 규칙 적용
          return {
            data: {
              ...organization,
              name: organization.name?.toLowerCase(),
            },
          };
        },

        afterUpdateOrganization: async ({ organization, user, member }) => {
          // 외부 시스템에 변경사항 동기화
          await syncOrganizationToExternalSystems(organization);
        },
      },
    }),
  ],
});

import { betterAuth } from "better-auth";
import { organization } from "better-auth/plugins";

export const auth = betterAuth({
  plugins: [
    organization({
      organizationHooks: {
        // 멤버가 조직에 추가되기 전
        beforeAddMember: async ({ member, user, organization }) => {
          // 사용자 정의 검증 또는 수정
          console.log(`${user.email}을(를) ${organization.name}에 추가 중`);

          // 선택적으로 멤버 데이터 수정
          return {
            data: {
              ...member,
              role: "custom-role", // 역할 재정의
            },
          };
        },

        // 멤버가 추가된 후
        afterAddMember: async ({ member, user, organization }) => {
          // 환영 이메일 전송, 기본 리소스 생성 등
          await sendWelcomeEmail(user.email, organization.name);
        },

        // 멤버가 제거되기 전
        beforeRemoveMember: async ({ member, user, organization }) => {
          // 사용자의 리소스 정리, 알림 전송 등
          await cleanupUserResources(user.id, organization.id);
        },

        // 멤버가 제거된 후
        afterRemoveMember: async ({ member, user, organization }) => {
          await logMemberRemoval(user.id, organization.id);
        },

        // 멤버의 역할을 업데이트하기 전
        beforeUpdateMemberRole: async ({
          member,
          newRole,
          user,
          organization,
        }) => {
          // 역할 변경 권한 검증
          if (newRole === "owner" && !hasOwnerUpgradePermission(user)) {
            throw new Error("owner 역할로 업그레이드할 수 없습니다");
          }

          // 선택적으로 역할 수정
          return {
            data: {
              role: newRole,
            },
          };
        },

        // 멤버의 역할을 업데이트한 후
        afterUpdateMemberRole: async ({
          member,
          previousRole,
          user,
          organization,
        }) => {
          await logRoleChange(user.id, previousRole, member.role);
        },
      },
    }),
  ],
});

export const auth = betterAuth({
  plugins: [
    organization({
      organizationHooks: {
        // 초대를 생성하기 전
        beforeCreateInvitation: async ({
          invitation,
          inviter,
          organization,
        }) => {
          // 사용자 정의 검증 또는 만료 로직
          const customExpiration = new Date(
            Date.now() + 1000 * 60 * 60 * 24 * 7
          ); // 7일

          return {
            data: {
              ...invitation,
              expiresAt: customExpiration,
            },
          };
        },

        // 초대를 생성한 후
        afterCreateInvitation: async ({
          invitation,
          inviter,
          organization,
        }) => {
          // 사용자 정의 초대 이메일 전송, 메트릭 추적 등
          await sendCustomInvitationEmail(invitation, organization);
        },

        // 초대를 수락하기 전
        beforeAcceptInvitation: async ({ invitation, user, organization }) => {
          // 수락 전 추가 검증
          await validateUserEligibility(user, organization);
        },

        // 초대를 수락한 후
        afterAcceptInvitation: async ({
          invitation,
          member,
          user,
          organization,
        }) => {
          // 사용자 계정 설정, 기본 리소스 할당
          await setupNewMemberResources(user, organization);
        },

        // 초대를 거부하기 전/후
        beforeRejectInvitation: async ({ invitation, user, organization }) => {
          // 거부 이유 로깅, 초대자에게 알림 전송
        },

        afterRejectInvitation: async ({ invitation, user, organization }) => {
          await notifyInviterOfRejection(invitation.inviterId, user.email);
        },

        // 초대를 취소하기 전/후
        beforeCancelInvitation: async ({
          invitation,
          cancelledBy,
          organization,
        }) => {
          // 취소 권한 확인
        },

        afterCancelInvitation: async ({
          invitation,
          cancelledBy,
          organization,
        }) => {
          await logInvitationCancellation(invitation.id, cancelledBy.id);
        },
      },
    }),
  ],
});

export const auth = betterAuth({
  plugins: [
    organization({
      teams: { enabled: true },
      organizationHooks: {
        // 팀을 생성하기 전
        beforeCreateTeam: async ({ team, user, organization }) => {
          // 팀 이름 검증, 명명 규칙 적용
          return {
            data: {
              ...team,
              name: team.name.toLowerCase().replace(/\s+/g, "-"),
            },
          };
        },

        // 팀을 생성한 후
        afterCreateTeam: async ({ team, user, organization }) => {
          // 기본 팀 리소스, 채널 등 생성
          await createDefaultTeamResources(team.id);
        },

        // 팀을 업데이트하기 전
        beforeUpdateTeam: async ({ team, updates, user, organization }) => {
          // 업데이트 검증, 비즈니스 규칙 적용
          return {
            data: {
              ...updates,
              name: updates.name?.toLowerCase(),
            },
          };
        },

        // 팀을 업데이트한 후
        afterUpdateTeam: async ({ team, user, organization }) => {
          await syncTeamChangesToExternalSystems(team);
        },

        // 팀을 삭제하기 전
        beforeDeleteTeam: async ({ team, user, organization }) => {
          // 팀 데이터 백업, 멤버에게 알림
          await backupTeamData(team.id);
        },

        // 팀을 삭제한 후
        afterDeleteTeam: async ({ team, user, organization }) => {
          await cleanupTeamResources(team.id);
        },

        // 팀 멤버 작업
        beforeAddTeamMember: async ({
          teamMember,
          team,
          user,
          organization,
        }) => {
          // 팀 멤버십 제한, 권한 검증
          const memberCount = await getTeamMemberCount(team.id);
          if (memberCount >= 10) {
            throw new Error("팀이 가득 찼습니다");
          }
        },

        afterAddTeamMember: async ({
          teamMember,
          team,
          user,
          organization,
        }) => {
          await grantTeamAccess(user.id, team.id);
        },

        beforeRemoveTeamMember: async ({
          teamMember,
          team,
          user,
          organization,
        }) => {
          // 사용자의 팀 관련 데이터 백업
          await backupTeamMemberData(user.id, team.id);
        },

        afterRemoveTeamMember: async ({
          teamMember,
          team,
          user,
          organization,
        }) => {
          await revokeTeamAccess(user.id, team.id);
        },
      },
    }),
  ],
});

import { APIError } from "better-auth/api";

export const auth = betterAuth({
  plugins: [
    organization({
      organizationHooks: {
        beforeAddMember: async ({ member, user, organization }) => {
          // 사용자의 위반 사항 확인
          const violations = await checkUserViolations(user.id);
          if (violations.length > 0) {
            throw new APIError("BAD_REQUEST", {
              message:
                "사용자에게 미해결 위반 사항이 있어 조직에 가입할 수 없습니다",
            });
          }
        },

        beforeCreateTeam: async ({ team, user, organization }) => {
          // 팀 이름 고유성 검증
          const existingTeam = await findTeamByName(team.name, organization.id);
          if (existingTeam) {
            throw new APIError("BAD_REQUEST", {
              message: "이 조직에 이미 존재하는 팀 이름입니다",
            });
          }
        },
      },
    }),
  ],
});

export const auth = betterAuth({
  databaseHooks: {
    session: {
      create: {
        before: async (session) => {
          const organization = await getActiveOrganization(session.userId);
          return {
            data: {
              ...session,
              activeOrganizationId: organization.id,
            },
          };
        },
      },
    },
  },
});

import { betterAuth } from "better-auth";
import { organization } from "better-auth/plugins";
import { sendOrganizationInvitation } from "./email";
export const auth = betterAuth({
  plugins: [
    organization({
      async sendInvitationEmail(data) {
        const inviteLink = `https://example.com/accept-invitation/${data.id}`;
        sendOrganizationInvitation({
          email: data.email,
          invitedByUsername: data.inviter.user.name,
          invitedByEmail: data.inviter.user.email,
          teamName: data.organization.name,
          inviteLink,
        });
      },
    }),
  ],
});

import { betterAuth } from "better-auth";
import { organization } from "better-auth/plugins";

export const auth = betterAuth({
  plugins: [
    organization({
      async sendInvitationEmail(data) {
        // ... 초대 이메일 로직
      },
      async onInvitationAccepted(data) {
        // 이 콜백은 초대가 수락될 때 트리거됩니다
      },
    }),
  ],
});

const invitations = await authClient.organization.listUserInvitations();

const invitations = await auth.api.listUserInvitations({
  query: {
    email: "user@example.com",
  },
});

import { auth } from "@/auth";

await auth.api.hasPermission({
  headers: await headers(),
  body: {
    permissions: {
      project: ["create"], // 접근 제어의 구조와 일치해야 합니다
    },
  },
});

// 여러 리소스 권한을 동시에 확인할 수도 있습니다
await auth.api.hasPermission({
  headers: await headers(),
  body: {
    permissions: {
      project: ["create"], // 접근 제어의 구조와 일치해야 합니다
      sale: ["create"],
    },
  },
});

const canCreateProject = await authClient.organization.hasPermission({
  permissions: {
    project: ["create"],
  },
});

// 여러 리소스 권한을 동시에 확인할 수도 있습니다
const canCreateProjectAndCreateSale =
  await authClient.organization.hasPermission({
    permissions: {
      project: ["create"],
      sale: ["create"],
    },
  });

const canCreateProject = authClient.organization.checkRolePermission({
  permissions: {
    organization: ["delete"],
  },
  role: "admin",
});

// 여러 리소스 권한을 동시에 확인할 수도 있습니다
const canCreateProjectAndCreateSale =
  authClient.organization.checkRolePermission({
    permissions: {
      organization: ["delete"],
      member: ["delete"],
    },
    role: "admin",
  });

import { createAuthClient } from "better-auth/client"
import { organizationClient, inferOrgAdditionalFields } from "better-auth/client/plugins"
import type { auth } from "./auth"

export const authClient = createAuthClient({
    plugins: [
        organizationClient({
            schema: inferOrgAdditionalFields<typeof auth>()
        })
    ]
})

import { createAuthClient } from "better-auth/client"
import { organizationClient } from "better-auth/client/plugins"

export const authClient = createAuthClient({
    plugins: [
        organizationClient({
            schema: {
                organizationRole: {
                    additionalFields: {
                        color: {
                            type: "string",
                            defaultValue: "#ffffff",
                        }
                    }
                }
            }
        })
    ]
})

import { betterAuth } from "better-auth";
import { organization } from "better-auth/plugins";

export const auth = betterAuth({
  plugins: [
    organization({
      teams: {
        enabled: true,
        maximumTeams: 10, // 선택 사항: 조직당 팀 제한
        allowRemovingAllTeams: false, // 선택 사항: 마지막 팀 제거 방지
      },
    }),
  ],
});

import { createAuthClient } from "better-auth/client";
import { organizationClient } from "better-auth/client/plugins";

export const authClient = createAuthClient({
  plugins: [
    organizationClient({
      teams: {
        enabled: true,
      },
    }),
  ],
});