@adonis-agora/authkit-react 0.12.0

package/build/src/queries/admin/index.js

@@ -0,0 +1,287 @@
+import { useAuthkitClient } from '../../client/context.js';
+import { authkitKeys } from '../keys.js';
+export function useOverviewQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.overview(),
+        queryFn: () => client.admin.overview(),
+    };
+}
+export function useUsersQueryOptions(params) {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.users(params),
+        queryFn: () => client.admin.users.list(params),
+    };
+}
+export function useUserQueryOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.user(id),
+        queryFn: () => client.admin.users.get(id),
+        enabled: !!id,
+    };
+}
+export function useUserSessionsQueryOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.userSessions(id),
+        queryFn: () => client.admin.users.getSessions(id),
+        enabled: !!id,
+    };
+}
+export function useCreateUserMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'users', 'create'],
+        mutationFn: (data) => client.admin.users.create(data),
+    };
+}
+export function useUpdateUserMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'users', id, 'update'],
+        mutationFn: (data) => client.admin.users.update(id, data),
+    };
+}
+export function useDisableUserMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'users', id, 'disable'],
+        mutationFn: () => client.admin.users.disable(id),
+    };
+}
+export function useEnableUserMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'users', id, 'enable'],
+        mutationFn: () => client.admin.users.enable(id),
+    };
+}
+export function useResetPasswordMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'users', id, 'reset-password'],
+        mutationFn: () => client.admin.users.resetPassword(id),
+    };
+}
+export function useDeleteUserMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'users', id, 'delete'],
+        mutationFn: () => client.admin.users.remove(id),
+    };
+}
+export function useRevokeUserSessionsMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'users', id, 'revoke-sessions'],
+        mutationFn: () => client.admin.users.revokeSessions(id),
+    };
+}
+export function useSessionsQueryOptions(accountId) {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.sessions(accountId),
+        queryFn: () => client.admin.sessions.list(accountId),
+    };
+}
+export function useRevokeAllSessionsMutationOptions(accountId) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'sessions', 'revoke-all', accountId ?? null],
+        mutationFn: () => client.admin.sessions.revokeAll(accountId),
+    };
+}
+export function useClientsQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.clients(),
+        queryFn: () => client.admin.clients.list(),
+    };
+}
+export function useClientQueryOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.client(id),
+        queryFn: () => client.admin.clients.get(id),
+        enabled: !!id,
+    };
+}
+export function useCreateClientMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'clients', 'create'],
+        mutationFn: (data) => client.admin.clients.create(data),
+    };
+}
+export function useUpdateClientMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'clients', id, 'update'],
+        mutationFn: (data) => client.admin.clients.update(id, data),
+    };
+}
+export function useDeleteClientMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'clients', id, 'delete'],
+        mutationFn: () => client.admin.clients.remove(id),
+    };
+}
+export function useRegenerateClientSecretMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'clients', id, 'regenerate-secret'],
+        mutationFn: () => client.admin.clients.regenerateSecret(id),
+    };
+}
+export function useRolesQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.roles(),
+        queryFn: () => client.admin.roles.list(),
+    };
+}
+export function useCreateRoleMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'roles', 'create'],
+        mutationFn: (data) => client.admin.roles.create(data),
+    };
+}
+export function useUpdateRoleMutationOptions(name) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'roles', name, 'update'],
+        mutationFn: (data) => client.admin.roles.update(name, data),
+    };
+}
+export function useDeleteRoleMutationOptions(name) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'roles', name, 'delete'],
+        mutationFn: () => client.admin.roles.remove(name),
+    };
+}
+export function useOrgsQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.orgs(),
+        queryFn: () => client.admin.orgs.list(),
+    };
+}
+export function useOrgQueryOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.org(id),
+        queryFn: () => client.admin.orgs.get(id),
+        enabled: !!id,
+    };
+}
+export function useCreateOrgMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'orgs', 'create'],
+        mutationFn: (data) => client.admin.orgs.create(data),
+    };
+}
+export function useUpdateOrgMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'orgs', id, 'update'],
+        mutationFn: (data) => client.admin.orgs.update(id, data),
+    };
+}
+export function useDeleteOrgMutationOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'orgs', id, 'delete'],
+        mutationFn: () => client.admin.orgs.remove(id),
+    };
+}
+export function useAddOrgMemberMutationOptions(orgId) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'orgs', orgId, 'members', 'add'],
+        mutationFn: (data) => client.admin.orgs.addMember(orgId, data),
+    };
+}
+export function useRemoveOrgMemberMutationOptions(orgId, accountId) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'orgs', orgId, 'members', accountId, 'remove'],
+        mutationFn: () => client.admin.orgs.removeMember(orgId, accountId),
+    };
+}
+export function useUpdateOrgMemberRoleMutationOptions(orgId, accountId) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'orgs', orgId, 'members', accountId, 'role'],
+        mutationFn: (role) => client.admin.orgs.updateMemberRole(orgId, accountId, role),
+    };
+}
+export function useCreateOrgInvitationMutationOptions(orgId) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'orgs', orgId, 'invitations', 'create'],
+        mutationFn: (data) => client.admin.orgs.createInvitation(orgId, data),
+    };
+}
+export function useRevokeOrgInvitationMutationOptions(orgId, invitationId) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'orgs', orgId, 'invitations', invitationId, 'revoke'],
+        mutationFn: () => client.admin.orgs.revokeInvitation(orgId, invitationId),
+    };
+}
+export function useAuditQueryOptions(params) {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.audit(params),
+        queryFn: () => client.admin.audit.list(params),
+    };
+}
+export function useSettingsQueryOptions(orgId) {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.settings(orgId),
+        queryFn: () => client.admin.settings.list(orgId),
+    };
+}
+export function useSetSettingMutationOptions(orgId) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'settings', 'set', orgId ?? null],
+        mutationFn: ({ key, value }) => client.admin.settings.set(key, value, orgId),
+    };
+}
+export function useRemoveSettingMutationOptions(orgId) {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'settings', 'remove', orgId ?? null],
+        mutationFn: (key) => client.admin.settings.remove(key, orgId),
+    };
+}
+export function useImpersonationQueryOptions(userId) {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.impersonation(userId),
+        queryFn: () => client.admin.impersonation.get(userId),
+        enabled: !!userId,
+    };
+}
+export function useKeysQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.admin.keys(),
+        queryFn: () => client.admin.keys.status(),
+    };
+}
+export function useRotateKeysMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'admin', 'keys', 'rotate'],
+        mutationFn: (input) => client.admin.keys.rotate(input),
+    };
+}

package/build/src/queries/keys.d.ts

@@ -0,0 +1,50 @@
+export declare const authkitKeys: {
+    readonly admin: {
+        readonly all: readonly ["authkit", "admin"];
+        readonly overview: () => readonly ["authkit", "admin", "overview"];
+        readonly users: (params?: {
+            search?: string;
+            page?: number;
+            limit?: number;
+        }) => readonly ["authkit", "admin", "users", {
+            search?: string;
+            page?: number;
+            limit?: number;
+        }];
+        readonly user: (id: string) => readonly ["authkit", "admin", "users", string];
+        readonly userSessions: (id: string) => readonly ["authkit", "admin", "users", string, "sessions"];
+        readonly sessions: (accountId?: string) => readonly ["authkit", "admin", "sessions", string | null];
+        readonly clients: () => readonly ["authkit", "admin", "clients"];
+        readonly client: (id: string) => readonly ["authkit", "admin", "clients", string];
+        readonly roles: () => readonly ["authkit", "admin", "roles"];
+        readonly orgs: () => readonly ["authkit", "admin", "orgs"];
+        readonly org: (id: string) => readonly ["authkit", "admin", "orgs", string];
+        readonly audit: (params?: {
+            type?: string;
+            page?: number;
+            limit?: number;
+            subject?: string;
+        }) => readonly ["authkit", "admin", "audit", {
+            type?: string;
+            page?: number;
+            limit?: number;
+            subject?: string;
+        }];
+        readonly settings: (orgId?: string | null) => readonly ["authkit", "admin", "settings", string] | readonly ["authkit", "admin", "settings"];
+        readonly impersonation: (userId: string) => readonly ["authkit", "admin", "impersonation", string];
+        readonly keys: () => readonly ["authkit", "admin", "keys"];
+    };
+    readonly account: {
+        readonly all: readonly ["authkit", "account"];
+        readonly me: () => readonly ["authkit", "account", "me"];
+        readonly security: () => readonly ["authkit", "account", "security"];
+        readonly sessions: () => readonly ["authkit", "account", "sessions"];
+        readonly apps: () => readonly ["authkit", "account", "apps"];
+        readonly mfa: () => readonly ["authkit", "account", "mfa"];
+        readonly passkeys: () => readonly ["authkit", "account", "passkeys"];
+        readonly tokens: () => readonly ["authkit", "account", "tokens"];
+        readonly orgs: () => readonly ["authkit", "account", "orgs"];
+        readonly org: (id: string) => readonly ["authkit", "account", "orgs", string];
+        readonly orgInvitations: () => readonly ["authkit", "account", "orgs", "invitations"];
+    };
+};

package/build/src/queries/keys.js

@@ -0,0 +1,34 @@
+export const authkitKeys = {
+    admin: {
+        all: ['authkit', 'admin'],
+        overview: () => ['authkit', 'admin', 'overview'],
+        users: (params) => ['authkit', 'admin', 'users', params ?? {}],
+        user: (id) => ['authkit', 'admin', 'users', id],
+        userSessions: (id) => ['authkit', 'admin', 'users', id, 'sessions'],
+        sessions: (accountId) => ['authkit', 'admin', 'sessions', accountId ?? null],
+        clients: () => ['authkit', 'admin', 'clients'],
+        client: (id) => ['authkit', 'admin', 'clients', id],
+        roles: () => ['authkit', 'admin', 'roles'],
+        orgs: () => ['authkit', 'admin', 'orgs'],
+        org: (id) => ['authkit', 'admin', 'orgs', id],
+        audit: (params) => ['authkit', 'admin', 'audit', params ?? {}],
+        settings: (orgId) => orgId
+            ? ['authkit', 'admin', 'settings', orgId]
+            : ['authkit', 'admin', 'settings'],
+        impersonation: (userId) => ['authkit', 'admin', 'impersonation', userId],
+        keys: () => ['authkit', 'admin', 'keys'],
+    },
+    account: {
+        all: ['authkit', 'account'],
+        me: () => ['authkit', 'account', 'me'],
+        security: () => ['authkit', 'account', 'security'],
+        sessions: () => ['authkit', 'account', 'sessions'],
+        apps: () => ['authkit', 'account', 'apps'],
+        mfa: () => ['authkit', 'account', 'mfa'],
+        passkeys: () => ['authkit', 'account', 'passkeys'],
+        tokens: () => ['authkit', 'account', 'tokens'],
+        orgs: () => ['authkit', 'account', 'orgs'],
+        org: (id) => ['authkit', 'account', 'orgs', id],
+        orgInvitations: () => ['authkit', 'account', 'orgs', 'invitations'],
+    },
+};

package/build/src/roles.d.ts

@@ -0,0 +1,7 @@
+import type { AuthUser } from './types.js';
+export declare function hasGlobalRole(user: AuthUser | null | undefined, role: string): boolean;
+export declare function hasAnyGlobalRole(user: AuthUser | null | undefined, roles: string[]): boolean;
+export declare function hasAllGlobalRoles(user: AuthUser | null | undefined, roles: string[]): boolean;
+export declare function hasAppRole(user: AuthUser | null | undefined, role: string): boolean;
+export declare function hasAnyAppRole(user: AuthUser | null | undefined, roles: string[]): boolean;
+export declare function hasAllAppRoles(user: AuthUser | null | undefined, roles: string[]): boolean;

package/build/src/roles.js

@@ -0,0 +1,39 @@
+function hasRole(arr, role) {
+    return arr.includes(role);
+}
+function hasAnyRole(arr, roles) {
+    return roles.some((role) => arr.includes(role));
+}
+function hasAllRoles(arr, roles) {
+    return roles.every((role) => arr.includes(role));
+}
+export function hasGlobalRole(user, role) {
+    if (!user)
+        return false;
+    return hasRole(user.globalRoles, role);
+}
+export function hasAnyGlobalRole(user, roles) {
+    if (!user)
+        return false;
+    return hasAnyRole(user.globalRoles, roles);
+}
+export function hasAllGlobalRoles(user, roles) {
+    if (!user)
+        return false;
+    return hasAllRoles(user.globalRoles, roles);
+}
+export function hasAppRole(user, role) {
+    if (!user || !user.appRoles)
+        return false;
+    return hasRole(user.appRoles, role);
+}
+export function hasAnyAppRole(user, roles) {
+    if (!user || !user.appRoles)
+        return false;
+    return hasAnyRole(user.appRoles, roles);
+}
+export function hasAllAppRoles(user, roles) {
+    if (!user || !user.appRoles)
+        return false;
+    return hasAllRoles(user.appRoles, roles);
+}

package/build/src/types.d.ts

@@ -0,0 +1,27 @@
+export interface AuthUser {
+    id: string;
+    email: string;
+    name?: string;
+    avatarUrl?: string;
+    globalRoles: string[];
+    appRoles?: string[];
+    [key: string]: unknown;
+}
+export interface AuthSharedProps {
+    authkit: {
+        user: AuthUser | null;
+        globalRoles: string[];
+        appRoles?: string[];
+    };
+    [key: string]: unknown;
+}
+export interface AuthState {
+    user: AuthUser | null;
+    isAuthenticated: boolean;
+    globalRoles: string[];
+    appRoles: string[];
+    hasGlobalRole(role: string): boolean;
+    hasAnyGlobalRole(roles: string[]): boolean;
+    hasAllGlobalRoles(roles: string[]): boolean;
+    hasAppRole(role: string): boolean;
+}

package/build/src/types.js

@@ -0,0 +1 @@
+export {};

package/build/src/use_auth.d.ts

@@ -0,0 +1,2 @@
+import type { AuthState } from './types.js';
+export declare function useAuth(): AuthState;

package/build/src/use_auth.js

@@ -0,0 +1,33 @@
+import { useContext, useMemo } from 'react';
+import { usePage } from '@inertiajs/react';
+import { AuthContext } from './provider.js';
+import { hasAllGlobalRoles as hasAllGlobalRolesPure, hasAnyGlobalRole as hasAnyGlobalRolePure, hasAppRole as hasAppRolePure, hasGlobalRole as hasGlobalRolePure, } from './roles.js';
+const UNAUTHENTICATED = {
+    user: null,
+    globalRoles: [],
+    appRoles: undefined,
+};
+export function useAuth() {
+    const contextValue = useContext(AuthContext);
+    const pageProps = usePage().props;
+    const resolved = contextValue ?? pageProps?.authkit;
+    if (!resolved && typeof process !== 'undefined' && process.env.NODE_ENV !== 'production') {
+        console.warn('[authkit] useAuth(): no <AuthProvider> nor shared-prop `authkit` found — returning unauthenticated state.');
+    }
+    const authkit = resolved ?? UNAUTHENTICATED;
+    return useMemo(() => {
+        const user = authkit.user ?? null;
+        const globalRoles = authkit.globalRoles ?? user?.globalRoles ?? [];
+        const appRoles = authkit.appRoles ?? user?.appRoles ?? [];
+        return {
+            user,
+            isAuthenticated: user !== null,
+            globalRoles,
+            appRoles,
+            hasGlobalRole: (role) => hasGlobalRolePure(user, role),
+            hasAnyGlobalRole: (roles) => hasAnyGlobalRolePure(user, roles),
+            hasAllGlobalRoles: (roles) => hasAllGlobalRolesPure(user, roles),
+            hasAppRole: (role) => hasAppRolePure(user, role),
+        };
+    }, [authkit]);
+}

package/build/src/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function deriveInitials(name?: string | null, email?: string | null): string;
+export declare function currentUrl(): string;

package/build/src/utils.js

@@ -0,0 +1,18 @@
+export function deriveInitials(name, email) {
+    const source = (name ?? '').trim();
+    if (source) {
+        const parts = source.split(/\s+/).filter(Boolean);
+        if (parts.length === 1)
+            return parts[0].slice(0, 2).toUpperCase();
+        return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase();
+    }
+    const e = (email ?? '').trim();
+    if (e)
+        return e[0].toUpperCase();
+    return '?';
+}
+export function currentUrl() {
+    if (typeof window === 'undefined')
+        return '';
+    return window.location.pathname + window.location.search;
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@adonis-agora/authkit-react",
+  "version": "0.12.0",
+  "description": "Frontend ergonomics over AuthKit for AdonisJS + Inertia + React apps: a typed useAuth() hook, role-gating hooks and gating components.",
+  "license": "MIT",
+  "author": "dudousxd",
+  "homepage": "https://github.com/DavideCarvalho/adonis-authkit/tree/main/packages/authkit-react#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DavideCarvalho/adonis-authkit.git",
+    "directory": "packages/authkit-react"
+  },
+  "bugs": {
+    "url": "https://github.com/DavideCarvalho/adonis-authkit/issues"
+  },
+  "keywords": [
+    "adonisjs",
+    "inertia",
+    "react",
+    "authentication",
+    "authkit",
+    "rbac",
+    "authorization"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "files": [
+    "build",
+    "styles.css"
+  ],
+  "exports": {
+    ".": "./build/index.js",
+    "./types": "./build/index.js",
+    "./styles.css": "./styles.css"
+  },
+  "peerDependencies": {
+    "@inertiajs/react": "3.3.0",
+    "@tanstack/react-query": "5.100.14",
+    "react": "19.2.6",
+    "react-dom": "19.2.6"
+  },
+  "dependencies": {
+    "@adonis-agora/authkit-core": "0.7.0"
+  },
+  "devDependencies": {
+    "@adonisjs/tsconfig": "2.0.0",
+    "@inertiajs/react": "3.3.0",
+    "@japa/assert": "4.2.0",
+    "@japa/runner": "5.3.0",
+    "@poppinss/ts-exec": "1.4.4",
+    "@tanstack/react-query": "5.100.14",
+    "@types/node": "25.9.1",
+    "@types/react": "19.2.15",
+    "@types/react-dom": "19.2.3",
+    "react": "19.2.6",
+    "react-dom": "19.2.6",
+    "typescript": "6.0.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "node --import=@poppinss/ts-exec bin/test.ts"
+  }
+}