@griddo/ax 12.6.1 → 12.6.2

package/src/containers/Redirects/thunks.ts

@@ -1,196 +0,0 @@
-import { redirects } from "@ax/api";
-import { appActions } from "@ax/containers/App";
-import { handleRequest } from "@ax/helpers";
-import type { IRedirect, IRootState } from "@ax/types";
-
-import { createAsyncThunk } from "@reduxjs/toolkit";
-import type { Dispatch } from "redux";
-
-import { DEFAULT_PARAMS, ERROR_CODE } from "./constants";
-import type { IRedirectsState } from "./slice";
-import { setImports, setRedirects, setTotalImports, setTotalItems } from "./slice";
-
-/**
- * Read and write side of UC-AX-manage-redirects, as createAsyncThunk.
- *
- * They keep calling `handleRequest` inside for the same reason the Languages pilot does:
- * that helper owns the loading-flag and error-channel conventions of the whole codebase —
- * see docs/RTK-MIGRATION.md §5.
- *
- * This area is where the **callback-as-thunk-argument** mine of §5 finally goes off.
- * `addRedirect` used to take an `errorAction: () => void` that it called on a 409, and
- * createAsyncThunk keeps its argument in `meta.arg` of every action it dispatches — a
- * function there trips the `serializableCheck` that GlobalStore deliberately leaves on.
- * So the 409 now comes back as **data** (`isOriginTaken`) and the screen decides what to
- * open, which is where a decision about modals belonged in the first place.
- *
- * As with the other areas, the legacy `try/catch` whose body was `console.log(e)` is gone:
- * createAsyncThunk turns a throw into a `rejected` action, so the failure is observable.
- */
-const onError = (response: unknown, dispatch: Dispatch) => appActions.handleError(response)(dispatch);
-
-interface IMessageResponse {
-	data: { message?: string | string[] };
-}
-
-// The two bulk endpoints answer with one message per offending row, and the screen reports
-// the count instead of the messages. Same wording as before, verb apart.
-const onCountedError = (response: IMessageResponse, dispatch: Dispatch, verb: "delete" | "import") => {
-	const { message } = response.data;
-	const isMultiple = Array.isArray(message) && message.length > 1;
-	const msg = isMultiple ? `The ${verb} action failed due to ${message.length} errors.` : undefined;
-	appActions.handleError(response, isMultiple, msg)(dispatch);
-};
-
-// Every write reloads the list, and the filter it reloads with depends on scope: the loaded
-// site if there is one, otherwise whatever filter the caller passed. Kept as a pure helper
-// so each thunk dispatches the reload with its own correctly typed `dispatch`.
-const scopedFilter = (getState: () => unknown, filter?: string) => {
-	const { currentSiteInfo } = (getState() as IRootState).sites;
-	return currentSiteInfo?.id ? `&sites=${currentSiteInfo.id}` : filter;
-};
-
-export interface IRedirectsQuery {
-	page: number;
-	itemsPerPage: number;
-	pagination: boolean;
-	query?: string;
-	filterBy?: string;
-}
-
-interface IGetRedirectsArgs {
-	params: IRedirectsQuery;
-	filters?: string;
-}
-
-export const getRedirects = createAsyncThunk(
-	"redirects/getRedirects",
-	async ({ params, filters }: IGetRedirectsArgs, { dispatch }) => {
-		// Empties the list before asking, as before: the table blanks instead of showing the
-		// previous page underneath the spinner.
-		dispatch(setRedirects([]));
-
-		return handleRequest(
-			async () => redirects.getRedirects(params, filters),
-			{
-				handleSuccess: ({ items, totalItems }: { items: IRedirect[]; totalItems: number }) => {
-					dispatch(setRedirects(items));
-					dispatch(setTotalItems(totalItems));
-				},
-				handleError: (response: unknown) => onError(response, dispatch),
-			},
-			[appActions.setIsLoading],
-		)(dispatch);
-	},
-);
-
-interface IRedirectForm {
-	from: string;
-	to: string | number;
-}
-
-interface IAddRedirectArgs {
-	redirect: IRedirectForm;
-	force?: boolean;
-	filter?: string;
-}
-
-export interface IAddRedirectResult {
-	saved: boolean;
-	/** The `from` already has a redirect (409). Not a failure — the screen offers to overwrite. */
-	isOriginTaken: boolean;
-}
-
-export const addRedirect = createAsyncThunk(
-	"redirects/addRedirect",
-	async ({ redirect, force, filter }: IAddRedirectArgs, { dispatch, getState }): Promise<IAddRedirectResult> => {
-		let isOriginTaken = false;
-
-		const saved = await handleRequest(
-			async () => redirects.createRedirect(redirect, force),
-			{
-				handleSuccess: () =>
-					dispatch(getRedirects({ params: { ...DEFAULT_PARAMS }, filters: scopedFilter(getState, filter) })),
-				handleError: (response: { status: number }) => {
-					if (response.status === ERROR_CODE.isBeingUsed) {
-						isOriginTaken = true;
-						return;
-					}
-					onError(response, dispatch);
-				},
-			},
-			[],
-		)(dispatch);
-
-		return { saved, isOriginTaken };
-	},
-);
-
-interface IUpdateRedirectArgs {
-	redirect: IRedirectForm;
-	redirectID: number;
-	filter?: string;
-}
-
-export const updateRedirect = createAsyncThunk(
-	"redirects/updateRedirect",
-	async ({ redirect, redirectID, filter }: IUpdateRedirectArgs, { dispatch, getState }) =>
-		handleRequest(
-			async () => redirects.updateRedirect(redirect, redirectID),
-			{
-				handleSuccess: () =>
-					dispatch(getRedirects({ params: { ...DEFAULT_PARAMS }, filters: scopedFilter(getState, filter) })),
-				handleError: (response: unknown) => onError(response, dispatch),
-			},
-			[],
-		)(dispatch),
-);
-
-interface IDeleteRedirectArgs {
-	redirectID: number | number[];
-	filter?: string;
-}
-
-export const deleteRedirect = createAsyncThunk(
-	"redirects/deleteRedirect",
-	async ({ redirectID, filter }: IDeleteRedirectArgs, { dispatch, getState }) =>
-		handleRequest(
-			async () =>
-				Array.isArray(redirectID) ? redirects.deleteRedirectsBulk(redirectID) : redirects.deleteRedirect(redirectID),
-			{
-				handleSuccess: () =>
-					dispatch(getRedirects({ params: { ...DEFAULT_PARAMS }, filters: scopedFilter(getState, filter) })),
-				handleError: (response: IMessageResponse) => onCountedError(response, dispatch, "delete"),
-			},
-			[appActions.setIsSaving],
-		)(dispatch),
-);
-
-interface IImportRedirectsArgs {
-	rows: IRedirectForm[];
-	/** First phase: ask the backend to classify the rows without writing anything. */
-	check: boolean;
-}
-
-export const importRedirects = createAsyncThunk(
-	"redirects/importRedirects",
-	async ({ rows, check }: IImportRedirectsArgs, { dispatch }) =>
-		handleRequest(
-			async () => (check ? redirects.createRedirectsBulkCheck(rows) : redirects.createRedirectsBulk(rows)),
-			{
-				handleSuccess: (data: { total: number } & NonNullable<IRedirectsState["imports"]>) => {
-					if (check) {
-						const { total, error, existing, ok } = data;
-						dispatch(setImports({ error, existing, ok }));
-						dispatch(setTotalImports(total));
-						return;
-					}
-					// Reloads UNFILTERED, unlike every other write. Kept as-is: after importing a
-					// batch the user is shown the whole catalogue, not the current site's slice.
-					dispatch(getRedirects({ params: { ...DEFAULT_PARAMS } }));
-				},
-				handleError: (response: IMessageResponse) => onCountedError(response, dispatch, "import"),
-			},
-			[],
-		)(dispatch),
-);

package/src/containers/Settings/Languages/slice.ts

@@ -1,48 +0,0 @@
-import type { ISiteLanguage } from "@ax/types";
-
-import { createSlice, type PayloadAction } from "@reduxjs/toolkit";
-
-/**
- * First area migrated to Redux Toolkit (UC-AX-manage-languages).
- *
- * The slice holds ONLY the language panel's form. The list of a site's languages
- * lives in `sites.currentSiteLanguages` and the loading flags in `app`, which is
- * why this area is so small — see docs/RTK-MIGRATION.md and the use case notes.
- *
- * `updateFormValue` and `resetForm` used to be thunks that read `getState()` to
- * merge onto the current form; as reducers they express the same thing directly,
- * so the public shape (name + argument) is unchanged for callers.
- */
-export interface ILanguageState {
-	form: ISiteLanguage;
-}
-
-export const initialState: ILanguageState = {
-	form: {
-		language: null,
-		path: "",
-		domain: null,
-		isDefault: false,
-	},
-};
-
-const languagesSlice = createSlice({
-	name: "languages",
-	initialState,
-	reducers: {
-		setForm(state, action: PayloadAction<ISiteLanguage>) {
-			state.form = action.payload;
-		},
-		updateFormValue(state, action: PayloadAction<Partial<ISiteLanguage>>) {
-			state.form = { ...state.form, ...action.payload };
-		},
-		resetForm(state) {
-			state.form = initialState.form;
-		},
-	},
-});
-
-export const { setForm, updateFormValue, resetForm } = languagesSlice.actions;
-
-export { initialState as languagesInitialState };
-export const languagesReducer = languagesSlice.reducer;

package/src/containers/Settings/Languages/thunks.ts

@@ -1,83 +0,0 @@
-import { languages } from "@ax/api";
-import { appActions } from "@ax/containers/App";
-import { sitesActions } from "@ax/containers/Sites";
-import { handleRequest } from "@ax/helpers";
-import type { ISiteLanguage } from "@ax/types";
-
-import { createAsyncThunk } from "@reduxjs/toolkit";
-import type { Dispatch } from "redux";
-
-/**
- * Write side of UC-AX-manage-languages, as createAsyncThunk.
- *
- * They keep calling `handleRequest` inside: that helper is the codebase's
- * hand-rolled createAsyncThunk (152 call-sites) and owns the loading-flag and
- * error-channel conventions. Replacing it is a cross-cutting job, not this
- * area's — see docs/RTK-MIGRATION.md §5.
- *
- * What does change: the legacy versions wrapped everything in a `try/catch` whose
- * body was `console.log(e) // TODO: capturar error bien`, swallowing failures.
- * createAsyncThunk turns a throw into a `rejected` action instead, so the failure
- * is at least observable in devtools rather than lost.
- *
- * Reads live in `sitesActions.getSiteLanguages` (the list belongs to `sites`), so
- * every write refreshes through it, exactly as before.
- */
-// Called through the namespaces rather than destructured at module scope: a
-// destructured reference is frozen at import time and cannot be spied on, which
-// would make the refresh-after-write behaviour untestable.
-const refreshList = (siteID: number, dispatch: Dispatch) => sitesActions.getSiteLanguages(siteID)(dispatch);
-
-const onError = (response: unknown, dispatch: Dispatch) => appActions.handleError(response)(dispatch);
-
-interface ISiteLanguageArgs {
-	siteID: number;
-	data: ISiteLanguage;
-}
-
-interface IDeleteSiteLanguageArgs {
-	siteID: number;
-	languageID: number;
-}
-
-export const createSiteLanguage = createAsyncThunk(
-	"languages/createSiteLanguage",
-	async ({ siteID, data }: ISiteLanguageArgs, { dispatch }) =>
-		handleRequest(
-			async () => languages.createSiteLanguage(siteID, data),
-			{
-				handleSuccess: () => refreshList(siteID, dispatch),
-				handleError: (response: unknown) => onError(response, dispatch),
-			},
-			[appActions.setIsSaving],
-		)(dispatch),
-);
-
-export const updateSiteLanguage = createAsyncThunk(
-	"languages/updateSiteLanguage",
-	async ({ siteID, data }: ISiteLanguageArgs, { dispatch }) =>
-		handleRequest(
-			async () => languages.updateSiteLanguage(siteID, data),
-			{
-				handleSuccess: () => refreshList(siteID, dispatch),
-				handleError: (response: unknown) => onError(response, dispatch),
-			},
-			[appActions.setIsSaving],
-		)(dispatch),
-);
-
-export const deleteSiteLanguage = createAsyncThunk(
-	"languages/deleteSiteLanguage",
-	// setIsLoading, not setIsSaving — kept as-is to preserve behaviour: the list
-	// view only renders <Loading /> off app.isLoading, so deleting shows the
-	// spinner while adding/editing does not. Inconsistency noted in the use case.
-	async ({ siteID, languageID }: IDeleteSiteLanguageArgs, { dispatch }) =>
-		handleRequest(
-			async () => languages.deleteSiteLanguage(siteID, languageID),
-			{
-				handleSuccess: () => refreshList(siteID, dispatch),
-				handleError: (response: unknown) => onError(response, dispatch),
-			},
-			[appActions.setIsLoading],
-		)(dispatch),
-);

package/src/containers/Settings/Social/slice.ts

@@ -1,40 +0,0 @@
-import type { ISocialState } from "@ax/types";
-
-import { createSlice, type PayloadAction } from "@reduxjs/toolkit";
-
-/**
- * The `social` area holds one site's social profile URLs (and the two things filed
- * alongside them, newsletter and podcast) as a flat `{ network: url }` map —
- * UC-AX-configure-social-networks. No types, order or icons: the screen is a plain
- * form of URL text fields saved in a single PUT, and the set of fields comes from the
- * instance config plus a hardcoded list, not from the state.
- *
- * `ISocialState` stays in `@ax/types` rather than moving next to the slice as
- * `ILanguageState` and `IAnalyticsState` did: seven preview components use it as a
- * prop type, so it is a shared domain type that happens to also be this area's state.
- *
- * STAYS in redux-persist, against the rule of ADR 0002: six page-editor screens read
- * `state.social` to feed the preview canvas and none of them fetches — only
- * `sites.setSiteInfo` writes it outside this screen, and that does not re-run on a hard
- * refresh. The persist was their loader. Leaves in waves 2-4 with those consumers.
- */
-export const initialState: ISocialState = {};
-
-const socialSlice = createSlice({
-	name: "social",
-	initialState,
-	reducers: {
-		// REPLACES, it does not merge — the opposite of its `analytics` sibling. The
-		// legacy reducer returned `{ ...payload }` and the screen leans on it: since
-		// "removing" a network means emptying its field and saving, a key the server
-		// drops has to drop out of the store too.
-		setSocial(_state, action: PayloadAction<ISocialState>) {
-			return { ...action.payload };
-		},
-	},
-});
-
-export const { setSocial } = socialSlice.actions;
-
-export { initialState as socialInitialState };
-export const socialReducer = socialSlice.reducer;

package/src/containers/Settings/Social/thunks.ts

@@ -1,68 +0,0 @@
-import { social } from "@ax/api";
-import { appActions } from "@ax/containers/App";
-import { handleRequest } from "@ax/helpers";
-import type { IRootState, ISocialState } from "@ax/types";
-
-import { createAsyncThunk } from "@reduxjs/toolkit";
-import type { Dispatch } from "redux";
-
-import { setSocial } from "./slice";
-
-/**
- * Read and write side of UC-AX-configure-social-networks, as createAsyncThunk.
- *
- * They keep calling `handleRequest` inside for the same reason the Languages pilot
- * does: that helper owns the loading-flag and error-channel conventions of the whole
- * codebase, and replacing it is a cross-cutting job — see docs/RTK-MIGRATION.md §5.
- *
- * Both keep reading the site from `sites.currentSiteInfo` instead of taking it as an
- * argument, exactly as the legacy thunks did. This area has a single scope — whatever
- * site is loaded — so there is nothing to make explicit the way Analytics had to with
- * its global scope, and no call site pays the single-argument rule here.
- *
- * What does change: the legacy versions wrapped everything in a `try/catch` whose
- * body was `console.log(e)`, swallowing failures. createAsyncThunk turns a throw into
- * a `rejected` action instead, so the failure is observable.
- */
-// Called through the namespace rather than destructured at module scope: a
-// destructured reference is frozen at import time and cannot be spied on.
-const onError = (response: unknown, dispatch: Dispatch) => appActions.handleError(response)(dispatch);
-
-// `currentSiteInfo` is typed `ISite | null`, which the legacy thunks never had to face
-// because they read it through an untyped `getState` — on a null site they built the
-// url off `undefined` and threw, and their `try/catch` swallowed it. The screen only
-// exists inside a loaded site, so the guard below is unreachable in practice; it is
-// there so the impossible case cannot turn into a request to `/site/undefined/socials`.
-const siteOf = (getState: () => unknown) => (getState() as IRootState).sites.currentSiteInfo;
-
-export const getSocial = createAsyncThunk<boolean, void>("social/getSocial", async (_arg, { dispatch, getState }) => {
-	const site = siteOf(getState);
-	if (!site) return false;
-
-	return handleRequest(
-		async () => social.getSocial(site.id),
-		{
-			handleSuccess: (data: ISocialState) => dispatch(setSocial(data)),
-			// No error channel on the read side, as before: the failure only reaches the
-			// console and the form is left empty. Wart documented in the use case.
-			handleError: () => console.log("Error en getSocial"),
-		},
-		[appActions.setIsLoading],
-	)(dispatch);
-});
-
-export const saveSocial = createAsyncThunk("social/saveSocial", async (form: ISocialState, { dispatch, getState }) => {
-	const site = siteOf(getState);
-	if (!site) return false;
-
-	return handleRequest(
-		// The whole map goes out in one PUT, emptied fields included — that is what
-		// makes clearing a field remove the network.
-		async () => social.updateSocial(site.id, form),
-		{
-			handleSuccess: (data: ISocialState) => dispatch(setSocial(data)),
-			handleError: (response: unknown) => onError(response, dispatch),
-		},
-		[appActions.setIsSaving],
-	)(dispatch);
-});

package/src/store/hooks.ts

@@ -1,37 +0,0 @@
-import type { TypedUseSelectorHook } from "react-redux";
-import { useDispatch, useSelector } from "react-redux";
-
-import type { IRootState } from "@ax/types";
-
-import type { ThunkDispatch } from "@reduxjs/toolkit";
-import type { AnyAction } from "redux";
-
-/**
- * Typed hooks — the replacement for `connect` during the RTK migration.
- *
- * `RootState` is `IRootState` (the hand-written shape the 145 legacy `connect`
- * call-sites already use) rather than `ReturnType<store.getState>`: the root
- * reducer is still declared as `Reducer<any>`, so deriving the type from the
- * store would silently collapse to `any`. Once every area owns a slice, the
- * derivation becomes the source of truth and `IRootState` can go.
- *
- * `AppDispatch` is spelled out as a thunk dispatch for the same reason — it is
- * what `configureStore`'s default middleware actually gives us, and writing it
- * explicitly keeps `dispatch` from degrading to `any`.
- *
- * The stack stays on react-redux 7.2.9 + redux 4.2.1 on purpose — RTK 2.9 accepts
- * both as peers, so nothing here needs them bumped. Both bumps were tried and
- * backed out, each for a measured reason (see docs/RTK-MIGRATION.md §8.3):
- *   - redux 5 retypes `Dispatch` to `UnknownAction`, which the 15 legacy
- *     `containers/*\/actions.tsx` action interfaces are not assignable to (361 type
- *     errors) — and three of those files are ones `main` has already changed.
- *   - react-redux 8 subscribes via `useSyncExternalStore`, which surfaces a
- *     pre-existing render loop in `components/TableFilters/CheckGroupFilter`
- *     (unconditional `setSelectedValue` in an effect keyed on fresh references).
- * Hence `AnyAction` rather than redux 5's `UnknownAction`.
- */
-export type RootState = IRootState;
-export type AppDispatch = ThunkDispatch<IRootState, undefined, AnyAction>;
-
-export const useAppDispatch = () => useDispatch<AppDispatch>();
-export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;

package/src/store/index.ts

@@ -1,2 +0,0 @@
-export type { AppDispatch, RootState } from "./hooks";
-export { useAppDispatch, useAppSelector } from "./hooks";