[No QA] Replace OnyxUpdate default union type with specific types - fifth batch

src/ONYXKEYS.ts

@@ -1211,8 +1211,8 @@ type OnyxValuesMapping = {
     [ONYXKEYS.DEVICE_ID]: string;
     [ONYXKEYS.ACTIVATED_CARD_PIN]: string | undefined;
     [ONYXKEYS.IS_SIDEBAR_LOADED]: boolean;
-    [ONYXKEYS.PERSISTED_REQUESTS]: OnyxTypes.Request[];
-    [ONYXKEYS.PERSISTED_ONGOING_REQUESTS]: OnyxTypes.Request;
+    [ONYXKEYS.PERSISTED_REQUESTS]: OnyxTypes.AnyRequest[];
+    [ONYXKEYS.PERSISTED_ONGOING_REQUESTS]: OnyxTypes.AnyRequest;
     [ONYXKEYS.CURRENT_DATE]: string;
     [ONYXKEYS.CREDENTIALS]: OnyxTypes.Credentials;
     [ONYXKEYS.STASHED_CREDENTIALS]: OnyxTypes.Credentials;

src/libs/API/index.ts

@@ -2,7 +2,7 @@ import Onyx from 'react-native-onyx';
 import type {OnyxKey} from 'react-native-onyx';
 import type {SetRequired} from 'type-fest';
 import {resolveDuplicationConflictAction, resolveEnableFeatureConflicts} from '@libs/actions/RequestConflictUtils';
-import type {EnablePolicyFeatureCommand, RequestMatcher} from '@libs/actions/RequestConflictUtils';
+import type {AnyRequestMatcher, EnablePolicyFeatureCommand} from '@libs/actions/RequestConflictUtils';
 import Log from '@libs/Log';
 import {handleDeletedAccount, HandleUnusedOptimisticID, Logging, Pagination, Reauthentication, RecheckConnection, SaveResponseInOnyx, SupportalPermission} from '@libs/Middleware';
 import FraudMonitoring from '@libs/Middleware/FraudMonitoring';
@@ -13,7 +13,7 @@ import {addMiddleware, processWithMiddleware} from '@libs/Request';
 import {getAll, getLength as getPersistedRequestsLength} from '@userActions/PersistedRequests';
 import CONST from '@src/CONST';
 import type OnyxRequest from '@src/types/onyx/Request';
-import type {OnyxData, PaginatedRequest, PaginationConfig, RequestConflictResolver} from '@src/types/onyx/Request';
+import type {AnyRequest, OnyxData, PaginatedRequest, PaginationConfig, RequestConflictResolver} from '@src/types/onyx/Request';
 import type Response from '@src/types/onyx/Response';
 import type {ApiCommand, ApiRequestCommandParameters, ApiRequestType, CommandOfType, ReadCommand, SideEffectRequestCommand, WriteCommand} from './types';
 import {READ_COMMANDS} from './types';
@@ -54,19 +54,19 @@ let requestIndex = 0;
 /**
  * Prepare the request to be sent. Bind data together with request metadata and apply optimistic Onyx data.
  */
-function prepareRequest<TCommand extends ApiCommand>(
+function prepareRequest<TCommand extends ApiCommand, TKey extends OnyxKey>(
     command: TCommand,
     type: ApiRequestType,
     params: ApiRequestCommandParameters[TCommand],
-    onyxData: OnyxData<OnyxKey> = {},
-    conflictResolver: RequestConflictResolver = {},
-): OnyxRequest {
+    onyxData: OnyxData<TKey> = {},
+    conflictResolver: RequestConflictResolver<TKey> = {},
+): OnyxRequest<TKey> {
     Log.info('[API] Preparing request', false, {command, type});
 
     let shouldApplyOptimisticData = true;
     if (conflictResolver?.checkAndFixConflictingRequest) {
         const requests = getAll();
-        const {conflictAction} = conflictResolver.checkAndFixConflictingRequest(requests);
+        const {conflictAction} = conflictResolver.checkAndFixConflictingRequest(requests as Array<OnyxRequest<TKey>>);
         shouldApplyOptimisticData = conflictAction.type !== 'noAction';
     }
 
@@ -95,7 +95,7 @@ function prepareRequest<TCommand extends ApiCommand>(
     };
 
     // Assemble all request metadata (used by middlewares, and for persisted requests stored in Onyx)
-    const request: SetRequired<OnyxRequest, 'data'> = {
+    const request: SetRequired<OnyxRequest<TKey>, 'data'> = {
         command,
         data,
         initiatedOffline: isOffline(),
@@ -118,7 +118,7 @@ function prepareRequest<TCommand extends ApiCommand>(
 /**
  * Process a prepared request according to its type.
  */
-function processRequest(request: OnyxRequest, type: ApiRequestType): Promise<void | Response> {
+function processRequest<TKey extends OnyxKey>(request: OnyxRequest<TKey>, type: ApiRequestType): Promise<void | Response<TKey>> {
     Log.info('[API] Processing request', false, {command: request.command, type});
     // Write commands can be saved and retried, so push it to the SequentialQueue
     if (type === CONST.API_REQUEST_TYPE.WRITE) {
@@ -143,13 +143,21 @@ function processRequest(request: OnyxRequest, type: ApiRequestType): Promise<voi
  * All calls to API.write() will be persisted to disk as JSON with the params, successData, and failureData (or finallyData, if included in place of the former two values).
  * This is so that if the network is unavailable or the app is closed, we can send the WRITE request later.
  */
+function write<TCommand extends WriteCommand>(command: TCommand, apiCommandParameters: ApiRequestCommandParameters[TCommand]): Promise<void | Response>;
 
-function write<TCommand extends WriteCommand>(
+function write<TCommand extends WriteCommand, TKey extends OnyxKey>(
     command: TCommand,
     apiCommandParameters: ApiRequestCommandParameters[TCommand],
-    onyxData: OnyxData<OnyxKey> = {},
-    conflictResolver: RequestConflictResolver = {},
-): Promise<void | Response> {
+    onyxData: OnyxData<TKey>,
+    conflictResolver?: RequestConflictResolver<TKey>,
+): Promise<void | Response<TKey>>;
+
+function write<TCommand extends WriteCommand, TKey extends OnyxKey>(
+    command: TCommand,
+    apiCommandParameters: ApiRequestCommandParameters[TCommand],
+    onyxData: OnyxData<TKey> = {},
+    conflictResolver: RequestConflictResolver<TKey> = {},
+): Promise<void | Response<TKey>> {
     Log.info('[API] Called API write', false, {command, ...apiCommandParameters});
     const request = prepareRequest(command, CONST.API_REQUEST_TYPE.WRITE, apiCommandParameters, onyxData, conflictResolver);
     return processRequest(request, CONST.API_REQUEST_TYPE.WRITE);
@@ -159,14 +167,14 @@ function write<TCommand extends WriteCommand>(
  * This function is used to write data to the API while ensuring that there are no duplicate requests in the queue.
  * If a duplicate request is found, it resolves the conflict by replacing the duplicated request with the new one.
  */
-function writeWithNoDuplicatesConflictAction<TCommand extends WriteCommand>(
+function writeWithNoDuplicatesConflictAction<TCommand extends WriteCommand, TKey extends OnyxKey>(
     command: TCommand,
     apiCommandParameters: ApiRequestCommandParameters[TCommand],
-    onyxData: OnyxData<OnyxKey> = {},
-    requestMatcher: RequestMatcher = (request) => request.command === command,
-): Promise<void | Response> {
+    onyxData: OnyxData<TKey> = {},
+    requestMatcher: AnyRequestMatcher = (request) => request.command === command,
+): Promise<void | Response<TKey>> {
     const conflictResolver = {
-        checkAndFixConflictingRequest: (persistedRequests: OnyxRequest[]) => resolveDuplicationConflictAction(persistedRequests, requestMatcher),
+        checkAndFixConflictingRequest: (persistedRequests: AnyRequest[]) => resolveDuplicationConflictAction(persistedRequests, requestMatcher),
     };
 
     return write(command, apiCommandParameters, onyxData, conflictResolver);
@@ -176,13 +184,13 @@ function writeWithNoDuplicatesConflictAction<TCommand extends WriteCommand>(
  * This function is used to write data to the API while ensuring that there are no conflicts with enabling policy features.
  * If a conflict is found, it resolves the conflict by deleting the duplicated request.
  */
-function writeWithNoDuplicatesEnableFeatureConflicts<TCommand extends EnablePolicyFeatureCommand>(
+function writeWithNoDuplicatesEnableFeatureConflicts<TCommand extends EnablePolicyFeatureCommand, TKey extends OnyxKey>(
     command: TCommand,
     apiCommandParameters: ApiRequestCommandParameters[TCommand],
-    onyxData: OnyxData<OnyxKey> = {},
-): Promise<void | Response> {
+    onyxData: OnyxData<TKey> = {},
+): Promise<void | Response<TKey>> {
     const conflictResolver = {
-        checkAndFixConflictingRequest: (persistedRequests: OnyxRequest[]) => resolveEnableFeatureConflicts(command, persistedRequests, apiCommandParameters),
+        checkAndFixConflictingRequest: (persistedRequests: Array<OnyxRequest<TKey>>) => resolveEnableFeatureConflicts(command, persistedRequests, apiCommandParameters),
     };
 
     return write(command, apiCommandParameters, onyxData, conflictResolver);
@@ -196,11 +204,11 @@ function writeWithNoDuplicatesEnableFeatureConflicts<TCommand extends EnablePoli
  * Using this method is discouraged and will throw an ESLint error. Use it sparingly and only when all other alternatives have been exhausted.
  * It is best to discuss it in Slack anytime you are tempted to use this method.
  */
-function makeRequestWithSideEffects<TCommand extends SideEffectRequestCommand>(
+function makeRequestWithSideEffects<TCommand extends SideEffectRequestCommand, TKey extends OnyxKey>(
     command: TCommand,
     apiCommandParameters: ApiRequestCommandParameters[TCommand],
-    onyxData: OnyxData<OnyxKey> = {},
-): Promise<void | Response> {
+    onyxData: OnyxData<TKey> = {},
+): Promise<void | Response<TKey>> {
     Log.info('[API] Called API makeRequestWithSideEffects', false, {command, ...apiCommandParameters});
     const request = prepareRequest(command, CONST.API_REQUEST_TYPE.MAKE_REQUEST_WITH_SIDE_EFFECTS, apiCommandParameters, onyxData);
 
@@ -222,7 +230,11 @@ function waitForWrites<TCommand extends ReadCommand | WriteCommand | SideEffectR
 /**
  * Requests made with this method are not be persisted to disk. If there is no network connectivity, the request is ignored and discarded.
  */
-function read<TCommand extends ReadCommand>(command: TCommand, apiCommandParameters: ApiRequestCommandParameters[TCommand], onyxData: OnyxData<OnyxKey> = {}): void {
+function read<TCommand extends ReadCommand>(command: TCommand, apiCommandParameters: ApiRequestCommandParameters[TCommand]): void;
+
+function read<TCommand extends ReadCommand, TKey extends OnyxKey>(command: TCommand, apiCommandParameters: ApiRequestCommandParameters[TCommand], onyxData: OnyxData<TKey>): void;
+
+function read<TCommand extends ReadCommand, TKey extends OnyxKey>(command: TCommand, apiCommandParameters: ApiRequestCommandParameters[TCommand], onyxData: OnyxData<TKey> = {}): void {
     Log.info('[API] Called API.read', false, {command, ...apiCommandParameters});
 
     // Apply optimistic updates of read requests immediately
@@ -237,38 +249,38 @@ function read<TCommand extends ReadCommand>(command: TCommand, apiCommandParamet
     });
 }
 
-function paginate<TRequestType extends typeof CONST.API_REQUEST_TYPE.MAKE_REQUEST_WITH_SIDE_EFFECTS, TCommand extends CommandOfType<TRequestType>>(
+function paginate<TRequestType extends typeof CONST.API_REQUEST_TYPE.MAKE_REQUEST_WITH_SIDE_EFFECTS, TCommand extends CommandOfType<TRequestType>, TKey extends OnyxKey>(
     type: TRequestType,
     command: TCommand,
     apiCommandParameters: ApiRequestCommandParameters[TCommand],
-    onyxData: OnyxData<OnyxKey>,
+    onyxData: OnyxData<TKey>,
     config: PaginationConfig,
 ): Promise<Response | void>;
-function paginate<TRequestType extends typeof CONST.API_REQUEST_TYPE.READ, TCommand extends CommandOfType<TRequestType>>(
+function paginate<TRequestType extends typeof CONST.API_REQUEST_TYPE.READ, TCommand extends CommandOfType<TRequestType>, TKey extends OnyxKey>(
     type: TRequestType,
     command: TCommand,
     apiCommandParameters: ApiRequestCommandParameters[TCommand],
-    onyxData: OnyxData<OnyxKey>,
+    onyxData: OnyxData<TKey>,
     config: PaginationConfig,
 ): void;
-function paginate<TRequestType extends typeof CONST.API_REQUEST_TYPE.WRITE, TCommand extends CommandOfType<TRequestType>>(
+function paginate<TRequestType extends typeof CONST.API_REQUEST_TYPE.WRITE, TCommand extends CommandOfType<TRequestType>, TKey extends OnyxKey>(
     type: TRequestType,
     command: TCommand,
     apiCommandParameters: ApiRequestCommandParameters[TCommand],
-    onyxData: OnyxData<OnyxKey>,
+    onyxData: OnyxData<TKey>,
     config: PaginationConfig,
-    conflictResolver?: RequestConflictResolver,
+    conflictResolver?: RequestConflictResolver<TKey>,
 ): void;
-function paginate<TRequestType extends ApiRequestType, TCommand extends CommandOfType<TRequestType>>(
+function paginate<TRequestType extends ApiRequestType, TCommand extends CommandOfType<TRequestType>, TKey extends OnyxKey>(
     type: TRequestType,
     command: TCommand,
     apiCommandParameters: ApiRequestCommandParameters[TCommand],
-    onyxData: OnyxData<OnyxKey>,
+    onyxData: OnyxData<TKey>,
     config: PaginationConfig,
-    conflictResolver: RequestConflictResolver = {},
-): Promise<Response | void> | void {
+    conflictResolver: RequestConflictResolver<TKey> = {},
+): Promise<Response<TKey> | void> | void {
     Log.info('[API] Called API.paginate', false, {command, ...apiCommandParameters});
-    const request: PaginatedRequest = {
+    const request: PaginatedRequest<TKey> = {
         ...prepareRequest(command, type, apiCommandParameters, onyxData, conflictResolver),
         ...config,
         ...{

src/libs/ApiUtils.ts

@@ -1,3 +1,4 @@
+import type {OnyxKey} from 'react-native-onyx';
 import Onyx from 'react-native-onyx';
 import type {ValueOf} from 'type-fest';
 import CONFIG from '@src/CONFIG';
@@ -36,7 +37,7 @@ getEnvironment().then((envName) => {
  * Get the currently used API endpoint, unless forceProduction is set to true
  * (Non-production environments allow for dynamically switching the API)
  */
-function getApiRoot(request?: Request, forceProduction = false): string {
+function getApiRoot<TKey extends OnyxKey = never>(request?: Partial<Pick<Request<TKey>, 'shouldUseSecure' | 'shouldSkipWebProxy' | 'command'>>, forceProduction = false): string {
     const shouldUseSecure = request?.shouldUseSecure ?? false;
 
     if (shouldUseStagingServer && forceProduction !== true) {
@@ -55,7 +56,7 @@ function getApiRoot(request?: Request, forceProduction = false): string {
  * Get the command url for the given request
  * @param - the name of the API command
  */
-function getCommandURL(request: Request): string {
+function getCommandURL<TKey extends OnyxKey>(request: Request<TKey>): string {
     // If request.command already contains ? then we don't need to append it
     return `${getApiRoot(request)}api/${request.command}${request.command.includes('?') ? '' : '?'}`;
 }

src/libs/AppState/RequestsQueuesState/types.ts

@@ -1,4 +1,4 @@
-import type {Request} from '@src/types/onyx';
+import type {AnyRequest} from '@src/types/onyx';
 
 /**
  * Main queue state
@@ -11,7 +11,7 @@ type MainQueueInfo = {
     queuedCommands?: string[];
 };
 
-type OngoingRequestInfo = Pick<Request, 'command' | 'persistWhenOngoing' | 'isRollback'>;
+type OngoingRequestInfo = Pick<AnyRequest, 'command' | 'persistWhenOngoing' | 'isRollback'>;
 
 /**
  * Persisted requests state

src/libs/HttpUtils.ts

@@ -1,3 +1,4 @@
+import type {OnyxKey} from 'react-native-onyx';
 import Onyx from 'react-native-onyx';
 import type {ValueOf} from 'type-fest';
 import alert from '@components/Alert';
@@ -53,7 +54,12 @@ const APICommandRegex = /\/api\/([^&?]+)\??.*/;
  * Send an HTTP request, and attempt to resolve the json response.
  * If there is a network error, we'll set the application offline.
  */
-function processHTTPRequest(url: string, method: RequestType = 'get', body: FormData | null = null, abortSignal: AbortSignal | undefined = undefined): Promise<Response> {
+function processHTTPRequest<TKey extends OnyxKey>(
+    url: string,
+    method: RequestType = 'get',
+    body: FormData | null = null,
+    abortSignal: AbortSignal | undefined = undefined,
+): Promise<Response<TKey>> {
     const startTime = new Date().valueOf();
     return fetch(url, {
         // We hook requests to the same Controller signal, so we can cancel them all at once
@@ -116,7 +122,7 @@ function processHTTPRequest(url: string, method: RequestType = 'get', body: Form
                 });
             }
 
-            return response.json() as Promise<Response>;
+            return response.json() as Promise<Response<TKey>>;
         })
         .then((response) => {
             // Some retried requests will result in a "Unique Constraints Violation" error from the server, which just means the record already exists
@@ -148,7 +154,7 @@ function processHTTPRequest(url: string, method: RequestType = 'get', body: Form
                 // Trigger a modal and disable the app as the user needs to upgrade to the latest minimum version to continue
                 alertUser();
             }
-            return response as Promise<Response>;
+            return response;
         });
 }
 
@@ -159,7 +165,13 @@ function processHTTPRequest(url: string, method: RequestType = 'get', body: Form
  * @param type HTTP request type (get/post)
  * @param shouldUseSecure should we use the secure server
  */
-function xhr(command: string, data: Record<string, unknown>, type: RequestType = CONST.NETWORK.METHOD.POST, shouldUseSecure = false, initiatedOffline = false): Promise<Response> {
+function xhr<TKey extends OnyxKey>(
+    command: string,
+    data: Record<string, unknown>,
+    type: RequestType = CONST.NETWORK.METHOD.POST,
+    shouldUseSecure = false,
+    initiatedOffline = false,
+): Promise<Response<TKey>> {
     return prepareRequestPayload(command, data, initiatedOffline).then((formData) => {
         const url = getCommandURL({shouldUseSecure, command});
         const abortSignalController = data.canCancel ? (abortControllerMap.get(command as AbortCommand) ?? abortControllerMap.get(ABORT_COMMANDS.All)) : undefined;

src/libs/Middleware/HandleUnusedOptimisticID.ts

@@ -9,6 +9,7 @@ import * as PersistedRequests from '@userActions/PersistedRequests';
 import ONYXKEYS from '@src/ONYXKEYS';
 import type {PersonalDetailsList} from '@src/types/onyx';
 import type Report from '@src/types/onyx/Report';
+import type {AnyOnyxUpdate} from '@src/types/onyx/Request';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
 
 // Local cache of reportID to optimistic Onyx data
@@ -80,7 +81,7 @@ const handleUnusedOptimisticID: Middleware = (requestResponse, request, isFromSe
             const {settledPersonalDetails, redundantParticipants} = reportOptimisticData.get(currentRequestReportID) ?? {};
             reportOptimisticData.delete(currentRequestReportID);
             if (!isEmptyObject(settledPersonalDetails) && !isEmptyObject(redundantParticipants)) {
-                response.onyxData.push(
+                (response.onyxData as AnyOnyxUpdate[]).push(
                     {
                         onyxMethod: Onyx.METHOD.MERGE,
                         key: `${ONYXKEYS.COLLECTION.REPORT}${currentRequestReportID}`,

src/libs/Middleware/Logging.ts

@@ -1,3 +1,4 @@
+import type {OnyxKey} from 'react-native-onyx';
 import {SIDE_EFFECT_REQUEST_COMMANDS} from '@libs/API/types';
 import type HttpsError from '@libs/Errors/HttpsError';
 import Log from '@libs/Log';
@@ -34,7 +35,7 @@ function serializeLoggingData<T extends Record<string, unknown> | undefined>(log
     }
 }
 
-function logRequestDetails(message: string, request: Request, response?: Response | void) {
+function logRequestDetails<TKey extends OnyxKey>(message: string, request: Request<TKey>, response?: Response<TKey> | void) {
     // Don't log about log or else we'd cause an infinite loop
     if (request.command === 'Log') {
         return;