@meistrari/auth-nuxt 0.2.0 → 1.0.0

package/dist/runtime/composables/api-key.js

@@ -0,0 +1,29 @@
+import { useCookie, useRuntimeConfig } from "#app";
+import { createNuxtAuthClient } from "../shared.js";
+export function useTelaApiKey() {
+  const { jwtCookieName, apiUrl } = useRuntimeConfig().public.telaAuth;
+  const tokenCookie = useCookie(jwtCookieName);
+  const authClient = createNuxtAuthClient(apiUrl, () => tokenCookie.value ?? null);
+  async function createApiKey(payload) {
+    return authClient.apiKey.createApiKey(payload);
+  }
+  async function updateApiKey(payload) {
+    return authClient.apiKey.updateApiKey(payload);
+  }
+  async function deleteApiKey(id) {
+    return authClient.apiKey.deleteApiKey(id);
+  }
+  async function listApiKeys() {
+    return authClient.apiKey.listApiKeys();
+  }
+  async function getApiKey(id) {
+    return authClient.apiKey.getApiKey(id);
+  }
+  return {
+    createApiKey,
+    updateApiKey,
+    deleteApiKey,
+    listApiKeys,
+    getApiKey
+  };
+}

package/dist/runtime/composables/organization.d.ts

@@ -0,0 +1,115 @@
+import type { Ref } from 'vue';
+import type { CreateTeamPayload, FullOrganization, Invitation, InviteUserToOrganizationOptions, ListMembersOptions, Member, RemoveUserFromOrganizationOptions, Team, TeamMember, UpdateMemberRoleOptions, UpdateOrganizationPayload, UpdateTeamPayload } from '@meistrari/auth-core';
+import { type FullOrganizationWithRelations } from './state.js';
+export interface UseTelaOrganizationReturn {
+    /** Reactive reference to the active organization with members, invitations, and teams. */
+    activeOrganization: Ref<FullOrganizationWithRelations | null>;
+    /** Reactive reference to the current user's membership in the active organization. */
+    activeMember: Ref<Member | null>;
+    /**
+     * Retrieves the active organization for the current user session and updates the active organization state.
+     * @returns The active organization with members, invitations, and teams
+     */
+    getActiveOrganization: () => Promise<FullOrganizationWithRelations | undefined>;
+    /**
+     * Lists all organizations for the current user session.
+     * @returns A list of organizations
+     */
+    listOrganizations: () => Promise<FullOrganization[]>;
+    /**
+     * Sets the active organization for the current user session and updates the active organization state.
+     * @param id - The ID of the organization to set as active
+     */
+    setActiveOrganization: (id: string) => Promise<void>;
+    /**
+     * Updates the active organization for the current user session and updates the active organization state.
+     * @param payload - The organization fields to update
+     * @returns The updated organization
+     */
+    updateOrganization: (payload: UpdateOrganizationPayload) => Promise<FullOrganization>;
+    /**
+     * Lists the members of the active organization.
+     * @param options - Pagination options
+     * @returns A list of members
+     */
+    listMembers: (options?: ListMembersOptions) => Promise<Member[]>;
+    /**
+     * Retrieves the active member of the current user session.
+     * @returns The active member
+     */
+    getActiveMember: () => Promise<Member>;
+    /**
+     * Invites a user to the active organization.
+     * @param options - Invitation configuration
+     * @returns The invitation
+     */
+    inviteUserToOrganization: (options: InviteUserToOrganizationOptions) => Promise<Invitation>;
+    /**
+     * Accepts an organization invitation and updates the active organization state.
+     * @param id - The invitation ID to accept
+     */
+    acceptInvitation: (id: string) => Promise<void>;
+    /**
+     * Cancels a pending organization invitation and updates the active organization state.
+     * @param id - The invitation ID to cancel
+     */
+    cancelInvitation: (id: string) => Promise<void>;
+    /**
+     * Removes a user from the active organization.
+     * @param options - User identifier (either memberId or userEmail must be provided)
+     */
+    removeUserFromOrganization: (options: RemoveUserFromOrganizationOptions) => Promise<void>;
+    /**
+     * Updates the role of an organization member.
+     * @param options - Role update configuration
+     */
+    updateMemberRole: (options: UpdateMemberRoleOptions) => Promise<void>;
+    /**
+     * Creates a new team within the active organization.
+     * @param payload - Team configuration
+     * @returns The created team
+     */
+    createTeam: (payload: CreateTeamPayload) => Promise<Team>;
+    /**
+     * Updates an existing team's details.
+     * @param id - The team ID to update
+     * @param payload - Team fields to update
+     * @returns The updated team
+     */
+    updateTeam: (id: string, payload: UpdateTeamPayload) => Promise<Team>;
+    /**
+     * Deletes a team from the active organization.
+     * @param id - The team ID to delete
+     */
+    deleteTeam: (id: string) => Promise<void>;
+    /**
+     * Lists all teams in the active organization.
+     * @returns An array of teams
+     */
+    listTeams: () => Promise<Team[]>;
+    /**
+     * Lists all members of a specific team.
+     * @param id - The team ID
+     * @returns An array of team members
+     */
+    listTeamMembers: (id: string) => Promise<TeamMember[]>;
+    /**
+     * Adds a user to a team.
+     * @param teamId - The team ID
+     * @param userId - The user ID to add
+     * @returns The added team member
+     */
+    addTeamMember: (teamId: string, userId: string) => Promise<TeamMember>;
+    /**
+     * Removes a user from a team.
+     * @param teamId - The team ID
+     * @param userId - The user ID to remove
+     */
+    removeTeamMember: (teamId: string, userId: string) => Promise<void>;
+}
+/**
+ * Composable for managing organizations and their members, invitations, and teams.
+ *
+ * @returns An object containing organization management functions and the active organization and member states.
+ */
+export declare function useTelaOrganization(): UseTelaOrganizationReturn;

package/dist/runtime/composables/organization.js

@@ -0,0 +1,164 @@
+import { useCookie, useRuntimeConfig } from "#app";
+import { createNuxtAuthClient } from "../shared.js";
+import { useOrganizationState, useSessionState } from "./state.js";
+export function useTelaOrganization() {
+  const { activeOrganization, activeMember } = useOrganizationState();
+  const { session } = useSessionState();
+  const { jwtCookieName, apiUrl } = useRuntimeConfig().public.telaAuth;
+  const tokenCookie = useCookie(jwtCookieName);
+  const authClient = createNuxtAuthClient(apiUrl, () => tokenCookie.value ?? null);
+  async function getActiveOrganization() {
+    if (!session.value?.activeOrganizationId) {
+      return;
+    }
+    const organization = await authClient.organization.getOrganization(
+      session.value?.activeOrganizationId,
+      {
+        includeMembers: true,
+        includeInvitations: true,
+        includeTeams: true
+      }
+    );
+    activeOrganization.value = organization;
+    return organization;
+  }
+  async function listOrganizations() {
+    return authClient.organization.listOrganizations();
+  }
+  async function setActiveOrganization(id) {
+    await authClient.organization.setActiveOrganization(id);
+    const organization = await authClient.organization.getOrganization(id, {
+      includeMembers: true,
+      includeInvitations: true,
+      includeTeams: true
+    });
+    activeOrganization.value = organization;
+  }
+  async function updateOrganization(payload) {
+    if (!activeOrganization.value) {
+      throw new Error("No active organization found");
+    }
+    const organization = await authClient.organization.updateOrganization(payload);
+    activeOrganization.value = { ...activeOrganization.value, ...organization };
+    return organization;
+  }
+  async function listMembers(options) {
+    return authClient.organization.listMembers(options);
+  }
+  async function getActiveMember() {
+    const member = await authClient.organization.getActiveMember();
+    activeMember.value = member;
+    return member;
+  }
+  async function inviteUserToOrganization(options) {
+    const invitation = await authClient.organization.inviteUserToOrganization(options);
+    if (activeOrganization.value) {
+      activeOrganization.value = {
+        ...activeOrganization.value,
+        invitations: [...activeOrganization.value?.invitations ?? [], invitation]
+      };
+    }
+    return invitation;
+  }
+  async function acceptInvitation(id) {
+    await authClient.organization.acceptInvitation(id);
+    const members = await authClient.organization.listMembers();
+    if (activeOrganization.value) {
+      activeOrganization.value = {
+        ...activeOrganization.value,
+        members
+      };
+    }
+  }
+  async function cancelInvitation(id) {
+    await authClient.organization.cancelInvitation(id);
+    if (activeOrganization.value) {
+      activeOrganization.value = {
+        ...activeOrganization.value,
+        invitations: activeOrganization.value?.invitations?.filter((invitation) => invitation.id !== id) ?? []
+      };
+    }
+  }
+  async function removeUserFromOrganization(options) {
+    await authClient.organization.removeUserFromOrganization(options);
+    if (activeOrganization.value) {
+      activeOrganization.value = {
+        ...activeOrganization.value,
+        members: activeOrganization.value?.members?.filter((member) => member.id !== options.memberId) ?? []
+      };
+    }
+  }
+  async function updateMemberRole(options) {
+    await authClient.organization.updateMemberRole(options);
+    const members = await authClient.organization.listMembers();
+    if (activeOrganization.value) {
+      activeOrganization.value = {
+        ...activeOrganization.value,
+        members
+      };
+    }
+  }
+  async function createTeam(payload) {
+    const team = await authClient.organization.createTeam(payload);
+    if (activeOrganization.value) {
+      activeOrganization.value = {
+        ...activeOrganization.value,
+        teams: [...activeOrganization.value?.teams ?? [], team]
+      };
+    }
+    return team;
+  }
+  async function updateTeam(id, payload) {
+    const updatedTeam = await authClient.organization.updateTeam(id, payload);
+    if (activeOrganization.value) {
+      activeOrganization.value = {
+        ...activeOrganization.value,
+        teams: activeOrganization.value?.teams?.map((team) => team.id === id ? updatedTeam : team) ?? []
+      };
+    }
+    return updatedTeam;
+  }
+  async function deleteTeam(id) {
+    await authClient.organization.deleteTeam(id);
+    if (activeOrganization.value) {
+      activeOrganization.value = {
+        ...activeOrganization.value,
+        teams: activeOrganization.value?.teams?.filter((team) => team.id !== id) ?? []
+      };
+    }
+  }
+  async function listTeams() {
+    return authClient.organization.listTeams();
+  }
+  async function listTeamMembers(id) {
+    return authClient.organization.listTeamMembers(id);
+  }
+  async function addTeamMember(teamId, userId) {
+    return authClient.organization.addTeamMember(teamId, userId);
+  }
+  async function removeTeamMember(teamId, userId) {
+    await authClient.organization.removeTeamMember(teamId, userId);
+  }
+  return {
+    activeOrganization,
+    activeMember,
+    getActiveOrganization,
+    listOrganizations,
+    setActiveOrganization,
+    updateOrganization,
+    listMembers,
+    getActiveMember,
+    inviteUserToOrganization,
+    acceptInvitation,
+    cancelInvitation,
+    removeUserFromOrganization,
+    updateMemberRole,
+    createTeam,
+    updateTeam,
+    deleteTeam,
+    listTeams,
+    listTeamMembers,
+    addTeamMember,
+    removeTeamMember
+  };
+}

package/dist/runtime/composables/session.d.ts

@@ -0,0 +1,63 @@
+import type { Session, SignInWithEmailAndPasswordOptions, SignInWithSamlOptions, SocialSignInOptions, User } from '@meistrari/auth-core';
+import type { Ref } from 'vue';
+export interface UseTelaSessionReturn {
+    /** Reactive reference to the current user. Null if not authenticated. */
+    user: Ref<User | null>;
+    /** Reactive reference to the current session. Null if not authenticated. */
+    session: Ref<Session | null>;
+    /**
+     * Retrieves the current user session.
+     * @returns The current user session
+     */
+    getSession: () => Promise<{
+        user: User;
+        session: Session;
+    } | null>;
+    /**
+     * Retrieves a valid JWT token.
+     * @returns The JWT token, or null if not authenticated
+     */
+    getToken: () => Promise<string | null>;
+    /**
+     * Authenticates a user with email and password credentials.
+     * @param options - Email/password sign-in configuration
+     */
+    signInWithEmailAndPassword: (options: SignInWithEmailAndPasswordOptions) => Promise<void>;
+    /**
+     * Initiates social authentication flow with Google or Microsoft.
+     * @param options - Social sign-in configuration
+     * @throws {InvalidSocialProvider} When the provider is not 'google' or 'microsoft'
+     * @throws {InvalidCallbackURL} When callback URLs are malformed
+     */
+    signInWithSocialProvider: (options: SocialSignInOptions) => Promise<void>;
+    /**
+     * Initiates SAML-based Single Sign-On authentication flow.
+     * @param options - SAML sign-in configuration
+     * @throws {EmailRequired} When email is not provided
+     * @throws {InvalidCallbackURL} When callback URLs are malformed
+     */
+    signInWithSaml: (options: SignInWithSamlOptions) => Promise<void>;
+    /**
+     * Signs out the currently authenticated user.
+     * @param callback - Optional callback function to execute after signing out
+     */
+    signOut: (callback?: (() => void) | (() => Promise<void>)) => Promise<void>;
+    /**
+     * Initiates a password reset request by sending a reset email.
+     * @param email - Email address of the user requesting password reset
+     * @param callbackURL - URL where the user will be redirected to complete the reset
+     */
+    requestPasswordReset: (email: string, callbackURL: string) => Promise<void>;
+    /**
+     * Completes the password reset process with a reset token and new password.
+     * @param token - The password reset token from the email
+     * @param password - The new password to set
+     */
+    resetPassword: (token: string, password: string) => Promise<void>;
+}
+/**
+ * Composable for managing user sessions and authentication.
+ *
+ * @returns An object containing session management functions and the user and session states.
+ */
+export declare function useTelaSession(): UseTelaSessionReturn;

package/dist/runtime/composables/session.js

@@ -0,0 +1,88 @@
+import { useCookie, useRuntimeConfig } from "#app";
+import { APIError } from "@meistrari/auth-core";
+import { createNuxtAuthClient } from "../shared.js";
+import { useOrganizationState, useSessionState } from "./state.js";
+export function useTelaSession() {
+  const { user, session } = useSessionState();
+  const { jwtCookieName, apiUrl } = useRuntimeConfig().public.telaAuth;
+  const tokenCookie = useCookie(jwtCookieName);
+  const authClient = createNuxtAuthClient(apiUrl, () => tokenCookie.value ?? null);
+  async function getSession() {
+    return await authClient.session.getSession();
+  }
+  async function getToken() {
+    try {
+      const { token } = await authClient.session.getToken();
+      return token;
+    } catch (error) {
+      if (error instanceof APIError && error.status === 401) {
+        await signOut();
+      }
+      return null;
+    }
+  }
+  async function signInWithSocialProvider({
+    provider,
+    callbackURL,
+    errorCallbackURL
+  }) {
+    await authClient.session.signInWithSocialProvider({
+      provider,
+      callbackURL,
+      errorCallbackURL
+    });
+  }
+  async function signInWithSaml({
+    email,
+    callbackURL,
+    errorCallbackURL
+  }) {
+    await authClient.session.signInWithSaml({
+      email,
+      callbackURL,
+      errorCallbackURL
+    });
+  }
+  async function signInWithEmailAndPassword({
+    email,
+    password,
+    callbackURL,
+    errorCallbackURL
+  }) {
+    await authClient.session.signInWithEmailAndPassword({
+      email,
+      password,
+      callbackURL,
+      errorCallbackURL
+    });
+  }
+  async function requestPasswordReset(email, callbackURL) {
+    await authClient.session.requestPasswordReset(email, callbackURL);
+  }
+  async function resetPassword(token, password) {
+    await authClient.session.resetPassword(token, password);
+  }
+  async function signOut(callback) {
+    const { activeOrganization, activeMember } = useOrganizationState();
+    await authClient.session.signOut(async () => {
+      tokenCookie.value = null;
+      user.value = null;
+      session.value = null;
+      activeOrganization.value = null;
+      activeMember.value = null;
+      await callback?.();
+    });
+  }
+  return {
+    user,
+    session,
+    getSession,
+    getToken,
+    signInWithEmailAndPassword,
+    signInWithSocialProvider,
+    signInWithSaml,
+    signOut,
+    requestPasswordReset,
+    resetPassword
+  };
+}

package/dist/runtime/composables/state.d.ts

@@ -0,0 +1,22 @@
+import type { FullOrganization, Invitation, Member, Team } from '@meistrari/auth-core';
+export type FullOrganizationWithRelations = FullOrganization & {
+    members: Member[];
+    invitations: Invitation[];
+    teams: Team[];
+};
+/**
+ * Shared state for session management.
+ * This module provides access to session-related state without creating circular dependencies.
+ */
+export declare function useSessionState(): {
+    user: import("vue").Ref<any, any>;
+    session: import("vue").Ref<any, any>;
+};
+/**
+ * Shared state for organization management.
+ * This module provides access to organization-related state without creating circular dependencies.
+ */
+export declare function useOrganizationState(): {
+    activeOrganization: import("vue").Ref<any, any>;
+    activeMember: import("vue").Ref<any, any>;
+};

package/dist/runtime/composables/state.js

@@ -0,0 +1,17 @@
+import { useState } from "#app";
+export function useSessionState() {
+  const user = useState("user", () => null);
+  const session = useState("session", () => null);
+  return {
+    user,
+    session
+  };
+}
+export function useOrganizationState() {
+  const activeOrganization = useState("activeOrganization", () => null);
+  const activeMember = useState("activeMember", () => null);
+  return {
+    activeOrganization,
+    activeMember
+  };
+}

package/dist/runtime/plugin.d.ts

@@ -1,15 +1,2 @@
-import { createAuthClient } from '@meistrari/auth-core';
-declare const _default: import("#app").Plugin<{
-    auth: {
-        client: ReturnType<typeof createAuthClient>;
-        getToken: () => Promise<string | null | undefined>;
-        refreshToken: () => Promise<string | null | undefined>;
-    };
-}> & import("#app").ObjectPlugin<{
-    auth: {
-        client: ReturnType<typeof createAuthClient>;
-        getToken: () => Promise<string | null | undefined>;
-        refreshToken: () => Promise<string | null | undefined>;
-    };
-}>;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;