16 implement workflow activities

package.json

@@ -30,14 +30,19 @@
   "packageManager": "pnpm@10.11.0",
   "dependencies": {
     "@aws-sdk/client-s3": "^3.758.0",
+    "@discordjs/rest": "^2.5.0",
+    "@discordjs/ws": "^2.0.2",
     "@temporalio/activity": "^1.11.7",
     "@temporalio/client": "^1.11.7",
+    "@temporalio/common": "^1.11.8",
     "@temporalio/worker": "^1.11.7",
     "@temporalio/workflow": "^1.11.7",
-    "@togethercrew.dev/db": "^3.3.0",
+    "@togethercrew.dev/db": "^3.10.0",
     "@togethercrew.dev/tc-messagebroker": "^0.0.51",
     "axios": "^1.8.3",
     "bottleneck": "^2.19.5",
+    "discord-api-types": "^0.38.8",
+    "discord.js": "^14.19.3",
     "dotenv": "^16.4.7",
     "grammy": "^1.35.0",
     "https-proxy-agent": "^7.0.6",

src/activities/discord/gateway/channelSelection.activity.ts

@@ -0,0 +1,37 @@
+import { Snowflake } from 'discord.js';
+
+import { PlatformNames, platformRepository } from '@togethercrew.dev/db';
+
+import parentLogger from '../../../config/logger.config';
+
+const logger = parentLogger.child({
+  activity: 'discord:event:channel-selection',
+});
+
+export async function isChannelSelected(
+  guildId: string,
+  channelId: Snowflake,
+): Promise<boolean> {
+  try {
+    const platform = await platformRepository.findOne({
+      name: PlatformNames.Discord,
+      'metadata.id': guildId,
+    });
+
+    const selected: Snowflake[] | undefined =
+      platform?.metadata?.selectedChannels;
+    const isSelected = !selected?.length || selected.includes(channelId);
+
+    logger.debug(
+      { guildId, channelId, selected },
+      isSelected ? 'channel accepted' : 'channel skipped',
+    );
+    return isSelected;
+  } catch (err) {
+    logger.error(
+      { err, guildId, channelId },
+      'channel-filter error, defaulting to true',
+    );
+    return true;
+  }
+}

src/activities/discord/gateway/ignoreUser.activity.ts

@@ -0,0 +1,21 @@
+import { Snowflake } from 'discord.js';
+
+import parentLogger from '../../../config/logger.config';
+import { GUILD_IGNORED_USERS } from '../../../shared/constants/discordGateway.constant';
+
+const logger = parentLogger.child({
+  activity: 'discord:event:ignore-user',
+});
+
+function getIgnoredUsersForGuild(guildId: string): Snowflake[] {
+  return GUILD_IGNORED_USERS[guildId] || [];
+}
+
+export async function isUserIgnored(
+  guildId: string,
+  userId: Snowflake,
+): Promise<boolean> {
+  const ignored = getIgnoredUsersForGuild(guildId).includes(userId);
+  if (ignored) logger.debug({ guildId, userId }, 'user ignored');
+  return ignored;
+}

src/activities/discord/gateway/index.ts

@@ -0,0 +1,4 @@
+export * from './channelSelection.activity';
+export * from './ignoreUser.activity';
+export * from './mapping.activity';
+export * from './persistence.activity';

src/activities/discord/gateway/mapping.activity.ts

@@ -0,0 +1,174 @@
+import {
+  GatewayChannelCreateDispatchData,
+  GatewayChannelDeleteDispatchData,
+  GatewayChannelUpdateDispatchData,
+  GatewayGuildMemberAddDispatchData,
+  GatewayGuildMemberRemoveDispatchData,
+  GatewayGuildMemberUpdateDispatchData,
+  GatewayGuildRoleCreateDispatchData,
+  GatewayGuildRoleDeleteDispatchData,
+  GatewayGuildRoleUpdateDispatchData,
+  GatewayMessageCreateDispatchData,
+  GatewayMessageDeleteBulkDispatchData,
+  GatewayMessageDeleteDispatchData,
+  GatewayMessageReactionAddDispatchData,
+  GatewayMessageReactionRemoveAllDispatchData,
+  GatewayMessageReactionRemoveDispatchData,
+  GatewayMessageReactionRemoveEmojiDispatchData,
+  GatewayMessageUpdateDispatchData,
+} from 'discord-api-types/v10';
+
+import { IRawInfo } from '@togethercrew.dev/db';
+
+import parentLogger from '../../../config/logger.config';
+import {
+  ChannelMappers,
+  GuildMemberMappers,
+  MessageMappers,
+  RoleMappers,
+} from '../../../workflows/discord/gateway/mappers';
+
+const logger = parentLogger.child({ activity: 'discord:event:map' });
+
+export async function mapChannelCreate(
+  payload: GatewayChannelCreateDispatchData,
+) {
+  return ChannelMappers.add(payload);
+}
+
+export async function mapChannelUpdate(
+  payload: GatewayChannelUpdateDispatchData,
+) {
+  return ChannelMappers.update(payload);
+}
+
+export async function mapChannelDelete(
+  payload: GatewayChannelDeleteDispatchData,
+) {
+  return ChannelMappers.remove(payload);
+}
+
+export async function mapGuildMemberCreate(
+  payload: GatewayGuildMemberAddDispatchData,
+) {
+  return GuildMemberMappers.add(payload);
+}
+
+export async function mapGuildMemberUpdate(
+  payload: GatewayGuildMemberUpdateDispatchData,
+) {
+  return GuildMemberMappers.update(payload);
+}
+
+export async function mapGuildMemberDelete(
+  payload: GatewayGuildMemberRemoveDispatchData,
+) {
+  return GuildMemberMappers.remove(payload);
+}
+
+export async function mapRoleCreate(
+  payload: GatewayGuildRoleCreateDispatchData,
+) {
+  return RoleMappers.add(payload);
+}
+
+export async function mapRoleUpdate(
+  payload: GatewayGuildRoleUpdateDispatchData,
+) {
+  return RoleMappers.update(payload);
+}
+
+export async function mapRoleDelete(
+  payload: GatewayGuildRoleDeleteDispatchData,
+) {
+  return RoleMappers.remove(payload);
+}
+
+// Message mapping activities
+export async function mapMessageCreate(
+  payload: GatewayMessageCreateDispatchData,
+) {
+  logger.debug({ messageId: payload.id }, 'Mapping message create event');
+  return MessageMappers.create(payload);
+}
+
+export async function mapMessageUpdate(
+  payload: GatewayMessageUpdateDispatchData,
+) {
+  logger.debug({ messageId: payload.id }, 'Mapping message update event');
+  return MessageMappers.update(payload);
+}
+
+export async function mapMessageDelete(
+  payload: GatewayMessageDeleteDispatchData,
+) {
+  logger.debug({ messageId: payload.id }, 'Mapping message delete event');
+  // Return the message ID for deletion - no mapping needed
+  return payload.id;
+}
+
+export async function mapMessageDeleteBulk(
+  payload: GatewayMessageDeleteBulkDispatchData,
+) {
+  logger.debug(
+    { messageIds: payload.ids },
+    'Mapping bulk message delete event',
+  );
+  // Return the message IDs for bulk deletion - no mapping needed
+  return payload.ids;
+}
+
+export async function mapMessageReactionAdd(
+  payload: GatewayMessageReactionAddDispatchData,
+  existingRawInfo?: IRawInfo,
+) {
+  logger.debug(
+    {
+      messageId: payload.message_id,
+      emoji: payload.emoji.name || payload.emoji.id,
+      userId: payload.user_id,
+    },
+    'Mapping reaction add event',
+  );
+  return MessageMappers.reactionAdd(payload, existingRawInfo);
+}
+
+export async function mapMessageReactionRemove(
+  payload: GatewayMessageReactionRemoveDispatchData,
+  existingRawInfo: IRawInfo,
+) {
+  logger.debug(
+    {
+      messageId: payload.message_id,
+      emoji: payload.emoji.name || payload.emoji.id,
+      userId: payload.user_id,
+    },
+    'Mapping reaction remove event',
+  );
+  return MessageMappers.reactionRemove(payload, existingRawInfo);
+}
+
+export async function mapMessageReactionRemoveAll(
+  payload: GatewayMessageReactionRemoveAllDispatchData,
+  existingRawInfo: IRawInfo,
+) {
+  logger.debug(
+    { messageId: payload.message_id },
+    'Mapping reaction remove all event',
+  );
+  return MessageMappers.reactionRemoveAll(payload, existingRawInfo);
+}
+
+export async function mapMessageReactionRemoveEmoji(
+  payload: GatewayMessageReactionRemoveEmojiDispatchData,
+  existingRawInfo: IRawInfo,
+) {
+  logger.debug(
+    {
+      messageId: payload.message_id,
+      emoji: payload.emoji.name || payload.emoji.id,
+    },
+    'Mapping reaction remove emoji event',
+  );
+  return MessageMappers.reactionRemoveEmoji(payload, existingRawInfo);
+}