@wpnuxt/auth 2.0.0-alpha.1

package/dist/module.d.mts

@@ -0,0 +1,7 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { WPNuxtAuthConfig } from '../dist/runtime/types/index.js';
+export { WPNuxtAuthConfig } from '../dist/runtime/types/index.js';
+
+declare const _default: _nuxt_schema.NuxtModule<WPNuxtAuthConfig, WPNuxtAuthConfig, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@wpnuxt/auth",
+  "configKey": "wpNuxtAuth",
+  "version": "2.0.0-alpha.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,46 @@
+import { defineNuxtModule, createResolver, addPlugin, addImports } from '@nuxt/kit';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@wpnuxt/auth",
+    configKey: "wpNuxtAuth"
+  },
+  defaults: {
+    enabled: true,
+    cookieName: "wpnuxt-auth-token",
+    refreshCookieName: "wpnuxt-refresh-token",
+    tokenMaxAge: 3600,
+    refreshTokenMaxAge: 604800,
+    redirectOnLogin: "/",
+    redirectOnLogout: "/",
+    loginPage: "/login"
+  },
+  async setup(options, nuxt) {
+    if (!options.enabled) {
+      return;
+    }
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.public.wpNuxtAuth = {
+      cookieName: options.cookieName,
+      refreshCookieName: options.refreshCookieName,
+      tokenMaxAge: options.tokenMaxAge,
+      refreshTokenMaxAge: options.refreshTokenMaxAge,
+      redirectOnLogin: options.redirectOnLogin,
+      redirectOnLogout: options.redirectOnLogout,
+      loginPage: options.loginPage
+    };
+    addPlugin(resolver.resolve("./runtime/plugins/auth"));
+    addImports([
+      { name: "useWPAuth", from: resolver.resolve("./runtime/composables/useWPAuth") },
+      { name: "useWPUser", from: resolver.resolve("./runtime/composables/useWPUser") }
+    ]);
+    nuxt.hook("prepare:types", ({ references }) => {
+      references.push({
+        path: resolver.resolve("./runtime/types/index.ts")
+      });
+    });
+    console.log("[WPNuxt Auth] Module loaded");
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/composables/useWPAuth.js

@@ -0,0 +1,103 @@
+import { computed, useState, useCookie, useRuntimeConfig, navigateTo, useGraphqlMutation } from "#imports";
+export function useWPAuth() {
+  const config = useRuntimeConfig().public.wpNuxtAuth;
+  const authState = useState("wpnuxt-auth", () => ({
+    user: null,
+    isAuthenticated: false,
+    isLoading: false,
+    error: null
+  }));
+  const authToken = useCookie(config.cookieName, {
+    maxAge: config.tokenMaxAge,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax"
+  });
+  const refreshToken = useCookie(config.refreshCookieName, {
+    maxAge: config.refreshTokenMaxAge,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax"
+  });
+  async function login(credentials) {
+    authState.value.isLoading = true;
+    authState.value.error = null;
+    try {
+      const { data, errors } = await useGraphqlMutation("Login", {
+        username: credentials.username,
+        password: credentials.password
+      });
+      if (errors?.length) {
+        const errorMessage = errors[0]?.message || "Login failed";
+        authState.value.error = errorMessage;
+        authState.value.isLoading = false;
+        return { success: false, error: errorMessage };
+      }
+      if (data?.login) {
+        authToken.value = data.login.authToken;
+        refreshToken.value = data.login.refreshToken;
+        authState.value.user = data.login.user;
+        authState.value.isAuthenticated = true;
+        authState.value.isLoading = false;
+        return {
+          success: true,
+          user: data.login.user,
+          tokens: {
+            authToken: data.login.authToken,
+            refreshToken: data.login.refreshToken
+          }
+        };
+      }
+      authState.value.isLoading = false;
+      return { success: false, error: "Invalid response from server" };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Login failed";
+      authState.value.error = errorMessage;
+      authState.value.isLoading = false;
+      return { success: false, error: errorMessage };
+    }
+  }
+  async function logout() {
+    authToken.value = null;
+    refreshToken.value = null;
+    authState.value.user = null;
+    authState.value.isAuthenticated = false;
+    authState.value.error = null;
+    if (config.redirectOnLogout) {
+      await navigateTo(config.redirectOnLogout);
+    }
+  }
+  async function refresh() {
+    if (!refreshToken.value) {
+      return false;
+    }
+    try {
+      const { data, errors } = await useGraphqlMutation("RefreshAuthToken", {
+        refreshToken: refreshToken.value
+      });
+      if (errors?.length || !data?.refreshJwtAuthToken) {
+        await logout();
+        return false;
+      }
+      authToken.value = data.refreshJwtAuthToken.authToken;
+      return true;
+    } catch {
+      await logout();
+      return false;
+    }
+  }
+  function getToken() {
+    return authToken.value || null;
+  }
+  return {
+    // State
+    state: authState,
+    user: computed(() => authState.value.user),
+    isAuthenticated: computed(() => authState.value.isAuthenticated),
+    isLoading: computed(() => authState.value.isLoading),
+    error: computed(() => authState.value.error),
+    // Methods
+    login,
+    logout,
+    refresh,
+    getToken
+  };
+}

package/dist/runtime/composables/useWPUser.js

@@ -0,0 +1,66 @@
+import { computed, useState, useGraphqlQuery } from "#imports";
+export function useWPUser() {
+  const userState = useState("wpnuxt-user", () => null);
+  const loadingState = useState("wpnuxt-user-loading", () => false);
+  const errorState = useState("wpnuxt-user-error", () => null);
+  async function fetchUser() {
+    loadingState.value = true;
+    errorState.value = null;
+    try {
+      const { data, errors } = await useGraphqlQuery("Viewer");
+      if (errors?.length) {
+        errorState.value = errors[0]?.message || "Failed to fetch user";
+        loadingState.value = false;
+        return null;
+      }
+      userState.value = data?.viewer || null;
+      loadingState.value = false;
+      return userState.value;
+    } catch (error) {
+      errorState.value = error instanceof Error ? error.message : "Failed to fetch user";
+      loadingState.value = false;
+      return null;
+    }
+  }
+  function clearUser() {
+    userState.value = null;
+    errorState.value = null;
+  }
+  function hasRole(roleName) {
+    if (!userState.value?.roles?.nodes) {
+      return false;
+    }
+    return userState.value.roles.nodes.some(
+      (role) => role.name.toLowerCase() === roleName.toLowerCase()
+    );
+  }
+  function isAdmin() {
+    return hasRole("administrator");
+  }
+  function isEditor() {
+    return hasRole("editor") || isAdmin();
+  }
+  function getDisplayName() {
+    if (!userState.value) {
+      return "";
+    }
+    return userState.value.name || `${userState.value.firstName || ""} ${userState.value.lastName || ""}`.trim() || userState.value.username || "";
+  }
+  function getAvatarUrl() {
+    return userState.value?.avatar?.url || null;
+  }
+  return {
+    // State
+    user: computed(() => userState.value),
+    isLoading: computed(() => loadingState.value),
+    error: computed(() => errorState.value),
+    // Methods
+    fetchUser,
+    clearUser,
+    hasRole,
+    isAdmin,
+    isEditor,
+    getDisplayName,
+    getAvatarUrl
+  };
+}

package/dist/runtime/plugins/auth.js

@@ -0,0 +1,19 @@
+import { defineNuxtPlugin, useCookie, useRuntimeConfig, useState } from "#imports";
+export default defineNuxtPlugin({
+  name: "wpnuxt-auth",
+  enforce: "pre",
+  async setup() {
+    const config = useRuntimeConfig().public.wpNuxtAuth;
+    const authState = useState("wpnuxt-auth", () => ({
+      user: null,
+      isAuthenticated: false,
+      isLoading: true,
+      error: null
+    }));
+    const authToken = useCookie(config.cookieName);
+    if (authToken.value) {
+      authState.value.isAuthenticated = true;
+    }
+    authState.value.isLoading = false;
+  }
+});

package/dist/runtime/queries/Auth.gql

@@ -0,0 +1,31 @@
+# Login mutation for WPGraphQL JWT Authentication
+mutation Login($username: String!, $password: String!) {
+  login(input: { username: $username, password: $password }) {
+    authToken
+    refreshToken
+    user {
+      id
+      databaseId
+      name
+      email
+      firstName
+      lastName
+      username
+      avatar {
+        url
+      }
+      roles {
+        nodes {
+          name
+        }
+      }
+    }
+  }
+}
+
+# Refresh auth token mutation
+mutation RefreshAuthToken($refreshToken: String!) {
+  refreshJwtAuthToken(input: { jwtRefreshToken: $refreshToken }) {
+    authToken
+  }
+}

package/dist/runtime/types/graphql-middleware.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Type augmentations for nuxt-graphql-middleware composables
+ * These are provided at runtime when @wpnuxt/core is installed
+ */
+
+// Make this a module to enable proper augmentation
+export {}
+
+declare module '#imports' {
+  export function useGraphqlQuery<T = unknown>(
+    operationName: string,
+    variables?: Record<string, unknown>,
+    options?: Record<string, unknown>
+  ): Promise<{ data: T | null, errors?: Array<{ message: string }> }>
+
+  export function useGraphqlMutation<T = unknown>(
+    operationName: string,
+    variables?: Record<string, unknown>,
+    options?: Record<string, unknown>
+  ): Promise<{ data: T | null, errors?: Array<{ message: string }> }>
+}

package/dist/types.d.mts

@@ -0,0 +1,9 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type WPNuxtAuthConfig } from '../dist/runtime/types/index.js'
+
+export { default } from './module.mjs'

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@wpnuxt/auth",
+  "version": "2.0.0-alpha.1",
+  "description": "Authentication module for WPNuxt using WPGraphQL JWT",
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "wordpress",
+    "authentication",
+    "jwt",
+    "wpgraphql",
+    "vue",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wpnuxt/wpnuxt.git",
+    "directory": "packages/auth"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "types": "./dist/types.d.mts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nuxt/kit": "4.2.2"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "4.2.2",
+    "@types/node": "^25.0.3",
+    "nuxt": "4.2.2",
+    "vue-tsc": "^3.2.1"
+  },
+  "peerDependencies": {
+    "nuxt": "^4.0.0",
+    "@wpnuxt/core": "2.0.0-alpha.1"
+  },
+  "scripts": {
+    "build": "nuxt-module-build build",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare",
+    "typecheck": "vue-tsc --noEmit",
+    "clean": "rm -rf dist .nuxt node_modules"
+  }
+}