@pleaseai/agent 0.1.16 → 0.1.18

package/.output/server/node_modules/better-auth/dist/plugins/organization/client.mjs

@@ -0,0 +1,107 @@
+import { useAuthQuery } from "../../client/query.mjs";
+import "../../client/index.mjs";
+import { adminAc, defaultRoles, memberAc, ownerAc } from "./access/statement.mjs";
+import "./access/index.mjs";
+import { ORGANIZATION_ERROR_CODES } from "./error-codes.mjs";
+import { hasPermissionFn } from "./permission.mjs";
+import { atom } from "nanostores";
+
+//#region src/plugins/organization/client.ts
+/**
+* Using the same `hasPermissionFn` function, but without the need for a `ctx` parameter or the `organizationId` parameter.
+*/
+const clientSideHasPermission = (input) => {
+	return hasPermissionFn(input, input.options.roles || defaultRoles);
+};
+const organizationClient = (options) => {
+	const $listOrg = atom(false);
+	const $activeOrgSignal = atom(false);
+	const $activeMemberSignal = atom(false);
+	const $activeMemberRoleSignal = atom(false);
+	const roles = {
+		admin: adminAc,
+		member: memberAc,
+		owner: ownerAc,
+		...options?.roles
+	};
+	return {
+		id: "organization",
+		$InferServerPlugin: {},
+		getActions: ($fetch, _$store, co) => ({
+			$Infer: {
+				ActiveOrganization: {},
+				Organization: {},
+				Invitation: {},
+				Member: {},
+				Team: {}
+			},
+			organization: { checkRolePermission: (data) => {
+				return clientSideHasPermission({
+					role: data.role,
+					options: {
+						ac: options?.ac,
+						roles
+					},
+					permissions: data.permissions
+				});
+			} }
+		}),
+		getAtoms: ($fetch) => {
+			const listOrganizations = useAuthQuery($listOrg, "/organization/list", $fetch, { method: "GET" });
+			return {
+				$listOrg,
+				$activeOrgSignal,
+				$activeMemberSignal,
+				$activeMemberRoleSignal,
+				activeOrganization: useAuthQuery([$activeOrgSignal], "/organization/get-full-organization", $fetch, () => ({ method: "GET" })),
+				listOrganizations,
+				activeMember: useAuthQuery([$activeOrgSignal, $activeMemberSignal], "/organization/get-active-member", $fetch, { method: "GET" }),
+				activeMemberRole: useAuthQuery([$activeOrgSignal, $activeMemberRoleSignal], "/organization/get-active-member-role", $fetch, { method: "GET" })
+			};
+		},
+		pathMethods: {
+			"/organization/get-full-organization": "GET",
+			"/organization/list-user-teams": "GET"
+		},
+		atomListeners: [
+			{
+				matcher(path) {
+					return path === "/organization/create" || path === "/organization/delete" || path === "/organization/update";
+				},
+				signal: "$listOrg"
+			},
+			{
+				matcher(path) {
+					return path.startsWith("/organization");
+				},
+				signal: "$activeOrgSignal"
+			},
+			{
+				matcher(path) {
+					return path.startsWith("/organization/set-active") || path === "/organization/create" || path === "/organization/delete" || path === "/organization/remove-member" || path === "/organization/leave" || path === "/organization/accept-invitation";
+				},
+				signal: "$sessionSignal"
+			},
+			{
+				matcher(path) {
+					return path.includes("/organization/update-member-role") || path.startsWith("/organization/set-active");
+				},
+				signal: "$activeMemberSignal"
+			},
+			{
+				matcher(path) {
+					return path.includes("/organization/update-member-role") || path.startsWith("/organization/set-active");
+				},
+				signal: "$activeMemberRoleSignal"
+			}
+		],
+		$ERROR_CODES: ORGANIZATION_ERROR_CODES
+	};
+};
+const inferOrgAdditionalFields = (schema) => {
+	return {};
+};
+
+//#endregion
+export { clientSideHasPermission, inferOrgAdditionalFields, organizationClient };
+//# sourceMappingURL=client.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/organization/error-codes.mjs

@@ -0,0 +1,66 @@
+import { defineErrorCodes } from "@better-auth/core/utils/error-codes";
+
+//#region src/plugins/organization/error-codes.ts
+const ORGANIZATION_ERROR_CODES = defineErrorCodes({
+	YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_ORGANIZATION: "You are not allowed to create a new organization",
+	YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_ORGANIZATIONS: "You have reached the maximum number of organizations",
+	ORGANIZATION_ALREADY_EXISTS: "Organization already exists",
+	ORGANIZATION_SLUG_ALREADY_TAKEN: "Organization slug already taken",
+	ORGANIZATION_NOT_FOUND: "Organization not found",
+	USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION: "User is not a member of the organization",
+	YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_ORGANIZATION: "You are not allowed to update this organization",
+	YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_ORGANIZATION: "You are not allowed to delete this organization",
+	NO_ACTIVE_ORGANIZATION: "No active organization",
+	USER_IS_ALREADY_A_MEMBER_OF_THIS_ORGANIZATION: "User is already a member of this organization",
+	MEMBER_NOT_FOUND: "Member not found",
+	ROLE_NOT_FOUND: "Role not found",
+	YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM: "You are not allowed to create a new team",
+	TEAM_ALREADY_EXISTS: "Team already exists",
+	TEAM_NOT_FOUND: "Team not found",
+	YOU_CANNOT_LEAVE_THE_ORGANIZATION_AS_THE_ONLY_OWNER: "You cannot leave the organization as the only owner",
+	YOU_CANNOT_LEAVE_THE_ORGANIZATION_WITHOUT_AN_OWNER: "You cannot leave the organization without an owner",
+	YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_MEMBER: "You are not allowed to delete this member",
+	YOU_ARE_NOT_ALLOWED_TO_INVITE_USERS_TO_THIS_ORGANIZATION: "You are not allowed to invite users to this organization",
+	USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION: "User is already invited to this organization",
+	INVITATION_NOT_FOUND: "Invitation not found",
+	YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION: "You are not the recipient of the invitation",
+	EMAIL_VERIFICATION_REQUIRED_BEFORE_ACCEPTING_OR_REJECTING_INVITATION: "Email verification required before accepting or rejecting invitation",
+	YOU_ARE_NOT_ALLOWED_TO_CANCEL_THIS_INVITATION: "You are not allowed to cancel this invitation",
+	INVITER_IS_NO_LONGER_A_MEMBER_OF_THE_ORGANIZATION: "Inviter is no longer a member of the organization",
+	YOU_ARE_NOT_ALLOWED_TO_INVITE_USER_WITH_THIS_ROLE: "You are not allowed to invite a user with this role",
+	FAILED_TO_RETRIEVE_INVITATION: "Failed to retrieve invitation",
+	YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_TEAMS: "You have reached the maximum number of teams",
+	UNABLE_TO_REMOVE_LAST_TEAM: "Unable to remove last team",
+	YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_MEMBER: "You are not allowed to update this member",
+	ORGANIZATION_MEMBERSHIP_LIMIT_REACHED: "Organization membership limit reached",
+	YOU_ARE_NOT_ALLOWED_TO_CREATE_TEAMS_IN_THIS_ORGANIZATION: "You are not allowed to create teams in this organization",
+	YOU_ARE_NOT_ALLOWED_TO_DELETE_TEAMS_IN_THIS_ORGANIZATION: "You are not allowed to delete teams in this organization",
+	YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM: "You are not allowed to update this team",
+	YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_TEAM: "You are not allowed to delete this team",
+	INVITATION_LIMIT_REACHED: "Invitation limit reached",
+	TEAM_MEMBER_LIMIT_REACHED: "Team member limit reached",
+	USER_IS_NOT_A_MEMBER_OF_THE_TEAM: "User is not a member of the team",
+	YOU_CAN_NOT_ACCESS_THE_MEMBERS_OF_THIS_TEAM: "You are not allowed to list the members of this team",
+	YOU_DO_NOT_HAVE_AN_ACTIVE_TEAM: "You do not have an active team",
+	YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM_MEMBER: "You are not allowed to create a new member",
+	YOU_ARE_NOT_ALLOWED_TO_REMOVE_A_TEAM_MEMBER: "You are not allowed to remove a team member",
+	YOU_ARE_NOT_ALLOWED_TO_ACCESS_THIS_ORGANIZATION: "You are not allowed to access this organization as an owner",
+	YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION: "You are not a member of this organization",
+	MISSING_AC_INSTANCE: "Dynamic Access Control requires a pre-defined ac instance on the server auth plugin. Read server logs for more information",
+	YOU_MUST_BE_IN_AN_ORGANIZATION_TO_CREATE_A_ROLE: "You must be in an organization to create a role",
+	YOU_ARE_NOT_ALLOWED_TO_CREATE_A_ROLE: "You are not allowed to create a role",
+	YOU_ARE_NOT_ALLOWED_TO_UPDATE_A_ROLE: "You are not allowed to update a role",
+	YOU_ARE_NOT_ALLOWED_TO_DELETE_A_ROLE: "You are not allowed to delete a role",
+	YOU_ARE_NOT_ALLOWED_TO_READ_A_ROLE: "You are not allowed to read a role",
+	YOU_ARE_NOT_ALLOWED_TO_LIST_A_ROLE: "You are not allowed to list a role",
+	YOU_ARE_NOT_ALLOWED_TO_GET_A_ROLE: "You are not allowed to get a role",
+	TOO_MANY_ROLES: "This organization has too many roles",
+	INVALID_RESOURCE: "The provided permission includes an invalid resource",
+	ROLE_NAME_IS_ALREADY_TAKEN: "That role name is already taken",
+	CANNOT_DELETE_A_PRE_DEFINED_ROLE: "Cannot delete a pre-defined role",
+	ROLE_IS_ASSIGNED_TO_MEMBERS: "Cannot delete a role that is assigned to members. Please reassign the members to a different role first"
+});
+
+//#endregion
+export { ORGANIZATION_ERROR_CODES };
+//# sourceMappingURL=error-codes.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/organization/has-permission.mjs

@@ -0,0 +1,36 @@
+import { APIError } from "../../api/index.mjs";
+import { defaultRoles } from "./access/statement.mjs";
+import "./access/index.mjs";
+import { cacheAllRoles, hasPermissionFn } from "./permission.mjs";
+import * as z from "zod";
+
+//#region src/plugins/organization/has-permission.ts
+const hasPermission = async (input, ctx) => {
+	let acRoles = { ...input.options.roles || defaultRoles };
+	if (ctx && input.organizationId && input.options.dynamicAccessControl?.enabled && input.options.ac && !input.useMemoryCache) {
+		const roles = await ctx.context.adapter.findMany({
+			model: "organizationRole",
+			where: [{
+				field: "organizationId",
+				value: input.organizationId
+			}]
+		});
+		for (const { role, permission: permissionsString } of roles) {
+			const result = z.record(z.string(), z.array(z.string())).safeParse(JSON.parse(permissionsString));
+			if (!result.success) {
+				ctx.context.logger.error("[hasPermission] Invalid permissions for role " + role, { permissions: JSON.parse(permissionsString) });
+				throw new APIError("INTERNAL_SERVER_ERROR", { message: "Invalid permissions for role " + role });
+			}
+			const merged = { ...acRoles[role]?.statements };
+			for (const [key, actions] of Object.entries(result.data)) merged[key] = [...new Set([...merged[key] ?? [], ...actions])];
+			acRoles[role] = input.options.ac.newRole(merged);
+		}
+	}
+	if (input.useMemoryCache) acRoles = cacheAllRoles.get(input.organizationId) || acRoles;
+	cacheAllRoles.set(input.organizationId, acRoles);
+	return hasPermissionFn(input, acRoles);
+};
+
+//#endregion
+export { hasPermission };
+//# sourceMappingURL=has-permission.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/organization/index.mjs

@@ -0,0 +1,5 @@
+import { getOrgAdapter } from "./adapter.mjs";
+import { hasPermission } from "./has-permission.mjs";
+import { organization, parseRoles } from "./organization.mjs";
+
+export { getOrgAdapter, hasPermission, organization, parseRoles };

package/.output/server/node_modules/better-auth/dist/plugins/organization/organization.mjs

@@ -0,0 +1,428 @@
+import { getSessionFromCtx } from "../../api/routes/session.mjs";
+import "../../api/index.mjs";
+import { defaultRoles } from "./access/statement.mjs";
+import "./access/index.mjs";
+import { ORGANIZATION_ERROR_CODES } from "./error-codes.mjs";
+import { getOrgAdapter } from "./adapter.mjs";
+import { shimContext } from "../../utils/shim.mjs";
+import { orgSessionMiddleware } from "./call.mjs";
+import { hasPermission } from "./has-permission.mjs";
+import { createOrgRole, deleteOrgRole, getOrgRole, listOrgRoles, updateOrgRole } from "./routes/crud-access-control.mjs";
+import { acceptInvitation, cancelInvitation, createInvitation, getInvitation, listInvitations, listUserInvitations, rejectInvitation } from "./routes/crud-invites.mjs";
+import { addMember, getActiveMember, getActiveMemberRole, leaveOrganization, listMembers, removeMember, updateMemberRole } from "./routes/crud-members.mjs";
+import { checkOrganizationSlug, createOrganization, deleteOrganization, getFullOrganization, listOrganizations, setActiveOrganization, updateOrganization } from "./routes/crud-org.mjs";
+import { addTeamMember, createTeam, listOrganizationTeams, listTeamMembers, listUserTeams, removeTeam, removeTeamMember, setActiveTeam, updateTeam } from "./routes/crud-team.mjs";
+import { APIError } from "@better-auth/core/error";
+import { createAuthEndpoint } from "@better-auth/core/api";
+import * as z from "zod";
+
+//#region src/plugins/organization/organization.ts
+function parseRoles(roles) {
+	return Array.isArray(roles) ? roles.join(",") : roles;
+}
+const createHasPermissionBodySchema = z.object({ organizationId: z.string().optional() }).and(z.union([z.object({
+	permission: z.record(z.string(), z.array(z.string())),
+	permissions: z.undefined()
+}), z.object({
+	permission: z.undefined(),
+	permissions: z.record(z.string(), z.array(z.string()))
+})]));
+const createHasPermission = (options) => {
+	return createAuthEndpoint("/organization/has-permission", {
+		method: "POST",
+		requireHeaders: true,
+		body: createHasPermissionBodySchema,
+		use: [orgSessionMiddleware],
+		metadata: {
+			$Infer: { body: {} },
+			openapi: {
+				description: "Check if the user has permission",
+				requestBody: { content: { "application/json": { schema: {
+					type: "object",
+					properties: {
+						permission: {
+							type: "object",
+							description: "The permission to check",
+							deprecated: true
+						},
+						permissions: {
+							type: "object",
+							description: "The permission to check"
+						}
+					},
+					required: ["permissions"]
+				} } } },
+				responses: { "200": {
+					description: "Success",
+					content: { "application/json": { schema: {
+						type: "object",
+						properties: {
+							error: { type: "string" },
+							success: { type: "boolean" }
+						},
+						required: ["success"]
+					} } }
+				} }
+			}
+		}
+	}, async (ctx) => {
+		const activeOrganizationId = ctx.body.organizationId || ctx.context.session.session.activeOrganizationId;
+		if (!activeOrganizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.NO_ACTIVE_ORGANIZATION);
+		const member = await getOrgAdapter(ctx.context, options).findMemberByOrgId({
+			userId: ctx.context.session.user.id,
+			organizationId: activeOrganizationId
+		});
+		if (!member) throw APIError.from("UNAUTHORIZED", ORGANIZATION_ERROR_CODES.USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION);
+		const result = await hasPermission({
+			role: member.role,
+			options,
+			permissions: ctx.body.permissions,
+			organizationId: activeOrganizationId
+		}, ctx);
+		return ctx.json({
+			error: null,
+			success: result
+		});
+	});
+};
+function organization(options) {
+	const opts = options || {};
+	let endpoints = {
+		createOrganization: createOrganization(opts),
+		updateOrganization: updateOrganization(opts),
+		deleteOrganization: deleteOrganization(opts),
+		setActiveOrganization: setActiveOrganization(opts),
+		getFullOrganization: getFullOrganization(opts),
+		listOrganizations: listOrganizations(opts),
+		createInvitation: createInvitation(opts),
+		cancelInvitation: cancelInvitation(opts),
+		acceptInvitation: acceptInvitation(opts),
+		getInvitation: getInvitation(opts),
+		rejectInvitation: rejectInvitation(opts),
+		listInvitations: listInvitations(opts),
+		getActiveMember: getActiveMember(opts),
+		checkOrganizationSlug: checkOrganizationSlug(opts),
+		addMember: addMember(opts),
+		removeMember: removeMember(opts),
+		updateMemberRole: updateMemberRole(opts),
+		leaveOrganization: leaveOrganization(opts),
+		listUserInvitations: listUserInvitations(opts),
+		listMembers: listMembers(opts),
+		getActiveMemberRole: getActiveMemberRole(opts)
+	};
+	const teamSupport = opts.teams?.enabled;
+	const teamEndpoints = {
+		createTeam: createTeam(opts),
+		listOrganizationTeams: listOrganizationTeams(opts),
+		removeTeam: removeTeam(opts),
+		updateTeam: updateTeam(opts),
+		setActiveTeam: setActiveTeam(opts),
+		listUserTeams: listUserTeams(opts),
+		listTeamMembers: listTeamMembers(opts),
+		addTeamMember: addTeamMember(opts),
+		removeTeamMember: removeTeamMember(opts)
+	};
+	if (teamSupport) endpoints = {
+		...endpoints,
+		...teamEndpoints
+	};
+	const dynamicAccessControlEndpoints = {
+		createOrgRole: createOrgRole(opts),
+		deleteOrgRole: deleteOrgRole(opts),
+		listOrgRoles: listOrgRoles(opts),
+		getOrgRole: getOrgRole(opts),
+		updateOrgRole: updateOrgRole(opts)
+	};
+	if (opts.dynamicAccessControl?.enabled) endpoints = {
+		...endpoints,
+		...dynamicAccessControlEndpoints
+	};
+	const roles = {
+		...defaultRoles,
+		...opts.roles
+	};
+	const teamSchema = teamSupport ? {
+		team: {
+			modelName: opts.schema?.team?.modelName,
+			fields: {
+				name: {
+					type: "string",
+					required: true,
+					fieldName: opts.schema?.team?.fields?.name
+				},
+				organizationId: {
+					type: "string",
+					required: true,
+					references: {
+						model: "organization",
+						field: "id"
+					},
+					fieldName: opts.schema?.team?.fields?.organizationId,
+					index: true
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					fieldName: opts.schema?.team?.fields?.createdAt
+				},
+				updatedAt: {
+					type: "date",
+					required: false,
+					fieldName: opts.schema?.team?.fields?.updatedAt,
+					onUpdate: () => /* @__PURE__ */ new Date()
+				},
+				...opts.schema?.team?.additionalFields || {}
+			}
+		},
+		teamMember: {
+			modelName: opts.schema?.teamMember?.modelName,
+			fields: {
+				teamId: {
+					type: "string",
+					required: true,
+					references: {
+						model: "team",
+						field: "id"
+					},
+					fieldName: opts.schema?.teamMember?.fields?.teamId,
+					index: true
+				},
+				userId: {
+					type: "string",
+					required: true,
+					references: {
+						model: "user",
+						field: "id"
+					},
+					fieldName: opts.schema?.teamMember?.fields?.userId,
+					index: true
+				},
+				createdAt: {
+					type: "date",
+					required: false,
+					fieldName: opts.schema?.teamMember?.fields?.createdAt
+				}
+			}
+		}
+	} : {};
+	const organizationRoleSchema = opts.dynamicAccessControl?.enabled ? { organizationRole: {
+		fields: {
+			organizationId: {
+				type: "string",
+				required: true,
+				references: {
+					model: "organization",
+					field: "id"
+				},
+				fieldName: opts.schema?.organizationRole?.fields?.organizationId,
+				index: true
+			},
+			role: {
+				type: "string",
+				required: true,
+				fieldName: opts.schema?.organizationRole?.fields?.role,
+				index: true
+			},
+			permission: {
+				type: "string",
+				required: true,
+				fieldName: opts.schema?.organizationRole?.fields?.permission
+			},
+			createdAt: {
+				type: "date",
+				required: true,
+				defaultValue: () => /* @__PURE__ */ new Date(),
+				fieldName: opts.schema?.organizationRole?.fields?.createdAt
+			},
+			updatedAt: {
+				type: "date",
+				required: false,
+				fieldName: opts.schema?.organizationRole?.fields?.updatedAt,
+				onUpdate: () => /* @__PURE__ */ new Date()
+			},
+			...opts.schema?.organizationRole?.additionalFields || {}
+		},
+		modelName: opts.schema?.organizationRole?.modelName
+	} } : {};
+	const schema = {
+		organization: {
+			modelName: opts.schema?.organization?.modelName,
+			fields: {
+				name: {
+					type: "string",
+					required: true,
+					sortable: true,
+					fieldName: opts.schema?.organization?.fields?.name
+				},
+				slug: {
+					type: "string",
+					required: true,
+					unique: true,
+					sortable: true,
+					fieldName: opts.schema?.organization?.fields?.slug,
+					index: true
+				},
+				logo: {
+					type: "string",
+					required: false,
+					fieldName: opts.schema?.organization?.fields?.logo
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					fieldName: opts.schema?.organization?.fields?.createdAt
+				},
+				metadata: {
+					type: "string",
+					required: false,
+					fieldName: opts.schema?.organization?.fields?.metadata
+				},
+				...opts.schema?.organization?.additionalFields || {}
+			}
+		},
+		...organizationRoleSchema,
+		...teamSchema,
+		member: {
+			modelName: opts.schema?.member?.modelName,
+			fields: {
+				organizationId: {
+					type: "string",
+					required: true,
+					references: {
+						model: "organization",
+						field: "id"
+					},
+					fieldName: opts.schema?.member?.fields?.organizationId,
+					index: true
+				},
+				userId: {
+					type: "string",
+					required: true,
+					fieldName: opts.schema?.member?.fields?.userId,
+					references: {
+						model: "user",
+						field: "id"
+					},
+					index: true
+				},
+				role: {
+					type: "string",
+					required: true,
+					sortable: true,
+					defaultValue: "member",
+					fieldName: opts.schema?.member?.fields?.role
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					fieldName: opts.schema?.member?.fields?.createdAt
+				},
+				...opts.schema?.member?.additionalFields || {}
+			}
+		},
+		invitation: {
+			modelName: opts.schema?.invitation?.modelName,
+			fields: {
+				organizationId: {
+					type: "string",
+					required: true,
+					references: {
+						model: "organization",
+						field: "id"
+					},
+					fieldName: opts.schema?.invitation?.fields?.organizationId,
+					index: true
+				},
+				email: {
+					type: "string",
+					required: true,
+					sortable: true,
+					fieldName: opts.schema?.invitation?.fields?.email,
+					index: true
+				},
+				role: {
+					type: "string",
+					required: false,
+					sortable: true,
+					fieldName: opts.schema?.invitation?.fields?.role
+				},
+				...teamSupport ? { teamId: {
+					type: "string",
+					required: false,
+					sortable: true,
+					fieldName: opts.schema?.invitation?.fields?.teamId
+				} } : {},
+				status: {
+					type: "string",
+					required: true,
+					sortable: true,
+					defaultValue: "pending",
+					fieldName: opts.schema?.invitation?.fields?.status
+				},
+				expiresAt: {
+					type: "date",
+					required: true,
+					fieldName: opts.schema?.invitation?.fields?.expiresAt
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					fieldName: opts.schema?.invitation?.fields?.createdAt,
+					defaultValue: () => /* @__PURE__ */ new Date()
+				},
+				inviterId: {
+					type: "string",
+					references: {
+						model: "user",
+						field: "id"
+					},
+					fieldName: opts.schema?.invitation?.fields?.inviterId,
+					required: true
+				},
+				...opts.schema?.invitation?.additionalFields || {}
+			}
+		}
+	};
+	return {
+		id: "organization",
+		endpoints: {
+			...shimContext(endpoints, {
+				orgOptions: opts,
+				roles,
+				getSession: async (context) => {
+					return await getSessionFromCtx(context);
+				}
+			}),
+			hasPermission: createHasPermission(opts)
+		},
+		schema: {
+			...schema,
+			session: { fields: {
+				activeOrganizationId: {
+					type: "string",
+					required: false,
+					fieldName: opts.schema?.session?.fields?.activeOrganizationId
+				},
+				...teamSupport ? { activeTeamId: {
+					type: "string",
+					required: false,
+					fieldName: opts.schema?.session?.fields?.activeTeamId
+				} } : {}
+			} }
+		},
+		$Infer: {
+			Organization: {},
+			Invitation: {},
+			Member: {},
+			Team: teamSupport ? {} : {},
+			TeamMember: teamSupport ? {} : {},
+			ActiveOrganization: {}
+		},
+		$ERROR_CODES: ORGANIZATION_ERROR_CODES,
+		options: opts
+	};
+}
+
+//#endregion
+export { organization, parseRoles };
+//# sourceMappingURL=organization.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/organization/permission.mjs

@@ -0,0 +1,16 @@
+//#region src/plugins/organization/permission.ts
+const hasPermissionFn = (input, acRoles) => {
+	if (!input.permissions) return false;
+	const roles = input.role.split(",");
+	const creatorRole = input.options.creatorRole || "owner";
+	const isCreator = roles.includes(creatorRole);
+	const allowCreatorsAllPermissions = input.allowCreatorAllPermissions || false;
+	if (isCreator && allowCreatorsAllPermissions) return true;
+	for (const role of roles) if ((acRoles[role]?.authorize(input.permissions))?.success) return true;
+	return false;
+};
+const cacheAllRoles = /* @__PURE__ */ new Map();
+
+//#endregion
+export { cacheAllRoles, hasPermissionFn };
+//# sourceMappingURL=permission.mjs.map