fix: read saved no-ai setting from replica

Use the read replica for the saved no-ai feed flag and cover the TIME ranking path so the v2 resolver behaves consistently across both feed generators.

Made-with: Cursor

Author: nimrodkra

__tests__/feeds.ts

@@ -775,6 +775,54 @@ describe('query feed', () => {
     expect(res.data.feed.edges.length).toEqual(2);
   });
 
+  it('should include no-ai blocked tags and title words for TIME ranking when the saved setting is enabled', async () => {
+    loggedUser = '1';
+    await saveFeedFixtures();
+    await saveFixtures(con, Settings, [
+      {
+        userId: '1',
+        flags: {
+          noAiFeedEnabled: true,
+        },
+      },
+    ]);
+    nock('http://localhost:6002')
+      .post('/config')
+      .reply(200, {
+        user_id: '1',
+        config: {
+          providers: {},
+        },
+      });
+    nock('http://localhost:6000')
+      .post('/feed.json', (body) => {
+        expect(body.blocked_tags).toEqual(
+          expect.arrayContaining(['golang', 'ai', 'openai']),
+        );
+        expect(body.blocked_title_words).toEqual(
+          expect.arrayContaining(['Claude', 'Elon Musk']),
+        );
+        expect(body.feed_config_name).toBe('for_you_by_date');
+
+        return true;
+      })
+      .reply(200, {
+        data: [{ post_id: 'p1' }, { post_id: 'p4' }],
+        cursor: 'b',
+      });
+
+    const res = await client.query(QUERY, {
+      variables: {
+        ...variables,
+        ranking: Ranking.TIME,
+        version: 20,
+      },
+    });
+
+    expect(res.errors).toBeFalsy();
+    expect(res.data.feed.edges.length).toEqual(2);
+  });
+
   describe('youtube content', () => {
     beforeEach(async () => {
       await saveFixtures(con, YouTubePost, videoPostsFixture);

src/schema/feeds.ts

@@ -89,6 +89,7 @@ import { SourceMemberRoles } from '../roles';
 import { ContentPreferenceKeyword } from '../entity/contentPreference/ContentPreferenceKeyword';
 import { briefingPostIdsMaxItems } from '../common/brief';
 import { NO_AI_BLOCKED_TAGS, NO_AI_BLOCKED_WORDS } from '../common/noAiFilter';
+import { queryReadReplica } from '../common/queryReadReplica';
 
 interface GQLTagsCategory {
   id: string;
@@ -1394,9 +1395,11 @@ const wrapGeneratorWithNoAi = (generator: FeedGenerator): FeedGenerator =>
   }));
 
 const isSavedNoAiEnabled = async (ctx: AuthContext): Promise<boolean> => {
-  const settings = await ctx.con.getRepository(Settings).findOneBy({
-    userId: ctx.userId,
-  });
+  const settings = await queryReadReplica(ctx.con, ({ queryRunner }) =>
+    queryRunner.manager.getRepository(Settings).findOneBy({
+      userId: ctx.userId,
+    }),
+  );
 
   return settings?.flags?.noAiFeedEnabled ?? false;
 };
@@ -1601,37 +1604,37 @@ export const resolvers: IResolvers<unknown, BaseContext> = {
       return anonymousFeedResolverV1(source, args, ctx, info);
     },
     feed: async (source, args: ConfiguredFeedArgs, ctx: AuthContext, info) => {
-      if (args.version >= 2 && args.ranking === Ranking.POPULARITY) {
-        const generator = versionToFeedGenerator(args.version);
+      if (args.version >= 2) {
         const shouldApplyNoAi = args.noAi || (await isSavedNoAiEnabled(ctx));
+        const getGeneratorWithNoAi = (generator: FeedGenerator): FeedGenerator =>
+          shouldApplyNoAi ? wrapGeneratorWithNoAi(generator) : generator;
 
-        return feedResolverCursor(
-          source,
-          {
-            ...(args as FeedArgs),
-            generator: shouldApplyNoAi
-              ? wrapGeneratorWithNoAi(generator)
-              : generator,
-          },
-          ctx,
-          info,
-        );
-      }
-      if (args.version >= 2 && args.ranking === Ranking.TIME) {
-        const generator = versionToTimeFeedGenerator(args.version);
-        const shouldApplyNoAi = args.noAi || (await isSavedNoAiEnabled(ctx));
-
-        return feedResolverCursor(
-          source,
-          {
-            ...(args as FeedArgs),
-            generator: shouldApplyNoAi
-              ? wrapGeneratorWithNoAi(generator)
-              : generator,
-          },
-          ctx,
-          info,
-        );
+        if (args.ranking === Ranking.POPULARITY) {
+          return feedResolverCursor(
+            source,
+            {
+              ...(args as FeedArgs),
+              generator: getGeneratorWithNoAi(
+                versionToFeedGenerator(args.version),
+              ),
+            },
+            ctx,
+            info,
+          );
+        }
+        if (args.ranking === Ranking.TIME) {
+          return feedResolverCursor(
+            source,
+            {
+              ...(args as FeedArgs),
+              generator: getGeneratorWithNoAi(
+                versionToTimeFeedGenerator(args.version),
+              ),
+            },
+            ctx,
+            info,
+          );
+        }
       }
       return feedResolverV1(source, args, ctx, info);
     },