@xenterprises/nuxt-x-auth-better 0.3.1 → 0.4.0

package/app/composables/useOrganization.ts

@@ -0,0 +1,532 @@
+import { computed } from 'vue';
+import type { Organization, OrganizationMember, OrganizationInvitation, OrganizationTeam, PermissionCheck } from './types';
+
+export function useOrganization() {
+  const config = useAppConfig();
+  // The authClient singleton is created with organizationClient(), but its type
+  // is not inferred through useXAuth's module-level singleton. Cast to any is
+  // intentional: the plugin is guaranteed at runtime and the composable owns
+  // all org-specific client calls.
+  const { authClient } = useXAuth() as { authClient: any };
+  const toast = useToast();
+
+  const orgConfig = computed(() => config.xAuth?.organization || {});
+  const isEnabled = computed(() =>
+    config.xAuth?.features?.organization !== false && orgConfig.value?.enabled !== false
+  );
+  const teamsEnabled = computed(() =>
+    isEnabled.value && orgConfig.value?.teams !== false
+  );
+
+  const listQuery = authClient.useListOrganizations();
+  const activeQuery = authClient.useActiveOrganization();
+  const activeMemberQuery = authClient.organization.useActiveMember ? authClient.organization.useActiveMember() : null;
+  const activeMemberRoleQuery = authClient.organization.useActiveMemberRole ? authClient.organization.useActiveMemberRole() : null;
+
+  const organizations = computed<Organization[]>(() => listQuery.value.data || []);
+  const organizationsLoading = computed(() => listQuery.value.isPending);
+  const organizationsError = computed(() => listQuery.value.error || null);
+
+  const activeOrganization = computed<Organization | null>(() => activeQuery.value.data || null);
+  const activeLoading = computed(() => activeQuery.value.isPending);
+  const activeError = computed(() => activeQuery.value.error || null);
+
+  const activeMember = computed<OrganizationMember | null>(() => activeMemberQuery?.value?.data || null);
+  const activeMemberRole = computed<string | null>(() => activeMemberRoleQuery?.value?.data?.role || null);
+
+  const members = computed<OrganizationMember[]>(() => activeQuery.value.data?.members || []);
+  const invitations = computed<OrganizationInvitation[]>(() => activeQuery.value.data?.invitations || []);
+  const teams = computed<OrganizationTeam[]>(() => activeQuery.value.data?.teams || []);
+
+  const showSuccess = (title: string, description?: string) => {
+    toast.add({
+      title,
+      description,
+      icon: 'i-lucide-check-circle',
+      color: 'success',
+    });
+  };
+
+  const showError = (title: string, description?: string) => {
+    toast.add({
+      title,
+      description,
+      icon: 'i-lucide-alert-circle',
+      color: 'error',
+    });
+  };
+
+  const withErrorHandling = async <T>(
+    title: string,
+    fn: () => Promise<{ data?: T | null; error?: { message?: string } | null }>,
+    success?: { title?: string; description?: string }
+  ): Promise<T | null | { error: string }> => {
+    try {
+      const result = await fn();
+      if (result.error) {
+        showError(title, result.error.message || 'An error occurred.');
+        return { error: result.error.message || 'An error occurred.' };
+      }
+      if (success?.title) {
+        showSuccess(success.title, success.description);
+      }
+      return result.data || null;
+    } catch (err: any) {
+      showError(title, err.message || 'An unexpected error occurred.');
+      return { error: err.message || 'An unexpected error occurred.' };
+    }
+  };
+
+  const ensureEnabled = (label: string): null | { error: string } => {
+    if (!isEnabled.value) {
+      showError(`${label} Failed`, 'Organizations are not enabled.');
+      return { error: 'Organizations are not enabled.' };
+    }
+    return null;
+  };
+
+  const createOrganization = async (name: string, slug?: string, logo?: string) => {
+    const disabled = ensureEnabled('Create Organization');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Create Organization',
+      () => authClient.organization.create({
+        name,
+        slug,
+        logo,
+      }),
+      { title: 'Organization Created', description: `${name} has been created.` }
+    );
+  };
+
+  const updateOrganization = async (data: { organizationId?: string; name?: string; slug?: string; logo?: string }) => {
+    const disabled = ensureEnabled('Update Organization');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Update Organization',
+      () => authClient.organization.update(data),
+      { title: 'Organization Updated' }
+    );
+  };
+
+  const deleteOrganization = async (organizationId?: string) => {
+    const disabled = ensureEnabled('Delete Organization');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Delete Organization',
+      () => authClient.organization.delete({ organizationId }),
+      { title: 'Organization Deleted' }
+    );
+  };
+
+  const setActiveOrganization = async (organizationId?: string | null, organizationSlug?: string) => {
+    const disabled = ensureEnabled('Set Active Organization');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Set Active Organization',
+      () => authClient.organization.setActive({ organizationId: organizationId || null, organizationSlug }),
+      { title: 'Active Organization Updated' }
+    );
+  };
+
+  const getFullOrganization = async (organizationId?: string, organizationSlug?: string) => {
+    const disabled = ensureEnabled('Get Organization');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Get Organization',
+      () => authClient.organization.getFullOrganization({ organizationId, organizationSlug })
+    );
+  };
+
+  const checkSlug = async (slug: string) => {
+    const disabled = ensureEnabled('Check Slug');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Check Slug',
+      () => authClient.organization.checkSlug({ slug })
+    );
+  };
+
+  const listMembers = async (organizationId?: string) => {
+    const disabled = ensureEnabled('List Members');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'List Members',
+      () => authClient.organization.listMembers({ organizationId })
+    );
+  };
+
+  const updateMemberRole = async (memberId: string, role: string | string[], organizationId?: string) => {
+    const disabled = ensureEnabled('Update Member Role');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Update Member Role',
+      () => authClient.organization.updateMemberRole({ memberId, role, organizationId }),
+      { title: 'Member Role Updated' }
+    );
+  };
+
+  const removeMember = async (memberId: string, organizationId?: string) => {
+    const disabled = ensureEnabled('Remove Member');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Remove Member',
+      () => authClient.organization.removeMember({ memberId, organizationId }),
+      { title: 'Member Removed' }
+    );
+  };
+
+  const leaveOrganization = async () => {
+    const disabled = ensureEnabled('Leave Organization');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Leave Organization',
+      () => authClient.organization.leave(),
+      { title: 'Left Organization' }
+    );
+  };
+
+  const inviteMember = async (email: string, role: string | string[], organizationId?: string) => {
+    const disabled = ensureEnabled('Invite Member');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Invite Member',
+      () => authClient.organization.inviteMember({ email, role, organizationId }),
+      { title: 'Invitation Sent', description: `An invitation has been sent to ${email}.` }
+    );
+  };
+
+  const cancelInvitation = async (invitationId: string) => {
+    const disabled = ensureEnabled('Cancel Invitation');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Cancel Invitation',
+      () => authClient.organization.cancelInvitation({ invitationId }),
+      { title: 'Invitation Canceled' }
+    );
+  };
+
+  const acceptInvitation = async (invitationId: string) => {
+    const disabled = ensureEnabled('Accept Invitation');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Accept Invitation',
+      () => authClient.organization.acceptInvitation({ invitationId }),
+      { title: 'Invitation Accepted' }
+    );
+  };
+
+  const rejectInvitation = async (invitationId: string) => {
+    const disabled = ensureEnabled('Reject Invitation');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Reject Invitation',
+      () => authClient.organization.rejectInvitation({ invitationId }),
+      { title: 'Invitation Rejected' }
+    );
+  };
+
+  const getInvitation = async (invitationId: string) => {
+    const disabled = ensureEnabled('Get Invitation');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'Get Invitation',
+      () => authClient.organization.getInvitation({ invitationId })
+    );
+  };
+
+  const listInvitations = async (organizationId?: string) => {
+    const disabled = ensureEnabled('List Invitations');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'List Invitations',
+      () => authClient.organization.listInvitations({ organizationId })
+    );
+  };
+
+  const listUserInvitations = async () => {
+    const disabled = ensureEnabled('List User Invitations');
+    if (disabled) return disabled;
+
+    return withErrorHandling(
+      'List User Invitations',
+      () => authClient.organization.listUserInvitations()
+    );
+  };
+
+  const listTeams = async (organizationId?: string) => {
+    const disabled = ensureEnabled('List Teams');
+    if (disabled) return disabled;
+
+    if (!teamsEnabled.value) {
+      showError('List Teams Failed', 'Teams are not enabled.');
+      return { error: 'Teams are not enabled.' };
+    }
+
+    return withErrorHandling(
+      'List Teams',
+      () => authClient.organization.listTeams({ organizationId })
+    );
+  };
+
+  const createTeam = async (name: string, organizationId?: string) => {
+    const disabled = ensureEnabled('Create Team');
+    if (disabled) return disabled;
+
+    if (!teamsEnabled.value) {
+      showError('Create Team Failed', 'Teams are not enabled.');
+      return { error: 'Teams are not enabled.' };
+    }
+
+    return withErrorHandling(
+      'Create Team',
+      () => authClient.organization.createTeam({ name, organizationId }),
+      { title: 'Team Created' }
+    );
+  };
+
+  const updateTeam = async (teamId: string, data: { name?: string }, organizationId?: string) => {
+    const disabled = ensureEnabled('Update Team');
+    if (disabled) return disabled;
+
+    if (!teamsEnabled.value) {
+      showError('Update Team Failed', 'Teams are not enabled.');
+      return { error: 'Teams are not enabled.' };
+    }
+
+    return withErrorHandling(
+      'Update Team',
+      () => authClient.organization.updateTeam({ teamId, ...data, organizationId }),
+      { title: 'Team Updated' }
+    );
+  };
+
+  const deleteTeam = async (teamId: string, organizationId?: string) => {
+    const disabled = ensureEnabled('Delete Team');
+    if (disabled) return disabled;
+
+    if (!teamsEnabled.value) {
+      showError('Delete Team Failed', 'Teams are not enabled.');
+      return { error: 'Teams are not enabled.' };
+    }
+
+    return withErrorHandling(
+      'Delete Team',
+      () => authClient.organization.deleteTeam({ teamId, organizationId }),
+      { title: 'Team Deleted' }
+    );
+  };
+
+  const setActiveTeam = async (teamId: string) => {
+    const disabled = ensureEnabled('Set Active Team');
+    if (disabled) return disabled;
+
+    if (!teamsEnabled.value) {
+      showError('Set Active Team Failed', 'Teams are not enabled.');
+      return { error: 'Teams are not enabled.' };
+    }
+
+    return withErrorHandling(
+      'Set Active Team',
+      () => authClient.organization.setActiveTeam({ teamId }),
+      { title: 'Active Team Updated' }
+    );
+  };
+
+  const listTeamMembers = async (teamId: string) => {
+    const disabled = ensureEnabled('List Team Members');
+    if (disabled) return disabled;
+
+    if (!teamsEnabled.value) {
+      showError('List Team Members Failed', 'Teams are not enabled.');
+      return { error: 'Teams are not enabled.' };
+    }
+
+    return withErrorHandling(
+      'List Team Members',
+      () => authClient.organization.listTeamMembers({ teamId })
+    );
+  };
+
+  const addTeamMember = async (teamId: string, memberId: string, organizationId?: string) => {
+    const disabled = ensureEnabled('Add Team Member');
+    if (disabled) return disabled;
+
+    if (!teamsEnabled.value) {
+      showError('Add Team Member Failed', 'Teams are not enabled.');
+      return { error: 'Teams are not enabled.' };
+    }
+
+    return withErrorHandling(
+      'Add Team Member',
+      () => authClient.organization.addTeamMember({ teamId, memberId, organizationId }),
+      { title: 'Team Member Added' }
+    );
+  };
+
+  const removeTeamMember = async (teamId: string, memberId: string) => {
+    const disabled = ensureEnabled('Remove Team Member');
+    if (disabled) return disabled;
+
+    if (!teamsEnabled.value) {
+      showError('Remove Team Member Failed', 'Teams are not enabled.');
+      return { error: 'Teams are not enabled.' };
+    }
+
+    return withErrorHandling(
+      'Remove Team Member',
+      () => authClient.organization.removeTeamMember({ teamId, memberId }),
+      { title: 'Team Member Removed' }
+    );
+  };
+
+  const listUserTeams = async () => {
+    const disabled = ensureEnabled('List User Teams');
+    if (disabled) return disabled;
+
+    if (!teamsEnabled.value) {
+      showError('List User Teams Failed', 'Teams are not enabled.');
+      return { error: 'Teams are not enabled.' };
+    }
+
+    return withErrorHandling(
+      'List User Teams',
+      () => authClient.organization.listUserTeams()
+    );
+  };
+
+  const hasPermission = (permissionCheck: PermissionCheck): boolean => {
+    if (!isEnabled.value) return false;
+    try {
+      return authClient.organization.hasPermission(permissionCheck);
+    } catch (err: any) {
+      return false;
+    }
+  };
+
+  const checkRolePermission = (role: string, permissions: Record<string, string[]>): boolean => {
+    if (!isEnabled.value) return false;
+    try {
+      return authClient.organization.checkRolePermission({ role, permissions });
+    } catch (err: any) {
+      return false;
+    }
+  };
+
+  const getDefaultPermissions = (role: string): Record<string, string[]> => {
+    switch (role) {
+      case 'owner':
+        return {
+          organization: ['update', 'delete'],
+          member: ['create', 'update', 'delete'],
+          invitation: ['create', 'cancel'],
+          team: ['create', 'update', 'delete'],
+        };
+      case 'admin':
+        return {
+          organization: ['update'],
+          member: ['create', 'update', 'delete'],
+          invitation: ['create', 'cancel'],
+          team: ['create', 'update', 'delete'],
+        };
+      case 'member':
+      default:
+        return {
+          organization: [],
+          member: [],
+          invitation: [],
+          team: [],
+        };
+    }
+  };
+
+  const canCreateOrganization = computed(() =>
+    orgConfig.value?.allowUserToCreateOrganization !== false
+  );
+
+  const isOrgAdmin = computed(() => {
+    const role = activeMemberRole.value || activeMember.value?.role || '';
+    return role === 'owner' || role === 'admin' || role.split(',').includes('owner') || role.split(',').includes('admin');
+  });
+
+  const isOrgOwner = computed(() => {
+    const role = activeMemberRole.value || activeMember.value?.role || '';
+    return role === 'owner' || role.split(',').includes('owner');
+  });
+
+  return {
+    isEnabled,
+    teamsEnabled,
+    config: orgConfig,
+
+    organizations,
+    organizationsLoading,
+    organizationsError,
+
+    activeOrganization,
+    activeLoading,
+    activeError,
+
+    activeMember,
+    activeMemberRole,
+    members,
+    invitations,
+    teams,
+
+    canCreateOrganization,
+    isOrgAdmin,
+    isOrgOwner,
+
+    createOrganization,
+    updateOrganization,
+    deleteOrganization,
+    setActiveOrganization,
+    getFullOrganization,
+    checkSlug,
+
+    listMembers,
+    updateMemberRole,
+    removeMember,
+    leaveOrganization,
+
+    inviteMember,
+    cancelInvitation,
+    acceptInvitation,
+    rejectInvitation,
+    getInvitation,
+    listInvitations,
+    listUserInvitations,
+
+    listTeams,
+    createTeam,
+    updateTeam,
+    deleteTeam,
+    setActiveTeam,
+    listTeamMembers,
+    addTeamMember,
+    removeTeamMember,
+    listUserTeams,
+
+    hasPermission,
+    checkRolePermission,
+    getDefaultPermissions,
+
+    authClient,
+  };
+}

package/app/composables/useXAuth.ts

@@ -1,5 +1,6 @@
 import { computed, ref } from 'vue';
 import { createAuthClient } from 'better-auth/vue';
+import { organizationClient } from 'better-auth/client/plugins';
 import type { AuthUser, AuthConfig } from './types';
 
 let authClientInstance: ReturnType<typeof createAuthClient> | null = null;
@@ -28,6 +29,13 @@ export function useXAuth() {
       fetchOptions: {
         credentials: 'include',
       },
+      plugins: [
+        organizationClient({
+          teams: {
+            enabled: true,
+          },
+        }),
+      ],
     });
   }
 
@@ -47,7 +55,6 @@ export function useXAuth() {
       description,
       icon: 'i-lucide-check-circle',
       color: 'success',
-      timeout: 2000,
     });
   };
 
@@ -57,7 +64,6 @@ export function useXAuth() {
       description,
       icon: 'i-lucide-alert-circle',
       color: 'error',
-      timeout: 3000,
     });
   };
 
@@ -102,7 +108,7 @@ export function useXAuth() {
       const result = await authClient.signUp.email({
         email,
         password,
-        name: name || email.split('@')[0],
+        name: name ?? (email.split('@')[0] || email),
       });
 
       if (result.error) {
@@ -157,7 +163,7 @@ export function useXAuth() {
     }
 
     try {
-      const result = await authClient.resetPassword({
+      const result = await authClient.requestPasswordReset({
         email,
         redirectTo: `${getOrigin()}/auth/handler/password-reset`,
       });
@@ -257,7 +263,7 @@ export function useXAuth() {
   const getToken = async (): Promise<string | null> => {
     try {
       const session = await authClient.getSession();
-      return session.data?.session?.accessToken || null;
+      return session.data?.session?.token || null;
     } catch {
       return null;
     }