Merge branch 'main' into VickyStash/poc/remove-batching

# Conflicts:
#	lib/OnyxUtils.ts

Author: VickyStash

.eslintignore

@@ -0,0 +1,141 @@
+import expensify from 'eslint-config-expensify';
+import tsPlugin from '@typescript-eslint/eslint-plugin';
+import tsParser from '@typescript-eslint/parser';
+import prettierConfig from 'eslint-config-prettier';
+
+export default [
+    ...expensify,
+    prettierConfig,
+    {
+        ignores: ['dist/**', 'node_modules/**', '.github/**', '*.d.ts', '*.config.js', '*.config.cjs', 'tests/types/**/*.ts'],
+    },
+    {
+        // Overwriting this for now because web-e will conflict with this
+        files: ['**/*.js', '**/*.jsx'],
+        settings: {
+            'import/resolver': {
+                node: {
+                    extensions: ['.js', '.website.js', '.desktop.js', '.native.js', '.ios.js', '.android.js', '.config.js', '.ts', '.tsx'],
+                },
+            },
+        },
+        rules: {
+            'react/jsx-filename-extension': [1, {extensions: ['.js']}],
+            'rulesdir/no-multiple-onyx-in-file': 'off',
+            'import/extensions': [
+                'error',
+                'ignorePackages',
+                {
+                    js: 'never',
+                    jsx: 'never',
+                    ts: 'never',
+                    tsx: 'never',
+                },
+            ],
+        },
+    },
+    {
+        files: ['**/*.ts', '**/*.tsx'],
+        plugins: {
+            '@typescript-eslint': tsPlugin,
+        },
+        languageOptions: {
+            parser: tsParser,
+            parserOptions: {
+                project: './tsconfig.json',
+            },
+        },
+        settings: {
+            'import/resolver': {
+                typescript: {
+                    alwaysTryTypes: true,
+                    project: './tsconfig.json',
+                },
+            },
+        },
+        rules: {
+            ...tsPlugin.configs.recommended.rules,
+            ...tsPlugin.configs.stylistic.rules,
+            'rulesdir/prefer-underscore-method': 'off',
+            'react/jsx-props-no-spreading': 'off',
+            'react/require-default-props': 'off',
+            'react/jsx-filename-extension': ['error', {extensions: ['.tsx', '.jsx']}],
+            'import/no-unresolved': 'error',
+            'import/consistent-type-specifier-style': ['error', 'prefer-top-level'],
+            'no-use-before-define': 'off',
+            '@typescript-eslint/no-use-before-define': 'off',
+            '@typescript-eslint/no-unused-vars': ['error', {argsIgnorePattern: '^_', caughtErrors: 'none'}],
+            '@typescript-eslint/consistent-type-imports': ['error', {prefer: 'type-imports'}],
+            '@typescript-eslint/consistent-type-exports': ['error', {fixMixedExportsWithInlineTypeSpecifier: false}],
+            '@typescript-eslint/no-non-null-assertion': 'off',
+            '@typescript-eslint/array-type': ['error', {default: 'array-simple'}],
+            '@typescript-eslint/consistent-type-definitions': 'off',
+            '@typescript-eslint/no-empty-object-type': 'off',
+            'rulesdir/no-multiple-onyx-in-file': 'off',
+            'valid-jsdoc': 'off',
+            'rulesdir/prefer-import-module-contents': 'off',
+            'es/no-optional-chaining': 'off',
+            'es/no-nullish-coalescing-operators': 'off',
+            // Disable JSDoc type rules for TypeScript files (TypeScript provides the types)
+            'jsdoc/require-param': 'off',
+            'jsdoc/require-param-type': 'off',
+            'jsdoc/check-param-names': 'off',
+            'jsdoc/check-tag-names': 'off',
+            'jsdoc/check-types': 'off',
+            'no-func-assign': 'off',
+            'no-loop-func': 'off',
+            'no-redeclare': 'off',
+            '@typescript-eslint/no-redeclare': 'error',
+            'import/extensions': [
+                'error',
+                'ignorePackages',
+                {
+                    js: 'never',
+                    jsx: 'never',
+                    ts: 'never',
+                    tsx: 'never',
+                },
+            ],
+            'rulesdir/prefer-onyx-connect-in-libs': 'off',
+        },
+    },
+    {
+        files: ['tests/**/*.{js,jsx,ts,tsx}', 'jestSetup.js', 'lib/**/__mocks__/**/*.{js,ts}'],
+        languageOptions: {
+            globals: {
+                jest: 'readonly',
+                describe: 'readonly',
+                it: 'readonly',
+                test: 'readonly',
+                expect: 'readonly',
+                beforeEach: 'readonly',
+                afterEach: 'readonly',
+                beforeAll: 'readonly',
+                afterAll: 'readonly',
+                fail: 'readonly',
+            },
+        },
+        rules: {
+            '@lwc/lwc/no-async-await': 'off',
+            'no-await-in-loop': 'off',
+            'no-restricted-syntax': ['error', 'ForInStatement', 'LabeledStatement', 'WithStatement'],
+            'import/extensions': 'off',
+            '@typescript-eslint/no-require-imports': 'off',
+            'no-restricted-imports': 'off',
+        },
+    },
+    {
+        files: ['**/*.native.ts', '**/*.native.tsx'],
+        rules: {
+            '@typescript-eslint/no-require-imports': 'off',
+        },
+    },
+    {
+        files: ['lib/storage/providers/MemoryOnlyProvider.ts'],
+        languageOptions: {
+            globals: {
+                jest: 'readonly',
+            },
+        },
+    },
+];

.eslintrc.js

@@ -17,7 +17,7 @@ function addGlobalSettingsChangeListener(listener: (settings: GlobalSettings) =>
 }
 
 function notifyListeners() {
-    listeners.forEach((listener) => listener(globalSettings));
+    for (const listener of listeners) listener(globalSettings);
 }
 
 function setPerformanceMetricsEnabled(enabled: boolean) {

.prettierrc.js .prettierrc.cjs.prettierrc.js renamed to .prettierrc.cjs

@@ -320,7 +320,7 @@ function clear(keysToPreserve: OnyxKey[] = []): Promise<void> {
             // 2. Any keys with a default state (because they need to remain in Onyx as their default, and setting them
             //      to null would cause unknown behavior)
             //   2.1 However, if a default key was explicitly set to null, we need to reset it to the default value
-            allKeys.forEach((key) => {
+            for (const key of allKeys) {
                 const isKeyToPreserve = keysToPreserve.includes(key);
                 const isDefaultKey = key in defaultKeyStates;
 
@@ -354,22 +354,22 @@ function clear(keysToPreserve: OnyxKey[] = []): Promise<void> {
                 }
 
                 if (isKeyToPreserve || isDefaultKey) {
-                    return;
+                    continue;
                 }
 
                 // If it isn't preserved and doesn't have a default, we'll remove it
                 keysToBeClearedFromStorage.push(key);
-            });
+            }
 
             const updatePromises: Array<Promise<void>> = [];
 
             // Notify the subscribers for each key/value group so they can receive the new values
-            Object.entries(keyValuesToResetIndividually).forEach(([key, value]) => {
+            for (const [key, value] of Object.entries(keyValuesToResetIndividually)) {
                 updatePromises.push(OnyxUtils.scheduleSubscriberUpdate(key, value));
-            });
-            Object.entries(keyValuesToResetAsCollection).forEach(([key, value]) => {
+            }
+            for (const [key, value] of Object.entries(keyValuesToResetAsCollection)) {
                 updatePromises.push(OnyxUtils.scheduleNotifyCollectionSubscribers(key, value));
-            });
+            }
 
             const defaultKeyValuePairs = Object.entries(
                 Object.keys(defaultKeyStates)
@@ -382,7 +382,7 @@ function clear(keysToPreserve: OnyxKey[] = []): Promise<void> {
             );
 
             // Remove only the items that we want cleared from storage, and reset others to default
-            keysToBeClearedFromStorage.forEach((key) => cache.drop(key));
+            for (const key of keysToBeClearedFromStorage) cache.drop(key);
             return Storage.removeItems(keysToBeClearedFromStorage)
                 .then(() => connectionManager.refreshSessionID())
                 .then(() => Storage.multiSet(defaultKeyValuePairs))
@@ -404,7 +404,7 @@ function clear(keysToPreserve: OnyxKey[] = []): Promise<void> {
  */
 function update<TKey extends OnyxKey>(data: Array<OnyxUpdate<TKey>>): Promise<void> {
     // First, validate the Onyx object is in the format we expect
-    data.forEach(({onyxMethod, key, value}) => {
+    for (const {onyxMethod, key, value} of data) {
         if (!Object.values(OnyxUtils.METHOD).includes(onyxMethod)) {
             throw new Error(`Invalid onyxMethod ${onyxMethod} in Onyx update.`);
         }
@@ -416,7 +416,7 @@ function update<TKey extends OnyxKey>(data: Array<OnyxUpdate<TKey>>): Promise<vo
         } else if (onyxMethod !== OnyxUtils.METHOD.CLEAR && typeof key !== 'string') {
             throw new Error(`Invalid ${typeof key} key provided in Onyx update. Onyx key must be of type string.`);
         }
-    });
+    }
 
     // The queue of operations within a single `update` call in the format of <item key - list of operations updating the item>.
     // This allows us to batch the operations per item and merge them into one operation in the order they were requested.
@@ -441,7 +441,7 @@ function update<TKey extends OnyxKey>(data: Array<OnyxUpdate<TKey>>): Promise<vo
     const promises: Array<() => Promise<void>> = [];
     let clearPromise: Promise<void> = Promise.resolve();
 
-    data.forEach(({onyxMethod, key, value}) => {
+    for (const {onyxMethod, key, value} of data) {
         const handlers: Record<OnyxMethodMap[keyof OnyxMethodMap], (k: typeof key, v: typeof value) => void> = {
             [OnyxUtils.METHOD.SET]: enqueueSetOperation,
             [OnyxUtils.METHOD.MERGE]: enqueueMergeOperation,
@@ -456,28 +456,30 @@ function update<TKey extends OnyxKey>(data: Array<OnyxUpdate<TKey>>): Promise<vo
                 const collectionKeys = Object.keys(collection);
                 if (OnyxUtils.doAllCollectionItemsBelongToSameParent(key, collectionKeys)) {
                     const mergedCollection: OnyxInputKeyValueMapping = collection;
-                    collectionKeys.forEach((collectionKey) => enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]));
+                    for (const collectionKey of collectionKeys) enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]);
                 }
             },
             [OnyxUtils.METHOD.SET_COLLECTION]: (k, v) => promises.push(() => setCollection(k as TKey, v as OnyxSetCollectionInput<TKey>)),
-            [OnyxUtils.METHOD.MULTI_SET]: (k, v) => Object.entries(v as Partial<OnyxInputKeyValueMapping>).forEach(([entryKey, entryValue]) => enqueueSetOperation(entryKey, entryValue)),
+            [OnyxUtils.METHOD.MULTI_SET]: (k, v) => {
+                for (const [entryKey, entryValue] of Object.entries(v as Partial<OnyxInputKeyValueMapping>)) enqueueSetOperation(entryKey, entryValue);
+            },
             [OnyxUtils.METHOD.CLEAR]: () => {
                 clearPromise = clear();
             },
         };
 
         handlers[onyxMethod](key, value);
-    });
+    }
 
     // Group all the collection-related keys and update each collection in a single `mergeCollection` call.
     // This is needed to prevent multiple `mergeCollection` calls for the same collection and `merge` calls for the individual items of the said collection.
     // This way, we ensure there is no race condition in the queued updates of the same key.
-    OnyxUtils.getCollectionKeys().forEach((collectionKey) => {
+    for (const collectionKey of OnyxUtils.getCollectionKeys()) {
         const collectionItemKeys = Object.keys(updateQueue).filter((key) => OnyxUtils.isKeyMatch(collectionKey, key));
         if (collectionItemKeys.length <= 1) {
             // If there are no items of this collection in the updateQueue, we should skip it.
             // If there is only one item, we should update it individually, therefore retain it in the updateQueue.
-            return;
+            continue;
         }
 
         const batchedCollectionUpdates = collectionItemKeys.reduce(
@@ -521,19 +523,19 @@ function update<TKey extends OnyxKey>(data: Array<OnyxUpdate<TKey>>): Promise<vo
         if (!utils.isEmptyObject(batchedCollectionUpdates.set)) {
             promises.push(() => OnyxUtils.partialSetCollection({collectionKey, collection: batchedCollectionUpdates.set as OnyxSetCollectionInput<OnyxKey>}));
         }
-    });
+    }
 
-    Object.entries(updateQueue).forEach(([key, operations]) => {
+    for (const [key, operations] of Object.entries(updateQueue)) {
         if (operations[0] === null) {
             const batchedChanges = OnyxUtils.mergeChanges(operations).result;
             promises.push(() => set(key, batchedChanges));
-            return;
+            continue;
         }
 
-        operations.forEach((operation) => {
+        for (const operation of operations) {
             promises.push(() => merge(key, operation));
-        });
-    });
+        }
+    }
 
     const snapshotPromises = OnyxUtils.updateSnapshots(data, merge);
 
@@ -578,7 +580,6 @@ const Onyx = {
 
 function applyDecorators() {
     // We are reassigning the functions directly so that internal function calls are also decorated
-    /* eslint-disable rulesdir/prefer-actions-set-data */
     // @ts-expect-error Reassign
     connect = decorateWithMetrics(connect, 'Onyx.connect');
     // @ts-expect-error Reassign
@@ -595,7 +596,6 @@ function applyDecorators() {
     update = decorateWithMetrics(update, 'Onyx.update');
     // @ts-expect-error Reassign
     clear = decorateWithMetrics(clear, 'Onyx.clear');
-    /* eslint-enable rulesdir/prefer-actions-set-data */
 }
 
 export default Onyx;