hotfix: date type (#3527)

Author: rebelchris

__tests__/posts.ts

@@ -10874,3 +10874,97 @@ describe('mutate poll vote', () => {
     );
   });
 });
+
+describe('query userPostsWithAnalytics', () => {
+  const QUERY = /* GraphQL */ `
+    query UserPostsWithAnalytics($first: Int, $after: String) {
+      userPostsWithAnalytics(first: $first, after: $after) {
+        edges {
+          node {
+            id
+            title
+            analytics {
+              id
+              impressions
+              reputation
+              upvotes
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  `;
+
+  beforeEach(async () => {
+    await saveFixtures(
+      con,
+      User,
+      usersFixture.map((item) => ({
+        ...item,
+        id: `${item.id}-upwa`,
+      })),
+    );
+
+    await saveFixtures(
+      con,
+      Post,
+      postsFixture.slice(0, 3).map((item) => ({
+        ...item,
+        id: `${item.id}-upwa`,
+        shortId: `${item.shortId}-upwa`,
+        url: `https://example.com/posts/${item.id}-upwa`,
+        canonicalUrl: `https://example.com/posts/${item.id}-upwa`,
+        yggdrasilId: randomUUID(),
+        authorId: '1-upwa',
+      })),
+    );
+
+    await saveFixtures(
+      con,
+      PostAnalytics,
+      postsFixture.slice(0, 3).map((item) =>
+        con.getRepository(PostAnalytics).create({
+          id: `${item.id}-upwa`,
+          impressions: 100,
+          impressionsAds: 50,
+          reputation: 25,
+          upvotes: 10,
+        }),
+      ),
+    );
+  });
+
+  it('should require authentication', async () => {
+    await testQueryErrorCode(client, { query: QUERY }, 'UNAUTHENTICATED');
+  });
+
+  it('should return paginated posts with analytics for the user', async () => {
+    loggedUser = '1-upwa';
+
+    const res = await client.query(QUERY, { variables: { first: 10 } });
+
+    expect(res.errors).toBeFalsy();
+    expect(res.data.userPostsWithAnalytics.edges).toHaveLength(3);
+    expect(res.data.userPostsWithAnalytics.edges[0].node).toMatchObject({
+      id: expect.stringContaining('-upwa'),
+      analytics: {
+        impressions: 150,
+        reputation: 25,
+        upvotes: 10,
+      },
+    });
+  });
+
+  it('should return empty for user with no posts', async () => {
+    loggedUser = '2-upwa';
+
+    const res = await client.query(QUERY, { variables: { first: 10 } });
+
+    expect(res.errors).toBeFalsy();
+    expect(res.data.userPostsWithAnalytics.edges).toHaveLength(0);
+  });
+});

__tests__/users.ts

@@ -7,6 +7,7 @@ import {
   addHours,
   addSeconds,
   addYears,
+  format,
   startOfDay,
   startOfISOWeek,
   subDays,
@@ -59,6 +60,7 @@ import {
 } from '../src/entity';
 import { UserProfileAnalytics } from '../src/entity/user/UserProfileAnalytics';
 import { UserProfileAnalyticsHistory } from '../src/entity/user/UserProfileAnalyticsHistory';
+import { PostAnalyticsHistory } from '../src/entity/posts/PostAnalyticsHistory';
 import { sourcesFixture } from './fixture/source';
 import {
   CioTransactionalMessageTemplateId,
@@ -7963,3 +7965,87 @@ describe('query userProfileAnalyticsHistory', () => {
     expect(res.data.userProfileAnalyticsHistory.edges).toHaveLength(0);
   });
 });
+
+describe('query userPostsAnalytics', () => {
+  const QUERY = /* GraphQL */ `
+    query UserPostsAnalytics {
+      userPostsAnalytics {
+        id
+        impressions
+        upvotes
+        comments
+      }
+    }
+  `;
+
+  it('should require authentication', async () => {
+    await testQueryErrorCode(client, { query: QUERY }, 'UNAUTHENTICATED');
+  });
+
+  it('should return null when no analytics exist', async () => {
+    loggedUser = '1';
+
+    const res = await client.query(QUERY);
+
+    expect(res.errors).toBeFalsy();
+    expect(res.data.userPostsAnalytics).toBeNull();
+  });
+});
+
+describe('query userPostsAnalyticsHistory', () => {
+  const QUERY = /* GraphQL */ `
+    query UserPostsAnalyticsHistory {
+      userPostsAnalyticsHistory {
+        date
+        impressions
+        impressionsAds
+      }
+    }
+  `;
+
+  beforeEach(async () => {
+    await saveFixtures(con, Post, [
+      {
+        id: 'p1-upah',
+        shortId: 'sp1-upah',
+        title: 'Test Post',
+        url: 'https://example.com/p1-upah',
+        sourceId: 'a',
+        authorId: '1',
+      },
+    ]);
+
+    await con.getRepository(PostAnalyticsHistory).save([
+      {
+        id: 'p1-upah',
+        date: format(new Date(), 'yyyy-MM-dd'),
+        impressions: 100,
+        impressionsAds: 50,
+      },
+      {
+        id: 'p1-upah',
+        date: format(subDays(new Date(), 1), 'yyyy-MM-dd'),
+        impressions: 80,
+        impressionsAds: 40,
+      },
+    ]);
+  });
+
+  it('should require authentication', async () => {
+    await testQueryErrorCode(client, { query: QUERY }, 'UNAUTHENTICATED');
+  });
+
+  it('should return aggregated daily impressions history', async () => {
+    loggedUser = '1';
+
+    const res = await client.query(QUERY);
+
+    expect(res.errors).toBeFalsy();
+    expect(res.data.userPostsAnalyticsHistory).toHaveLength(2);
+    expect(res.data.userPostsAnalyticsHistory[0]).toMatchObject({
+      date: expect.any(String),
+      impressions: 150,
+      impressionsAds: 50,
+    });
+  });
+});

src/graphorm/index.ts

@@ -819,31 +819,6 @@ const obj = new GraphORM({
           childColumn: 'postId',
         },
       },
-      isBoosted: {
-        select: (ctx, alias, qb) => {
-          const subQuery = qb
-            .subQuery()
-            .select('1')
-            .from('campaign_post', 'cp')
-            .where(`cp."postId" = "${alias}".id`)
-            .andWhere('cp.state = :activeCampaignState')
-            .getQuery();
-          qb.setParameter('activeCampaignState', 1); // CampaignState.Active
-          return `EXISTS${subQuery}`;
-        },
-        transform: (value: boolean, ctx, parent) => {
-          const post = parent as Post;
-          const isAuthor = post?.authorId && ctx.userId === post.authorId;
-          const isScout = post?.scoutId && ctx.userId === post.scoutId;
-
-          // Only show boost status to author/scout
-          if (isAuthor || isScout) {
-            return value;
-          }
-
-          return null;
-        },
-      },
       analytics: {
         relation: {
           isMany: false,
@@ -1702,6 +1677,11 @@ const obj = new GraphORM({
           `;
         },
       },
+      reputation: {
+        transform: (value) => {
+          return Math.max(0, value);
+        },
+      },
     },
   },
   UserProfileAnalytics: {

src/schema/posts.ts

@@ -818,11 +818,6 @@ export const typeDefs = /* GraphQL */ `
     """
     numPollVotes: Int
 
-    """
-    Whether the post is currently being boosted (only visible to author/scout)
-    """
-    isBoosted: Boolean
-
     """
     Post analytics
     """
@@ -1054,6 +1049,8 @@ export const typeDefs = /* GraphQL */ `
   type PostAnalyticsPublic {
     id: ID!
     impressions: Int!
+    reputation: Int!
+    upvotes: Int!
   }
 
   type PostAnalyticsHistory {
@@ -1280,6 +1277,20 @@ export const typeDefs = /* GraphQL */ `
       """
       id: ID!
     ): PostAnalyticsHistoryConnection! @auth
+
+    """
+    Get paginated list of posts authored by the authenticated user with analytics
+    """
+    userPostsWithAnalytics(
+      """
+      Paginate after opaque cursor
+      """
+      after: String
+      """
+      Paginate first
+      """
+      first: Int
+    ): PostConnection! @auth
   }
 
   extend type Mutation {
@@ -2390,6 +2401,33 @@ export const resolvers: IResolvers<unknown, BaseContext> = traceResolvers<
         },
       );
     },
+    userPostsWithAnalytics: async (
+      _,
+      args: ConnectionArguments,
+      ctx: AuthContext,
+      info,
+    ): Promise<ConnectionRelay<GQLPost>> => {
+      return queryPaginatedByDate(
+        ctx,
+        info,
+        args,
+        { key: 'createdAt' },
+        {
+          queryBuilder: (builder) => {
+            builder.queryBuilder = builder.queryBuilder
+              .andWhere(`${builder.alias}.authorId = :userId`, {
+                userId: ctx.userId,
+              })
+              .andWhere(`${builder.alias}.deleted = false`)
+              .andWhere(`${builder.alias}.visible = true`);
+
+            return builder;
+          },
+          orderByKey: 'DESC',
+          readReplica: true,
+        },
+      );
+    },
   },
   Mutation: {
     createSourcePostModeration: async (