@adonis-agora/authkit-react 0.12.0

package/build/src/client/client.js

@@ -0,0 +1,218 @@
+export class AuthkitClientError extends Error {
+    status;
+    code;
+    body;
+    constructor(status, message, code, body) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.body = body;
+        this.name = 'AuthkitClientError';
+        Object.defineProperty(this, 'isUnauthorized', { value: status === 401, enumerable: true });
+    }
+    isUnauthorized;
+}
+const MUTATING = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
+function resolveWindow() {
+    try {
+        if (typeof window === 'undefined')
+            return null;
+        return window.__AUTHKIT__ ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function toQueryString(params) {
+    const parts = [];
+    for (const [k, v] of Object.entries(params)) {
+        if (v === undefined || v === null)
+            continue;
+        parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+    }
+    return parts.length ? `?${parts.join('&')}` : '';
+}
+class AuthkitClient {
+    _baseUrl;
+    _accountBaseUrl;
+    _csrfToken;
+    _fetch;
+    constructor(opts = {}) {
+        const win = resolveWindow();
+        this._baseUrl = opts.baseUrl ?? win?.endpoints.api;
+        this._accountBaseUrl = opts.accountBaseUrl ?? '/account/api';
+        this._csrfToken = opts.csrfToken ?? win?.csrfToken;
+        this._fetch = opts.fetch ?? globalThis.fetch.bind(globalThis);
+    }
+    async request(method, url, body, extraHeaders) {
+        const isMutating = MUTATING.has(method.toUpperCase());
+        const headers = {
+            Accept: 'application/json',
+            ...extraHeaders,
+        };
+        if (isMutating && this._csrfToken) {
+            headers['X-CSRF-TOKEN'] = this._csrfToken;
+        }
+        if (body !== undefined) {
+            headers['Content-Type'] = 'application/json';
+        }
+        const res = await this._fetch(url, {
+            method: method.toUpperCase(),
+            credentials: 'include',
+            headers,
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        if (!res.ok) {
+            let message = `Request failed (${res.status})`;
+            let code;
+            let parsed;
+            try {
+                parsed = await res.json();
+                const envelope = parsed;
+                if (envelope?.error?.message)
+                    message = envelope.error.message;
+                if (envelope?.error?.code)
+                    code = envelope.error.code;
+                else if (typeof envelope?.message === 'string')
+                    message = envelope.message;
+            }
+            catch {
+            }
+            throw new AuthkitClientError(res.status, message, code, parsed);
+        }
+        const text = await res.text();
+        return (text ? JSON.parse(text) : null);
+    }
+    get(path, params) {
+        const qs = params ? toQueryString(params) : '';
+        return this.request('GET', `${path}${qs}`);
+    }
+    post(path, body) {
+        return this.request('POST', path, body);
+    }
+    patch(path, body) {
+        return this.request('PATCH', path, body);
+    }
+    put(path, body) {
+        return this.request('PUT', path, body);
+    }
+    delete(path) {
+        return this.request('DELETE', path);
+    }
+    b(path) {
+        if (!this._baseUrl) {
+            throw new Error('[AuthkitClient] admin base URL ausente: passe `baseUrl` em createAuthkitClient({ baseUrl }) ' +
+                'ou use o client onde window.__AUTHKIT__ está injetado (console admin). ' +
+                'Telas que só usam client.account.* não precisam de baseUrl.');
+        }
+        return `${this._baseUrl}${path}`;
+    }
+    a(path) {
+        return `${this._accountBaseUrl}${path}`;
+    }
+    admin = {
+        overview: () => this.get(this.b('/overview')),
+        users: {
+            list: (params) => this.get(this.b('/users'), params),
+            get: (id) => this.get(this.b(`/users/${encodeURIComponent(id)}`)),
+            create: (data) => this.post(this.b('/users'), data),
+            update: (id, data) => this.patch(this.b(`/users/${encodeURIComponent(id)}`), data),
+            disable: (id) => this.post(this.b(`/users/${encodeURIComponent(id)}/disable`)),
+            enable: (id) => this.post(this.b(`/users/${encodeURIComponent(id)}/enable`)),
+            resetPassword: (id) => this.post(this.b(`/users/${encodeURIComponent(id)}/reset-password`)),
+            remove: (id) => this.delete(this.b(`/users/${encodeURIComponent(id)}`)),
+            getSessions: (id) => this.get(this.b(`/users/${encodeURIComponent(id)}/sessions`)),
+            revokeSessions: (id) => this.post(this.b(`/users/${encodeURIComponent(id)}/revoke-sessions`)),
+        },
+        sessions: {
+            list: (accountId) => this.get(this.b('/sessions'), accountId ? { accountId } : undefined),
+            revokeAll: (accountId) => this.post(this.b('/sessions/revoke-all'), accountId ? { accountId } : undefined),
+        },
+        clients: {
+            list: () => this.get(this.b('/clients')),
+            get: (id) => this.get(this.b(`/clients/${encodeURIComponent(id)}`)),
+            create: (data) => this.post(this.b('/clients'), data),
+            update: (id, data) => this.patch(this.b(`/clients/${encodeURIComponent(id)}`), data),
+            remove: (id) => this.delete(this.b(`/clients/${encodeURIComponent(id)}`)),
+            regenerateSecret: (id) => this.post(this.b(`/clients/${encodeURIComponent(id)}/regenerate-secret`)),
+        },
+        roles: {
+            list: () => this.get(this.b('/roles')),
+            create: (data) => this.post(this.b('/roles'), data),
+            update: (name, data) => this.patch(this.b(`/roles/${encodeURIComponent(name)}`), data),
+            remove: (name) => this.delete(this.b(`/roles/${encodeURIComponent(name)}`)),
+        },
+        orgs: {
+            list: () => this.get(this.b('/orgs')),
+            create: (data) => this.post(this.b('/orgs'), data),
+            get: (id) => this.get(this.b(`/orgs/${encodeURIComponent(id)}`)),
+            update: (id, data) => this.patch(this.b(`/orgs/${encodeURIComponent(id)}`), data),
+            remove: (id) => this.delete(this.b(`/orgs/${encodeURIComponent(id)}`)),
+            addMember: (orgId, data) => this.post(this.b(`/orgs/${encodeURIComponent(orgId)}/members`), data),
+            removeMember: (orgId, accountId) => this.delete(this.b(`/orgs/${encodeURIComponent(orgId)}/members/${encodeURIComponent(accountId)}`)),
+            updateMemberRole: (orgId, accountId, role) => this.patch(this.b(`/orgs/${encodeURIComponent(orgId)}/members/${encodeURIComponent(accountId)}`), { role }),
+            createInvitation: (orgId, data) => this.post(this.b(`/orgs/${encodeURIComponent(orgId)}/invitations`), data),
+            revokeInvitation: (orgId, invitationId) => this.delete(this.b(`/orgs/${encodeURIComponent(orgId)}/invitations/${encodeURIComponent(invitationId)}`)),
+        },
+        audit: {
+            list: (params) => this.get(this.b('/audit'), params),
+        },
+        settings: {
+            list: (orgId) => {
+                const qs = orgId ? `?organizationId=${encodeURIComponent(orgId)}` : '';
+                return this.get(this.b(`/settings${qs}`));
+            },
+            set: (key, value, orgId) => {
+                const qs = orgId ? `?organizationId=${encodeURIComponent(orgId)}` : '';
+                return this.put(this.b(`/settings/${encodeURIComponent(key)}${qs}`), { value });
+            },
+            remove: (key, orgId) => {
+                const qs = orgId ? `?organizationId=${encodeURIComponent(orgId)}` : '';
+                return this.delete(this.b(`/settings/${encodeURIComponent(key)}${qs}`));
+            },
+        },
+        impersonation: {
+            get: (userId) => this.get(this.b(`/impersonation/${encodeURIComponent(userId)}`)),
+        },
+        keys: {
+            status: () => this.get(this.b('/keys')),
+            rotate: (input) => this.post(this.b('/keys/rotate'), input ?? {}),
+        },
+    };
+    account = {
+        me: () => this.get(this.a('/me')),
+        security: () => this.get(this.a('/security')),
+        updateProfile: (data) => this.patch(this.a('/profile'), data),
+        changePassword: (data) => this.post(this.a('/password'), data),
+        emailChange: (data) => this.post(this.a('/email-change'), data),
+        cancelEmailChange: () => this.post(this.a('/email-change/cancel')),
+        sessions: {
+            list: () => this.get(this.a('/sessions')),
+            revoke: (id) => this.delete(this.a(`/sessions/${encodeURIComponent(id)}`)),
+            revokeOthers: () => this.post(this.a('/sessions/revoke-others')),
+            revokeAll: () => this.post(this.a('/sessions/revoke-all')),
+        },
+        apps: {
+            list: () => this.get(this.a('/apps')),
+            revoke: (clientId) => this.delete(this.a(`/apps/${encodeURIComponent(clientId)}`)),
+        },
+        mfa: () => this.get(this.a('/mfa')),
+        passkeys: {
+            list: () => this.get(this.a('/passkeys')),
+            remove: (id) => this.delete(this.a(`/passkeys/${encodeURIComponent(id)}`)),
+        },
+        tokens: {
+            list: () => this.get(this.a('/tokens')),
+            create: (data) => this.post(this.a('/tokens'), data),
+            remove: (id) => this.delete(this.a(`/tokens/${encodeURIComponent(id)}`)),
+        },
+        orgs: {
+            list: () => this.get(this.a('/orgs')),
+            invitations: () => this.get(this.a('/orgs/invitations')),
+            get: (id) => this.get(this.a(`/orgs/${encodeURIComponent(id)}`)),
+        },
+    };
+}
+export function createAuthkitClient(opts) {
+    return new AuthkitClient(opts);
+}

package/build/src/client/context.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+import { QueryClient } from '@tanstack/react-query';
+import { type AuthkitClient, type AuthkitClientOptions } from './client.js';
+export declare function useAuthkitClient(): AuthkitClient;
+export interface AuthkitClientProviderProps {
+    client?: AuthkitClient;
+    opts?: AuthkitClientOptions;
+    children: ReactNode;
+}
+export declare function AuthkitClientProvider({ client, opts, children }: AuthkitClientProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<AuthkitClient | null>>;
+export declare function createAuthkitQueryClient(): QueryClient;

package/build/src/client/context.js

@@ -0,0 +1,28 @@
+import { createContext, createElement, useContext } from 'react';
+import { QueryClient } from '@tanstack/react-query';
+import { createAuthkitClient } from './client.js';
+const AuthkitClientContext = createContext(null);
+export function useAuthkitClient() {
+    const client = useContext(AuthkitClientContext);
+    if (!client) {
+        throw new Error('[AuthkitClient] useAuthkitClient() chamado fora de <AuthkitClientProvider>. ' +
+            'Envolva sua árvore com <AuthkitClientProvider>.');
+    }
+    return client;
+}
+export function AuthkitClientProvider({ client, opts, children }) {
+    const resolved = client ?? createAuthkitClient(opts);
+    return createElement(AuthkitClientContext.Provider, { value: resolved }, children);
+}
+export function createAuthkitQueryClient() {
+    return new QueryClient({
+        defaultOptions: {
+            queries: {
+                staleTime: 30_000,
+                gcTime: 5 * 60_000,
+                retry: 1,
+                refetchOnWindowFocus: false,
+            },
+        },
+    });
+}

package/build/src/client/types.d.ts

@@ -0,0 +1,425 @@
+export interface ApiErrorBody {
+    error: {
+        code: string;
+        message: string;
+    };
+}
+export interface AdminUser {
+    id: string;
+    email: string;
+    name: string | null;
+    avatarUrl: string | null;
+    globalRoles: string[];
+    disabled: boolean;
+    invited?: boolean;
+}
+export interface AdminUserListResult {
+    data: AdminUser[];
+    total: number;
+    page: number;
+    limit: number;
+}
+export interface CreateUserInput {
+    email: string;
+    name?: string | null;
+    password?: string | null;
+    invite?: boolean;
+}
+export interface UpdateUserInput {
+    globalRoles?: string[];
+    name?: string | null;
+    avatarUrl?: string | null;
+}
+export interface AdminSessionEntry {
+    id: string;
+    accountId: string;
+    email: string | null;
+    loginTs: string | null;
+    amr: string[];
+    userAgent: string | null;
+    browser: string | null;
+    os: string | null;
+    ip: string | null;
+    location: string | null;
+}
+export interface AdminGrantEntry {
+    id: string;
+    accountId: string;
+    clientId: string | null;
+    accessTokens: number;
+    refreshTokens: number;
+}
+export interface UserSessionsResult {
+    supported: boolean;
+    truncated?: boolean;
+    sessions: AdminSessionEntry[];
+    grants: AdminGrantEntry[];
+}
+export interface RevokeSessionsResult {
+    revoked?: number;
+    [key: string]: unknown;
+}
+export interface AdminSessionListResult {
+    canList: boolean;
+    sessions: AdminSessionEntry[];
+    grants: AdminGrantEntry[];
+}
+export interface AdminClient {
+    clientId: string;
+    confidential: boolean;
+    grants: string[];
+    redirectUris: string[];
+    postLogoutRedirectUris: string[];
+    tokenEndpointAuthMethod: string;
+    backchannelLogoutUri: string | null;
+    backchannelLogoutSessionRequired: boolean;
+}
+export interface AdminClientListResult {
+    data: AdminClient[];
+    canList: boolean;
+}
+export interface CreatedClientResult {
+    clientId: string;
+    clientSecret: string | null;
+}
+export interface RegenerateSecretResult {
+    clientId: string;
+    clientSecret: string;
+}
+export interface CreateClientInput {
+    clientId?: string;
+    redirectUris?: string[];
+    postLogoutRedirectUris?: string[];
+    grantTypes?: string[];
+    tokenEndpointAuthMethod?: string;
+    backchannelLogoutUri?: string;
+    backchannelLogoutSessionRequired?: boolean;
+}
+export type UpdateClientInput = CreateClientInput;
+export interface RoleCatalogEntry {
+    name: string;
+    description?: string;
+}
+export interface RoleListResult {
+    data: RoleCatalogEntry[];
+}
+export interface CreateRoleInput {
+    name: string;
+    description?: string;
+}
+export interface UpdateRoleInput {
+    description?: string;
+}
+export interface AdminOrgEntry {
+    id: string;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    metadata: unknown | null;
+    createdAt: string;
+    memberCount?: number;
+}
+export interface AdminOrgMember {
+    accountId: string;
+    email: string | null;
+    role: string;
+    joinedAt: string;
+}
+export interface AdminOrgInvitation {
+    id: string;
+    organizationId: string;
+    email: string;
+    role: string;
+    invitedBy: string;
+    expiresAt: string;
+    acceptedAt: string | null;
+    createdAt: string;
+}
+export interface AdminOrgDetail extends AdminOrgEntry {
+    members: AdminOrgMember[];
+    pendingInvitations: AdminOrgInvitation[];
+}
+export interface AdminOrgListResult {
+    data: AdminOrgEntry[];
+}
+export interface CreateOrgInput {
+    name: string;
+    slug: string;
+    ownerAccountId: string;
+    logoUrl?: string | null;
+}
+export interface UpdateOrgInput {
+    name?: string;
+    logoUrl?: string | null;
+}
+export interface AuditEventEntry {
+    id: string;
+    type: string;
+    accountId: string | null;
+    email: string | null;
+    clientId: string | null;
+    actorId: string | null;
+    ip: string | null;
+    metadata: unknown | null;
+    createdAt: string;
+}
+export interface AuditListResult {
+    data: AuditEventEntry[];
+    total: number;
+    page: number;
+    limit: number;
+}
+export interface AuditListParams {
+    type?: string;
+    page?: number;
+    limit?: number;
+    subject?: string;
+}
+export interface SettingEntry {
+    key: string;
+    organizationId: string | null;
+    value: unknown;
+    updatedAt: string | null;
+    updatedBy: string | null;
+}
+export interface SettingListResult {
+    data: SettingEntry[];
+}
+export interface ImpersonationPanel {
+    targetUserId: string;
+    targetEmail: string;
+    clientId: string;
+    [key: string]: unknown;
+}
+export interface DailyPoint {
+    date: string;
+    count: number;
+}
+export interface AdminOverview {
+    usersTotal: number;
+    activeSessions: number | null;
+    mau: number;
+    signInsTotal: number;
+    signUpsTotal: number;
+    signInsPerDay: DailyPoint[];
+    signUpsPerDay: DailyPoint[];
+    windowDays: number;
+    auditSupported: boolean;
+    clientsCount: number;
+    auditTotal: number;
+    recentEvents: AuditEventEntry[];
+}
+export interface AccountCapabilities {
+    securitySupported: boolean;
+    profileSupported: boolean;
+    passkeysSupported: boolean;
+    orgsSupported: boolean;
+    tokensSupported: boolean;
+    avatarUploadSupported: boolean;
+    sessionsSupported: boolean;
+}
+export interface AccountMe {
+    id: string;
+    email: string;
+    emailVerified: boolean | null;
+    name: string | null;
+    avatarUrl: string | null;
+    globalRoles: string[];
+    hasPassword: boolean;
+    mfaEnabled: boolean;
+    passkeyCount: number;
+    sudoActive: boolean;
+    capabilities: AccountCapabilities;
+}
+export interface AccountSessionEntry {
+    id: string;
+    loginTs: string | null;
+    browser: string | null;
+    os: string | null;
+    ip: string | null;
+    location: string | null;
+    amr: string[];
+}
+export interface AccountSecurityOverview {
+    email: string;
+    pendingEmail: string | null;
+    securitySupported: boolean;
+    profileSupported: boolean;
+    sessionsSupported: boolean;
+    activeSessions: AccountSessionEntry[];
+    mfa: {
+        enabled: boolean;
+        totpEnrolled: boolean;
+        passkeyCount: number;
+        passkeysSupported: boolean;
+    };
+}
+export interface AccountSessionsResult {
+    supported: boolean;
+    sessions: AccountSessionEntry[];
+}
+export interface RevokeSessionResult {
+    ok: boolean;
+    revoked: string;
+}
+export interface RevokeOthersResult {
+    ok: boolean;
+    [key: string]: unknown;
+}
+export interface RevokeAllResult {
+    ok: boolean;
+    signedOut: boolean;
+    [key: string]: unknown;
+}
+export interface AccountAppEntry {
+    clientId: string;
+    accessTokens: number;
+    refreshTokens: number;
+}
+export interface AccountAppsResult {
+    supported: boolean;
+    apps: AccountAppEntry[];
+}
+export interface RevokeAppResult {
+    ok: boolean;
+    [key: string]: unknown;
+}
+export interface PasskeySummaryEntry {
+    id: string;
+    label: string | null;
+    createdAt: string | null;
+}
+export interface AccountMfaStatus {
+    enabled: boolean;
+    totp: {
+        enrolled: boolean;
+    };
+    passkeys: {
+        supported: boolean;
+        count: number;
+        items: PasskeySummaryEntry[];
+    };
+    recovery: {
+        available: boolean;
+    };
+}
+export interface AccountPasskeysResult {
+    supported: boolean;
+    passkeys: PasskeySummaryEntry[];
+}
+export interface RemovePasskeyResult {
+    ok: boolean;
+    removed: string;
+}
+export interface PatEntry {
+    id: string;
+    name: string;
+    scopes: string[];
+    audience: string | null;
+    lastUsedAt: string | null;
+    createdAt: string;
+}
+export interface CreatedPatResult extends PatEntry {
+    secret: string;
+}
+export interface AccountTokensResult {
+    supported: boolean;
+    tokens: PatEntry[];
+}
+export interface CreateTokenInput {
+    name?: string;
+}
+export interface RevokeTokenResult {
+    ok: boolean;
+    revoked: string;
+}
+export interface UpdateProfileInput {
+    name?: string | null;
+    avatarUrl?: string | null;
+}
+export interface UpdateProfileResult {
+    id: string;
+    name: string | null;
+    avatarUrl: string | null;
+}
+export interface ChangePasswordInput {
+    currentPassword: string;
+    newPassword: string;
+}
+export interface RequestEmailChangeInput {
+    newEmail: string;
+    currentPassword?: string;
+}
+export interface OkResult {
+    ok: boolean;
+}
+export interface EmailChangeResult {
+    ok: boolean;
+    email: string;
+}
+export interface AccountOrgEntry {
+    id: string;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    role: string;
+    isActive: boolean;
+}
+export interface AccountOrgsResult {
+    supported: boolean;
+    activeOrgId: string | null;
+    orgs: AccountOrgEntry[];
+}
+export interface AccountOrgDetail {
+    id: string;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    role: string;
+    canManage: boolean;
+    members: Array<{
+        accountId: string;
+        email: string | null;
+        role: string;
+        joinedAt: string;
+    }>;
+}
+export interface AccountOrgInvitationsResult {
+    supported: boolean;
+    invitations: Array<{
+        id: string;
+        organizationId: string;
+        orgName: string;
+        orgSlug: string;
+        email: string;
+        role: string;
+        expiresAt: string;
+        createdAt: string;
+    }>;
+}
+export interface ManagedKeyInfo {
+    kid: string;
+    alg: string;
+    ageDays: number;
+    active: boolean;
+}
+export interface KeysStatus {
+    ageDays: number;
+    policy: {
+        enabled: boolean;
+        maxAgeDays: number;
+        keep: number;
+    };
+    nextRotationInDays: number | null;
+    keys: ManagedKeyInfo[];
+}
+export interface KeysRotateInput {
+    retire?: boolean;
+    keep?: number;
+}
+export interface KeysRotateResult {
+    rotated: true;
+    newKid: string;
+    retiredKids: string[];
+    keptKids: string[];
+}

package/build/src/client/types.js

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

package/build/src/components/authenticated.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+export interface AuthenticatedProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+export declare function Authenticated({ children, fallback }: AuthenticatedProps): import("react").FunctionComponentElement<import("react").FragmentProps>;
+export interface GuestProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+export declare function Guest({ children, fallback }: GuestProps): import("react").FunctionComponentElement<import("react").FragmentProps>;

package/build/src/components/authenticated.js

@@ -0,0 +1,10 @@
+import { createElement, Fragment } from 'react';
+import { useAuth } from '../use_auth.js';
+export function Authenticated({ children, fallback = null }) {
+    const { isAuthenticated } = useAuth();
+    return createElement(Fragment, null, isAuthenticated ? children : fallback);
+}
+export function Guest({ children, fallback = null }) {
+    const { isAuthenticated } = useAuth();
+    return createElement(Fragment, null, isAuthenticated ? fallback : children);
+}