migrations/004_guild_settings.sql

@@ -1,16 +0,0 @@
--- Create Discord guild settings table for storing Discord guild configuration
-CREATE TABLE IF NOT EXISTS discord.guild_settings (
-    guild_id Numeric NOT NULL, -- Discord guild ID
-    key TEXT NOT NULL,
-    value JSONB NOT NULL DEFAULT '{}',
-    PRIMARY KEY (guild_id, key)
-);
-
--- Create index for faster lookups by guild_id
-CREATE INDEX idx_discord_guild_settings_guild_id ON discord.guild_settings(guild_id);
-
--- Add comments for documentation
-COMMENT ON TABLE discord.guild_settings IS 'Stores Discord guild-specific configuration settings as key-value pairs with JSONB values';
-COMMENT ON COLUMN discord.guild_settings.guild_id IS 'Discord guild ID';
-COMMENT ON COLUMN discord.guild_settings.key IS 'Setting key/name';
-COMMENT ON COLUMN discord.guild_settings.value IS 'Setting value stored as JSONB for flexibility';

ts/package.json

@@ -49,7 +49,7 @@
     "pino": "^9.6.0",
     "pino-logfmt": "^0.1.1",
     "pino-pretty": "^13.0.0",
-    "postgres": "^3.4.7",
+    "postgres": "^3.4.5",
     "superjson": "^2.2.2",
     "ts-markdown-builder": "^0.4.0",
     "why-is-node-running": "^3.2.2",

ts/src/activities/discord.ts

@@ -1,35 +1,27 @@
-import { type InteractionCallbackData, type InteractionCallbackOptions, MessageFlags } from 'discordeno'
+import { type InteractionCallbackData, type InteractionCallbackOptions, InteractionResponseTypes, InteractionTypes, MessageFlags } from 'discordeno'
 import { c } from '#/di'
 import type { InteractionRef } from '#/discord'
-import { InteractionResponseTypes } from '@discordeno/types'
 import { Bot } from '#/discord/bot'
 
 // from https://github.com/discordeno/discordeno/blob/21.0.0/packages/bot/src/transformers/interaction.ts#L33
 export const reply_to_interaction = async (props: {
   ref: InteractionRef
-  type: InteractionResponseTypes
-  options?: InteractionCallbackOptions & { isPrivate?: boolean; content?: string }
+  type: number
+  options: InteractionCallbackOptions & { isPrivate?: boolean; content?: string }
 }) => {
   const bot = await c.getAsync(Bot)
 
   const { ref, type, options } = props
 
-  const data: InteractionCallbackData = options || {}
+  const data: InteractionCallbackData = options
 
   if (options?.isPrivate) {
     data.flags = MessageFlags.Ephemeral
   }
 
-  switch (type) {
-    case InteractionResponseTypes.UpdateMessage:
-      if(ref.acknowledged) {
-        return await bot.helpers.editOriginalInteractionResponse(ref.token, data)
-      }
-    default:
-      if (ref.acknowledged) {
-        const followUp = await bot.helpers.sendFollowupMessage(ref.token, data)
-        return followUp
-      }
-      return await bot.helpers.sendInteractionResponse(ref.id, ref.token, { type, data }, { withResponse: options?.withResponse })
+  if (ref.acknowledged) {
+    return await bot.helpers.sendFollowupMessage(ref.token, data)
   }
+
+  return await bot.helpers.sendInteractionResponse(ref.id, ref.token, { type, data }, { withResponse: options?.withResponse })
 }

ts/src/activities/discord_guild_settings.ts

@@ -1,61 +0,0 @@
-import { c } from '#/di'
-import { PG } from '#/services/pg'
-import { DiscordGuildSettingsService, DiscordGuildSettingKey, DiscordGuildSettingValue } from '#/services/guild_settings'
-import { logger } from '#/logger'
-
-export interface SetDiscordGuildSettingParams<K extends DiscordGuildSettingKey> {
-  guildId: bigint
-  key: K
-  value: DiscordGuildSettingValue<K>
-}
-
-export async function set_discord_guild_setting<K extends DiscordGuildSettingKey>(
-  params: SetDiscordGuildSettingParams<K>
-): Promise<void> {
-  const settingsService = await c.getAsync(DiscordGuildSettingsService)
-
-  await settingsService.setSetting(params.guildId, params.key, params.value)
-
-  logger.info({
-    guildId: params.guildId,
-    key: params.key,
-  }, 'discord guild setting updated')
-}
-
-export async function get_discord_guild_setting<K extends DiscordGuildSettingKey>(
-  guildId: bigint,
-  key: K
-): Promise<DiscordGuildSettingValue<K> | null> {
-  const settingsService = await c.getAsync(DiscordGuildSettingsService)
-
-  return await settingsService.getSetting(guildId, key)
-}
-
-export async function delete_discord_guild_setting(
-  guildId: bigint,
-  key: DiscordGuildSettingKey
-): Promise<boolean> {
-  const settingsService = await c.getAsync(DiscordGuildSettingsService)
-
-  return await settingsService.deleteSetting(guildId, key)
-}
-
-export async function get_wynn_guild_info(guildNameOrTag: string): Promise<{ uid: string; name: string; prefix: string } | null> {
-  const { sql } = await c.getAsync(PG)
-
-  // Try to find by name or prefix (case-insensitive)
-  const result = await sql<{ uid: string; name: string; prefix: string }[]>`
-    SELECT uid, name, prefix
-    FROM wynn.guild_info
-    WHERE LOWER(name) = LOWER(${guildNameOrTag})
-       OR LOWER(prefix) = LOWER(${guildNameOrTag})
-    LIMIT 1
-  `
-
-  if (result.length === 0) {
-    return null
-  }
-
-  return result[0]
-}
-

ts/src/activities/index.ts

@@ -4,7 +4,6 @@
 
 export * from './database'
 export * from './discord'
-export * from './discord_guild_settings'
 export * from './guild'
 export * from './guild_messages'
 export * from './leaderboards'

ts/src/activities/players.ts

@@ -6,36 +6,58 @@ import { WApi } from '#/lib/wynn/wapi'
 import { PG } from '#/services/pg'
 
 const playerSchemaFail = type({
-  path: 'string',
-  errorMessage: 'string',
+  code: 'string',
+  message: 'string',
+  data: type({
+    player: {
+      meta: {
+        cached_at: 'number',
+      },
+      username: 'string',
+      id: 'string',
+      raw_id: 'string',
+      avatar: 'string',
+      skin_texture: 'string',
+      properties: [
+        {
+          name: 'string',
+          value: 'string',
+          signature: 'string',
+        },
+      ],
+      name_history: 'unknown[]',
+    },
+  }),
+  success: 'false',
 })
 const playerSchemaSuccess = type({
-  id: 'string',
-  name: 'string',
+  code: 'string',
+  message: 'string',
+  data: type({
+    player: {
+      meta: {
+        cached_at: 'number',
+      },
+      username: 'string',
+      id: 'string',
+      raw_id: 'string',
+      avatar: 'string',
+      skin_texture: 'string',
+      properties: [
+        {
+          name: 'string',
+          value: 'string',
+          signature: 'string',
+        },
+      ],
+      name_history: 'unknown[]',
+    },
+  }),
+  success: 'true',
 })
 
 const playerSchema = playerSchemaFail.or(playerSchemaSuccess)
 
-
-const getUUIDForUsername = async (username: string) => {
-  const resp = await axios.get(`https://api.mojang.com/users/profiles/minecraft/${username}`, {
-    validateStatus: function (status) {
-      return status < 500;
-    },
-  })
-  if (resp.headers['content-type'] !== 'application/json') {
-    throw new Error('invalid content type')
-  }
-  log.info('response data', {data: resp.data})
-  const parsed = playerSchema.assert(resp.data)
-  if('errorMessage' in parsed) {
-    throw new Error(`error message: ${parsed.errorMessage}`)
-  }
-  const pid = parsed.id
-  // TODO: the pid is a uuid with no hyphens. add the hyphens back in.
-  return pid
-}
-
 export const scrape_online_players = async () => {
   const api = await c.getAsync(WApi)
   const raw = await api.get('/v3/player')
@@ -55,7 +77,19 @@ export const scrape_online_players = async () => {
     if (ans.length === 0) {
       // the user doesn't exist, so we need to grab their uuid
       try {
-        const uuid = await getUUIDForUsername(playerName)
+        const resp = await axios.get(`https://playerdb.co/api/player/minecraft/${playerName}`, {
+          headers: {
+            'User-Agent': 'lil-robot-guy (a@tuxpa.in)',
+          },
+        })
+        const parsedPlayer = playerSchema.assert(resp.data)
+        if (!parsedPlayer.success) {
+          log.warn(`failed to get uuid for ${playerName}`, {
+            payload: parsedPlayer,
+          })
+          continue
+        }
+        const uuid = parsedPlayer.data.player.id
         // insert the user.
         await sql`insert into minecraft.user (name, uid, server) values (${playerName}, ${uuid},${server})
           on conflict (uid) do update set

ts/src/cmd/bot.ts

@@ -6,9 +6,8 @@ import { config } from '#/config'
 import { DISCORD_GUILD_ID } from '#/constants'
 import { c } from '#/di'
 import { Bot } from '#/discord/bot'
-import { events } from '#/discord/handler'
-import { SLASH_COMMANDS } from '#/discord/slash_commands'
-import { logger } from '#/logger'
+import { events } from '#/discord/botevent/handler'
+import { SLASH_COMMANDS } from '#/discord/botevent/slash_commands'
 
 export class BotCommand extends Command {
   static paths = [['bot']]
@@ -18,12 +17,12 @@ export class BotCommand extends Command {
     }
     const bot = await c.getAsync(Bot)
     bot.events = events()
-    logger.info('registering slash commands')
-    await bot.rest.upsertGuildApplicationCommands(DISCORD_GUILD_ID, SLASH_COMMANDS).catch((err) => logger.error(err, 'failed to register slash commands for main guild'))
-    await bot.rest.upsertGuildApplicationCommands('547828454972850196', SLASH_COMMANDS).catch((err) => logger.error(err, 'failed to register slash commands for secondary guild'))
+    console.log('registring slash commands')
+    await bot.rest.upsertGuildApplicationCommands(DISCORD_GUILD_ID, SLASH_COMMANDS).catch(console.error)
+    await bot.rest.upsertGuildApplicationCommands('547828454972850196', SLASH_COMMANDS).catch(console.error)
 
-    logger.info('connecting bot to gateway')
+    console.log('connecting bot to gateway')
     await bot.start()
-    logger.info('bot connected')
+    console.log('bot connected')
   }
 }

ts/src/cmd/worker.ts

@@ -6,13 +6,12 @@ import { c } from '#/di'
 import '#/services/temporal'
 import path from 'node:path'
 import { Client, ScheduleNotFoundError, type ScheduleOptions, ScheduleOverlapPolicy } from '@temporalio/client'
-import { NativeConnection, Worker, Runtime } from '@temporalio/worker'
+import { NativeConnection, Worker } from '@temporalio/worker'
 import { PG } from '#/services/pg'
 import { workflowSyncAllGuilds, workflowSyncGuildLeaderboardInfo, workflowSyncGuilds, workflowSyncOnline } from '#/workflows'
 import * as activities from '../activities'
 
 import { config } from '#/config'
-import { logger } from '#/logger'
 
 const schedules: ScheduleOptions[] = [
   {
@@ -94,11 +93,10 @@ const addSchedules = async (c: Client) => {
     const handle = c.schedule.getHandle(o.scheduleId)
     try {
       const desc = await handle.describe()
-      logger.info({ scheduleId: o.scheduleId, description: desc }, 'schedule already exists')
+      console.log(desc)
     } catch (e: any) {
       if (e instanceof ScheduleNotFoundError) {
         await c.schedule.create(o)
-        logger.info({ scheduleId: o.scheduleId }, 'created schedule')
       } else {
         throw e
       }
@@ -109,38 +107,15 @@ const addSchedules = async (c: Client) => {
 export class WorkerCommand extends Command {
   static paths = [['worker']]
   async execute() {
-    logger.info('starting worker')
-
-    // Install pino logger for Temporal
-    Runtime.install({
-      logger: {
-        log: (level, message, attrs) => {
-          const pinoLevel = level.toLowerCase()
-          if (pinoLevel in logger) {
-            (logger as any)[pinoLevel](attrs, message)
-          } else {
-            logger.info(attrs, message)
-          }
-        },
-        info: (message, attrs) => logger.info(attrs, message),
-        warn: (message, attrs) => logger.warn(attrs, message),
-        error: (message, attrs) => logger.error(attrs, message),
-        debug: (message, attrs) => logger.debug(attrs, message),
-        trace: (message, attrs) => logger.trace(attrs, message),
-      },
-    })
-
     const { db } = await c.getAsync(PG)
 
     const client = await c.getAsync(Client)
     // schedules
-    logger.info('configuring schedules')
     await addSchedules(client)
 
     const connection = await NativeConnection.connect({
       address: config.TEMPORAL_HOSTPORT,
     })
-    logger.info({ address: config.TEMPORAL_HOSTPORT }, 'connected to temporal')
     const worker = await Worker.create({
       connection,
       namespace: config.TEMPORAL_NAMESPACE,
@@ -163,10 +138,9 @@ export class WorkerCommand extends Command {
       stickyQueueScheduleToStartTimeout: 5 * 1000,
       activities,
     })
-    logger.info({ taskQueue: 'wynn-worker-ts', namespace: config.TEMPORAL_NAMESPACE }, 'starting temporal worker')
     await worker.run()
 
-    logger.info('worker.run exited')
+    console.log('worked.run exited')
     await db.end()
     await connection.close()
   }

ts/src/discord/bot.ts

@@ -2,27 +2,12 @@ import { InjectionToken } from '@needle-di/core'
 import { createBot } from 'discordeno'
 import { config } from '#/config'
 import { c } from '#/di'
-import { logger } from '#/logger'
-import { type BotType, desiredProperties, intents } from './index'
+import { type BotType, createBotParameters } from './index'
 
 const createBotWithToken = (token: string) => {
   return createBot({
-    intents: intents.reduce((acc, curr) => acc | curr, 1 as any),
-    desiredProperties,
+    ...createBotParameters,
     token,
-    loggerFactory: (name: 'REST' | 'GATEWAY' | 'BOT') => {
-      // Create a child logger with the component name
-      const childLogger = logger.child({ component: `discordeno-${name.toLowerCase()}` })
-
-      // Return logger object with required methods
-      return {
-        debug: (message: string, ...args: any[]) => childLogger.debug({ args }, message),
-        info: (message: string, ...args: any[]) => childLogger.info({ args }, message),
-        warn: (message: string, ...args: any[]) => childLogger.warn({ args }, message),
-        error: (message: string, ...args: any[]) => childLogger.error({ args }, message),
-        fatal: (message: string, ...args: any[]) => childLogger.fatal({ args }, message),
-      }
-    },
   })
 }
 export const Bot = new InjectionToken<BotType>('DISCORD_BOT')

ts/src/discord/botevent/handler.ts

@@ -31,8 +31,6 @@ export const events = () => {
               token: interaction.token,
               type: interaction.type,
               acknowledged: interaction.acknowledged,
-              guildId: interaction.guildId,
-              channelId: interaction.channel.id || interaction.channelId,
             },
             data,
           },
@@ -61,5 +59,5 @@ export const events = () => {
         ],
       })
     },
-  } as const satisfies BotType['events']
+  } as BotType['events']
 }

ts/src/discord/botevent/slash_commands.ts

@@ -33,14 +33,6 @@ export const SLASH_COMMANDS = [
         name: 'set_wynn_guild',
         description: 'set the default wynncraft guild for the server',
         type: ApplicationCommandOptionTypes.SubCommand,
-        options: [
-          {
-            name: 'guild',
-            description: 'the wynncraft guild',
-            type: ApplicationCommandOptionTypes.String,
-            required: true,
-          },
-        ],
       },
     ],
   },

ts/src/discord/botevent/types.ts

@@ -0,0 +1,11 @@
+import type { BotType } from '#/discord'
+
+export type BotEventsType = BotType['events']
+export type InteractionHandler = NonNullable<BotType['events']['interactionCreate']>
+export type InteractionType = Parameters<InteractionHandler>[0]
+
+export type MuxHandler<T> = (interaction: InteractionType, params?: T) => Promise<any>
+
+export interface SlashHandler {
+  [key: string]: MuxHandler<any> | SlashHandler
+}

ts/src/discord/index.ts

@@ -1,5 +1,5 @@
 import { Intents, type InteractionTypes } from '@discordeno/types'
-import type { Bot, CompleteDesiredProperties, DesiredPropertiesBehavior, DiscordInteractionContextType, InteractionData, RecursivePartial, TransformersDesiredProperties } from 'discordeno'
+import type { Bot, CompleteDesiredProperties, DesiredPropertiesBehavior, InteractionData } from 'discordeno'
 export const intents = [
   Intents.GuildModeration,
   Intents.GuildWebhooks,
@@ -18,63 +18,42 @@ export const intents = [
   Intents.GuildMessages,
 ] as const
 
-
-export const desiredProperties = {
-  interaction: {
-    id: true,
-    data: true,
-    type: true,
-    token: true,
-    message: true,
-    channelId: true,
-    channel: true,
-    guildId: true,
-    guild: true,
-    user: true,
-    member: true,
-    context: true,
-  },
-  message: {
-    id: true,
-    member: true,
-    guildId: true,
-  },
-} as const satisfies RecursivePartial<TransformersDesiredProperties>
-
-export type DesiredProperties = typeof desiredProperties
-
 export const createBotParameters = {
   intents: intents.reduce((acc, curr) => acc | curr, Intents.Guilds),
-  desiredProperties,
+  desiredProperties: {
+    interaction: {
+      id: true,
+      data: true,
+      type: true,
+      token: true,
+      message: true,
+      channelId: true,
+      channel: true,
+      guildId: true,
+      guild: true,
+      user: true,
+      member: true,
+    },
+    message: {
+      id: true,
+      member: true,
+      guildId: true,
+    },
+  },
 } as const
 
-export type BotType = Bot<CompleteDesiredProperties<DesiredProperties>, DesiredPropertiesBehavior.RemoveKey>
+// Extract the type of desired properties from our parameters
+type ExtractedDesiredProperties = typeof createBotParameters.desiredProperties
+
+// The BotType uses the CompleteDesiredProperties helper to fill in the missing properties
+export type BotType = Bot<CompleteDesiredProperties<ExtractedDesiredProperties>, DesiredPropertiesBehavior.RemoveKey>
 
 // Type for the interaction reference passed to workflows/activities
 export interface InteractionRef {
-  // id of the interaction
   id: bigint
-  /** A continuation token for responding to the interaction */
   token: string
   type: InteractionTypes
   acknowledged?: boolean
-  /** The guild it was sent from */
-  guildId?: bigint;
-  channelId?: bigint;
-  /** Guild member data for the invoking user, including permissions */
-  memberId?: bigint ;
-  /** User object for the invoking user, if invoked in a DM */
-  userId?: bigint;
-  /** For the message the button was attached to */
-  messageId?: bigint;
-
-  // locale of the interaction
-  locale?: string;
-  /** The guild's preferred locale, if invoked in a guild */
-  guildLocale?: string;
-
-  /** Context where the interaction was triggered from */
-  context?: DiscordInteractionContextType;
 }
 
 // Type for the complete interaction handling payload

ts/src/discord/mux/index.ts

@@ -0,0 +1,4 @@
+import { c } from '#/di'
+
+export class EventMux {
+}

ts/src/logger/index.ts

@@ -1,12 +1,10 @@
 import { pino } from 'pino'
 
 export const logger = pino({
-  level: process.env.PINO_LOG_LEVEL || 'info',
-  formatters: {
-    level: (label) => {
-      return { level: label }
-    },
+  transport: {
+    target: 'pino-logfmt',
   },
-  timestamp: pino.stdTimeFunctions.isoTime,
+  level: process.env.PINO_LOG_LEVEL || 'info',
+
   redact: [], // prevent logging of sensitive data
 })

ts/src/services/guild_settings.ts

@@ -1,163 +0,0 @@
-import { type } from 'arktype'
-import { c } from '#/di'
-import { PG } from '#/services/pg'
-import { logger } from '#/logger'
-import { JSONValue } from 'postgres'
-import { snowflake } from '#/utils/types'
-import { inject } from '@needle-di/core'
-
-// Define the guild settings types
-export const DiscordGuildSettingSchema = type({
-  guild_id: 'string', // Discord guild ID
-  key: 'string',
-  value: 'unknown', // JSONB can be any valid JSON
-})
-
-export type DiscordGuildSetting = typeof DiscordGuildSettingSchema.infer
-
-
-// Define setting schemas with arktype
-export const DISCORD_GUILD_SETTING_SCHEMAS = {
-  wynn_guild: type('string.uuid'),
-  rank_roles: type({
-    member: snowflake.optional(),
-    recruiter: snowflake.optional(),
-    captain: snowflake.optional(),
-    strategist: snowflake.optional(),
-    chief: snowflake.optional(),
-    owner: snowflake.optional(),
-  }),
-  features: type({
-    autoRole: 'boolean',
-    warTracking: 'boolean',
-    activityTracking: 'boolean',
-    leaderboard: 'boolean',
-  }),
-} as const
-
-export type DiscordGuildSettingKey = keyof typeof DISCORD_GUILD_SETTING_SCHEMAS
-
-export type DiscordGuildSettingValue<K extends DiscordGuildSettingKey> =
-  typeof DISCORD_GUILD_SETTING_SCHEMAS[K]['infer']
-
-export class DiscordGuildSettingsService {
-  constructor(private readonly pg = inject(PG)) {}
-
-  /**
-   * Get a specific setting for a guild
-   */
-  async getSetting<K extends DiscordGuildSettingKey>(
-    guildId: bigint,
-    key: K
-  ): Promise<DiscordGuildSettingValue<K> | null> {
-    const { sql } = this.pg
-
-    const result = await sql<{ value: unknown }[]>`
-      SELECT value
-      FROM discord.guild_settings
-      WHERE guild_id = ${guildId.toString()} AND key = ${key}
-    `
-
-    if (result.length === 0) return null
-
-    // Validate the value with arktype
-    const schema = DISCORD_GUILD_SETTING_SCHEMAS[key]
-    const parsed = schema(result[0].value)
-
-    if (parsed instanceof type.errors) {
-      logger.error({ guildId, key, errors: parsed.summary }, 'Invalid guild setting value in database')
-      return null
-    }
-
-    return parsed as DiscordGuildSettingValue<K>
-  }
-
-  /**
-   * Get all settings for a guild
-   */
-  async getAllSettings(guildId: bigint): Promise<DiscordGuildSetting[]> {
-    const { sql } = this.pg
-
-    const result = await sql<DiscordGuildSetting[]>`
-      SELECT guild_id, key, value
-      FROM discord.guild_settings
-      WHERE guild_id = ${guildId.toString()}
-      ORDER BY key
-    `
-    return result.map(row => DiscordGuildSettingSchema.assert(row))
-  }
-
-  /**
-   * Set a setting for a guild (upsert)
-   */
-  async setSetting<K extends DiscordGuildSettingKey>(
-    guildId: bigint,
-    key: K,
-    value: DiscordGuildSettingValue<K>
-  ): Promise<void> {
-    const { sql } = this.pg
-
-    // Validate the value with arktype
-    const schema = DISCORD_GUILD_SETTING_SCHEMAS[key]
-    const parsed = schema(value)
-
-    if (parsed instanceof type.errors) {
-      throw new Error(`Invalid value for guild setting ${key}: ${parsed.summary}`)
-    }
-
-    await sql`
-      INSERT INTO discord.guild_settings (guild_id, key, value)
-      VALUES (${guildId.toString()}, ${key}, ${sql.json(parsed as JSONValue)})
-      ON CONFLICT (guild_id, key)
-      DO UPDATE SET
-        value = EXCLUDED.value
-    `
-
-    logger.info({ guildId, key }, 'guild setting updated')
-  }
-
-  /**
-   * Delete a specific setting for a guild
-   */
-  async deleteSetting(guildId: bigint, key: DiscordGuildSettingKey): Promise<boolean> {
-    const { sql } = this.pg
-
-    const result = await sql`
-      DELETE FROM discord.guild_settings
-      WHERE guild_id = ${guildId.toString()} AND key = ${key}
-      RETURNING 1
-    `
-
-    const deleted = result.length > 0
-    if (deleted) {
-      logger.info({ guildId, key }, 'guild setting deleted')
-    }
-
-    return deleted
-  }
-
-  /**
-   * Delete all settings for a guild
-   */
-  async deleteAllSettings(guildId: bigint): Promise<number> {
-    const { sql } = this.pg
-
-    const result = await sql`
-      DELETE FROM discord.guild_settings
-      WHERE guild_id = ${guildId.toString()}
-      RETURNING 1
-    `
-
-    const count = result.length
-    if (count > 0) {
-      logger.info({ guildId, count }, 'guild settings deleted')
-    }
-
-    return count
-  }
-
-
-}
-
-// Register the service with dependency injection
-c.bind(DiscordGuildSettingsService)

ts/src/services/temporal/index.ts

@@ -1,7 +1,6 @@
 import { Client, Connection } from '@temporalio/client'
 import { config } from '#/config'
 import { c } from '#/di'
-import { logger } from '#/logger'
 
 c.bind({
   provide: Client,
@@ -18,7 +17,7 @@ c.bind({
       },
     })
     process.on('exit', () => {
-      logger.info('closing temporal client')
+      console.log('closing temporal client')
       client.connection.close()
     })
     return client

ts/src/utils/types/index.ts

@@ -1 +0,0 @@
-export * from './snowflake'

ts/src/utils/types/snowflake.ts

@@ -1,15 +0,0 @@
-import { type } from 'arktype'
-
-// Custom arktype for Discord snowflake IDs (bigint)
-export const snowflake = type('string|bigint').pipe((value, ctx) => {
-  if (typeof value === 'bigint') return value
-
-  // Parse string as base 10 bigint
-  try {
-    return BigInt(value)
-  } catch {
-    return ctx.error(`Invalid snowflake ID: ${value}`)
-  }
-})
-
-export type Snowflake = bigint

ts/src/workflows/discord.ts

@@ -2,11 +2,10 @@ import { InteractionTypes } from '@discordeno/types'
 import { proxyActivities, startChild, workflowInfo } from '@temporalio/workflow'
 import type * as activities from '#/activities'
 import type { InteractionCreatePayload } from '#/discord'
-import { CommandHandlers, createCommandHandler } from '#/discord/command_parser'
-import { SLASH_COMMANDS } from '#/discord/slash_commands'
+import { CommandHandlers, createCommandHandler } from '#/discord/botevent/command_parser'
+import { SLASH_COMMANDS } from '#/discord/botevent/slash_commands'
 import { handleCommandGuildInfo, handleCommandGuildLeaderboard, handleCommandGuildOnline } from './guild_messages'
 import { handleCommandPlayerLookup } from './player_messages'
-import { handleCommandSetWynnGuild } from './set_wynn_guild'
 
 const { reply_to_interaction } = proxyActivities<typeof activities>({
   startToCloseTimeout: '1 minute',
@@ -74,14 +73,14 @@ const workflowHandleApplicationCommand = async (payload: InteractionCreatePayloa
       },
       admin: {
         set_wynn_guild: async (args) => {
-          const handle = await startChild(handleCommandSetWynnGuild, {
-            workflowId: `${workflowInfo().workflowId}-set-wynn-guild`,
-            args: [{
-              ref,
-              args,
-            }],
+          await reply_to_interaction({
+            ref,
+            type: 4,
+            options: {
+              content: 'Not implemented yet',
+              isPrivate: true,
+            },
           })
-          await handle.result()
         },
       },
     },

ts/src/workflows/guild_messages.ts

@@ -3,28 +3,17 @@ import type * as activities from '#/activities'
 import { WYNN_GUILD_ID } from '#/constants'
 import type { InteractionRef } from '#/discord'
 
-const { formGuildInfoMessage, formGuildOnlineMessage, formGuildLeaderboardMessage, reply_to_interaction, get_discord_guild_setting } = proxyActivities<typeof activities>({
+const { formGuildInfoMessage, formGuildOnlineMessage, formGuildLeaderboardMessage, reply_to_interaction } = proxyActivities<typeof activities>({
   startToCloseTimeout: '30 seconds',
 })
 
 interface CommandPayload {
   ref: InteractionRef
-  discordGuildId?: bigint
 }
 
 export async function handleCommandGuildInfo(payload: CommandPayload): Promise<void> {
-  const { ref, discordGuildId } = payload
-  
-  // Try to get the associated Wynncraft guild for this Discord guild
-  let guildId = WYNN_GUILD_ID // Default fallback
-  if (discordGuildId) {
-    const wynnGuild = await get_discord_guild_setting(discordGuildId, 'wynn_guild')
-    if (wynnGuild?.uid) {
-      guildId = wynnGuild.uid
-    }
-  }
-  
-  const msg = await formGuildInfoMessage(guildId)
+  const { ref } = payload
+  const msg = await formGuildInfoMessage(WYNN_GUILD_ID)
   await reply_to_interaction({
     ref,
     type: 4,
@@ -33,18 +22,8 @@ export async function handleCommandGuildInfo(payload: CommandPayload): Promise<v
 }
 
 export async function handleCommandGuildOnline(payload: CommandPayload): Promise<void> {
-  const { ref, discordGuildId } = payload
-  
-  // Try to get the associated Wynncraft guild for this Discord guild
-  let guildId = WYNN_GUILD_ID // Default fallback
-  if (discordGuildId) {
-    const wynnGuild = await get_discord_guild_setting(discordGuildId, 'wynn_guild')
-    if (wynnGuild?.uid) {
-      guildId = wynnGuild.uid
-    }
-  }
-  
-  const msg = await formGuildOnlineMessage(guildId)
+  const { ref } = payload
+  const msg = await formGuildOnlineMessage(WYNN_GUILD_ID)
   await reply_to_interaction({
     ref,
     type: 4,
@@ -53,18 +32,8 @@ export async function handleCommandGuildOnline(payload: CommandPayload): Promise
 }
 
 export async function handleCommandGuildLeaderboard(payload: CommandPayload): Promise<void> {
-  const { ref, discordGuildId } = payload
-  
-  // Try to get the associated Wynncraft guild for this Discord guild
-  let guildId = WYNN_GUILD_ID // Default fallback
-  if (discordGuildId) {
-    const wynnGuild = await get_discord_guild_setting(discordGuildId, 'wynn_guild')
-    if (wynnGuild?.uid) {
-      guildId = wynnGuild.uid
-    }
-  }
-  
-  const msg = await formGuildLeaderboardMessage(guildId)
+  const { ref } = payload
+  const msg = await formGuildLeaderboardMessage(WYNN_GUILD_ID)
   await reply_to_interaction({
     ref,
     type: 4,

ts/src/workflows/index.ts

@@ -8,4 +8,3 @@ export * from './guilds'
 export * from './items'
 export * from './player_messages'
 export * from './players'
-export * from './set_wynn_guild'

ts/src/workflows/set_wynn_guild.ts

@@ -1,81 +0,0 @@
-import { proxyActivities } from '@temporalio/workflow'
-import type * as activities from '#/activities'
-import type { InteractionRef } from '#/discord'
-import { InteractionResponseTypes } from '@discordeno/types'
-
-const { reply_to_interaction, set_discord_guild_setting, get_wynn_guild_info } = proxyActivities<typeof activities>({
-  startToCloseTimeout: '10 seconds',
-})
-
-export interface SetWynnGuildPayload {
-  ref: InteractionRef
-  args: {
-    guild: string
-  }
-}
-
-export async function handleCommandSetWynnGuild(payload: SetWynnGuildPayload): Promise<void> {
-  const { ref, args } = payload
-
-  // Defer the response since this might take a moment
-  await reply_to_interaction({
-    ref,
-    type: InteractionResponseTypes.DeferredChannelMessageWithSource,
-  })
-  ref.acknowledged = true
-
-
-  if (!ref.guildId) {
-    await reply_to_interaction({
-      ref,
-      type: InteractionResponseTypes.UpdateMessage,
-      options: {
-        content: `❌ Could not find discord guild. Please try again.`,
-        isPrivate: true,
-      },
-    })
-    return
-  }
-
-  try {
-    // Validate the Wynncraft guild exists
-    const guildInfo = await get_wynn_guild_info(args.guild)
-
-    if (!guildInfo) {
-      await reply_to_interaction({
-        ref,
-        type: InteractionResponseTypes.UpdateMessage, // Update the deferred response
-        options: {
-          content: `❌ Could not find Wynncraft guild "${args.guild}". Please check the guild name and try again.`,
-          isPrivate: true,
-        },
-      })
-      return
-    }
-
-    // Set the association in the database using the generic activity
-    await set_discord_guild_setting({
-      guildId: ref.guildId,
-      key: 'wynn_guild',
-      value: guildInfo.uid,
-    })
-
-    await reply_to_interaction({
-      ref,
-      type: InteractionResponseTypes.UpdateMessage, // Update the deferred response
-      options: {
-        content: `✅ Successfully linked this Discord server to Wynncraft guild **[${guildInfo.prefix}] ${guildInfo.name}**`,
-        isPrivate: true,
-      },
-    })
-  } catch (error) {
-    await reply_to_interaction({
-      ref,
-      type: InteractionResponseTypes.UpdateMessage, // Update the deferred response
-      options: {
-        content: `❌ An error occurred while setting the guild: ${error}`,
-        isPrivate: true,
-      },
-    })
-  }
-}

ts/yarn.lock

@@ -1922,7 +1922,7 @@ __metadata:
     pino: "npm:^9.6.0"
     pino-logfmt: "npm:^0.1.1"
     pino-pretty: "npm:^13.0.0"
-    postgres: "npm:^3.4.7"
+    postgres: "npm:^3.4.5"
     rollup: "npm:^4.34.8"
     superjson: "npm:^2.2.2"
     ts-markdown-builder: "npm:^0.4.0"
@@ -4178,10 +4178,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"postgres@npm:^3.4.7":
-  version: 3.4.7
-  resolution: "postgres@npm:3.4.7"
-  checksum: 10c0/b2e61b1064d38e7e1df8291f6d5a7e11f892a3240e00cf2b5e5542bf9abbfe97f3963164aeb56b42c1ab6b8aae3454c57f5bbc1791df0769375542740a7cde72
+"postgres@npm:^3.4.5":
+  version: 3.4.5
+  resolution: "postgres@npm:3.4.5"
+  checksum: 10c0/53415acea77e97bdc1eeb861048f34964e2236e4d4d42f408fc9b901e62bfcf7443a487ebfdad18b57b468c6e297bf8d22097106a200f62eb1262eb5a71355df
   languageName: node
   linkType: hard