Expanding Functionality

Ideal Final State

As previously mentioned, we want to implement a virtual currency system with a balance, daily, and gamble system. For this we will leverage DynamoDB, AWS’ fully managed NoSQL database service.

Amazon DynamoDB

Amazon DynamoDB is a fully managed, serverless, key-value NoSQL database that runs high-performance applications at any scale, with built-in security, continuous backups, and automated multi-region replication.

aws.amazon.com

Functionality wise we want the ability to:

Create or get a user
Get a user’s balance
Set a user’s balance
Gamble with a user’s balance
Daily reward for a user

Table Structure

We will have a users table with the following attributes:

User ID
Guild ID
Balance
Last Daily Claim

We will use the User ID as the partition key and Guild ID as the sort key.

Definition (What are Partition and Sort Keys?)

In DynamoDB, a partition key determines where your data is physically stored and distributed across servers, while a sort key allows you to store multiple items with the same partition key in sorted order.

When you combine them into a composite primary key—like using User ID as the partition key and Guild ID as the sort key—both values become required for every item, and together they must be unique. This design is perfect for one-to-many relationships like ours where all guilds for a specific user are stored together on the same partition, sorted by Guild ID, which makes queries like “get all guilds for this user” incredibly fast and efficient. You can retrieve a specific user-guild combination by providing both keys, or query all guilds for a user by providing just the partition key.

Adding Table to SST

The beauty about NoSQL databases is that they are schema-less, which means you can change the setup at any point. This is in contrast to traditional SQL databases, which require you to define a schema upfront. For us this means all we need to define is the partition key and the sort key, everything else is just added on demand!

We will also need to link the users table to lambda function so that the function can have permissions to the table (which SST will handle for us).

1
/// <reference path="./.sst/platform/config.d.ts" />
2

3
export default $config({
4
  app(input) {
5
    return {
6
      name: "serverless-bot",
7
      removal: input?.stage === "production" ? "retain" : "remove",
8
      protect: ["production"].includes(input?.stage),
9
      home: "aws",
10
    };
11
  },
12
  async run() {
13
    const botToken = new sst.Secret("DiscordBotToken");
14
    const appId = new sst.Secret("DiscordAppId");
15
    const publicKey = new sst.Secret("DiscordPublicKey");
16

17
    const usersTable = new sst.aws.Dynamo("Users", {
18
      fields: {
19
        userId: "string",
20
        guildId: "string",
21
      },
22
      primaryIndex: {
23
        hashKey: "userId",
24
        rangeKey: "guildId",
25
      },
26
    });
27

28
    new sst.aws.Function("DiscordInteractionHandler", {
29
      handler: "lambdas/interaction.handler",
30
      url: true,
31
      link: [usersTable],
32
      environment: {
33
        DISCORD_TOKEN: botToken.value,
34
        DISCORD_APP_ID: appId.value,
35
        DISCORD_PUBLIC_KEY: publicKey.value,
36
      },
37
    });
38
  },
39
});

As always, just go ahead and npx sst deploy to deploy your changes!

New Balance Command

Let’s get rolling with a new balance command, but we will need a couple packages and some setup. In this case we will use the @aws-sdk/client-dynamodb package to interact with DynamoDB. We’ll also use date-fns to handle date and time operations more reliably.

npm install @aws-sdk/client-dynamodb date-fns

Dynamo Utilities

We will also want some DynamoDB utilities to just make our lives easier.

1
import {
2
  DynamoDBClient,
3
  PutItemCommand,
4
  QueryCommand,
5
} from "@aws-sdk/client-dynamodb";
6
import { Resource } from "sst";
7

8
const client = new DynamoDBClient();
9
const usersTableName = Resource.Users.name;
10

11
export async function getUser(userId, guildId) {
12
  const command = new QueryCommand({
13
    TableName: usersTableName,
14
    KeyConditionExpression: "userId = :userId AND guildId = :guildId",
15
    ExpressionAttributeValues: {
16
      ":userId": { S: userId },
17
      ":guildId": { S: guildId },
18
    },
19
  });
20

21
  const { Items } = await client.send(command);
22

23
  return Items?.[0] ?? null;
24
}
25

26
export async function createUser(user, guildId) {
27
  const putCommand = new PutItemCommand({
28
    TableName: usersTableName,
29
    Item: {
30
      userId: { S: user.id },
31
      guildId: { S: guildId },
32
      // Default starting balance
33
      balance: { N: '1000' },
34
      lastDaily: { N: "0" },
35
    },
36
  });
37

38
  await client.send(putCommand);
39
}
40

41
export async function getOrCreateUser(user, guildId) {
42
  const dbUser = await getUser(user.id, guildId);
43

44
  if (dbUser) {
45
    return dbUser;
46
  }
47

48
  await createUser(user, guildId);
49
  return await getUser(user.id, guildId);
50
}
51

52
export async function updateUser(user, update) {
53
  const command = new PutItemCommand({
54
    TableName: usersTableName,
55
    Item: {
56
      ...user,
57
      ...update,
58
    },
59
  });
60

61
  await client.send(command);
62
}

The New Command

We will now create a new command that will display the user’s balance using our handy DynamoDB utilities.

1
import type { CommandConfig, CommandInteraction } from "dressed";
2
import { getOrCreateUser } from "../../utilities/dynamodb";
3

4
export const config = {
5
  description: "Balance",
6
  integration_type: "Guild",
7
  contexts: ["Guild"],
8
  guilds: ["YOUR_GUILD_ID"],
9
} satisfies CommandConfig;
10

11
export default async function(interaction: CommandInteraction) {
12
  const user = await getOrCreateUser(interaction.user, interaction.guild!.id);
13
  const balance = user.balance?.N ?? 0;
14

15
  return interaction.reply(`Your current balance is $${balance}`);
16
}

Deploying the New Command

Now that we’re using DynamoDB, we need to use the npm scripts we set up in Part 2. The sst shell wrapper ensures that linked resources like our DynamoDB table are available during the build process.

Deploy your changes:

npm run deploy

npm run register

At this point, you should be able to use your fancy new /balance command in your Discord server.

Balance

Exploring the DynamoDB Table

You should be able to go directly to the DynamoDB Console and you should see a new table for your project. If you click into it and explore the items you should also see your new user entry.

DynamoDB Table

Daily Command

We have all the scaffolding we need to do a daily command. However we have a couple specific requirements for a daily, mainly the user can only claim a daily every 24 hours, for this we will leverage date-fns to handle the date logic.

1
import { differenceInHours, getTime, subHours } from "date-fns";
2
import type { CommandConfig, CommandInteraction } from "dressed";
3
import { getOrCreateUser, updateUser } from "../../utilities/dynamodb";
4

5
export const config = {
6
  description: "Daily",
7
  integration_type: "Guild",
8
  contexts: ["Guild"],
9
  guilds: ["YOUR_GUILD_ID"],
10
} satisfies CommandConfig;
11

12
export default async function(interaction: CommandInteraction) {
13
  const user = await getOrCreateUser(interaction.user, interaction.guild!.id);
14
  const dailyAmount = 100;
15
  const now = Date.now();
16
  const lastDaily = getTime(
17
    Number(user?.lastDaily?.N) < 1
18
      ? subHours(new Date(), 25)
19
      : Number(user?.lastDaily?.N)
20
  );
21

22
  if (differenceInHours(now, lastDaily) < 24) {
23
    const hoursRemaining = Math.ceil(24 - differenceInHours(now, lastDaily));
24
    return interaction.reply(`You can claim your daily in ${hoursRemaining} hours`);
25
  }
26

27
  const newBalance = Number.parseInt(user?.balance?.N ?? "0", 10) + dailyAmount;
28

29
  await updateUser(user, {
30
    lastDaily: { N: now.toString() },
31
    balance: { N: newBalance.toString() },
32
  });
33

34
  return interaction.reply(
35
    `You claimed your daily and received $100, you now have $${newBalance}`
36
  );
37
}

You’ll see us taking full advantage of our utilities here as we get the user, check their last daily, and if they can claim their daily, we update their balance and last daily timestamp.

Now just:

npm run register && npm run deploy

And you’ll have your daily up and running!

Daily

High Risk, High Reward. Our Gamble Command

Next up, a gamble command! Again, we’ll use the same utilities we’ve been using so far. We’ll also take advantage of Dressed’s built in options to allow people to place custom bets.

First, install the Discord API types package we’ll need:

npm install discord-api-types

Now create the gamble command:

1
import { MessageFlags } from "discord-api-types/v10";
2
import {
3
  ActionRow,
4
  Button,
5
  type CommandConfig,
6
  type CommandInteraction,
7
  CommandOption,
8
  TextDisplay,
9
} from "dressed";
10
import { getOrCreateUser, updateUser } from "../../utilities/dynamodb";
11

12
export const config = {
13
  description: "Gamble",
14
  integration_type: "Guild",
15
  contexts: ["Guild"],
16
  guilds: ["YOUR_GUILD_ID"],
17
  options: [
18
    CommandOption({
19
      name: "bet",
20
      description: "Amount to gamble",
21
      type: "Integer",
22
      required: false,
23
    }),
24
  ],
25
} satisfies CommandConfig;
26

27
export default async function(interaction: CommandInteraction) {
28
  const user = await getOrCreateUser(interaction.user, interaction.guild!.id);
29
  // 100 is our minimum bet
30
  const bet = interaction.getOption("bet")?.integer() ?? 100;
31
  const balance = Number.parseInt(user?.balance?.N ?? "0", 10);
32

33
  if (bet < 100) {
34
    return interaction.reply({
35
      content: `You must bet at least $100.`,
36
      ephemeral: true,
37
    });
38
  }
39

40
  if (bet > balance) {
41
    return interaction.reply({
42
      content: `You don't have enough to gamble! You need at least $${
43
        bet - balance
44
      }.`,
45
      ephemeral: true,
46
    });
47
  }
48

49
  const result = Math.random() > 0.75 ? bet * 3 : -bet;
50
  const newBalance = balance + result;
51
  await updateUser(user, { balance: { N: newBalance.toString() } });
52

53
  return interaction.reply({
54
    components: [
55
      TextDisplay(
56
        `You gambled $${bet} and ${result > 0 ? "won" : "lost"} $${Math.abs(
57
          result
58
        )}. You now have $${newBalance}`
59
      )
60
    ],
61
    flags: MessageFlags.IsComponentsV2,
62
  });
63
}

Easy Re-Gamble

We can also add a button that allows us to re-gamble without having to type the command again.

1
return interaction.reply({
2
  components: [
3
    TextDisplay(
4
      `You gambled $${bet} and ${result > 0 ? 'won' : 'lost'} $${Math.abs(result)}. You now have $${newBalance}`,
5
    ),
6
    ActionRow(
7
      Button({
8
        label: `Gamble Again ($${bet})`,
9
        custom_id: `gamble-again-${bet}`,
10
      }),
11
    ),
12
  ],
13
  flags: MessageFlags.IsComponentsV2,
14
})

To make this work…we need a new component to handle the button click.

1
import {
2
  ActionRow,
3
  Button,
4
  type MessageComponentInteraction,
5
  TextDisplay,
6
} from "dressed";
7
import { getOrCreateUser, updateUser } from "../../../utilities/dynamodb";
8

9
export const pattern = `gamble-again-:amount(\\d+)`;
10

11
export default async function(
12
  interaction: MessageComponentInteraction,
13
  args: { amount: number }
14
) {
15
  const user = await getOrCreateUser(interaction.user, interaction.guild!.id);
16
  const amountToGamble = args.amount ?? 100;
17
  const balance = Number.parseInt(user?.balance?.N ?? "0", 10);
18

19
  if (amountToGamble > balance) {
20
    return interaction.update({
21
      components: [
22
        TextDisplay(
23
          `You don't have enough to gamble! You need at least $${
24
            amountToGamble - balance
25
          } more.`
26
        ),
27
      ],
28
    });
29
  }
30

31
  const result = Math.random() > 0.75 ? amountToGamble * 3 : -amountToGamble;
32
  const newBalance = balance + result;
33

34
  await updateUser(user, { balance: { N: newBalance.toString() } });
35

36
  return interaction.update({
37
    components: [
38
      TextDisplay(
39
        `You gambled $${amountToGamble} and ${
40
          result > 0 ? "won" : "lost"
41
        } $${Math.abs(result)}. You now have $${newBalance}`
42
      ),
43
      ActionRow(
44
        Button({
45
          label: `Gamble Again ($${amountToGamble})`,
46
          custom_id: `gamble-again-${amountToGamble}`,
47
        })
48
      ),
49
    ],
50
  });
51
}

Now we have the ability to keep on gambling!

Gamble Again Button

Wrapping Up

Now you’ve got a fully functional, no cost, serverless Discord bot that requires no server to run. You can leverage any of the AWS services to continue iterating and expanding the functionality of your bot.

What’s Next?

Here are some ideas to expand your bot:

More Commands

Leaderboards using DynamoDB queries
Trading between users
Daily streaks with bonus rewards
More gamble commands such as blackjack, slots, and more

Resources

If you’ve gotten this far, thank you! I appreciate all you’ve gone through and would appreciate a share on social media!