check: async () => {
  try {
    const token = await getIdTokenClaims();
    if (token) {
      axios.defaults.headers.common = {
        Authorization: `Bearer ${token.__raw}`,
      };
      return {
        authenticated: true,
      };
    } else {
      // Handle case when token is not found
    }
  } catch (error: any) {
    // Handle errors
  }
},

check: async () => {
  try {
    const token = await getIdTokenClaims();
    if (token) {
      axios.defaults.headers.common = {
        Authorization: `Bearer ${token.__raw}`,
      };
      return {
        authenticated: true,
      };
    } else {
      // Handle case when token is not found
    }
  } catch (error: any) {
    // Handle errors
  }
},

import jwt from "jsonwebtoken";

export default function handler(req, res) {
  const { authorization } = req.headers;
  if (!authorization) {
    return res.status(401).json({ message: "Authorization header missing" });
  }

  const token = authorization.split(" ")[1];
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    // Proceed with the request
  } catch (error) {
    return res.status(401).json({ message: "Invalid token" });
  }
}

import jwt from "jsonwebtoken";

export default function handler(req, res) {
  const { authorization } = req.headers;
  if (!authorization) {
    return res.status(401).json({ message: "Authorization header missing" });
  }

  const token = authorization.split(" ")[1];
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    // Proceed with the request
  } catch (error) {
    return res.status(401).json({ message: "Invalid token" });
  }
}

import { Refine, Authenticated } from "@refinedev/core";
import { BrowserRouter, Routes, Route, Outlet } from "react-router-dom";
import { AuthPage } from "@refinedev/antd";

const App = () => {
  return (
    <BrowserRouter>
      <Refine
        authProvider={authProvider}
        // ... other props
      >
        <Routes>
          <Route
            element={
              <Authenticated fallback={<Outlet />}>
                <Outlet />
              </Authenticated>
            }
          >
            {/* Your authenticated routes */}
          </Route>
          <Route
            element={
              <Authenticated fallback={<Outlet />}>
                <NavigateToResource />
              </Authenticated>
            }
          >
            <Route path="/login" element={<AuthPage type="login" />} />
          </Route>
        </Routes>
      </Refine>
    </BrowserRouter>
  );
};

import { Refine, Authenticated } from "@refinedev/core";
import { BrowserRouter, Routes, Route, Outlet } from "react-router-dom";
import { AuthPage } from "@refinedev/antd";

const App = () => {
  return (
    <BrowserRouter>
      <Refine
        authProvider={authProvider}
        // ... other props
      >
        <Routes>
          <Route
            element={
              <Authenticated fallback={<Outlet />}>
                <Outlet />
              </Authenticated>
            }
          >
            {/* Your authenticated routes */}
          </Route>
          <Route
            element={
              <Authenticated fallback={<Outlet />}>
                <NavigateToResource />
              </Authenticated>
            }
          >
            <Route path="/login" element={<AuthPage type="login" />} />
          </Route>
        </Routes>
      </Refine>
    </BrowserRouter>
  );
};

import { AuthProvider } from "@refinedev/core";

export const authProvider: AuthProvider = {
  // ... other methods

  check: async () => {
    // Check if there's a valid token or session
    const token = localStorage.getItem("auth_token");
    
    if (token) {
      // Verify if the token is still valid
      // This could involve checking the token's expiration or making an API call
      const isTokenValid = await verifyToken(token);
      
      if (isTokenValid) {
        return {
          authenticated: true,
        };
      }
    }

    // If there's no token or it's invalid, redirect to login
    return {
      authenticated: false,
      redirectTo: "/login",
      error: {
        message: "Please login to continue",
        name: "Authentication Error",
      },
    };
  },

  // ... other methods
};

import { AuthProvider } from "@refinedev/core";

export const authProvider: AuthProvider = {
  // ... other methods

  check: async () => {
    // Check if there's a valid token or session
    const token = localStorage.getItem("auth_token");
    
    if (token) {
      // Verify if the token is still valid
      // This could involve checking the token's expiration or making an API call
      const isTokenValid = await verifyToken(token);
      
      if (isTokenValid) {
        return {
          authenticated: true,
        };
      }
    }

    // If there's no token or it's invalid, redirect to login
    return {
      authenticated: false,
      redirectTo: "/login",
      error: {
        message: "Please login to continue",
        name: "Authentication Error",
      },
    };
  },

  // ... other methods
};

const { formProps, saveButtonProps, onFinish } = useForm<TData, TError, TVariables>();

const { formProps, saveButtonProps, onFinish } = useForm<TData, TError, TVariables>();

const { formProps, saveButtonProps, onFinish } = useModalForm<TData, TError, TVariables>();

const { formProps, saveButtonProps, onFinish } = useModalForm<TData, TError, TVariables>();

interface User {
  id: number;
  name: string;
  email: string;
}

interface UserForm {
  name: string;
  email: string;
}

const { formProps, saveButtonProps, onFinish } = useForm<User, HttpError, UserForm>();

interface User {
  id: number;
  name: string;
  email: string;
}

interface UserForm {
  name: string;
  email: string;
}

const { formProps, saveButtonProps, onFinish } = useForm<User, HttpError, UserForm>();

(values: UserForm) => Promise<CreateResponse<User> | UpdateResponse<User> | void>

(values: UserForm) => Promise<CreateResponse<User> | UpdateResponse<User> | void>

accessControlProvider: {
  can: async ({ resource, action, params }) => {
    const enforcer = await newEnforcer(model, adapter);
    
    // Split the resource into its hierarchical parts
    const resourceParts = resource.split('/');
    
    // Check access for each level of the resource hierarchy
    for (let i = 1; i <= resourceParts.length; i++) {
      const resourceToCheck = resourceParts.slice(0, i).join('/');
      const can = await enforcer.enforce(role, resourceToCheck, action);
      
      if (!can) {
        return { can: false };
      }
    }

    return { can: true };
  },
}

accessControlProvider: {
  can: async ({ resource, action, params }) => {
    const enforcer = await newEnforcer(model, adapter);
    
    // Split the resource into its hierarchical parts
    const resourceParts = resource.split('/');
    
    // Check access for each level of the resource hierarchy
    for (let i = 1; i <= resourceParts.length; i++) {
      const resourceToCheck = resourceParts.slice(0, i).join('/');
      const can = await enforcer.enforce(role, resourceToCheck, action);
      
      if (!can) {
        return { can: false };
      }
    }

    return { can: true };
  },
}

p, admin, posts, (list)|(create)
p, admin, posts/*, (edit)|(show)|(delete)
p, admin, posts/comments, (list)|(create)
p, admin, posts/comments/*, (edit)|(show)|(delete)

p, admin, posts, (list)|(create)
p, admin, posts/*, (edit)|(show)|(delete)
p, admin, posts/comments, (list)|(create)
p, admin, posts/comments/*, (edit)|(show)|(delete)