541 lines
14 KiB
JavaScript
541 lines
14 KiB
JavaScript
import {
|
|
useTypedDispatch,
|
|
useTypedSelector
|
|
} from "./chunk-QEGMJR7H.js";
|
|
import {
|
|
adminApi,
|
|
deleteCookie,
|
|
getCookieValue,
|
|
require_lib,
|
|
setCookie
|
|
} from "./chunk-LCL5TIBZ.js";
|
|
import {
|
|
createSlice
|
|
} from "./chunk-WOQNBAGN.js";
|
|
import {
|
|
createContext
|
|
} from "./chunk-76QM3EFM.js";
|
|
import {
|
|
useLocation,
|
|
useNavigate
|
|
} from "./chunk-TUXTO2Z5.js";
|
|
import {
|
|
require_jsx_runtime
|
|
} from "./chunk-NIAJZ5MX.js";
|
|
import {
|
|
require_react
|
|
} from "./chunk-MADUDGYZ.js";
|
|
import {
|
|
__toESM
|
|
} from "./chunk-PLDDJCW6.js";
|
|
|
|
// node_modules/@strapi/admin/dist/admin/admin/src/features/StrapiApp.mjs
|
|
var [StrapiAppProvider, useStrapiApp] = createContext("StrapiApp");
|
|
|
|
// node_modules/@strapi/admin/dist/admin/admin/src/hooks/useQueryParams.mjs
|
|
var import_react = __toESM(require_react(), 1);
|
|
var import_qs = __toESM(require_lib(), 1);
|
|
var useQueryParams = (initialParams) => {
|
|
const { search } = useLocation();
|
|
const navigate = useNavigate();
|
|
const query = (0, import_react.useMemo)(() => {
|
|
const searchQuery = search.startsWith("?") ? search.slice(1) : search;
|
|
if (!search && initialParams) {
|
|
return initialParams;
|
|
}
|
|
return {
|
|
...initialParams,
|
|
...(0, import_qs.parse)(searchQuery)
|
|
};
|
|
}, [
|
|
search,
|
|
initialParams
|
|
]);
|
|
const setQuery = (0, import_react.useCallback)((nextParams, method = "push", replace = false) => {
|
|
let nextQuery = {
|
|
...query
|
|
};
|
|
if (method === "remove") {
|
|
Object.keys(nextParams).forEach((key) => {
|
|
if (Object.prototype.hasOwnProperty.call(nextQuery, key)) {
|
|
delete nextQuery[key];
|
|
}
|
|
});
|
|
} else {
|
|
nextQuery = {
|
|
...query,
|
|
...nextParams
|
|
};
|
|
}
|
|
navigate({
|
|
search: (0, import_qs.stringify)(nextQuery, {
|
|
encode: false
|
|
})
|
|
}, {
|
|
replace
|
|
});
|
|
}, [
|
|
navigate,
|
|
query
|
|
]);
|
|
return [
|
|
{
|
|
query,
|
|
rawQuery: search
|
|
},
|
|
setQuery
|
|
];
|
|
};
|
|
|
|
// node_modules/@strapi/admin/dist/admin/admin/src/reducer.mjs
|
|
var STORAGE_KEYS = {
|
|
TOKEN: "jwtToken",
|
|
STATUS: "isLoggedIn"
|
|
};
|
|
var THEME_LOCAL_STORAGE_KEY = "STRAPI_THEME";
|
|
var LANGUAGE_LOCAL_STORAGE_KEY = "strapi-admin-language";
|
|
var getStoredToken = () => {
|
|
const fromLocalStorage = localStorage.getItem(STORAGE_KEYS.TOKEN);
|
|
if (fromLocalStorage) {
|
|
return JSON.parse(fromLocalStorage);
|
|
}
|
|
const fromCookie = getCookieValue(STORAGE_KEYS.TOKEN);
|
|
return fromCookie ?? null;
|
|
};
|
|
var adminSlice = createSlice({
|
|
name: "admin",
|
|
initialState: () => {
|
|
return {
|
|
language: {
|
|
locale: "en",
|
|
localeNames: {
|
|
en: "English"
|
|
}
|
|
},
|
|
permissions: {},
|
|
theme: {
|
|
availableThemes: [],
|
|
currentTheme: localStorage.getItem(THEME_LOCAL_STORAGE_KEY) || "system"
|
|
},
|
|
token: null
|
|
};
|
|
},
|
|
reducers: {
|
|
setAppTheme(state, action) {
|
|
state.theme.currentTheme = action.payload;
|
|
window.localStorage.setItem(THEME_LOCAL_STORAGE_KEY, action.payload);
|
|
},
|
|
setAvailableThemes(state, action) {
|
|
state.theme.availableThemes = action.payload;
|
|
},
|
|
setLocale(state, action) {
|
|
state.language.locale = action.payload;
|
|
window.localStorage.setItem(LANGUAGE_LOCAL_STORAGE_KEY, action.payload);
|
|
document.documentElement.setAttribute("lang", action.payload);
|
|
},
|
|
setToken(state, action) {
|
|
state.token = action.payload;
|
|
},
|
|
login(state, action) {
|
|
const { token, persist } = action.payload;
|
|
if (!persist) {
|
|
setCookie(STORAGE_KEYS.TOKEN, token);
|
|
} else {
|
|
window.localStorage.setItem(STORAGE_KEYS.TOKEN, JSON.stringify(token));
|
|
}
|
|
window.localStorage.setItem(STORAGE_KEYS.STATUS, "true");
|
|
state.token = token;
|
|
},
|
|
logout(state) {
|
|
state.token = null;
|
|
deleteCookie(STORAGE_KEYS.TOKEN);
|
|
window.localStorage.removeItem(STORAGE_KEYS.TOKEN);
|
|
window.localStorage.removeItem(STORAGE_KEYS.STATUS);
|
|
}
|
|
}
|
|
});
|
|
var reducer = adminSlice.reducer;
|
|
var { setAppTheme, setAvailableThemes, setLocale, setToken, logout, login } = adminSlice.actions;
|
|
|
|
// node_modules/@strapi/admin/dist/admin/admin/src/services/auth.mjs
|
|
var authService = adminApi.enhanceEndpoints({
|
|
addTagTypes: [
|
|
"User",
|
|
"Me",
|
|
"ProvidersOptions"
|
|
]
|
|
}).injectEndpoints({
|
|
endpoints: (builder) => ({
|
|
/**
|
|
* ME
|
|
*/
|
|
getMe: builder.query({
|
|
query: () => ({
|
|
method: "GET",
|
|
url: "/admin/users/me"
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
},
|
|
providesTags: (res) => res ? [
|
|
"Me",
|
|
{
|
|
type: "User",
|
|
id: res.id
|
|
}
|
|
] : [
|
|
"Me"
|
|
]
|
|
}),
|
|
getMyPermissions: builder.query({
|
|
query: () => ({
|
|
method: "GET",
|
|
url: "/admin/users/me/permissions"
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
}
|
|
}),
|
|
updateMe: builder.mutation({
|
|
query: (body) => ({
|
|
method: "PUT",
|
|
url: "/admin/users/me",
|
|
data: body
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
},
|
|
invalidatesTags: [
|
|
"Me"
|
|
]
|
|
}),
|
|
/**
|
|
* Permissions
|
|
*/
|
|
checkPermissions: builder.query({
|
|
query: (permissions) => ({
|
|
method: "POST",
|
|
url: "/admin/permissions/check",
|
|
data: permissions
|
|
})
|
|
}),
|
|
/**
|
|
* Auth methods
|
|
*/
|
|
login: builder.mutation({
|
|
query: (body) => ({
|
|
method: "POST",
|
|
url: "/admin/login",
|
|
data: body
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
},
|
|
invalidatesTags: [
|
|
"Me"
|
|
]
|
|
}),
|
|
logout: builder.mutation({
|
|
query: () => ({
|
|
method: "POST",
|
|
url: "/admin/logout"
|
|
})
|
|
}),
|
|
resetPassword: builder.mutation({
|
|
query: (body) => ({
|
|
method: "POST",
|
|
url: "/admin/reset-password",
|
|
data: body
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
}
|
|
}),
|
|
renewToken: builder.mutation({
|
|
query: (body) => ({
|
|
method: "POST",
|
|
url: "/admin/renew-token",
|
|
data: body
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
}
|
|
}),
|
|
getRegistrationInfo: builder.query({
|
|
query: (registrationToken) => ({
|
|
url: "/admin/registration-info",
|
|
method: "GET",
|
|
config: {
|
|
params: {
|
|
registrationToken
|
|
}
|
|
}
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
}
|
|
}),
|
|
registerAdmin: builder.mutation({
|
|
query: (body) => ({
|
|
method: "POST",
|
|
url: "/admin/register-admin",
|
|
data: body
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
}
|
|
}),
|
|
registerUser: builder.mutation({
|
|
query: (body) => ({
|
|
method: "POST",
|
|
url: "/admin/register",
|
|
data: body
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
}
|
|
}),
|
|
forgotPassword: builder.mutation({
|
|
query: (body) => ({
|
|
url: "/admin/forgot-password",
|
|
method: "POST",
|
|
data: body
|
|
})
|
|
}),
|
|
isSSOLocked: builder.query({
|
|
query: () => ({
|
|
url: "/admin/providers/isSSOLocked",
|
|
method: "GET"
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
}
|
|
}),
|
|
getProviders: builder.query({
|
|
query: () => ({
|
|
url: "/admin/providers",
|
|
method: "GET"
|
|
})
|
|
}),
|
|
getProviderOptions: builder.query({
|
|
query: () => ({
|
|
url: "/admin/providers/options",
|
|
method: "GET"
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
},
|
|
providesTags: [
|
|
"ProvidersOptions"
|
|
]
|
|
}),
|
|
updateProviderOptions: builder.mutation({
|
|
query: (body) => ({
|
|
url: "/admin/providers/options",
|
|
method: "PUT",
|
|
data: body
|
|
}),
|
|
transformResponse(res) {
|
|
return res.data;
|
|
},
|
|
invalidatesTags: [
|
|
"ProvidersOptions"
|
|
]
|
|
})
|
|
}),
|
|
overrideExisting: false
|
|
});
|
|
var { useCheckPermissionsQuery, useLazyCheckPermissionsQuery, useGetMeQuery, useLoginMutation, useRenewTokenMutation, useLogoutMutation, useUpdateMeMutation, useResetPasswordMutation, useRegisterAdminMutation, useRegisterUserMutation, useGetRegistrationInfoQuery, useForgotPasswordMutation, useGetMyPermissionsQuery, useIsSSOLockedQuery, useGetProvidersQuery, useGetProviderOptionsQuery, useUpdateProviderOptionsMutation } = authService;
|
|
|
|
// node_modules/@strapi/admin/dist/admin/admin/src/features/Auth.mjs
|
|
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
|
|
var React = __toESM(require_react(), 1);
|
|
var [Provider, useAuth] = createContext("Auth");
|
|
var STORAGE_KEYS2 = {
|
|
TOKEN: "jwtToken",
|
|
STATUS: "isLoggedIn"
|
|
};
|
|
var AuthProvider = ({ children, _defaultPermissions = [], _disableRenewToken = false }) => {
|
|
const dispatch = useTypedDispatch();
|
|
const runRbacMiddleware = useStrapiApp("AuthProvider", (state) => state.rbac.run);
|
|
const location = useLocation();
|
|
const [{ rawQuery }] = useQueryParams();
|
|
const token = useTypedSelector((state) => state.admin_app.token ?? null);
|
|
const { data: user, isLoading: isLoadingUser } = useGetMeQuery(void 0, {
|
|
/**
|
|
* If there's no token, we don't try to fetch
|
|
* the user data because it will fail.
|
|
*/
|
|
skip: !token
|
|
});
|
|
const { data: userPermissions = _defaultPermissions, refetch, isUninitialized, isLoading: isLoadingPermissions } = useGetMyPermissionsQuery(void 0, {
|
|
skip: !token
|
|
});
|
|
const navigate = useNavigate();
|
|
const [loginMutation] = useLoginMutation();
|
|
const [renewTokenMutation] = useRenewTokenMutation();
|
|
const [logoutMutation] = useLogoutMutation();
|
|
const clearStateAndLogout = React.useCallback(() => {
|
|
dispatch(adminApi.util.resetApiState());
|
|
dispatch(logout());
|
|
navigate("/auth/login");
|
|
}, [
|
|
dispatch,
|
|
navigate
|
|
]);
|
|
React.useEffect(() => {
|
|
if (token && !_disableRenewToken) {
|
|
renewTokenMutation({
|
|
token
|
|
}).then((res) => {
|
|
if ("data" in res) {
|
|
dispatch(login({
|
|
token: res.data.token
|
|
}));
|
|
} else {
|
|
clearStateAndLogout();
|
|
}
|
|
});
|
|
}
|
|
}, [
|
|
token,
|
|
dispatch,
|
|
renewTokenMutation,
|
|
clearStateAndLogout,
|
|
_disableRenewToken
|
|
]);
|
|
React.useEffect(() => {
|
|
if (user) {
|
|
if (user.preferedLanguage) {
|
|
dispatch(setLocale(user.preferedLanguage));
|
|
}
|
|
}
|
|
}, [
|
|
dispatch,
|
|
user
|
|
]);
|
|
React.useEffect(() => {
|
|
const handleUserStorageChange = (event) => {
|
|
if (event.key === STORAGE_KEYS2.STATUS && event.newValue === null) {
|
|
clearStateAndLogout();
|
|
}
|
|
};
|
|
window.addEventListener("storage", handleUserStorageChange);
|
|
return () => {
|
|
window.removeEventListener("storage", handleUserStorageChange);
|
|
};
|
|
});
|
|
const login$1 = React.useCallback(async ({ rememberMe, ...body }) => {
|
|
const res = await loginMutation(body);
|
|
if ("data" in res) {
|
|
const { token: token2 } = res.data;
|
|
dispatch(login({
|
|
token: token2,
|
|
persist: rememberMe
|
|
}));
|
|
}
|
|
return res;
|
|
}, [
|
|
dispatch,
|
|
loginMutation
|
|
]);
|
|
const logout$1 = React.useCallback(async () => {
|
|
await logoutMutation();
|
|
clearStateAndLogout();
|
|
}, [
|
|
clearStateAndLogout,
|
|
logoutMutation
|
|
]);
|
|
const refetchPermissions = React.useCallback(async () => {
|
|
if (!isUninitialized) {
|
|
await refetch();
|
|
}
|
|
}, [
|
|
isUninitialized,
|
|
refetch
|
|
]);
|
|
const [checkPermissions] = useLazyCheckPermissionsQuery();
|
|
const checkUserHasPermissions = React.useCallback(async (permissions, passedPermissions, rawQueryContext) => {
|
|
if (!permissions || permissions.length === 0) {
|
|
return [
|
|
{
|
|
action: "",
|
|
subject: ""
|
|
}
|
|
];
|
|
}
|
|
const actualUserPermissions = passedPermissions ?? userPermissions;
|
|
const matchingPermissions = actualUserPermissions.filter((permission) => permissions.findIndex((perm) => perm.action === permission.action && // Only check the subject if it's provided
|
|
(perm.subject == void 0 || perm.subject === permission.subject)) >= 0);
|
|
const middlewaredPermissions = await runRbacMiddleware({
|
|
user,
|
|
permissions: userPermissions,
|
|
pathname: location.pathname,
|
|
search: (rawQueryContext || rawQuery).split("?")[1] ?? ""
|
|
}, matchingPermissions);
|
|
const shouldCheckConditions = middlewaredPermissions.some((perm) => Array.isArray(perm.conditions) && perm.conditions.length > 0);
|
|
if (!shouldCheckConditions) {
|
|
return middlewaredPermissions;
|
|
}
|
|
const { data, error } = await checkPermissions({
|
|
permissions: middlewaredPermissions.map((perm) => ({
|
|
action: perm.action,
|
|
subject: perm.subject
|
|
}))
|
|
});
|
|
if (error) {
|
|
throw error;
|
|
} else {
|
|
return middlewaredPermissions.filter((_, index) => (data == null ? void 0 : data.data[index]) === true);
|
|
}
|
|
}, [
|
|
checkPermissions,
|
|
location.pathname,
|
|
rawQuery,
|
|
runRbacMiddleware,
|
|
user,
|
|
userPermissions
|
|
]);
|
|
const isLoading = isLoadingUser || isLoadingPermissions;
|
|
return (0, import_jsx_runtime.jsx)(Provider, {
|
|
token,
|
|
user,
|
|
login: login$1,
|
|
logout: logout$1,
|
|
permissions: userPermissions,
|
|
checkUserHasPermissions,
|
|
refetchPermissions,
|
|
isLoading,
|
|
children
|
|
});
|
|
};
|
|
|
|
export {
|
|
StrapiAppProvider,
|
|
useStrapiApp,
|
|
useQueryParams,
|
|
THEME_LOCAL_STORAGE_KEY,
|
|
LANGUAGE_LOCAL_STORAGE_KEY,
|
|
getStoredToken,
|
|
reducer,
|
|
setAppTheme,
|
|
setAvailableThemes,
|
|
setLocale,
|
|
logout,
|
|
login,
|
|
useCheckPermissionsQuery,
|
|
useUpdateMeMutation,
|
|
useResetPasswordMutation,
|
|
useRegisterAdminMutation,
|
|
useRegisterUserMutation,
|
|
useGetRegistrationInfoQuery,
|
|
useForgotPasswordMutation,
|
|
useIsSSOLockedQuery,
|
|
useGetProvidersQuery,
|
|
useGetProviderOptionsQuery,
|
|
useUpdateProviderOptionsMutation,
|
|
useAuth,
|
|
AuthProvider
|
|
};
|
|
//# sourceMappingURL=chunk-W2TBR6J3.js.map
|