组织

await authClient.organization.create({
    name: "My Organization",
    slug: "my-org",
    logo: "https://example.com/logo.png"
})

await authClient.organization.checkSlug({
    slug: "my-org",
});

import { betterAuth } from "better-auth"
import { organization } from "better-auth/plugins"
 
export const auth = betterAuth({
    plugins: [
        organization({
            organizationCreation: {
                disabled: false, // 设置为true以禁用组织创建
                beforeCreate: async ({ organization, user }, request) => {
                    // 在组织创建前运行自定义逻辑
                    // 可选地修改组织数据
                    return {
                        data: {
                            ...organization,
                            metadata: {
                                customField: "value"
                            }
                        }
                    }
                },
                afterCreate: async ({ organization, member, user }, request) => {
                    // 在组织创建后运行自定义逻辑
                    // 例如，创建默认资源，发送通知
                    await setupDefaultResources(organization.id)
                }
            }
        })
    ]
})

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

await client.organization.update({
  data: {
    name: "updated-name",
    logo: "new-logo.url",
    metadata: {
      customerId: "test"
    },
    slug: "updated-slug"
  },
  organizationId: 'org-id' //默认为当前活跃组织
})

await authClient.organization.delete({
  organizationId: "test"
});

const auth = betterAuth({
  plugins: [
    organization({
      organizationDeletion: {
        disabled: true, //完全禁用删除功能
        beforeDelete: async (data, request) => {
          // 删除组织前运行的回调
        },
        afterDelete: async (data, request) => {
          // 删除组织后运行的回调
        },
      },
    }),
  ],
});

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
					})
			},
		}),
	],
});

await authClient.organization.inviteMember({
    email: "test@email.com",
    role: "admin", //这也可以是多个角色的数组（例如 ["admin", "sale"]）
})

await authClient.organization.acceptInvitation({
    invitationId: "invitation-id"
})

//取消邀请
await authClient.organization.cancelInvitation({
    invitationId: "invitation-id"
})
 
//拒绝邀请（需要在收到邀请的用户登录时调用）
await authClient.organization.rejectInvitation({
    invitationId: "invitation-id"
})

client.organization.getInvitation({
    query: {
        id: params.id
    }
})

const invitations = await authClient.organization.listInvitations({
    query: {
        organizationId: "organization-id" // 可选，默认将使用活跃组织
    }
})

//移除成员
await authClient.organization.removeMember({
    memberIdOrEmail: "member-id", // 这也可以是成员的电子邮件
    organizationId: "organization-id" // 可选，默认将使用活跃组织
})

await authClient.organization.updateMemberRole({
    memberId: "member-id",
    role: "admin" // 这也可以是多个角色的数组（例如 ["admin", "sale"]）
})

const member = await authClient.organization.getActiveMember()

import { auth } from "@/auth";
 
auth.api.addMember({
  body: {
      userId: "user-id",
      organizationId: "organization-id",
      role: "admin", // 这也可以是多个角色的数组（例如 ["admin", "sale"]）
      teamId: "team-id" // 可选指定teamId将成员添加到团队。（需要启用teams）
  }
})

await authClient.organization.leave({
    organizationId: "organization-id"
})

import { auth } from "@/auth";
auth.api.hasPermission({
  headers: await headers(),
    body: {
      permissions: {
        project: ["create"] // 这必须匹配您的访问控制中的结构
      }
    }
});
 
// 您也可以同时检查多个资源权限
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 = client.organization.checkRolePermission({
	permissions: {
		organization: ["delete"],
	},
	role: "admin",
});
 
// 您也可以同时检查多个资源权限
const canCreateProjectAndCreateSale = client.organization.checkRolePermission({
	permissions: {
		organization: ["delete"],
    member: ["delete"]
	},
	role: "admin",
});

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 client = createAuthClient({
    plugins: [
        organizationClient({
            teams: {
                enabled: true
            }
        })
    ]
})

const team = await client.organization.createTeam({
    name: "Development Team",
    organizationId: "org-id" // 可选：默认为活跃组织
})

const teams = await authClient.organization.listTeams({
  query: {
    organizationId: org.id, // 可选：默认为活跃组织
  },
});

const updatedTeam = await client.organization.updateTeam({
    teamId: "team-id",
    data: {
        name: "Updated Team Name"
    }
})

await client.organization.removeTeam({
    teamId: "team-id",
    organizationId: "org-id" // 可选：默认为活跃组织
})

await client.organization.inviteMember({
    email: "user@example.com",
    role: "member",
    teamId: "team-id"
})

const auth = betterAuth({
  plugins: [organization({
    schema: {
      organization: {
        modelName: "organizations",  //将organization表映射到organizations
        fields: {
          name: "title" //将name字段映射到title
        }
      }
    }
  })]
})