* Centralize creator post logic

danthonywalker · danthonywalker · commit 9fa37a03e5be · 2023-10-06T18:08:00.000-05:00
* Change RSS contentId calculation
diff --git a/flyway/sql/V8__Update_RSS_subscriptions.sql b/flyway/sql/V8__Update_RSS_subscriptions.sql
@@ -0,0 +1,7 @@
+-- content_id (creator_post) calculation for RSS feeds was changed
+-- Prevent reposting content by updating subscription's created_at
+update creator_subscription as cs
+set created_at = now()
+from creator as c
+where c.id = cs.creator_id
+  and c.type = 'RSS';
diff --git a/src/commands/rss/post.ts b/src/commands/rss/post.ts
@@ -1,52 +1,32 @@
-import type { Item } from "rss-parser";
-
 import assert from "node:assert";
 
 import { CreatorType, registerPoster } from "../../creators";
-import { byDate } from "../../helpers";
 import * as rss from "./rss.manager";
 
-registerPoster(
-  CreatorType.RSS,
-  // eslint-disable-next-line sonarjs/cognitive-complexity
-  async ({ createdAt, creatorDomainId, lastContentId }) => {
-    const feed = await rss.getFeed(creatorDomainId);
-    const { image, items, title: feedName } = feed;
-
-    // All other properties are optional and cannot be asserted
-    // https://www.rssboard.org/rss-specification
-    assert(feedName !== undefined);
-
-    const { url: avatarURL } = image ?? {};
-    const orderedItems = items.sort(
-      byDate(({ pubDate }: Item) => pubDate, "desc"),
-    );
-
-    const options = [];
-    for (const [index, { link, pubDate, title }] of orderedItems.entries()) {
-      if (title === undefined) break;
-      // Do not post items created before the last posted item
-      if (link === undefined || link === lastContentId) break;
-
-      if (pubDate === undefined) {
-        // If no item has been posted yet then only post the 1st one
-        if (lastContentId === null && index > 0) break;
-      } else {
-        // Do not post items created before the subscription was created
-        const itemDate = new Date(pubDate);
-        if (itemDate < createdAt) break;
-      }
-
-      options.push({
-        avatarURL,
-        contentId: link,
-        title,
-        url: link,
-        username: feedName,
-      });
-    }
-
-    // Reverse options so the oldest items are posted first
-    return options.reverse();
-  },
-);
+registerPoster(CreatorType.RSS, async (creatorDomainId) => {
+  const feed = await rss.getFeed(creatorDomainId);
+  const { image, items, title: feedName } = feed;
+
+  // All other properties are optional and cannot be asserted
+  // https://www.rssboard.org/rss-specification
+  assert(feedName !== undefined);
+
+  const { url: avatarURL } = image ?? {};
+
+  const options = [];
+  for (const { guid, link, pubDate, title } of items) {
+    if (link === undefined || title === undefined) break;
+    const contentId = guid ?? link;
+
+    options.push({
+      avatarURL,
+      contentId,
+      timestamp: pubDate,
+      title,
+      url: link,
+      username: feedName,
+    });
+  }
+
+  return options;
+});
diff --git a/src/commands/youtube/post/index.ts b/src/commands/youtube/post/index.ts
@@ -1,54 +1,38 @@
 import assert from "node:assert";
 
 import { CreatorType, registerPoster } from "../../../creators";
-import { byDate, isNonNullable } from "../../../helpers";
+import { isNonNullable } from "../../../helpers";
 import { getThumbnailUrl, getVideoUrl } from "../../../services/youtube";
 import * as youtube from "../youtube.manager";
 import UI from "./ui";
 
-registerPoster(
-  CreatorType.YouTube,
-  async ({ createdAt, creatorDomainId, lastContentId }) => {
-    const { contentDetails, snippet } =
-      await youtube.getChannel(creatorDomainId);
-
-    const { relatedPlaylists } = contentDetails ?? {};
-    const { uploads } = relatedPlaylists ?? {};
-    assert(uploads !== undefined);
-
-    const { thumbnails, title: channelName } = snippet ?? {};
-    assert(isNonNullable(channelName));
-
-    const videos = await youtube.getVideos(uploads);
-    const orderedVideos = videos.sort(
-      byDate(({ publishedAt }) => publishedAt, "desc"),
-    );
-
-    const options = [];
-    for (const video of orderedVideos) {
-      const { publishedAt, resourceId, title } = video;
-      assert(isNonNullable(title));
-
-      // Do not post videos created before the subscription was created
-      assert(isNonNullable(publishedAt));
-      const videoDate = new Date(publishedAt);
-      if (videoDate < createdAt) break;
-      // Do not post videos created before the last posted video
-      const { videoId } = resourceId ?? {};
-      assert(isNonNullable(videoId));
-      if (videoId === lastContentId) break;
-
-      options.push({
-        avatarURL: getThumbnailUrl(thumbnails),
-        components: UI.viewDescription(videoId),
-        contentId: videoId,
-        title,
-        url: getVideoUrl(videoId),
-        username: channelName,
-      });
-    }
-
-    // Reverse options so the oldest videos are posted first
-    return options.reverse();
-  },
-);
+registerPoster(CreatorType.YouTube, async (creatorDomainId) => {
+  const { contentDetails, snippet } = await youtube.getChannel(creatorDomainId);
+  const { thumbnails, title: channelName } = snippet ?? {};
+  assert(isNonNullable(channelName));
+
+  const { relatedPlaylists } = contentDetails ?? {};
+  const { uploads } = relatedPlaylists ?? {};
+  assert(uploads !== undefined);
+  const videos = await youtube.getVideos(uploads);
+
+  const options = [];
+  for (const video of videos) {
+    const { publishedAt, resourceId, title } = video;
+    assert(isNonNullable(title));
+    const { videoId } = resourceId ?? {};
+    assert(isNonNullable(videoId));
+
+    options.push({
+      avatarURL: getThumbnailUrl(thumbnails),
+      components: UI.viewDescription(videoId),
+      contentId: videoId,
+      timestamp: publishedAt,
+      title,
+      url: getVideoUrl(videoId),
+      username: channelName,
+    });
+  }
+
+  return options;
+});
diff --git a/src/creators/post/database.ts b/src/creators/post/database.ts
@@ -1,5 +1,3 @@
-import type { BaseMessageOptions } from "discord.js";
-
 import type { CreatorType } from "../constants";
 
 import { caller } from "../../helpers";
@@ -27,16 +25,7 @@ export type CreatorPost = {
   id: string;
 };
 
-export type Option = {
-  avatarURL?: string;
-  components?: BaseMessageOptions["components"];
-  contentId: string;
-  title: string;
-  url: string;
-  username: string;
-};
-
-type ContentIdRow = {
+type ContentId = {
   contentId: string;
 };
 // endregion
@@ -110,11 +99,11 @@ export const createCreatorPosts = (creatorPosts: CreatorPost[]) =>
     return client.query(query, values);
   });
 
-export const getInvalidContentIds = (
+export const getPostedContentIds = (
   { creatorChannelId, creatorDomainId, creatorType }: CreatorSubscription,
   contentIds: string[],
 ) =>
-  useClient(caller(module, getInvalidContentIds), async (client) => {
+  useClient(caller(module, getPostedContentIds), async (client) => {
     const query = `
       select cp.content_id as "contentId"
       from creator_post as cp
@@ -129,6 +118,6 @@ export const getInvalidContentIds = (
     `;
 
     const values = [creatorChannelId, creatorDomainId, creatorType, contentIds];
-    const { rows } = await client.query<ContentIdRow>(query, values);
+    const { rows } = await client.query<ContentId>(query, values);
     return rows.map(({ contentId }) => contentId);
   });
diff --git a/src/creators/post/index.ts b/src/creators/post/index.ts
@@ -1,4 +1,4 @@
-import type { APIMessage } from "discord.js";
+import type { APIMessage, BaseMessageOptions } from "discord.js";
 
 import { CronJob } from "cron";
 import {
@@ -11,16 +11,27 @@ import {
 import assert from "node:assert";
 import loggerFactory from "pino";
 
+import type { Nullable } from "../../helpers";
 import type { CreatorType } from "../constants";
-import type { CreatorSubscription, Option } from "./database";
+import type { CreatorSubscription } from "./database";
 
-import { isUnique } from "../../helpers";
+import { byDate, isNullable, isUnique } from "../../helpers";
 import discord from "../../services/discord";
 import * as creatorsDatabase from "../database";
 import * as postDatabase from "./database";
 
 // region Types
-type Poster = (creatorSubscription: CreatorSubscription) => Promise<Option[]>;
+export type Option = {
+  avatarURL?: string;
+  components?: BaseMessageOptions["components"];
+  contentId: string;
+  timestamp: Date | Nullable | number | string;
+  title: string;
+  url: string;
+  username: string;
+};
+
+type Poster = (creatorDomainId: string) => Promise<Option[]>;
 // endregion
 
 const logger = loggerFactory({
@@ -45,18 +56,52 @@ const getChannel = async ({
 };
 
 const getOptions = async (creatorSubscription: CreatorSubscription) => {
-  const poster = posters.get(creatorSubscription.creatorType);
+  const { createdAt, creatorDomainId, creatorType, lastContentId } =
+    creatorSubscription;
+
+  const poster = posters.get(creatorType);
   assert(poster !== undefined);
 
   try {
-    const options = await poster(creatorSubscription);
-    const contentIds = options.map(({ contentId }) => contentId);
-    const invalidContentIds =
-      // prettier-ignore
-      await postDatabase.getInvalidContentIds(creatorSubscription, contentIds);
+    const options = await poster(creatorDomainId);
+    // Iterate options from latest to oldest
+    const orderedOptions = options.sort(
+      byDate(({ timestamp }) => timestamp, "desc"),
+    );
+
+    const optionsToPost = [];
+    for (const [index, option] of orderedOptions.entries()) {
+      const { contentId, timestamp } = option;
+
+      // Do not post options created before the last posted option
+      if (contentId === lastContentId) break;
 
-    return options.filter(
-      ({ contentId }) => !invalidContentIds.includes(contentId),
+      if (isNullable(timestamp)) {
+        // Only post latest option if none has been previously posted
+        if (lastContentId === null && index > 0) break;
+      } else {
+        // Do not post options created before the subscription
+        const timestampDate = new Date(timestamp);
+        if (timestampDate < createdAt) break;
+      }
+
+      optionsToPost.push(option);
+    }
+
+    // If no options will be posted skip checking for posted content
+    if (optionsToPost.length === 0) return optionsToPost;
+
+    const contentIds = optionsToPost.map(({ contentId }) => contentId);
+    const postedContentIds =
+      // prettier-ignore
+      await postDatabase.getPostedContentIds(creatorSubscription, contentIds);
+
+    return (
+      optionsToPost
+        // Do not post options previously posted (handles some edge cases)
+        .filter(({ contentId }) => !postedContentIds.includes(contentId))
+        // Post options from oldest to latest
+        .reverse()
     );
   } catch (error) {
     const childLogger = logger.child({ creatorSubscription });
