feat(bot): add initial migration, schemas and business logic

backend/src/bot/context.ts

@@ -1,8 +1,10 @@
 import type { Context } from 'grammy'
 import type { LoggingFlavor } from './plugins/logging'
 import type { TranslationsFlavor } from './plugins/translations'
+import type { DomainFlavor } from './plugins/domain'
 
 export type Ctx =
   & Context
   & LoggingFlavor
+  & DomainFlavor
   & TranslationsFlavor

backend/src/bot/index.ts

@@ -2,19 +2,27 @@ import { Bot } from 'grammy'
 import plugins from './plugins'
 import type { Ctx } from './context'
 import type { Logger } from '~/lib/logging'
+import type { Domain } from '~/domain'
 
 export function createBot({
   logger,
   token,
+  domain,
 }: {
   logger: Logger
   token: string
+  domain: Domain
 }): Bot<Ctx> {
   const bot = new Bot<Ctx>(token)
 
   plugins.logging.install(bot, { logger })
   plugins.floodControl.install(bot)
+  plugins.domain.install(bot, { domain })
   plugins.translations.install(bot)
 
+  bot.command('start', async (ctx) => {
+    ctx.reply(`${ctx.t.Welcome}\n\n${JSON.stringify(ctx.user)}`)
+  })
+
   return bot
 }

backend/src/bot/plugins/domain.ts

@@ -0,0 +1,28 @@
+import type { InstallFn } from '.'
+import type { User } from '~/domain/schemas/user'
+import type { Domain } from '~/domain'
+
+export type DomainOptions = {
+  domain: Domain
+}
+
+export type DomainFlavor = {
+  domain: Domain
+  user?: User
+}
+
+export const install: InstallFn<DomainFlavor, DomainOptions> = (bot, { domain }) => {
+  bot.use(async (ctx, next) => {
+    ctx.domain = domain
+    if (ctx.from) {
+      ctx.user = await domain.upsertUser({
+        telegramId: ctx.from.id,
+        username: ctx.from.username,
+        firstName: ctx.from.first_name,
+        lastName: ctx.from.last_name,
+        notificationPreferences: { classes: [] },
+      })
+    }
+    return next()
+  })
+}

backend/src/bot/plugins/index.ts

@@ -1,7 +1,8 @@
 import type { Bot, Context } from 'grammy'
 import * as logging from './logging'
-import * as translations from './translations'
 import * as floodControl from './flood-control'
+import * as domain from './domain'
+import * as translations from './translations'
 
 // eslint-disable-next-line ts/ban-types
 export type InstallFn<F = {}, O = undefined> =
@@ -11,6 +12,7 @@ export type InstallFn<F = {}, O = undefined> =
 
 export default {
   logging,
-  translations,
   floodControl,
+  domain,
+  translations,
 }

backend/src/domain/index.ts

@@ -0,0 +1,43 @@
+import { User } from './schemas/user'
+import type { Logger } from '~/lib/logging'
+import { type Database, Prisma } from '~/services/database'
+import type { Sport } from '~/services/sport'
+
+export class Domain {
+  private logger: Logger
+  private db: Database
+  private sport: Sport
+
+  constructor(options: {
+    logger: Logger
+    db: Database
+    sport: Sport
+  }) {
+    this.logger = options.logger
+    this.db = options.db
+    this.sport = options.sport
+  }
+
+  public async upsertUser({
+    telegramId,
+    ...data
+  }: Omit<Partial<User> & Pick<User, 'telegramId' | 'firstName' | 'notificationPreferences'>, 'createdAt'>): Promise<User> {
+    const user = await this.db.user.upsert({
+      where: { telegramId },
+      create: { telegramId, ...data },
+      update: { ...data },
+    })
+    return User.parse(user)
+  }
+
+  public async updateUser({
+    telegramId,
+    ...patch
+  }: Partial<User> & Pick<User, 'telegramId'>): Promise<User> {
+    const user = await this.db.user.update({
+      where: { telegramId },
+      data: patch,
+    })
+    return User.parse(user)
+  }
+}

backend/src/domain/schemas/common.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod'
+
+export const Language = z.string().regex(/^[a-z]{2}$/)
+export type Language = z.infer<typeof Language>

backend/src/domain/schemas/index.ts

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

backend/src/domain/schemas/notifications.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod'
+
+export const ClassesNotificationPreferenceSpecificTime = z.object({
+  type: z.literal('specific-time'),
+  daysBefore: z.number().int(),
+  time: z.object({
+    hours: z.number().int(),
+    minutes: z.number().int(),
+  }),
+})
+export type ClassesNotificationPreferenceSpecificTime = z.infer<typeof ClassesNotificationPreferenceSpecificTime>
+
+export const ClassesNotificationPreferenceRelative = z.object({
+  type: z.literal('relative'),
+  minutesBefore: z.number().int(),
+})
+export type ClassesNotificationPreferenceRelative = z.infer<typeof ClassesNotificationPreferenceRelative>
+
+export const ClassesNotificationPreference = z.union([
+  ClassesNotificationPreferenceSpecificTime,
+  ClassesNotificationPreferenceRelative,
+])
+export type ClassesNotificationPreference = z.infer<typeof ClassesNotificationPreference>
+
+export const NotificationPreferences = z.object({
+  classes: z.array(ClassesNotificationPreference),
+})
+export type NotificationPreferences = z.infer<typeof NotificationPreferences>

backend/src/domain/schemas/user.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod'
+import { Language } from './common'
+import { NotificationPreferences } from './notifications'
+
+export const User = z.object({
+  telegramId: z.coerce.number().int(),
+  createdAt: z.date(),
+  username: z.string().nullable(),
+  firstName: z.string(),
+  lastName: z.string().nullable(),
+  language: Language.nullable(),
+  notificationPreferences: NotificationPreferences,
+})
+export type User = z.infer<typeof User>

backend/src/main.ts

@@ -1,6 +1,9 @@
 import { loadConfigFromEnv } from './config'
 import { createLogger } from './lib/logging'
 import { createBot } from './bot'
+import { Domain } from './domain'
+import { createDatabase } from './services/database'
+import { Sport } from './services/sport'
 
 async function main() {
   const config = loadConfigFromEnv()
@@ -13,6 +16,14 @@ async function main() {
   const bot = createBot({
     logger: logger.child({ tag: 'bot' }),
     token: config.bot.token,
+    domain: new Domain({
+      logger: logger.child({ tag: 'domain' }),
+      db: await createDatabase({
+        logger: logger.child({ tag: 'database' }),
+        connectionUrl: config.postgresUrl,
+      }),
+      sport: new Sport(),
+    }),
   })
 
   await bot.start()

backend/src/services/database/migrations/20240310111305_add_user_model/migration.sql

@@ -0,0 +1,12 @@
+-- CreateTable
+CREATE TABLE "User" (
+    "telegramId" BIGINT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "username" TEXT,
+    "firstName" TEXT NOT NULL,
+    "lastName" TEXT,
+    "language" TEXT,
+    "notificationPreferences" JSONB NOT NULL,
+
+    CONSTRAINT "User_pkey" PRIMARY KEY ("telegramId")
+);

backend/src/services/database/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (i.e. Git)
+provider = "postgresql"

backend/src/services/database/schema.prisma

@@ -14,4 +14,10 @@ model User {
   username   String?
   firstName  String
   lastName   String?
+
+  // Interface language user prefers as ISO 639-1 language code
+  // or null if user did not specify it.
+  language String?
+
+  notificationPreferences Json
 }

backend/src/services/sport/index.ts

@@ -0,0 +1,3 @@
+export class Sport {
+
+}