Trigger everytime a new item post on reddit matches at least one mention

import { fetchPosts } from "https://deno.land/x/redditposts/src/mod.ts";

import * as wmill from "https://deno.land/x/[email protected]/mod.ts";

export async function main(

  amountOfPosts: string,

  subreddit: string,

  mentions: string[],

) {

  let lastState = await wmill.getInternalState();

  const posts = await fetchPosts(`${subreddit}`, {

    amount: `${amountOfPosts}`,

    category: "top",

  });

  const items = [];

  for (let item in posts) {

    if (

      mentions.find((mention) => posts[item]["title"]?.includes(mention)) ||

      mentions.find((mention) => posts[item]["selftext"]?.includes(mention))

    ) {

      items.push(posts[item]["title"]);

    }

  }

  await wmill.setInternalState(items);

  let currentState = await wmill.getInternalState();

  let missingVals = currentState.filter(item => lastState.indexOf(item) < 0);

  const subset = missingVals.every(val => lastState.includes(val));

  if (lastState && !arrayEquals(currentState, lastState) && !subset) {

    return { items: items };

  }

  return "No new mentions on reddit.";

}

function arrayEquals(a, b) {

  return Array.isArray(a) &&

    Array.isArray(b) &&

    a.length === b.length &&

    a.every((val, index) => val === b[index]);

}

import {

  getState,

  setState,

} from "https://deno.land/x/[email protected]/mod.ts";

/**

 * @returns A list of posts that mentioned given phrases in ascending order

 * of date of publication.

 *

 * @param mentions Case **insensitive** phrases that should be searched for.

 */

export async function main(

  subreddit: string,

  mentions: string[],

  max_number_of_posts: number = 100,

) {

  mentions = mentions?.map((m) => m.trim().toLowerCase())?.filter(Boolean);

  if (!mentions?.length) {

    throw Error("\nAt least one mentioned phrase is needed to search for.");

  }

  const url = new URL(`https://www.reddit.com/r/${subreddit}/new.json`);

  if (max_number_of_posts < 1) {

    max_number_of_posts = 1;

  }

  const limit = max_number_of_posts < 100 ? max_number_of_posts : 100;

  const processedPosts: Post[] = [];

  let runLoop = true;

  do {

    const lastPostId = await getState();

    url.searchParams.append("limit", limit.toString());

    lastPostId && url.searchParams.append("before", lastPostId);

    const result = await fetch(url);

    if (!result.ok) {

      throw Error("\n" + (await result.text()));

    }

    const data = (await result.json()).data;

    const posts: Post[] = data.children.map(

      ({ data: { name, title, selftext, url } }: { data: Post }) => {

        return { name, title, selftext, url };

      },

    );

    if (!posts.length) {

      return processedPosts;

    } else if (posts.length < limit) {

      runLoop = false;

    }

    await setState(posts[0].name);

    const temp: Post[] = [];

    for (let i = 0; i < posts.length; i++) {

      const post = posts[i];

      const mention =

        mentions.find((mention) =>

          post.title.toLowerCase().includes(mention),

        ) ||

        mentions.find((mention) =>

          post.selftext.toLowerCase().includes(mention),

        );

      mention && temp.push(post);

      if (processedPosts.length + temp.length >= max_number_of_posts) {

        break;

      }

    }

    processedPosts.push(...temp.reverse());

    if (processedPosts.length >= max_number_of_posts) {

      runLoop = false;

    }

  } while (runLoop);

  return processedPosts;

}

interface Post {

  name: string;

  title: string;

  selftext: string;

  url: string;

}