@meistrari/auth-nuxt 0.1.0 → 1.0.0-beta.1

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

@@ -0,0 +1,28 @@
+import type { CreateTeamPayload, InviteUserToOrganizationOptions, ListMembersOptions, RemoveUserFromOrganizationOptions, UpdateMemberRoleOptions, UpdateOrganizationPayload, UpdateTeamPayload } from '@meistrari/auth-core';
+/**
+ * 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(): {
+    activeOrganization: import("vue").Ref<any, any>;
+    activeMember: import("vue").Ref<any, any>;
+    getActiveOrganization: () => Promise<any>;
+    listOrganizations: () => Promise<any>;
+    setActiveOrganization: (id: string) => Promise<void>;
+    updateOrganization: (payload: UpdateOrganizationPayload) => Promise<any>;
+    listMembers: (options?: ListMembersOptions) => Promise<any>;
+    getActiveMember: () => Promise<any>;
+    inviteUserToOrganization: (options: InviteUserToOrganizationOptions) => Promise<any>;
+    acceptInvitation: (id: string) => Promise<void>;
+    cancelInvitation: (id: string) => Promise<void>;
+    removeUserFromOrganization: (options: RemoveUserFromOrganizationOptions) => Promise<void>;
+    updateMemberRole: (options: UpdateMemberRoleOptions) => Promise<void>;
+    createTeam: (payload: CreateTeamPayload) => Promise<any>;
+    updateTeam: (id: string, payload: UpdateTeamPayload) => Promise<any>;
+    deleteTeam: (id: string) => Promise<void>;
+    listTeams: () => Promise<any>;
+    listTeamMembers: (id: string) => Promise<any>;
+    addTeamMember: (teamId: string, userId: string) => Promise<any>;
+    removeTeamMember: (teamId: string, userId: string) => Promise<void>;
+};

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,18 @@
+import { type SignInWithEmailAndPasswordOptions, type SignInWithSamlOptions, type SocialSignInOptions } from '@meistrari/auth-core';
+/**
+ * Composable for managing user sessions and authentication.
+ *
+ * @returns An object containing session management functions and the user and session states.
+ */
+export declare function useTelaSession(): {
+    user: import("vue").Ref<any, any>;
+    session: import("vue").Ref<any, any>;
+    getSession: () => Promise<any>;
+    getToken: () => Promise<any>;
+    signInWithEmailAndPassword: ({ email, password, callbackURL, errorCallbackURL, }: SignInWithEmailAndPasswordOptions) => Promise<void>;
+    signInWithSocialProvider: ({ provider, callbackURL, errorCallbackURL, }: SocialSignInOptions) => Promise<void>;
+    signInWithSaml: ({ email, callbackURL, errorCallbackURL, }: SignInWithSamlOptions) => Promise<void>;
+    signOut: (callback?: (() => void) | (() => Promise<void>)) => Promise<void>;
+    requestPasswordReset: (email: string, callbackURL: string) => Promise<void>;
+    resetPassword: (token: string, password: string) => Promise<void>;
+};

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 { useSessionState, useOrganizationState } 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;

package/dist/runtime/plugin.js

@@ -1,105 +1,90 @@
-import { defineNuxtPlugin, useCookie, useRequestHeaders, useRuntimeConfig } from "#app";
+import { defineNuxtPlugin, useCookie, useRuntimeConfig, useRequestURL } from "#app";
 import { watch } from "vue";
-import { createAuthClient, isTokenExpired } from "@meistrari/auth-core";
-import { useMeistrariAuth } from "./composable.js";
+import { useTelaSession } from "./composables/session.js";
+import { createNuxtAuthClient } from "./shared.js";
+import { useRoute, navigateTo } from "#imports";
 export default defineNuxtPlugin({
-  name: "meistrari-auth",
-  parallel: true,
+  name: "tela-auth",
+  enforce: "pre",
+  env: {
+    islands: false
+  },
   async setup() {
-    const config = useRuntimeConfig().public.auth;
-    const authClient = createAuthClient(config.apiUrl);
-    const { user, session } = useMeistrariAuth();
-    async function getToken() {
-      const token = useCookie(config.jwtCookieName);
-      if (token.value) {
-        if (!isTokenExpired(token.value)) {
-          return token.value;
-        }
-      }
-      try {
-        return await refreshToken();
-      } catch (error) {
-        throw new Error("Failed to get token: " + (error instanceof Error ? error.message : String(error)));
-      }
-    }
-    async function refreshToken() {
-      const token = useCookie(config.jwtCookieName);
-      const headers = useRequestHeaders();
-      const session2 = await authClient.getSession({
-        fetchOptions: {
-          // on the client side we include credentials
-          credentials: "include",
-          // on the server side we forward the cookies
-          headers,
-          onSuccess: (ctx) => {
-            const jwt = ctx.response.headers.get("set-auth-jwt");
-            if (jwt) {
-              token.value = jwt;
-            }
+    const authConfig = useRuntimeConfig().public.telaAuth;
+    const { session, user, getToken } = useTelaSession();
+    const tokenCookie = useCookie(authConfig.jwtCookieName);
+    tokenCookie.value = null;
+    const authClient = createNuxtAuthClient(authConfig.apiUrl, () => tokenCookie.value ?? null);
+    const query = useRoute().query;
+    const nonce = query.nonce;
+    const origin = useRequestURL();
+    if (import.meta.server) {
+      if (nonce && typeof nonce === "string") {
+        if (nonce !== "null") {
+          try {
+            const payload = await authClient.session.getNoncePayload(nonce);
+            tokenCookie.value = payload.token;
+          } catch {
+            await navigateTo(`${authConfig.apiUrl}/api/auth/handshake?origin=${origin.toString()}`, {
+              external: true,
+              redirectCode: 302
+            });
+            return;
           }
         }
-      });
-      if (session2.error || !session2.data?.session) {
-        throw new Error("Failed to refresh token");
+      } else {
+        await navigateTo(`${authConfig.apiUrl}/api/auth/handshake?origin=${origin.toString()}`, {
+          external: true,
+          redirectCode: 302
+        });
+        return;
+      }
+    } else if (import.meta.client && !session.value) {
+      const token = await getToken();
+      if (token) {
+        tokenCookie.value = token;
       }
-      return token.value;
     }
     async function initializeSession() {
       if (session.value && user.value)
         return;
-      const token = useCookie(config.jwtCookieName);
-      const headers = import.meta.server ? useRequestHeaders() : void 0;
-      const { data: sessionData, error: sessionError } = await authClient.getSession(
-        {
-          fetchOptions: {
-            // on the client side we include credentials
-            credentials: "include",
-            // on the server side we forward the cookies
-            headers,
-            ...config.useJwt && {
-              onSuccess: (context) => {
-                const jwt = context.response.headers.get("Set-Auth-Jwt");
-                if (jwt) {
-                  token.value = jwt;
-                }
-              }
-            }
-          }
-        }
-      );
-      if (sessionError || !sessionData) {
+      const sessionData = await authClient.session.getSession();
+      if (!sessionData) {
         return;
       }
       user.value = sessionData.user;
       session.value = sessionData.session;
     }
-    await initializeSession();
+    if (tokenCookie.value) {
+      await initializeSession();
+    }
     if (import.meta.client) {
-      if (config.useJwt) {
-        let tokenRefreshInterval = null;
-        watch(session, async (newVal) => {
-          if (tokenRefreshInterval) {
-            clearTimeout(tokenRefreshInterval);
-            tokenRefreshInterval = null;
-          }
-          if (newVal) {
-            async function createTokenRefreshInterval() {
-              await refreshToken();
-              tokenRefreshInterval = window.setTimeout(createTokenRefreshInterval, 6e4);
+      let tokenRefreshInterval = null;
+      watch(session, async (newVal) => {
+        if (tokenRefreshInterval) {
+          clearTimeout(tokenRefreshInterval);
+          tokenRefreshInterval = null;
+        }
+        if (newVal) {
+          async function createTokenRefreshInterval() {
+            const token = await getToken();
+            if (token) {
+              tokenCookie.value = token;
             }
-            createTokenRefreshInterval();
+            tokenRefreshInterval = window.setTimeout(createTokenRefreshInterval, 6e4);
           }
-        }, { immediate: true });
-      }
-    }
-    return {
-      provide: {
-        auth: {
-          client: authClient,
-          getToken,
-          refreshToken
+          createTokenRefreshInterval();
         }
-      }
-    };
+      }, { immediate: true });
+    }
+  },
+  hooks: {
+    "app:mounted": () => {
+      const url = new URL(window.location.href);
+      url.searchParams.delete("session");
+      url.searchParams.delete("session_data");
+      url.searchParams.delete("nonce");
+      window.history.replaceState({}, "", url.pathname + url.search + url.hash);
+    }
   }
 });

package/dist/runtime/server/middleware/auth.js

@@ -1,26 +1,21 @@
+import { validateToken, extractTokenPayload } from "@meistrari/auth-core";
 import { defineEventHandler, getCookie } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime/config";
-import { createAuthClient } from "@meistrari/auth-core";
 async function setAuthContext(event) {
   event.context.auth = {
-    session: null,
-    user: null
+    user: null,
+    workspace: null
   };
-  const sessionCookie = getCookie(event, "__Secure-__session");
-  if (!sessionCookie)
+  const authConfig = useRuntimeConfig(event).public.telaAuth;
+  const tokenCookie = getCookie(event, authConfig.jwtCookieName);
+  if (!tokenCookie)
     return;
-  const authConfig = useRuntimeConfig(event).public.auth;
-  const authClient = createAuthClient(authConfig.apiUrl);
-  const { data: sessionData, error: sessionError } = await authClient.getSession({
-    fetchOptions: {
-      headers: event.headers
-    }
-  });
-  if (sessionError || !sessionData) {
+  const isValid = await validateToken(tokenCookie, authConfig.apiUrl);
+  if (!isValid)
     return;
-  }
-  event.context.auth.session = sessionData.session;
-  event.context.auth.user = sessionData.user;
+  const payload = extractTokenPayload(tokenCookie);
+  event.context.auth.user = { email: payload.email, ...payload.user };
+  event.context.auth.workspace = payload.workspace;
 }
 export function meistrariAuthMiddleware(callback) {
   return defineEventHandler(async (event) => {

package/dist/runtime/server/tsconfig.json

@@ -1,3 +1,6 @@
 {
-  "extends": "../../../.nuxt/tsconfig.server.json",
+    "extends": [
+        "../../../../../../node_modules/@meistrari/mise-en-place/tsconfig.base.json",
+        "../../../.nuxt/tsconfig.server.json"
+    ],
 }

package/dist/runtime/server/types/h3.d.ts

@@ -1,19 +1,19 @@
-import type { User, Session } from '@meistrari/auth-core'
+import type { JWTTokenPayload } from '@meistrari/auth-core'
 import type { H3Event, H3EventContext } from 'h3'
 
 declare module 'h3' {
   interface H3EventContext {
     auth?: {
-      user: User | null
-      session: Session | null
+      user: { email: string } & JWTTokenPayload['user'] | null
+      workspace: JWTTokenPayload['workspace'] | null
     }
   }
 }
 
 export interface AuthenticatedH3EventContext extends H3EventContext {
   auth: {
-    user: User | null
-    session: Session | null
+    user: { email: string } & JWTTokenPayload['user'] | null
+    workspace: JWTTokenPayload['workspace'] | null
   }
 }
 

package/dist/runtime/shared.d.ts

@@ -0,0 +1 @@
+export declare function createNuxtAuthClient(apiUrl: string, getAuthToken: () => string | null): any;

package/dist/runtime/shared.js

@@ -0,0 +1,19 @@
+import { AuthClient } from "@meistrari/auth-core";
+import { version } from "../../package.json";
+export function createNuxtAuthClient(apiUrl, getAuthToken) {
+  const serviceName = typeof process !== "undefined" ? process.env.SERVICE_NAME : "";
+  const userAgent = `auth-sdk:nuxt:${version}${serviceName ? `@${serviceName}` : ""}`;
+  return new AuthClient(apiUrl, {
+    headers: {
+      "X-User-Agent": userAgent
+    },
+    onRequest: (context) => {
+      const requestUrl = new URL(context.url);
+      const token = getAuthToken();
+      const isTokenRequest = requestUrl.pathname.endsWith("/api/auth/token");
+      if (token && !isTokenRequest) {
+        context.headers.set("Authorization", `Bearer ${token}`);
+      }
+    }
+  });
+}