@vatts/auth 1.1.4-alpha.9 → 1.2.0-alpha.2

package/dist/react/index.d.ts

@@ -1,6 +1,5 @@
-export * from '../react';
+export * from './react';
 export * from '../client';
-export * from '../components';
-export { getSession } from '../client';
-export { useSession, useAuth, SessionProvider } from '../react';
-export { AuthGuard, GuestOnly } from '../components';
+export * from './components';
+export { useSession, useAuth, SessionProvider } from './react';
+export { AuthGuard, GuestOnly } from './components';

package/dist/react/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GuestOnly = exports.AuthGuard = exports.SessionProvider = exports.useAuth = exports.useSession = exports.getSession = void 0;
+exports.GuestOnly = exports.AuthGuard = exports.SessionProvider = exports.useAuth = exports.useSession = void 0;
 /*
  * This file is part of the Vatts.js Project.
  * Copyright (c) 2026 itsmuzin
@@ -32,16 +32,14 @@ exports.GuestOnly = exports.AuthGuard = exports.SessionProvider = exports.useAut
  * limitations under the License.
  */
 // Exportações do frontend
-__exportStar(require("../react"), exports);
+__exportStar(require("./react"), exports);
 __exportStar(require("../client"), exports);
-__exportStar(require("../components"), exports);
+__exportStar(require("./components"), exports);
 // Re-exports das funções mais usadas para conveniência
-var client_1 = require("../client");
-Object.defineProperty(exports, "getSession", { enumerable: true, get: function () { return client_1.getSession; } });
-var react_1 = require("../react");
+var react_1 = require("./react");
 Object.defineProperty(exports, "useSession", { enumerable: true, get: function () { return react_1.useSession; } });
 Object.defineProperty(exports, "useAuth", { enumerable: true, get: function () { return react_1.useAuth; } });
 Object.defineProperty(exports, "SessionProvider", { enumerable: true, get: function () { return react_1.SessionProvider; } });
-var components_1 = require("../components");
+var components_1 = require("./components");
 Object.defineProperty(exports, "AuthGuard", { enumerable: true, get: function () { return components_1.AuthGuard; } });
 Object.defineProperty(exports, "GuestOnly", { enumerable: true, get: function () { return components_1.GuestOnly; } });

package/dist/{react.d.ts → react/react.d.ts}

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import type { SessionContextType, User } from './types';
+import type { SessionContextType, User } from '../types';
 interface SessionProviderProps {
     children: ReactNode;
     basePath?: string;

package/dist/vue/component.vue

@@ -0,0 +1,25 @@
+<script setup lang="ts">
+/**
+ * This file is part of the Vatts.js Project.
+ * Copyright (c) 2026 itsmuzin
+ */
+import { useSessionProviderLogic } from './session';
+
+// Definição das props com valores padrão
+const props = withDefaults(defineProps<{
+  basePath?: string;
+  refetchInterval?: number;
+  refetchOnWindowFocus?: boolean;
+}>(), {
+  basePath: '/api/auth',
+  refetchInterval: 0,
+  refetchOnWindowFocus: true
+});
+
+// Inicializa a lógica do provider passando as props reativas
+useSessionProviderLogic(props);
+</script>
+
+<template>
+  <slot />
+</template>

package/dist/vue/guards.d.ts

@@ -0,0 +1,72 @@
+import { type PropType, type VNode } from 'vue';
+/**
+ * Guard simples que só renderiza o slot default se estiver autenticado.
+ * * Uso:
+ * <AuthGuard redirectTo="/login">
+ * <ConteudoProtegido />
+ * </AuthGuard>
+ */
+export declare const AuthGuard: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fallback: {
+        type: PropType<VNode | string | object>;
+        default: null;
+    };
+    redirectTo: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fallback: {
+        type: PropType<VNode | string | object>;
+        default: null;
+    };
+    redirectTo: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    fallback: string | object | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    redirectTo: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * Componente para mostrar conteúdo apenas para usuários NÃO autenticados (ex: página de Login)
+ */
+export declare const GuestOnly: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fallback: {
+        type: PropType<VNode | string | object>;
+        default: null;
+    };
+    redirectTo: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fallback: {
+        type: PropType<VNode | string | object>;
+        default: null;
+    };
+    redirectTo: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    fallback: string | object | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    redirectTo: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * Composable para redirecionar baseado no status de autenticação.
+ * Equivalente ao hook useAuthRedirect do React.
+ */
+export declare function useAuthRedirect(authenticatedRedirect?: string, unauthenticatedRedirect?: string): void;

package/dist/vue/guards.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuestOnly = exports.AuthGuard = void 0;
+exports.useAuthRedirect = useAuthRedirect;
+/*
+ * This file is part of the Vatts.js Project.
+ * Copyright (c) 2026 itsmuzin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const vue_1 = require("vue");
+const session_1 = require("./session");
+const vue_2 = require("vatts/vue");
+// Helper reativo interno para garantir acesso às Refs
+// O useAuth do session.ts pode retornar valores estáticos dependendo da implementação,
+// então usamos useSession diretamente aqui para garantir reatividade via computed.
+function useAuthReactive() {
+    const { data, status } = (0, session_1.useSession)();
+    // Casting para Ref pois o inject traz as refs do provide
+    const isAuthenticated = (0, vue_1.computed)(() => status.value === 'authenticated');
+    const isLoading = (0, vue_1.computed)(() => status.value === 'loading');
+    return { isAuthenticated, isLoading };
+}
+/**
+ * Guard simples que só renderiza o slot default se estiver autenticado.
+ * * Uso:
+ * <AuthGuard redirectTo="/login">
+ * <ConteudoProtegido />
+ * </AuthGuard>
+ */
+exports.AuthGuard = (0, vue_1.defineComponent)({
+    name: 'AuthGuard',
+    props: {
+        fallback: {
+            type: [Object, String],
+            default: null
+        },
+        redirectTo: {
+            type: String,
+            default: undefined
+        }
+    },
+    setup(props, { slots }) {
+        const { isAuthenticated, isLoading } = useAuthReactive();
+        // Lógica de redirecionamento
+        (0, vue_1.watchEffect)(() => {
+            if (props.redirectTo && !isLoading.value && !isAuthenticated.value) {
+                if (vue_2.router && typeof vue_2.router.push === 'function') {
+                    vue_2.router.push(props.redirectTo);
+                }
+                else {
+                    window.location.href = props.redirectTo;
+                }
+            }
+        });
+        // Render Function
+        return () => {
+            if (isLoading.value) {
+                // Se houver fallback, renderiza ele (se for string cria text node, se for comp renderiza)
+                // Caso contrário renderiza div vazia para manter paridade com React
+                return props.fallback
+                    ? (typeof props.fallback === 'string' ? (0, vue_1.h)('div', props.fallback) : (0, vue_1.h)(props.fallback))
+                    : (0, vue_1.h)('div');
+            }
+            if (!isAuthenticated.value) {
+                return props.fallback
+                    ? (typeof props.fallback === 'string' ? (0, vue_1.h)('div', props.fallback) : (0, vue_1.h)(props.fallback))
+                    : null;
+            }
+            // Renderiza conteúdo principal
+            return slots.default ? slots.default() : null;
+        };
+    }
+});
+/**
+ * Componente para mostrar conteúdo apenas para usuários NÃO autenticados (ex: página de Login)
+ */
+exports.GuestOnly = (0, vue_1.defineComponent)({
+    name: 'GuestOnly',
+    props: {
+        fallback: {
+            type: [Object, String],
+            default: null
+        },
+        redirectTo: {
+            type: String,
+            default: undefined
+        }
+    },
+    setup(props, { slots }) {
+        const { isAuthenticated, isLoading } = useAuthReactive();
+        (0, vue_1.watchEffect)(() => {
+            if (props.redirectTo && !isLoading.value && isAuthenticated.value) {
+                if (vue_2.router && typeof vue_2.router.push === 'function') {
+                    vue_2.router.push(props.redirectTo);
+                }
+                else {
+                    window.location.href = props.redirectTo;
+                }
+            }
+        });
+        return () => {
+            if (isLoading.value || isAuthenticated.value) {
+                return props.fallback
+                    ? (typeof props.fallback === 'string' ? (0, vue_1.h)('div', props.fallback) : (0, vue_1.h)(props.fallback))
+                    : (0, vue_1.h)('div');
+            }
+            return slots.default ? slots.default() : null;
+        };
+    }
+});
+/**
+ * Composable para redirecionar baseado no status de autenticação.
+ * Equivalente ao hook useAuthRedirect do React.
+ */
+function useAuthRedirect(authenticatedRedirect, unauthenticatedRedirect) {
+    const { isAuthenticated, isLoading } = useAuthReactive();
+    (0, vue_1.watchEffect)(() => {
+        if (isLoading.value)
+            return;
+        if (isAuthenticated.value && authenticatedRedirect) {
+            window.location.href = authenticatedRedirect;
+        }
+        else if (!isAuthenticated.value && unauthenticatedRedirect) {
+            window.location.href = unauthenticatedRedirect;
+        }
+    });
+}

package/dist/vue/index.d.ts

@@ -0,0 +1,6 @@
+export * from './session';
+export * from './guards';
+export { useSession, useAuth } from './session';
+export { AuthGuard, GuestOnly } from './guards';
+import SessionProvider from "./component.vue";
+export { SessionProvider };

package/dist/vue/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionProvider = exports.GuestOnly = exports.AuthGuard = exports.useAuth = exports.useSession = void 0;
+/*
+ * This file is part of the Vatts.js Project.
+ * Copyright (c) 2026 itsmuzin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Exportações do frontend
+__exportStar(require("./session"), exports);
+__exportStar(require("./guards"), exports);
+// Re-exports das funções mais usadas para conveniência
+var session_1 = require("./session");
+Object.defineProperty(exports, "useSession", { enumerable: true, get: function () { return session_1.useSession; } });
+Object.defineProperty(exports, "useAuth", { enumerable: true, get: function () { return session_1.useAuth; } });
+var guards_1 = require("./guards");
+Object.defineProperty(exports, "AuthGuard", { enumerable: true, get: function () { return guards_1.AuthGuard; } });
+Object.defineProperty(exports, "GuestOnly", { enumerable: true, get: function () { return guards_1.GuestOnly; } });
+const component_vue_1 = __importDefault(require("./component.vue"));
+exports.SessionProvider = component_vue_1.default;

package/dist/vue/session.d.ts

@@ -0,0 +1,36 @@
+import { type InjectionKey, type Ref } from 'vue';
+import type { Session, SessionContextType, User } from '../types';
+export declare const SessionKey: InjectionKey<SessionContextType>;
+export interface SessionProviderProps {
+    basePath: string;
+    refetchInterval: number;
+    refetchOnWindowFocus: boolean;
+}
+/**
+ * Composable que contém toda a lógica do SessionProvider.
+ * Deve ser chamado dentro do setup do componente.
+ */
+export declare function useSessionProviderLogic(props: SessionProviderProps): {
+    session: Ref<{
+        user: User;
+        expires: string;
+        accessToken?: string | undefined;
+    } | null, Session | {
+        user: User;
+        expires: string;
+        accessToken?: string | undefined;
+    } | null>;
+    status: Ref<"loading" | "authenticated" | "unauthenticated", "loading" | "authenticated" | "unauthenticated">;
+};
+/**
+ * Hook para acessar a sessão atual
+ */
+export declare function useSession(): SessionContextType;
+/**
+ * Hook para verificar autenticação
+ */
+export declare function useAuth(): {
+    user: User | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+};

package/dist/vue/session.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionKey = void 0;
+exports.useSessionProviderLogic = useSessionProviderLogic;
+exports.useSession = useSession;
+exports.useAuth = useAuth;
+/*
+ * This file is part of the Vatts.js Project.
+ * Copyright (c) 2026 itsmuzin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const vue_1 = require("vue");
+const vue_2 = require("vatts/vue");
+// Chave de injeção para o TypeScript
+exports.SessionKey = Symbol('SessionKey');
+/**
+ * Composable que contém toda a lógica do SessionProvider.
+ * Deve ser chamado dentro do setup do componente.
+ */
+function useSessionProviderLogic(props) {
+    // Estado reativo
+    const session = (0, vue_1.ref)(null);
+    const status = (0, vue_1.ref)('loading');
+    // Fetch da sessão atual
+    const fetchSession = async () => {
+        try {
+            const response = await fetch(`${props.basePath}/session`, {
+                credentials: 'include'
+            });
+            if (!response.ok) {
+                status.value = 'unauthenticated';
+                session.value = null;
+                return null;
+            }
+            const data = await response.json();
+            const sessionData = data.session;
+            if (sessionData) {
+                session.value = sessionData;
+                status.value = 'authenticated';
+                return sessionData;
+            }
+            else {
+                session.value = null;
+                status.value = 'unauthenticated';
+                return null;
+            }
+        }
+        catch (error) {
+            console.error('[vatts-auth] Error fetching session:', error);
+            session.value = null;
+            status.value = 'unauthenticated';
+            return null;
+        }
+    };
+    // SignIn function
+    const signIn = async (provider = 'credentials', options = {}) => {
+        try {
+            const { redirect = true, callbackUrl, ...credentials } = options;
+            const response = await fetch(`${props.basePath}/signin`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                credentials: 'include',
+                body: JSON.stringify({
+                    provider,
+                    ...credentials
+                })
+            });
+            const data = await response.json();
+            if (response.ok && data.success) {
+                await fetchSession();
+                if (data.type === 'oauth' && data.redirectUrl) {
+                    if (redirect && typeof window !== 'undefined') {
+                        window.location.href = data.redirectUrl;
+                    }
+                    return { ok: true, status: 200, url: data.redirectUrl };
+                }
+                if (data.type === 'session') {
+                    const finalUrl = callbackUrl || '/';
+                    if (redirect && typeof window !== 'undefined') {
+                        try {
+                            if (vue_2.router && typeof vue_2.router.push === 'function') {
+                                vue_2.router.push(finalUrl);
+                            }
+                            else {
+                                window.location.href = finalUrl;
+                            }
+                        }
+                        catch (e) {
+                            window.location.href = finalUrl;
+                        }
+                    }
+                    return { ok: true, status: 200, url: finalUrl };
+                }
+            }
+            else {
+                return {
+                    error: data.error || 'Authentication failed',
+                    status: response.status,
+                    ok: false
+                };
+            }
+        }
+        catch (error) {
+            console.error('[vatts-auth] Error on signIn:', error);
+            return { error: 'Network error', status: 500, ok: false };
+        }
+    };
+    // SignOut function
+    const signOut = async (options = {}) => {
+        try {
+            await fetch(`${props.basePath}/signout`, {
+                method: 'POST',
+                credentials: 'include'
+            });
+            session.value = null;
+            status.value = 'unauthenticated';
+            if (typeof window !== 'undefined') {
+                const url = options.callbackUrl || '/';
+                try {
+                    if (vue_2.router && typeof vue_2.router.push === 'function') {
+                        vue_2.router.push(url);
+                    }
+                    else {
+                        window.location.href = url;
+                    }
+                }
+                catch (e) {
+                    window.location.href = url;
+                }
+            }
+        }
+        catch (error) {
+            console.error('[vatts-auth] Error on signOut:', error);
+        }
+    };
+    const update = async () => {
+        return await fetchSession();
+    };
+    // Ciclo de vida e Listeners
+    (0, vue_1.onMounted)(() => {
+        fetchSession();
+        // Refetch Interval
+        let intervalId = null;
+        if (props.refetchInterval > 0) {
+            intervalId = setInterval(() => {
+                if (status.value === 'authenticated') {
+                    fetchSession();
+                }
+            }, props.refetchInterval * 1000);
+        }
+        // Refetch on Focus
+        const handleFocus = () => {
+            if (props.refetchOnWindowFocus && status.value === 'authenticated') {
+                fetchSession();
+            }
+        };
+        if (props.refetchOnWindowFocus) {
+            window.addEventListener('focus', handleFocus);
+        }
+        (0, vue_1.onUnmounted)(() => {
+            if (intervalId)
+                clearInterval(intervalId);
+            window.removeEventListener('focus', handleFocus);
+        });
+    });
+    // Fornece o contexto para os filhos
+    (0, vue_1.provide)(exports.SessionKey, {
+        data: session,
+        status: status,
+        signIn,
+        signOut,
+        update
+    });
+    return { session, status };
+}
+/**
+ * Hook para acessar a sessão atual
+ */
+function useSession() {
+    const context = (0, vue_1.inject)(exports.SessionKey);
+    if (!context) {
+        throw new Error('useSession must be used inside a SessionProvider');
+    }
+    return context;
+}
+/**
+ * Hook para verificar autenticação
+ */
+function useAuth() {
+    const context = useSession();
+    // Tratando Refs injetadas
+    const sessionData = context.data.value;
+    const statusVal = context.status.value;
+    return {
+        user: sessionData?.user || null,
+        isAuthenticated: statusVal === 'authenticated',
+        isLoading: statusVal === 'loading'
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vatts/auth",
-  "version": "1.1.4-alpha.9",
+  "version": "1.2.0-alpha.2",
   "description": "Authentication package for Vatts.js framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,6 +17,11 @@
       "types": "./dist/react/index.d.ts",
       "import": "./dist/react/index.js",
       "require": "./dist/react/index.js"
+    },
+    "./vue": {
+      "types": "./dist/vue/index.d.ts",
+      "import": "./dist/vue/index.js",
+      "require": "./dist/vue/index.js"
     }
   },
   "keywords": [
@@ -36,13 +41,16 @@
   "devDependencies": {
     "@types/node": "^20.11.24",
     "@types/react": "^19.2.2",
+    "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vue": "^3.5.27"
   },
   "peerDependencies": {
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
-    "vatts": "^1.1.4-alpha.9"
+    "vue": "^3.5.27",
+    "vatts": "^1.2.0-alpha.2"
   },
   "peerDependenciesMeta": {
     "react-dom": {
@@ -50,7 +58,7 @@
     }
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && copyfiles -u 1 \"src/**/*.vue\" dist",
     "build:watch": "tsc --watch",
     "clean": "rimraf dist",
     "test": "echo \"Error: no test specified\" && exit 1"