nuxt-directus-sdk 2.1.4 → 3.0.0

package/dist/module.d.mts

@@ -14,18 +14,6 @@ interface ModuleOptions {
      * @type string
      */
     adminToken?: string;
-    /**
-     * Fetch the user serverside
-     *
-     * @default true
-     */
-    fetchUser?: boolean;
-    /**
-     * Directus Auth Options
-     * @default {}
-     * @type Query<DirectusSchema, DirectusSchema['directus_users']>['fields']
-     */
-    fetchUserFields?: Query<DirectusSchema, DirectusSchema['directus_users']>['fields'];
     /**
      * Add Directus Admin in Nuxt Devtools
      *
@@ -33,61 +21,104 @@ interface ModuleOptions {
      */
     devtools?: boolean;
     /**
-     * Token Cookie Name
-     * @type string
-     * @default 'directus_access_token'
-     */
-    cookieNameAccessToken?: string;
-    /**
-     * Refresh Token Cookie Name
-     * @type string
-     * @default 'directus_refresh_token'
-     */
-    cookieNameRefreshToken?: string;
-    /**
-     * The max age for auth cookies in seconds.
-     * This should match your directus env key AUTH_TOKEN_TTL
-     * @type string
-     * @default 900
-     */
-    cookieMaxAge?: number;
-    /**
-     * The max age for auth cookies in seconds.
-     * This should match your directus env key REFRESH_TOKEN_TTL
-     * @type string
-     * @default 604800
-     */
-    cookieMaxAgeRefreshToken?: number;
-    /**
-     * The SameSite attribute for auth cookies.
-     * @type string
-     * @default 'lax'
-     */
-    cookieSameSite?: 'strict' | 'lax' | 'none' | undefined;
-    /**
-     * The Secure attribute for auth cookies.
-     * @type boolean
-     * @default false
-     */
-    cookieSecure?: boolean;
-    /**
-     * The Domain attribute for auth cookies.
-     * @type string
-     * @default undefined
-     */
-    cookieDomain?: boolean;
-    /**
-     * The prefix to your custom types
-     * @type string
-     * @default ''
-     */
-    typePrefix?: string;
-    /**
-     * A path to redirect a user to when not logged in using auth middleware
-     * @type string
-     * @default '/login'
+     * Auth options
      */
-    loginPath?: string;
+    auth?: {
+        /**
+         * Enable auth middleware
+         * @default true
+         * @type boolean
+         *
+         */
+        enabled?: boolean;
+        /**
+         * Enable global auth middleware
+         * @default false
+         * @type boolean
+         */
+        enableGlobalAuthMiddleware?: boolean;
+        /**
+         * ReadMe fields to fetch
+         * @default []
+         * @type Query<AllDirectusCollections, AllDirectusCollections['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;
+        };
+        redirect?: {
+            /**
+             * Redirect to home page after login
+             * @default '/home'
+             */
+            home?: string;
+            /**
+             * Redirect to login page after logout
+             * @default '/auth/login'
+             */
+            login?: string;
+            /**
+             * Redirect to login page after logout
+             * @default '/auth/login'
+             */
+            logout?: string;
+        };
+    };
+    types?: {
+        /**
+         * Generate types for your Directus instance
+         * @type boolean
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * The prefix to your custom types
+         * @type string
+         * @default ''
+         */
+        prefix?: string;
+    };
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
@@ -95,7 +126,7 @@ declare module '@nuxt/schema' {
     interface ConfigSchema {
         directus?: ModuleOptions;
         publicRuntimeConfig?: {
-            directus?: ModuleOptions;
+            directus?: Omit<ModuleOptions, 'adminToken'>;
         };
     }
 }

package/dist/module.d.ts

@@ -14,18 +14,6 @@ interface ModuleOptions {
      * @type string
      */
     adminToken?: string;
-    /**
-     * Fetch the user serverside
-     *
-     * @default true
-     */
-    fetchUser?: boolean;
-    /**
-     * Directus Auth Options
-     * @default {}
-     * @type Query<DirectusSchema, DirectusSchema['directus_users']>['fields']
-     */
-    fetchUserFields?: Query<DirectusSchema, DirectusSchema['directus_users']>['fields'];
     /**
      * Add Directus Admin in Nuxt Devtools
      *
@@ -33,61 +21,104 @@ interface ModuleOptions {
      */
     devtools?: boolean;
     /**
-     * Token Cookie Name
-     * @type string
-     * @default 'directus_access_token'
-     */
-    cookieNameAccessToken?: string;
-    /**
-     * Refresh Token Cookie Name
-     * @type string
-     * @default 'directus_refresh_token'
-     */
-    cookieNameRefreshToken?: string;
-    /**
-     * The max age for auth cookies in seconds.
-     * This should match your directus env key AUTH_TOKEN_TTL
-     * @type string
-     * @default 900
-     */
-    cookieMaxAge?: number;
-    /**
-     * The max age for auth cookies in seconds.
-     * This should match your directus env key REFRESH_TOKEN_TTL
-     * @type string
-     * @default 604800
-     */
-    cookieMaxAgeRefreshToken?: number;
-    /**
-     * The SameSite attribute for auth cookies.
-     * @type string
-     * @default 'lax'
-     */
-    cookieSameSite?: 'strict' | 'lax' | 'none' | undefined;
-    /**
-     * The Secure attribute for auth cookies.
-     * @type boolean
-     * @default false
-     */
-    cookieSecure?: boolean;
-    /**
-     * The Domain attribute for auth cookies.
-     * @type string
-     * @default undefined
-     */
-    cookieDomain?: boolean;
-    /**
-     * The prefix to your custom types
-     * @type string
-     * @default ''
-     */
-    typePrefix?: string;
-    /**
-     * A path to redirect a user to when not logged in using auth middleware
-     * @type string
-     * @default '/login'
+     * Auth options
      */
-    loginPath?: string;
+    auth?: {
+        /**
+         * Enable auth middleware
+         * @default true
+         * @type boolean
+         *
+         */
+        enabled?: boolean;
+        /**
+         * Enable global auth middleware
+         * @default false
+         * @type boolean
+         */
+        enableGlobalAuthMiddleware?: boolean;
+        /**
+         * ReadMe fields to fetch
+         * @default []
+         * @type Query<AllDirectusCollections, AllDirectusCollections['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;
+        };
+        redirect?: {
+            /**
+             * Redirect to home page after login
+             * @default '/home'
+             */
+            home?: string;
+            /**
+             * Redirect to login page after logout
+             * @default '/auth/login'
+             */
+            login?: string;
+            /**
+             * Redirect to login page after logout
+             * @default '/auth/login'
+             */
+            logout?: string;
+        };
+    };
+    types?: {
+        /**
+         * Generate types for your Directus instance
+         * @type boolean
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * The prefix to your custom types
+         * @type string
+         * @default ''
+         */
+        prefix?: string;
+    };
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
@@ -95,7 +126,7 @@ declare module '@nuxt/schema' {
     interface ConfigSchema {
         directus?: ModuleOptions;
         publicRuntimeConfig?: {
-            directus?: ModuleOptions;
+            directus?: Omit<ModuleOptions, 'adminToken'>;
         };
     }
 }

package/dist/module.mjs

@@ -1,10 +1,10 @@
-import { useLogger, defineNuxtModule, createResolver, installModule, addPlugin, addImportsDir, addComponentsDir, addImportsSources, addTypeTemplate } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, installModule, addPlugin, addRouteMiddleware, addImportsDir, addComponentsDir, addImportsSources, addTypeTemplate } from '@nuxt/kit';
 import { defu } from 'defu';
 import { generateTypes } from '../dist/runtime/types/index.js';
 import { useUrl } from '../dist/runtime/utils/index.js';
 
 const name = "nuxt-directus-sdk";
-const version = "2.1.4";
+const version = "3.0.0";
 
 const configKey = "directus";
 const logger = useLogger("nuxt-directus-sdk");
@@ -22,31 +22,41 @@ const module = defineNuxtModule({
     url: import.meta.env.DIRECTUS_URL ?? "",
     adminToken: import.meta.env.DIRECTUS_ADMIN_TOKEN ?? "",
     devtools: true,
-    fetchUser: true,
-    fetchUserFields: [],
-    cookieNameAccessToken: "directus_access_token",
-    cookieNameRefreshToken: "directus_refresh_token",
-    // Nuxt Cookies Docs @ https://nuxt.com/docs/api/composables/use-cookie
-    cookieMaxAge: 900,
-    cookieMaxAgeRefreshToken: 604800,
-    cookieSameSite: "lax",
-    cookieSecure: false,
-    cookieDomain: void 0,
-    typePrefix: "",
-    loginPath: "/login"
+    types: {
+      enabled: true,
+      prefix: ""
+    },
+    auth: {
+      enabled: true,
+      enableGlobalAuthMiddleware: false,
+      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",
+        logout: "/"
+      }
+    }
   },
   async setup(options, nuxtApp) {
     if (!options.url) {
       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;
     }
-    nuxtApp.options.runtimeConfig[configKey] = { adminToken: options.adminToken ?? "" };
+    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,
-      // Don't add the admin token to the public config
-      adminToken: null
-    });
+    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: {
@@ -54,6 +64,11 @@ const module = defineNuxtModule({
       }
     });
     addPlugin(resolver.resolve("./runtime/plugin"));
+    addRouteMiddleware({
+      name: "auth",
+      path: resolver.resolve("./runtime/middleware/auth"),
+      global: options.auth?.enableGlobalAuthMiddleware
+    });
     addImportsDir(resolver.resolve("./runtime/composables"));
     addComponentsDir({
       path: resolver.resolve("./runtime/components"),
@@ -103,6 +118,7 @@ const module = defineNuxtModule({
         "readProviders",
         "readFolder",
         "readFolders",
+        "uploadFiles",
         "updateField",
         "updateFile",
         "updateFiles",
@@ -151,27 +167,29 @@ const module = defineNuxtModule({
     } else {
       logger.info("Set devtools to true to view the Directus admin panel from inside Nuxt Devtools");
     }
-    if (options.adminToken) {
-      logger.info("Generating Directus types");
-      try {
-        const typesPath = addTypeTemplate({
-          filename: `types/${configKey}.d.ts`,
-          getContents() {
-            return generateTypes({
-              url: useUrl(options.url),
-              token: options.adminToken,
-              prefix: options.typePrefix ?? ""
-            });
-          }
-        }, { nitro: true, nuxt: true }).dst;
-        nuxtApp.hook("prepare:types", (options2) => {
-          options2.references.push({ path: typesPath });
-        });
-      } catch (error) {
-        logger.error(error.message);
+    if (options.types?.enabled) {
+      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 {
+          const typesPath = addTypeTemplate({
+            filename: `types/${configKey}.d.ts`,
+            getContents() {
+              return generateTypes({
+                url: useUrl(options.url),
+                token: options.adminToken,
+                prefix: options.types?.prefix ?? ""
+              });
+            }
+          }, { nitro: true, nuxt: true }).dst;
+          nuxtApp.hook("prepare:types", (options2) => {
+            options2.references.push({ path: typesPath });
+          });
+        } catch (error) {
+          logger.error(error.message);
+        }
       }
-    } else {
-      logger.info("Add DIRECTUS_ADMIN_TOKEN to the .env file to generate directus types");
     }
   }
 });

package/dist/runtime/composables/auth.js

@@ -16,12 +16,17 @@ export function useDirectusAuth() {
   const loggedIn = computed(() => user.value !== null);
   async function readMe() {
     try {
+      if (tokens.directusUrl.value !== config.public.directus.url) {
+        tokens.directusUrl.value = config.public.directus.url;
+        await logout();
+        throw new Error("Directus URL changed");
+      }
       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.fetchUserFields }));
+      user.value = await directus.request(directusReadMe({ fields: config.public.directus.auth?.readMeFields ?? ["*"] }));
     } catch {
       user.value = null;
     }
@@ -32,21 +37,24 @@ export function useDirectusAuth() {
     const currentUser = user.value;
     if (!currentUser?.id)
       throw new Error("No user available");
-    user.value = await directus.request(directusUpdateMe(data, { fields: config.public.directus.fetchUserFields }));
+    user.value = await directus.request(directusUpdateMe(data, { fields: config.public.directus.auth?.readMeFields ?? ["*"] }));
     return user.value;
   }
   async function login(email, password, options) {
-    const response = await directus.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 readMe();
     const redirect = options?.redirect ?? true;
     if (redirect !== false) {
       const route = router.currentRoute.value;
-      if (typeof redirect !== "boolean")
+      if (typeof redirect !== "boolean") {
         navigateTo(redirect);
-      else if (route?.query?.redirect)
+      } else if (route?.query?.redirect) {
         navigateTo({ path: decodeURIComponent(route.query.redirect) });
+      } else {
+        navigateTo(config.public.directus.auth?.redirect?.home ?? "/");
+      }
     }
     return {
       user: user.value,
@@ -82,6 +90,7 @@ export function useDirectusAuth() {
   async function logout() {
     try {
       await directus.logout();
+      await navigateTo(config.public.directus.auth?.redirect?.logout ?? config.public.directus.auth?.redirect?.home ?? "/");
     } finally {
       user.value = null;
       tokens.refreshToken.value = null;

package/dist/runtime/composables/directus.js

@@ -27,7 +27,7 @@ function createDirectusStorage() {
 export function useDirectus(token) {
   const directus = createDirectus(useDirectusUrl()).with(authentication("json", {
     storage: createDirectusStorage(),
-    autoRefresh: token !== ""
+    autoRefresh: token === ""
   })).with(rest()).with(realtime());
   if (token)
     directus.setToken(token);

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

@@ -7,7 +7,9 @@ export declare function uploadDirectusFile(file: DirectusFileUpload, query?: Que
 export declare function uploadDirectusFiles(files: DirectusFileUpload[], query?: Query<AllDirectusCollections, AllDirectusCollections['directus_files']>): Promise<any>;
 export type DirectusThumbnailFormat = 'jpg' | 'png' | 'webp' | 'tiff' | 'avif';
 export type DirectusThumbnailFit = 'cover' | 'contain' | 'inside' | 'outside';
-export interface DirectusThumbnailOptions {
+export interface DirectusFileOptions {
+    filename?: string;
+    download?: boolean;
     width?: number;
     height?: number;
     quality?: number;
@@ -17,5 +19,5 @@ export interface DirectusThumbnailOptions {
     key?: string;
     token?: string | boolean;
 }
-export declare function getDirectusFileUrl(file: string | DirectusFiles, options?: DirectusThumbnailOptions): string;
+export declare function getDirectusFileUrl(file: string | DirectusFiles, options?: DirectusFileOptions): string;
 export {};

package/dist/runtime/composables/files.js

@@ -16,11 +16,14 @@ export async function uploadDirectusFiles(files, query) {
     }
     formData.set("file", file);
   });
-  return await directus.request(uploadFiles(formData, query));
+  return directus.request(uploadFiles(formData, query));
 }
 export function getDirectusFileUrl(file, options) {
   const fileId = typeof file === "string" ? file : file.id;
-  const url = new URL(useDirectusUrl(`assets/${fileId}`));
+  const url = new URL(useDirectusUrl(`assets/${fileId}${options?.filename ? `/${options.filename}` : ""}`));
+  if (options?.download) {
+    url.searchParams.append("download", "true");
+  }
   if (options?.width) {
     url.searchParams.append("width", options.width.toFixed(0));
   }

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

@@ -1 +1 @@
-export declare function isVisualEditorPage(route: any): any;
+export declare function isVisualEditorPage(route: any): boolean;

package/dist/runtime/composables/preview.js

@@ -1,3 +1,3 @@
 export function isVisualEditorPage(route) {
-  return route.query["visual-editor"] && route.query["visual-editor"] === "true";
+  return route.query["visual-editor"] === "true" || route.query["visual-editor"] === true || route.query["visual-editor"] === 1;
 }

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

@@ -1,5 +1,6 @@
 import type { CookieRef } from '#app';
 export interface DirectusTokens {
+    directusUrl: CookieRef<string | null>;
     accessToken: CookieRef<string | null>;
     refreshToken: CookieRef<string | null>;
     expires: CookieRef<number | null>;

package/dist/runtime/composables/tokens.js

@@ -9,37 +9,44 @@ function directusCookie(name, cookieOptions) {
   return cookie;
 }
 export function useDirectusTokens() {
-  const config = useRuntimeConfig().public.directus;
+  const { cookies } = useRuntimeConfig().public.directus.auth;
   const sharedOptions = {
-    sameSite: config.cookieSameSite,
-    secure: config.cookieSecure,
-    domain: config.cookieDomain
+    sameSite: cookies.sameSite,
+    secure: cookies.secure,
+    domain: cookies.domain
   };
+  function directusUrl() {
+    return directusCookie("directus_url", {
+      ...sharedOptions,
+      maxAge: cookies.maxAge
+    });
+  }
   function accessToken() {
-    return directusCookie(config.cookieNameAccessToken, {
+    return directusCookie(cookies.accessToken, {
       ...sharedOptions,
-      maxAge: config.cookieMaxAge
+      maxAge: cookies.maxAge
     });
   }
   function refreshToken() {
-    return directusCookie(config.cookieNameRefreshToken, {
+    return directusCookie(cookies.refreshToken, {
       ...sharedOptions,
-      maxAge: config.cookieMaxAgeRefreshToken
+      maxAge: cookies.maxAgeRefreshToken
     });
   }
   function expires() {
     return directusCookie("directus_access_expires", {
       ...sharedOptions,
-      maxAge: config.cookieMaxAge
+      maxAge: cookies.maxAge
     });
   }
   function expiresAt() {
     return directusCookie("directus_access_expires_at", {
       ...sharedOptions,
-      maxAge: config.cookieMaxAge
+      maxAge: cookies.maxAge
     });
   }
   return {
+    directusUrl: directusUrl(),
     accessToken: accessToken(),
     refreshToken: refreshToken(),
     expires: expires(),

package/dist/runtime/middleware/auth.js

@@ -7,10 +7,16 @@ import {
 export default defineNuxtRouteMiddleware((to) => {
   const config = useRuntimeConfig();
   const user = useDirectusUser();
+  const redirect = config.public.directus.auth?.redirect ?? {};
+  const loginPath = redirect.login ?? "/login";
+  const homePath = redirect.home ?? "/";
+  if (to.path === loginPath) {
+    return;
+  }
   if (!user.value) {
     return navigateTo({
-      path: config.public.directus.loginPath ?? "/login",
-      query: { redirect: to.path !== "/" ? encodeURIComponent(to.path) : void 0 }
+      path: loginPath,
+      query: { redirect: to.path !== homePath ? encodeURIComponent(to.path) : void 0 }
     });
   }
 });

package/dist/runtime/plugin.js

@@ -1,15 +1,23 @@
-import { addRouteMiddleware, defineNuxtPlugin, refreshNuxtData, useRoute, useRuntimeConfig } from "#app";
+import { defineNuxtPlugin, refreshNuxtData, useRoute, useRuntimeConfig } from "#app";
 import { apply, remove } from "@directus/visual-editing";
 import { useDirectusAuth } from "./composables/auth.js";
 import { useDirectus } from "./composables/directus.js";
 import { isVisualEditorPage } from "./composables/preview.js";
-import auth from "./middleware/auth.js";
+import { useDirectusTokens } from "./composables/tokens.js";
 export default defineNuxtPlugin(async (nuxtApp) => {
   const route = useRoute();
   const config = useRuntimeConfig();
+  const tokens = useDirectusTokens();
+  const directusAuth = useDirectusAuth();
   const preview = route.query.preview && route.query.preview === "true";
   const token = route.query.token;
   const livePreview = isVisualEditorPage(route);
+  if (!tokens.directusUrl.value || tokens.directusUrl.value !== config.public.directus.url) {
+    tokens.directusUrl.value = config.public.directus.url;
+    if (tokens.accessToken.value || tokens.refreshToken.value) {
+      await directusAuth.logout();
+    }
+  }
   if (preview && token) {
     useDirectus().setToken(token);
     nuxtApp.hook("page:finish", () => {
@@ -29,8 +37,8 @@ export default defineNuxtPlugin(async (nuxtApp) => {
     });
   }
   async function fetchUser() {
-    if (config.public.directus.fetchUser)
-      await useDirectusAuth().readMe();
+    if (config.public.directus.auth?.enabled ?? true)
+      await directusAuth.readMe();
   }
   await fetchUser();
   let loadedUser = false;
@@ -40,5 +48,4 @@ export default defineNuxtPlugin(async (nuxtApp) => {
       loadedUser = true;
     }
   });
-  addRouteMiddleware("auth", auth);
 });

package/dist/runtime/server/services/directus.js

@@ -3,7 +3,7 @@ import { authentication, createDirectus, rest } from "@directus/sdk";
 import { getCookie } from "h3";
 import { useUrl } from "../../utils/index.js";
 export function useDirectusAccessToken(event) {
-  return getCookie(event, useRuntimeConfig().public.directus.cookieNameAccessToken);
+  return getCookie(event, useRuntimeConfig().public.directus.auth?.cookies?.accessToken ?? "directus_access_token");
 }
 export function useDirectusUrl(path = "") {
   return useUrl(useRuntimeConfig().public.directus.url, path);

package/dist/runtime/types/generate.js

@@ -15,7 +15,7 @@ export async function generateTypes(options) {
     const name = collection.collection;
     const typeName = name.startsWith("directus_") ? pascalCase(name) : pascalCase(`${options.prefix}${name}`);
     const isSingleton = collection.meta?.singleton === true;
-    types += `export type ${typeName} = {
+    types += `interface ${typeName} {
 `;
     collection.fields.forEach((field) => {
       if (field.meta?.interface?.startsWith("presentation-"))
@@ -36,20 +36,8 @@ export async function generateTypes(options) {
     return item.startsWith("directus_users") || !item.startsWith("directus_");
   }));
   return `
-  declare module '#app' {
-    ${types.replaceAll("export type", "type")}
-
-    interface AllDirectusCollections {
-      ${allTypes}
-    };
-
-    interface DirectusSchema {
-      ${schemaTypes}
-    };
-  }
-  
   declare global {
-    ${types.replaceAll("export type", "type")}
+    ${types}
 
     interface AllDirectusCollections {
       ${allTypes}
@@ -102,11 +90,9 @@ async function getCollections(options) {
     const relations = await directus.request(readRelations());
     relations?.forEach((relation) => {
       if (!relation.meta) {
-        warn(`Not yet implemented: Relation on field '${relation.field}' in collection '${relation.collection}' has no meta. Maybe missing a relation inside directus_relations table.`);
         return;
       }
       if (!relation.meta.one_collection) {
-        warn("Not yet implemented: Missing one collection");
         return;
       }
       const oneField = collections[relation.meta.one_collection]?.fields.find((field) => field.field === relation.meta.one_field);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-directus-sdk",
   "type": "module",
-  "version": "2.1.4",
+  "version": "3.0.0",
   "description": "A Directus nuxt module that uses the Directus SDK",
   "author": "Matthew Rollinson <matt@rolley.io>",
   "license": "MIT",