nuxt-directus-sdk 3.1.0 → 4.0.1

package/README.md

@@ -5,13 +5,14 @@
 [![License][license-src]][license-href]
 [![Nuxt][nuxt-src]][nuxt-href]
 
-> A Nuxt 3 Directus module that uses the Directus SDK to enhance your Nuxt application
+> A Nuxt 4 Directus module that uses the Directus SDK to enhance your Nuxt application
 
 - [✨  Release Notes](/CHANGELOG.md)
-- [🔗  Documentation - Coming soon!](http://nuxt-directus-sdk.vercel.app)
+- [📚  Documentation](https://nuxt-directus-sdk.rolley.io)
 
 ## Features
 
+- 🔒  **Session-based authentication** with cross-domain support
 - ⛰  Authentication out of the box
 - 🚠  Type generation based on Directus collections
 - 🔥  Typesafe Client Websockets enabled
@@ -44,17 +45,29 @@ export default defineNuxtConfig({
     'nuxt-directus-sdk'
   ],
   directus: {
-    url: '',
+    // Optional: customize authentication (defaults shown)
+    auth: {
+      autoRefresh: true,
+      credentials: 'include', // Required for cross-domain
+      realtimeAuthMode: 'public',
+    }
   }
 })
 ```
 
-3. OPTIONAL: Add an Directus admin token to .env file for additional goodies (Type generation, admin server directus)
+3. Create a `.env` file:
 
-DIRECTUS_ADMIN_TOKEN=""
+```env
+DIRECTUS_URL=https://your-directus-url.com
+DIRECTUS_ADMIN_TOKEN=your_admin_token # Optional: for type generation
+```
+
+4. **Configure your Directus backend** for cross-domain authentication (see [Authentication Guide](https://nuxt-directus-sdk.rolley.io/guide/authentication))
 
 That's it! You can now use Directus within your Nuxt app ✨
 
+For cross-domain setups (e.g., `app.example.com` ↔ `api.example.com`), see the [Authentication Guide](https://nuxt-directus-sdk.rolley.io/guide/authentication).
+
 ## Development
 
 ```bash

package/dist/module.d.mts

@@ -8,6 +8,25 @@ interface ModuleOptions {
      * @type string
      */
     url: string;
+    /**
+     * Development proxy configuration
+     * When enabled, creates a proxy at /directus that forwards to your Directus URL
+     * This solves CORS and cookie issues in development
+     * @default { enabled: true, path: '/directus' } in dev mode
+     * @type boolean | { enabled?: boolean, path?: string }
+     */
+    devProxy?: boolean | {
+        /**
+         * Enable the development proxy
+         * @default true in dev mode, false in production
+         */
+        enabled?: boolean;
+        /**
+         * Proxy path (where the proxy will be mounted)
+         * @default '/directus'
+         */
+        path?: string;
+    };
     /**
      * Admin Auth Token used for generating types and server functions
      * @default process.env.DIRECTUS_ADMIN_TOKEN
@@ -43,56 +62,31 @@ interface ModuleOptions {
          * @type boolean
          */
         enableGlobalAuthMiddleware?: boolean;
+        /**
+         * Auto refresh tokens
+         * @default true
+         * @type boolean
+         */
+        autoRefresh?: boolean;
+        /**
+         * Credentials mode for cross-domain requests
+         * Set to 'include' when your frontend and backend are on different domains
+         * @default 'include'
+         * @type RequestCredentials
+         */
+        credentials?: RequestCredentials;
+        /**
+         * Realtime/WebSocket authentication mode
+         * @default 'handshake'
+         * @type 'public' | 'handshake' | 'strict'
+         */
+        realtimeAuthMode?: 'public' | 'handshake' | 'strict';
         /**
          * ReadMe fields to fetch
          * @default []
-         * @type Query<AllDirectusCollections, AllDirectusCollections['directus_users']>['fields']
+         * @type Query<DirectusSchema, DirectusSchema['directus_users']>['fields']
          */
-        readMeFields?: Query<AllDirectusCollections, AllDirectusCollections['directus_users']>['fields'];
-        cookies?: {
-            /**
-             * Session token cookie name
-             * @default 'directus_access_token'
-             */
-            accessToken?: string;
-            /**
-             * Refresh token cookie name
-             * @default 'directus_refresh_token'
-             */
-            refreshToken?: string;
-            /**
-             * Logged in token cookie name
-             * @default 'directus_logged_in'
-             */
-            loggedInToken?: string;
-            /**
-             * Session token cookie max age
-             * @default 900
-             */
-            maxAge?: number;
-            /**
-             * Refresh token cookie max age
-             * @default 604800
-             */
-            maxAgeRefreshToken?: number;
-            /**
-             * SameSite cookie attribute
-             * @default 'lax'
-             */
-            sameSite?: 'lax' | 'strict' | 'none';
-            /**
-             * Secure cookie attribute
-             * @default false
-             * @type boolean
-             */
-            secure?: boolean;
-            /**
-             * Domain cookie attribute
-             * @default undefined
-             * @type string | undefined
-             */
-            domain?: string | undefined;
-        };
+        readMeFields?: Query<DirectusSchema, DirectusSchema['directus_users']>['fields'];
         redirect?: {
             /**
              * Redirect to home page after login
@@ -128,13 +122,18 @@ interface ModuleOptions {
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
+interface NuxtDirectusModuleOptions extends ModuleOptions {
+    directusUrl: string;
+    wsProxyUrl?: string;
+}
 declare module '@nuxt/schema' {
     interface ConfigSchema {
-        directus?: ModuleOptions;
+        directus?: NuxtDirectusModuleOptions;
         publicRuntimeConfig?: {
-            directus?: Omit<ModuleOptions, 'adminToken'>;
+            directus?: Omit<NuxtDirectusModuleOptions, 'adminToken'>;
         };
     }
 }
 
-export { type ModuleOptions, _default as default };
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "nuxt-directus-sdk",
+  "version": "4.0.1",
+  "configKey": "directus",
+  "compatibility": {
+    "nuxt": "^4.0.0"
+  },
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -1,10 +1,11 @@
-import { useLogger, defineNuxtModule, createResolver, installModule, addPlugin, addRouteMiddleware, addImportsDir, addComponentsDir, addImportsSources, addTypeTemplate } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, addServerHandler, installModule, addPlugin, addRouteMiddleware, addImportsDir, addComponentsDir, addImportsSources, addTypeTemplate } from '@nuxt/kit';
 import { defu } from 'defu';
+import { joinURL } from 'ufo';
 import { generateTypes } from '../dist/runtime/types/index.js';
 import { useUrl } from '../dist/runtime/utils/index.js';
 
 const name = "nuxt-directus-sdk";
-const version = "3.1.0";
+const version = "4.0.1";
 
 const configKey = "directus";
 const logger = useLogger("nuxt-directus-sdk");
@@ -14,12 +15,13 @@ const module = defineNuxtModule({
     version,
     configKey,
     compatibility: {
-      nuxt: "^3.0.0",
-      bridge: false
+      nuxt: "^4.0.0"
     }
   },
   defaults: {
     url: import.meta.env.DIRECTUS_URL ?? "",
+    devProxy: void 0,
+    // Will be set based on dev mode in setup
     adminToken: import.meta.env.DIRECTUS_ADMIN_TOKEN ?? "",
     devtools: true,
     visualEditor: true,
@@ -30,18 +32,10 @@ const module = defineNuxtModule({
     auth: {
       enabled: true,
       enableGlobalAuthMiddleware: false,
+      autoRefresh: true,
+      credentials: "include",
+      realtimeAuthMode: "public",
       readMeFields: [],
-      cookies: {
-        accessToken: "directus_access_token",
-        refreshToken: "directus_refresh_token",
-        loggedInToken: "directus_logged_in",
-        maxAge: 900,
-        maxAgeRefreshToken: 604800,
-        // Nuxt Cookies Docs @ https://nuxt.com/docs/api/composables/use-cookie
-        sameSite: "lax",
-        secure: false,
-        domain: void 0
-      },
       redirect: {
         home: "/",
         login: "/account/login",
@@ -54,11 +48,88 @@ const module = defineNuxtModule({
       logger.error("nuxt-directus-sdk requires a url to your Directus instance, set it in the config options or .env file as DIRECTUS_URL");
       return;
     }
+    const resolver = createResolver(import.meta.url);
+    const devProxyConfig = typeof options.devProxy === "boolean" ? { enabled: options.devProxy } : { ...options.devProxy };
+    const devProxyEnabled = devProxyConfig.enabled ?? nuxtApp.options.dev;
+    const devProxyPath = devProxyConfig.path ?? "/directus";
+    const directusUrl = options.url;
+    if (devProxyEnabled && nuxtApp.options.dev) {
+      const devPort = nuxtApp.options.devServer?.port ?? 3e3;
+      const devHost = nuxtApp.options.devServer?.host ?? "localhost";
+      const baseUrl = `http://${devHost}:${devPort}`;
+      const proxyUrl = `${baseUrl}${devProxyPath}/`;
+      const wsProxyPath = `${devProxyPath}-ws`;
+      const wsTarget = joinURL(directusUrl, "websocket");
+      logger.info(`\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+      logger.info(`\u{1F504} Directus Development Proxy Enabled`);
+      logger.info(`   Proxy path: ${devProxyPath}`);
+      logger.info(`   Forwarding to: ${directusUrl}`);
+      logger.info(`   Local URL: ${proxyUrl}`);
+      logger.info(`   WebSocket proxy path: ${wsProxyPath}`);
+      logger.info(`   WebSocket target: ${wsTarget}`);
+      logger.info(`\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+      nuxtApp.options.nitro = nuxtApp.options.nitro || {};
+      nuxtApp.options.nitro.devProxy = nuxtApp.options.nitro.devProxy || {};
+      nuxtApp.options.nitro.devProxy[wsProxyPath] = {
+        target: directusUrl,
+        changeOrigin: true,
+        ws: true
+      };
+      const httpProxy = await import('http-proxy');
+      const proxy = httpProxy.default.createProxyServer({
+        target: directusUrl,
+        changeOrigin: true,
+        ws: true,
+        secure: false
+        // Allow self-signed certificates
+      });
+      proxy.on("error", (err, _req, socket) => {
+        logger.error(`WebSocket proxy error:`, err.message);
+        if (socket && !socket.destroyed) {
+          socket.end();
+        }
+      });
+      proxy.on("proxyReqWs", (proxyReq, req, _socket) => {
+        proxyReq.path = "/websocket";
+        if (req.headers.cookie) {
+          proxyReq.setHeader("cookie", req.headers.cookie);
+        }
+      });
+      nuxtApp.hook("ready", () => {
+        const originalUpgrade = nuxtApp.server?.upgrade;
+        if (nuxtApp.server) {
+          nuxtApp.server.upgrade = (req, socket, head) => {
+            if (req.url?.startsWith(wsProxyPath)) {
+              try {
+                proxy.ws(req, socket, head);
+              } catch (err) {
+                logger.error("WebSocket proxy error:", err.message);
+                if (!socket.destroyed) {
+                  socket.destroy();
+                }
+              }
+            } else if (originalUpgrade) {
+              return originalUpgrade(req, socket, head);
+            } else if (!socket.destroyed) {
+              socket.destroy();
+            }
+          };
+        }
+      });
+      addServerHandler({
+        route: `${devProxyPath}/**`,
+        handler: resolver.resolve("./runtime/server/routes/directus")
+      });
+      options.url = proxyUrl;
+      options.wsProxyUrl = joinURL(baseUrl, wsProxyPath);
+    } else if (!nuxtApp.options.dev) {
+      logger.info(`\u{1F310} Production mode: Connecting directly to ${directusUrl}`);
+    }
+    options.directusUrl = directusUrl;
     nuxtApp.options.runtimeConfig[configKey] = options;
     nuxtApp.options.runtimeConfig.public = nuxtApp.options.runtimeConfig.public || {};
     nuxtApp.options.runtimeConfig.public[configKey] = defu(nuxtApp.options.runtimeConfig.public[configKey], options);
     delete nuxtApp.options.runtimeConfig.public[configKey].adminToken;
-    const resolver = createResolver(import.meta.url);
     await installModule("@nuxt/image", {
       directus: {
         baseURL: useUrl(options.url, "assets")
@@ -70,6 +141,10 @@ const module = defineNuxtModule({
       path: resolver.resolve("./runtime/middleware/auth"),
       global: options.auth?.enableGlobalAuthMiddleware
     });
+    addRouteMiddleware({
+      name: "guest",
+      path: resolver.resolve("./runtime/middleware/guest")
+    });
     addImportsDir(resolver.resolve("./runtime/composables"));
     addComponentsDir({
       path: resolver.resolve("./runtime/components"),
@@ -143,16 +218,16 @@ const module = defineNuxtModule({
       nitroConfig.imports.presets.push({
         from: resolver.resolve("./runtime/server/services"),
         imports: [
-          "useDirectus",
-          "useUserDirectus",
+          "getDirectusSessionToken",
           "useAdminDirectus",
+          "useServerDirectus",
           "useDirectusUrl",
-          "useDirectusAccessToken"
+          "useTokenDirectus"
         ]
       });
     });
     if (options.devtools) {
-      const adminUrl = useUrl(options.url, "admin");
+      const adminUrl = useUrl(directusUrl, "admin");
       logger.info(`Directus Admin URL: ${adminUrl}`);
       nuxtApp.hook("devtools:customTabs", (iframeTabs) => {
         iframeTabs.push({
@@ -172,16 +247,19 @@ const module = defineNuxtModule({
       if (!options.adminToken) {
         logger.warn("Directus types generation is disabled, set the admin token in the config or .env file as DIRECTUS_ADMIN_TOKEN");
       } else {
-        logger.info("Generating Directus types");
         try {
+          let cachedTypes = null;
           const typesPath = addTypeTemplate({
             filename: `types/${configKey}.d.ts`,
-            getContents() {
-              return generateTypes({
-                url: useUrl(options.url),
-                token: options.adminToken,
-                prefix: options.types?.prefix ?? ""
-              });
+            async getContents() {
+              if (!cachedTypes) {
+                cachedTypes = await generateTypes({
+                  url: useUrl(directusUrl),
+                  token: options.adminToken,
+                  prefix: options.types?.prefix ?? ""
+                });
+              }
+              return cachedTypes;
             }
           }, { nitro: true, nuxt: true }).dst;
           nuxtApp.hook("prepare:types", (options2) => {

package/dist/runtime/components/directus-visual-editor.d.vue.ts

@@ -0,0 +1,21 @@
+import type { PrimaryKey } from '@directus/types';
+declare const _default: <T extends keyof DirectusSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        collection: T;
+        item: PrimaryKey;
+        fields?: (string | number | symbol) | (string | number | symbol)[];
+        mode?: "drawer" | "modal" | "popover";
+    } & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/components/directus-visual-editor.vue

@@ -1,47 +1,51 @@
-<script setup lang="ts" generic="T extends keyof DirectusSchema">
-import type { PrimaryKey } from '@directus/types'
-import { computed } from '#imports'
-import { setAttr } from '@directus/visual-editing'
-import { useDirectusPreview } from '../composables/directus'
-import { Slot } from '../utils'
-
-type SingleDirectusCollection = DirectusSchema[T] extends Array<any> ? DirectusSchema[T][0] : DirectusSchema[T]
-type FieldKey = keyof SingleDirectusCollection
-
-const props = defineProps<{
-  collection: T
-  item: PrimaryKey
-  fields?: FieldKey | FieldKey[]
-  mode?: 'drawer' | 'modal' | 'popover'
-}>()
-
-const directusPreview = useDirectusPreview()
-
+<script setup>
+import { computed, onBeforeUnmount, onMounted, ref, useRuntimeConfig } from "#imports";
+import { apply, setAttr } from "@directus/visual-editing";
+import { useDirectusPreview } from "../composables/directus";
+import { Slot } from "../utils";
+const props = defineProps({
+  collection: { type: null, required: true },
+  item: { type: [String, Number], required: true },
+  fields: { type: null, required: false },
+  mode: { type: String, required: false }
+});
+const config = useRuntimeConfig();
+const directusPreview = useDirectusPreview();
+const editorElement = ref(null);
 const directusAttr = computed(() => {
-  const data: Record<any, any> = {}
-
+  const data = {};
   Object.entries(props).forEach(([key, value]) => {
-    if (value !== undefined) {
-      data[key] = value
+    if (value !== void 0) {
+      data[key] = value;
     }
-  })
-
-  return setAttr(data as any)
-})
-
+  });
+  return setAttr(data);
+});
 const attributes = computed(() => {
   if (!directusPreview.value) {
-    return null
+    return null;
   }
-
   return {
-    'data-directus': directusAttr.value,
+    "data-directus": directusAttr.value
+  };
+});
+onMounted(async () => {
+  if (!config.public.directus.visualEditor || !editorElement.value || import.meta.server) {
+    return;
+  }
+  const applied = await apply({ directusUrl: config.public.directus.url });
+  if (!applied) {
+    return;
   }
-})
+  applied.enable();
+  onBeforeUnmount(() => {
+    applied.remove();
+  });
+});
 </script>
 
 <template>
-  <Slot v-bind="attributes">
+  <Slot ref="editorElement" v-bind="attributes">
     <slot />
   </Slot>
 </template>

package/dist/runtime/components/directus-visual-editor.vue.d.ts

@@ -0,0 +1,21 @@
+import type { PrimaryKey } from '@directus/types';
+declare const _default: <T extends keyof DirectusSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        collection: T;
+        item: PrimaryKey;
+        fields?: (string | number | symbol) | (string | number | symbol)[];
+        mode?: "drawer" | "modal" | "popover";
+    } & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

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

@@ -8,20 +8,14 @@ export interface DirectusAuth {
     updateMe: (data: Partial<DirectusUsers>) => Promise<DirectusUsers | null>;
     login: (email: string, password: string, options?: LoginOptions & {
         redirect?: boolean | RouteLocationRaw;
-    }) => Promise<{
-        user: DirectusUsers | null;
-        accessToken: string;
-        refreshToken: string | null;
-        expires: number | null;
-        expiresAt: number | null;
-    }>;
+    }) => Promise<DirectusUsers | null>;
     loginWithProvider: (provider: string, redirectOnLogin?: string) => Promise<void>;
     logout: (redirect?: boolean | RouteLocationRaw) => Promise<void>;
     createUser: (data: Partial<DirectusUsers>) => Promise<DirectusUsers>;
     register: (data: Partial<DirectusUsers>) => Promise<DirectusUsers>;
     inviteUser: (email: string, role: string, inviteUrl?: string | undefined) => Promise<void>;
     acceptUserInvite: (token: string, password: string) => Promise<void>;
-    passwordRequest: (email: string, resetUrl?: string | null | undefined) => Promise<void>;
+    passwordRequest: (email: string, resetUrl?: string | undefined) => Promise<void>;
     passwordReset: (token: string, password: string) => Promise<void>;
 }
 export declare function useDirectusUser(): Ref<DirectusUsers | null>;

package/dist/runtime/composables/auth.js

@@ -1,29 +1,33 @@
 import { navigateTo, useNuxtApp, useRouter, useRuntimeConfig } from "#app";
 import { computed, useState } from "#imports";
 import { acceptUserInvite as directusAcceptUserInvite, createUser as directusCreateUser, inviteUser as directusInviteUser, passwordRequest as directusPasswordRequest, passwordReset as directusPasswordReset, readMe as directusReadMe, updateMe as directusUpdateMe } from "@directus/sdk";
-import { useDirectus } from "./directus.js";
-import { useDirectusTokens } from "./tokens.js";
+import { useDirectus, useDirectusUrl } from "./directus.js";
 export function useDirectusUser() {
   return useState("directus.user", () => null);
 }
+function useDirectusUserLoading() {
+  return useState("directus.user.loading", () => false);
+}
 export function useDirectusAuth() {
   const config = useRuntimeConfig();
   const router = useRouter();
   const directus = useDirectus();
-  const tokens = useDirectusTokens();
   const user = useDirectusUser();
+  const loading = useDirectusUserLoading();
   const nuxtApp = useNuxtApp();
   const loggedIn = computed(() => user.value !== null);
   async function readMe() {
+    if (loading.value) {
+      return user.value;
+    }
+    loading.value = true;
     try {
-      if (!tokens.accessToken.value) {
-        if (!tokens.refreshToken.value)
-          throw new Error("No refresh token");
-        await directus.refresh();
-      }
       user.value = await directus.request(directusReadMe({ fields: config.public.directus.auth?.readMeFields ?? ["*"] }));
-    } catch {
+    } catch (error) {
+      console.error("[Auth] Failed to fetch user:", error);
       user.value = null;
+    } finally {
+      loading.value = false;
     }
     await nuxtApp.callHook("directus:loggedIn", user.value);
     return user.value;
@@ -36,9 +40,7 @@ export function useDirectusAuth() {
     return user.value;
   }
   async function login(email, password, options) {
-    const response = await directus.login(email, password, { ...options, mode: "json" });
-    if (!response.access_token)
-      throw new Error("Login failed, please check your credentials.");
+    await directus.login({ email, password }, { ...options, mode: "session" });
     await readMe();
     const redirect = options?.redirect ?? true;
     if (redirect !== false) {
@@ -51,16 +53,9 @@ export function useDirectusAuth() {
         navigateTo(config.public.directus.auth?.redirect?.home ?? "/");
       }
     }
-    return {
-      user: user.value,
-      accessToken: response.access_token,
-      refreshToken: response.refresh_token,
-      expires: response.expires,
-      expiresAt: response.expires_at
-    };
+    return user.value;
   }
   async function loginWithProvider(provider, redirectOnLogin) {
-    await logout();
     const redirect = `${window.location.origin}${redirectOnLogin ?? router.currentRoute.value.fullPath}`;
     await navigateTo(useDirectusUrl(`/auth/login/${provider}?redirect=${encodeURIComponent(redirect)}`), { external: true });
   }
@@ -87,10 +82,6 @@ export function useDirectusAuth() {
       await directus.logout();
     } finally {
       user.value = null;
-      tokens.refreshToken.value = null;
-      tokens.accessToken.value = null;
-      tokens.expires.value = null;
-      tokens.expiresAt.value = null;
     }
     if (redirect) {
       const defaultRedirect = config.public.directus.auth?.redirect?.logout ?? config.public.directus.auth?.redirect?.home ?? "/";

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

@@ -1,4 +1,4 @@
 import type { Ref } from '#imports';
 export declare function useDirectusPreview(): Ref<boolean>;
 export declare function useDirectusUrl(path?: string): string;
-export declare function useDirectus(token?: string): import("@directus/sdk").DirectusClient<DirectusSchema> & import("@directus/sdk").AuthenticationClient<DirectusSchema> & import("@directus/sdk").RestClient<DirectusSchema> & import("@directus/sdk").WebSocketClient<DirectusSchema>;
+export declare function useDirectus(): import("@directus/sdk").DirectusClient<DirectusSchema> & import("@directus/sdk").AuthenticationClient<DirectusSchema> & import("@directus/sdk").RestClient<DirectusSchema> & import("@directus/sdk").WebSocketClient<DirectusSchema>;