@adonis-agora/authkit-react 0.12.0

package/build/src/hooks/use_switch_organization.js

@@ -0,0 +1,42 @@
+import { useCallback, useState } from 'react';
+import { useAuthkitConfig } from '../config.js';
+import { jsonRequest } from './use_resource.js';
+export function useSwitchOrganization() {
+    const config = useAuthkitConfig();
+    const base = config.endpoints.orgs.replace('/json', '');
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const activate = useCallback(async (orgId) => {
+        setLoading(true);
+        setError(null);
+        try {
+            await jsonRequest(`${base}/${encodeURIComponent(orgId)}/activate`, {
+                method: 'POST',
+                csrfToken: config.csrfToken,
+            });
+        }
+        catch (err) {
+            setError(err);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [base, config.csrfToken]);
+    const deactivate = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            await jsonRequest(`${base}/deactivate`, {
+                method: 'POST',
+                csrfToken: config.csrfToken,
+            });
+        }
+        catch (err) {
+            setError(err);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [base, config.csrfToken]);
+    return { loading, error, activate, deactivate };
+}

package/build/src/hooks/use_user.d.ts

@@ -0,0 +1,6 @@
+import type { AuthUser } from '../types.js';
+export interface UseUserResult {
+    user: AuthUser | null;
+    isAuthenticated: boolean;
+}
+export declare function useUser(): UseUserResult;

package/build/src/hooks/use_user.js

@@ -0,0 +1,5 @@
+import { useAuth } from '../use_auth.js';
+export function useUser() {
+    const { user, isAuthenticated } = useAuth();
+    return { user, isAuthenticated };
+}

package/build/src/provider.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+import type { AuthSharedProps } from './types.js';
+export declare const AuthContext: import("react").Context<{
+    user: import("./types.js").AuthUser | null;
+    globalRoles: string[];
+    appRoles?: string[];
+} | undefined>;
+export interface AuthProviderProps {
+    value: AuthSharedProps['authkit'];
+    children: ReactNode;
+}
+export declare function AuthProvider({ value, children }: AuthProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<{
+    user: import("./types.js").AuthUser | null;
+    globalRoles: string[];
+    appRoles?: string[];
+} | undefined>>;

package/build/src/provider.js

@@ -0,0 +1,5 @@
+import { createContext, createElement } from 'react';
+export const AuthContext = createContext(undefined);
+export function AuthProvider({ value, children }) {
+    return createElement(AuthContext.Provider, { value }, children);
+}

package/build/src/queries/account/index.d.ts

@@ -0,0 +1,86 @@
+import type { AccountMe, AccountSecurityOverview, UpdateProfileInput, UpdateProfileResult, ChangePasswordInput, RequestEmailChangeInput, OkResult, EmailChangeResult, AccountSessionsResult, RevokeSessionResult, RevokeOthersResult, RevokeAllResult, AccountAppsResult, RevokeAppResult, AccountMfaStatus, AccountPasskeysResult, RemovePasskeyResult, AccountTokensResult, CreatedPatResult, RevokeTokenResult, CreateTokenInput, AccountOrgsResult, AccountOrgDetail, AccountOrgInvitationsResult } from '../../client/types.js';
+export declare function useMeQueryOptions(): {
+    queryKey: readonly ["authkit", "account", "me"];
+    queryFn: () => Promise<AccountMe>;
+};
+export declare function useSecurityQueryOptions(): {
+    queryKey: readonly ["authkit", "account", "security"];
+    queryFn: () => Promise<AccountSecurityOverview>;
+};
+export declare function useUpdateProfileMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (data: UpdateProfileInput) => Promise<UpdateProfileResult>;
+};
+export declare function useChangePasswordMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (data: ChangePasswordInput) => Promise<OkResult>;
+};
+export declare function useEmailChangeMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (data: RequestEmailChangeInput) => Promise<EmailChangeResult>;
+};
+export declare function useCancelEmailChangeMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: () => Promise<OkResult>;
+};
+export declare function useAccountSessionsQueryOptions(): {
+    queryKey: readonly ["authkit", "account", "sessions"];
+    queryFn: () => Promise<AccountSessionsResult>;
+};
+export declare function useRevokeSessionMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (id: string) => Promise<RevokeSessionResult>;
+};
+export declare function useRevokeOtherSessionsMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: () => Promise<RevokeOthersResult>;
+};
+export declare function useAccountRevokeAllSessionsMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: () => Promise<RevokeAllResult>;
+};
+export declare function useAppsQueryOptions(): {
+    queryKey: readonly ["authkit", "account", "apps"];
+    queryFn: () => Promise<AccountAppsResult>;
+};
+export declare function useRevokeAppMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (clientId: string) => Promise<RevokeAppResult>;
+};
+export declare function useMfaQueryOptions(): {
+    queryKey: readonly ["authkit", "account", "mfa"];
+    queryFn: () => Promise<AccountMfaStatus>;
+};
+export declare function usePasskeysQueryOptions(): {
+    queryKey: readonly ["authkit", "account", "passkeys"];
+    queryFn: () => Promise<AccountPasskeysResult>;
+};
+export declare function useRemovePasskeyMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (id: string) => Promise<RemovePasskeyResult>;
+};
+export declare function useTokensQueryOptions(): {
+    queryKey: readonly ["authkit", "account", "tokens"];
+    queryFn: () => Promise<AccountTokensResult>;
+};
+export declare function useCreateTokenMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (data?: CreateTokenInput) => Promise<CreatedPatResult>;
+};
+export declare function useRevokeTokenMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (id: string) => Promise<RevokeTokenResult>;
+};
+export declare function useAccountOrgsQueryOptions(): {
+    queryKey: readonly ["authkit", "account", "orgs"];
+    queryFn: () => Promise<AccountOrgsResult>;
+};
+export declare function useAccountOrgQueryOptions(id: string): {
+    queryKey: readonly ["authkit", "account", "orgs", string];
+    queryFn: () => Promise<AccountOrgDetail>;
+    enabled: boolean;
+};
+export declare function useAccountOrgInvitationsQueryOptions(): {
+    queryKey: readonly ["authkit", "account", "orgs", "invitations"];
+    queryFn: () => Promise<AccountOrgInvitationsResult>;
+};

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

@@ -0,0 +1,150 @@
+import { useAuthkitClient } from '../../client/context.js';
+import { authkitKeys } from '../keys.js';
+export function useMeQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.account.me(),
+        queryFn: () => client.account.me(),
+    };
+}
+export function useSecurityQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.account.security(),
+        queryFn: () => client.account.security(),
+    };
+}
+export function useUpdateProfileMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'profile', 'update'],
+        mutationFn: (data) => client.account.updateProfile(data),
+    };
+}
+export function useChangePasswordMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'password', 'change'],
+        mutationFn: (data) => client.account.changePassword(data),
+    };
+}
+export function useEmailChangeMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'email-change'],
+        mutationFn: (data) => client.account.emailChange(data),
+    };
+}
+export function useCancelEmailChangeMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'email-change', 'cancel'],
+        mutationFn: () => client.account.cancelEmailChange(),
+    };
+}
+export function useAccountSessionsQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.account.sessions(),
+        queryFn: () => client.account.sessions.list(),
+    };
+}
+export function useRevokeSessionMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'sessions', 'revoke'],
+        mutationFn: (id) => client.account.sessions.revoke(id),
+    };
+}
+export function useRevokeOtherSessionsMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'sessions', 'revoke-others'],
+        mutationFn: () => client.account.sessions.revokeOthers(),
+    };
+}
+export function useAccountRevokeAllSessionsMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'sessions', 'revoke-all'],
+        mutationFn: () => client.account.sessions.revokeAll(),
+    };
+}
+export function useAppsQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.account.apps(),
+        queryFn: () => client.account.apps.list(),
+    };
+}
+export function useRevokeAppMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'apps', 'revoke'],
+        mutationFn: (clientId) => client.account.apps.revoke(clientId),
+    };
+}
+export function useMfaQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.account.mfa(),
+        queryFn: () => client.account.mfa(),
+    };
+}
+export function usePasskeysQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.account.passkeys(),
+        queryFn: () => client.account.passkeys.list(),
+    };
+}
+export function useRemovePasskeyMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'passkeys', 'remove'],
+        mutationFn: (id) => client.account.passkeys.remove(id),
+    };
+}
+export function useTokensQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.account.tokens(),
+        queryFn: () => client.account.tokens.list(),
+    };
+}
+export function useCreateTokenMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'tokens', 'create'],
+        mutationFn: (data) => client.account.tokens.create(data),
+    };
+}
+export function useRevokeTokenMutationOptions() {
+    const client = useAuthkitClient();
+    return {
+        mutationKey: ['authkit', 'account', 'tokens', 'revoke'],
+        mutationFn: (id) => client.account.tokens.remove(id),
+    };
+}
+export function useAccountOrgsQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.account.orgs(),
+        queryFn: () => client.account.orgs.list(),
+    };
+}
+export function useAccountOrgQueryOptions(id) {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.account.org(id),
+        queryFn: () => client.account.orgs.get(id),
+        enabled: !!id,
+    };
+}
+export function useAccountOrgInvitationsQueryOptions() {
+    const client = useAuthkitClient();
+    return {
+        queryKey: authkitKeys.account.orgInvitations(),
+        queryFn: () => client.account.orgs.invitations(),
+    };
+}

package/build/src/queries/admin/index.d.ts

@@ -0,0 +1,226 @@
+import type { AdminOverview, AdminUser, AdminUserListResult, CreateUserInput, UpdateUserInput, UserSessionsResult, RevokeSessionsResult, AdminClientListResult, AdminClient, CreatedClientResult, RegenerateSecretResult, CreateClientInput, UpdateClientInput, RoleListResult, RoleCatalogEntry, CreateRoleInput, UpdateRoleInput, AdminOrgListResult, AdminOrgDetail, AdminOrgInvitation, AuditListResult, AuditListParams, SettingListResult, SettingEntry, ImpersonationPanel, AdminOrgEntry, CreateOrgInput, UpdateOrgInput, KeysStatus, KeysRotateInput, KeysRotateResult } from '../../client/types.js';
+export declare function useOverviewQueryOptions(): {
+    queryKey: readonly ["authkit", "admin", "overview"];
+    queryFn: () => Promise<AdminOverview>;
+};
+export declare function useUsersQueryOptions(params?: {
+    search?: string;
+    page?: number;
+    limit?: number;
+}): {
+    queryKey: readonly ["authkit", "admin", "users", {
+        search?: string;
+        page?: number;
+        limit?: number;
+    }];
+    queryFn: () => Promise<AdminUserListResult>;
+};
+export declare function useUserQueryOptions(id: string): {
+    queryKey: readonly ["authkit", "admin", "users", string];
+    queryFn: () => Promise<AdminUser>;
+    enabled: boolean;
+};
+export declare function useUserSessionsQueryOptions(id: string): {
+    queryKey: readonly ["authkit", "admin", "users", string, "sessions"];
+    queryFn: () => Promise<UserSessionsResult>;
+    enabled: boolean;
+};
+export declare function useCreateUserMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (data: CreateUserInput) => Promise<AdminUser & {
+        invited?: boolean;
+    }>;
+};
+export declare function useUpdateUserMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: (data: UpdateUserInput) => Promise<AdminUser>;
+};
+export declare function useDisableUserMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<{
+        id: string;
+        disabled: true;
+    }>;
+};
+export declare function useEnableUserMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<{
+        id: string;
+        disabled: false;
+    }>;
+};
+export declare function useResetPasswordMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<{
+        id: string;
+        sent: boolean;
+    }>;
+};
+export declare function useDeleteUserMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
+};
+export declare function useRevokeUserSessionsMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<RevokeSessionsResult>;
+};
+export declare function useSessionsQueryOptions(accountId?: string): {
+    queryKey: readonly ["authkit", "admin", "sessions", string | null];
+    queryFn: () => Promise<UserSessionsResult>;
+};
+export declare function useRevokeAllSessionsMutationOptions(accountId?: string): {
+    mutationKey: (string | null)[];
+    mutationFn: () => Promise<RevokeSessionsResult>;
+};
+export declare function useClientsQueryOptions(): {
+    queryKey: readonly ["authkit", "admin", "clients"];
+    queryFn: () => Promise<AdminClientListResult>;
+};
+export declare function useClientQueryOptions(id: string): {
+    queryKey: readonly ["authkit", "admin", "clients", string];
+    queryFn: () => Promise<AdminClient>;
+    enabled: boolean;
+};
+export declare function useCreateClientMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (data?: CreateClientInput) => Promise<CreatedClientResult>;
+};
+export declare function useUpdateClientMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: (data?: UpdateClientInput) => Promise<AdminClient>;
+};
+export declare function useDeleteClientMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<{
+        clientId: string;
+        deleted: boolean;
+    }>;
+};
+export declare function useRegenerateClientSecretMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<RegenerateSecretResult>;
+};
+export declare function useRolesQueryOptions(): {
+    queryKey: readonly ["authkit", "admin", "roles"];
+    queryFn: () => Promise<RoleListResult>;
+};
+export declare function useCreateRoleMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (data: CreateRoleInput) => Promise<RoleCatalogEntry>;
+};
+export declare function useUpdateRoleMutationOptions(name: string): {
+    mutationKey: string[];
+    mutationFn: (data: UpdateRoleInput) => Promise<RoleCatalogEntry>;
+};
+export declare function useDeleteRoleMutationOptions(name: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<{
+        ok: boolean;
+        deleted: string;
+    }>;
+};
+export declare function useOrgsQueryOptions(): {
+    queryKey: readonly ["authkit", "admin", "orgs"];
+    queryFn: () => Promise<AdminOrgListResult>;
+};
+export declare function useOrgQueryOptions(id: string): {
+    queryKey: readonly ["authkit", "admin", "orgs", string];
+    queryFn: () => Promise<AdminOrgDetail>;
+    enabled: boolean;
+};
+export declare function useCreateOrgMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (data: CreateOrgInput) => Promise<AdminOrgEntry>;
+};
+export declare function useUpdateOrgMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: (data: UpdateOrgInput) => Promise<AdminOrgEntry>;
+};
+export declare function useDeleteOrgMutationOptions(id: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
+};
+export declare function useAddOrgMemberMutationOptions(orgId: string): {
+    mutationKey: string[];
+    mutationFn: (data: {
+        accountId: string;
+        role: string;
+    }) => Promise<{
+        ok: boolean;
+    }>;
+};
+export declare function useRemoveOrgMemberMutationOptions(orgId: string, accountId: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<{
+        ok: boolean;
+    }>;
+};
+export declare function useUpdateOrgMemberRoleMutationOptions(orgId: string, accountId: string): {
+    mutationKey: string[];
+    mutationFn: (role: string) => Promise<{
+        ok: boolean;
+    }>;
+};
+export declare function useCreateOrgInvitationMutationOptions(orgId: string): {
+    mutationKey: string[];
+    mutationFn: (data: {
+        email: string;
+        role: string;
+    }) => Promise<{
+        ok: boolean;
+        invitation: AdminOrgInvitation;
+    }>;
+};
+export declare function useRevokeOrgInvitationMutationOptions(orgId: string, invitationId: string): {
+    mutationKey: string[];
+    mutationFn: () => Promise<{
+        ok: boolean;
+    }>;
+};
+export declare function useAuditQueryOptions(params?: AuditListParams): {
+    queryKey: readonly ["authkit", "admin", "audit", {
+        type?: string;
+        page?: number;
+        limit?: number;
+        subject?: string;
+    }];
+    queryFn: () => Promise<AuditListResult>;
+};
+export declare function useSettingsQueryOptions(orgId?: string | null): {
+    queryKey: readonly ["authkit", "admin", "settings", string] | readonly ["authkit", "admin", "settings"];
+    queryFn: () => Promise<SettingListResult>;
+};
+export declare function useSetSettingMutationOptions(orgId?: string | null): {
+    mutationKey: (string | null)[];
+    mutationFn: ({ key, value }: {
+        key: string;
+        value: unknown;
+    }) => Promise<SettingEntry>;
+};
+export declare function useRemoveSettingMutationOptions(orgId?: string | null): {
+    mutationKey: (string | null)[];
+    mutationFn: (key: string) => Promise<{
+        key: string;
+        organizationId: string | null;
+        deleted: boolean;
+    }>;
+};
+export declare function useImpersonationQueryOptions(userId: string): {
+    queryKey: readonly ["authkit", "admin", "impersonation", string];
+    queryFn: () => Promise<ImpersonationPanel>;
+    enabled: boolean;
+};
+export declare function useKeysQueryOptions(): {
+    queryKey: readonly ["authkit", "admin", "keys"];
+    queryFn: () => Promise<KeysStatus>;
+};
+export declare function useRotateKeysMutationOptions(): {
+    mutationKey: string[];
+    mutationFn: (input?: KeysRotateInput) => Promise<KeysRotateResult>;
+};