В Price Monitor я использую PostgreSQL, реляционную СУБД. Данные в ней хранятся в виде таблиц.

У меня есть таблица для наименований Product, таблицы для товаров каждого магазина GlobusProduct/LentaProduct/..., таблицы для связей товаров и наименований ProductGlobusLink/ProductLentaLink/..., таблица для штрих-кодов ProductEan, материализованные view для актуальных цен GlobusProductLastPrice/LentaProductLastPrice/..., несколько обычных view для удобства (например, ProductWithLinks) и много чего ещё. И из этого зоопарка таблиц нужно уметь доставать нужные данные.

Результатом SELECT-запросов тоже является таблица. Это значит, что результат будет представлен в виде набора столбцов и набора строк, без каких-либо вложенных полей. Но часто хочется уметь вытаскивать одним SQL-запросом какую-нибудь сложную структуру данных (например, всю информацию о товаре и массив изменений цен во времени). На первый взгляд кажется, что это невозможно, но я нашёл интересное решение.

В PostgreSQL есть неплохой набор инструментов для работы с JSON. В ячейках таблицы можно хранить произвольные JSON-структуры, обращаться к вложенным полям с помощью операторов -> и ->> и даже индексировать их. А ещё там есть функция json_agg, которая позволяет преобразовать любую таблицу в json массив объектов.

Например:

 a | b
-------
 1 | 2
 3 | 4

> select json_agg(t) from t;

[{"a": 1, "b": 2}, {"a": 3, "b": 4}]

Если эту функцию использовать в подзапросе, то в результате получается ровно такое поведение, какое мне хотелось. Если нужно достать одиночное значение, то подзапрос будет выглядеть вот так (SELECT json_agg(t) -> 0 FROM (подзапрос) t), если нужен весь массив целиком, то так (SELECT COALESCE(json_agg(t), '[]'::json) as j FROM (подзапрос) t). coalesce нужен, чтобы возвращался пустой массив, если в подзапросе ничего не нашлось.

Теперь плавно перейдём к коду. Весь бэкенд Price Monitor написан на Typescript. Для работы с базой из кода я использую библиотеку kysely. Это небольшой, но мощный query builder со строгой типизацией запросов. Сначала нужно описать схему базы данных в виде типов, а потом можно строить запросы вот в таком виде:

И если допустить ошибку в запросе, она тут же её подсветит:

И, что самое главное, она позволяет выносить куски логики в отдельные функции, не теряя при этом типизации. И не только всякие простые куски кода, чтобы не копипастить их несколько раз, но и целые слои абстракции. Например, я написал утилиты для работы с json, о которых рассказал выше:

Выглядит как магия. Полностью кастомный кусок SQL, который идеально интегрируется в запросы и сохраняет при этом типизацию!

Я использую эти функции во многих местах, но, в частности, в функции для поиска товара:

eans тут достаются в виде массива, а товары из разных магазинов — в виде одиночных объектов. Второе необязательно, но очень упрощает дальнейшую обработку.

Для выборки товаров по условию у меня тоже есть отдельные функции: по id, по ean и по категории (но она не влезла в кадр)

И теперь, чтобы получить товар по id, можно просто написать...

Kysely поддерживает не только вот такие махинации с запросами, но и стриминг результатов, транзакции и много чего ещё. Очень доволен этой библиотекой.

Спасибо, что прочитали! Надеюсь, стало понятнее, как устроен Price Monitor. В следующей части (когда-нибудь) расскажу, как я объединял товары друг с другом.

Недавно я участвовал в соревновании Yandex Cup, где одним из заданий в треке фронтенд-разработки было решить некую задачку полностью в рамках системы типов Typescript. Я очень люблю тайпскрипт в целом и его систему типов в частности, поэтому на это задание я потратил значительную часть всего времени. Что там было — совсем другая история, но именно тогда мне пришла идея написать свой сумматор на типах.

В процессе решения задания я немного поискал в интернете и наткнулся на проект calc-ts, который реализует основные арифметические операции и парсинг выражений. Но у него обнаружился один фатальный недостаток. В силу особенностей реализации, в которые я не буду вдаваться, он перестаёт работать на числах больше нескольких тысяч. Там используется довольно наивный подход "давайте увеличивать одно число на единичку, а второе уменьшать, пока оно не станет равно нулю", и тайпскрипт захлёбывается на таком количестве итераций.

Вместо этого я решил взять за основу десятичную систему и алгоритм сложения столбиком. Что ж, начнём!

Нам нужно реализовать тип, который принимает на вход два числа, а на выход выдаёт ещё одно число — сумму.

Сначала нужно превратить числа в строки, а строки разбить на отдельные цифры. Это, пожалуй, единственный способ удобной работы с числами в TS, ведь никаких арифметических операций в системе типов нет.

type StringToChars<T extends string> = T extends `${infer C}${infer Rest}`
  ? [C, ...StringToChars<Rest>]
  : [];
type NumToChars<T extends number> = StringToChars<`${T}`>;

Для преобразования числа в строку мы используем подстановку в template literal. А вот для разбиения строки на символы пригодится рекурсия и немного infer-магии. Простыми словами можно описать так:

• на каждом шаге мы проверяем, представляет ли строка из себя нечто формата `${первый символ}${всё остальное}` (причём всё остальное может быть пустой строкой)
• если да, то возвращаем первый символ и результат разбиения оставшейся строки (которая возвращает второй символ и результат разбиения оставшейся строки и так далее)
• если нет, то возвращаем пустой массив (это нужно для завершения рекурсии, когда строка пустая)

Теперь из числа 12345 мы можем получить кортеж цифр ["1", "2", "3", "4", "5"]. Дальше вспоминаем алгоритм сложения столбиком: числа нужно записать так, чтобы одинаковые разряды оказались друг над другом. В нашем случае — чтобы одинаковые разряды была на одинаковых позициях в кортеже. Как бы сделать так, чтобы цифра 5 в числе 12345 была на том же месте, что и 8 в 678? Развернуть массив!

Для этого опять используем infer и рекурсию:

type Reverse<T extends any[]> = T extends [infer V, ...infer Rest]
  ? [...Reverse<Rest>, V]
  : [];

Reverse<NumToChars<12345>> даст нам ["5", "4", "3", "2", "1"], а Reverse<NumToChars<678>> — ["8", "7", "6"]. Как видите, разряды действительно совпадают.

Теперь нужно научиться складывать две цифры. Для этого я написал маленький скриптик, который генерирует look-up table:

for (let i = 0; i <= 9; ++i) {
  console.log(`A extends '${i}' ? (`)
  for (let j = 0; j <= 9; ++j) {
    console.log(`B extends '${j}' ? [${i + j >= 10 ? `'${(i+j) % 10}', true`: `'${i+j}', false`}] :`)
  }
  console.log('never) :')
}
console.log('never')

Результат выглядит примерно так:

type AddDigitsCore<A extends string, B extends string> = A extends "0" ? (
    B extends "0" ? ["0", false]
      : B extends "1" ? ["1", false]
      : B extends "2" ? ["2", false]
      // тут ещё 100 строчек…

Тип принимает на вход два символа и на выход отдаёт символ, который нужно записать в ответ, а также нужно ли добавить единичку к следующему разряду.

Как добавлять единичку? Тут мне пришлось написать маленький костыль, потому что переделывать по-нормальному мне было лень.

type AddOne<T extends [string, boolean]> = [
  AddDigitsCore<T[0], "1">[0],
  AddDigitsCore<T[0], "1">[1] extends true ? true : T[1],
];

Тип принимает на вход кортеж из символа и индикатора переполнения и отдаёт такой же кортеж на выход. Символ — это результат прибавления единички к входному символу. А вот для индикатора переполнения написано условие. Если он равен true, то возвращаем true. Иначе возвращаем то, что было передано на вход. Выглядит не очень красиво, но работает, и вот почему:

1. Если на вход передаётся число с переполнением (например 12, то есть ["2", true]), то на выходе переполнение остаётся (получается 13, то есть ["3", true])
2. Переполнения переполнения случиться не может, потому что максимальное число на входе — это 9+9, то есть 18
3. Если на вход передаётся число от 0 до 8, то переполнения не появляется
4. Единственный случай, когда появляется переполнение — когда передаётся 9 (["9", false] => ["0", true])

Теперь напишем тип для сложения двух цифр, но с учётом возможной «единички»:

type AddDigits<
  A extends string,
  B extends string,
  Leftover extends boolean = false,
> = Leftover extends true ? AddOne<AddDigitsCore<A, B>> : AddDigitsCore<A, B>;

Тут всё просто: если Leftover = true, то складываем цифры и добавляем единичку; если нет, то просто складываем цифры.

Дальше напишем ещё несколько типов, которые пригодятся нам позже.
Первый — это тип Shift, который удаляет первый элемент из кортежа.

type Shift<T extends any[]> = ((...v: T) => void) extends
  ((v: any, ...rest: infer V) => void) ? V : [];

Я не очень понимаю, зачем тут используются сигнатуры функций, но без них что-то ломается. В общем, тип «проглатывает» первый элемент, а все остальные возвращает обратно. Если массив и так пустой, то просто возвращает пустой массив.

Второй — это тип FallbackToZero, тут всё очевидно.

type FallbackToZero<T extends string | undefined> = T extends undefined ? "0" : T;

Теперь подумаем о том, как бы нам реализовать алгоритм сложения. Шаги должны быть такие:

1. Сложить два числа в текущем разряде (не забыть про возможную «единичку» сверху)
2. Записать последнюю цифру результата в ответ
3. Запомнить «единичку» (если она есть) для следующего разряда
4. Перейти к следующему разряду

В качестве решения напрашивается рекурсия, её и будем использовать. Получился тип

type AddCore<
  A extends string[],
  B extends string[],
  Leftover extends boolean = false,
> = true extends (
  & (A[0] extends undefined ? true : false)
  & (B[0] extends undefined ? true : false)
) ? Leftover extends true ? "1" : ""
  : `${AddCore<
    Shift<A>,
    Shift<B>,
    AddDigits<
      FallbackToZero<A[0]>,
      FallbackToZero<B[0]>,
      Leftover
    >[1]
  >}${AddDigits<
    FallbackToZero<A[0]>,
    FallbackToZero<B[0]>,
    Leftover
  >[0]}`;

Давайте разбираться, что тут происходит. На вход приходит два числа (в виде массива символов в обратном порядке) и индикатор «единички». Для первого разряда он всегда false, но для следующих итераций пригодится.

AddDigits<
  FallbackToZero<A[0]>,
  FallbackToZero<B[0]>,
  Leftover
>[0]

Тут мы получаем цифру, которая идёт в ответ.

AddCore<
  Shift<A>,
  Shift<B>,
  AddDigits<
    FallbackToZero<A[0]>,
    FallbackToZero<B[0]>,
    Leftover
  >[1]
>

Тут мы запускаем рекурсию для следующего разряда. В Leftover передаётся индикатор переполнения из результата сложения текущего разряда. Из чисел убирается по одной цифре с помощью метода Shift. С каждой итерацией остаётся всё меньше и меньше цифр. Если одно число короче другого, то в один момент у него закончатся цифры, и A[0] (или B[0]) вернёт undefined. Тут пригождается FallbackToZero, который заменяет undefined на "0".

true extends (
  & (A[0] extends undefined ? true : false)
  & (B[0] extends undefined ? true : false)
) ? Leftover extends true ? "1" : ""

Тут мы проверяем, не закончились ли у нас разряды у обоих чисел сразу. Если так, то мы завершаем рекурсию и возвращаем 1, если у нас осталась «единичка», либо пустую строку.

В результате у нас получается сумма чисел в виде строки. Никаких дополнительных манипуляций с ней производить не нужно, она уже записана в правильном порядке (старший разряд слева). Можно было попытаться возвращать результат в виде числа, но я не смог придумать оптимальный способ конвертации символов в число.

Ну и наконец делаем юзер-френдли тип, который принимает на вход два числа, конвертирует их в обратный массив символов и вызывает AddCore

type Add<A extends number, B extends number> = AddCore<
  Reverse<NumToChars<A>>,
  Reverse<NumToChars<B>>
>;

Готово! Потыкать можно в песочнице посмотреть код — на гитхабе.

Подписывайтесь на мой телеграм-канал, ставьте лайки, до связи!

На днях вышло большое обновление для grammY — современной typescript-библиотеки для создания телеграм-ботов.

Главная тема обновления — первый стабильный релиз @grammyjs/conversations. Это библиотека, позволяющая строить сложные диалоговые взаимодействия с пользователем, почти об этом не задумываясь.

Наверное, каждый, кто пробовал писать телеграм-ботов, хотя бы раз думал «как круто было бы, если бы можно было написать "подожди следующего сообщения от пользователя и продолжи функцию"». Так вот, conversations позволяют делать именно так! Например:

async function greeting(conversation: MyConversation, ctx: MyContext) {
  await ctx.reply("Hi there! What is your name?");
  const { message } = await conversation.wait();
  await ctx.reply(`Welcome to the chat, ${message.text}!`);
}

Причём, в отличие от наивных реализаций через промисы, все данные тут хранятся в сессии, и бот получается полностью устойчив к перезагрузкам.

И хотя я всё ещё придерживаюсь классического подхода со сценами (grammy-views), conversations — это интересная новая абстракция, которая (наверное) будет более интуитивно понятна для начинающих разработчиков. Подробнее »

Кроме этого добавили ctx.has — набор методов у контекста, позволяющих выполнять проверки. Раньше это было доступно только со стороны Composer'а. Например:

composer.command('start', (ctx) => ctx.reply(ctx.match.toString()))

Эквивалент этого с помощью ctx.has будет выглядеть примерно так:

composer.use((ctx, next) => {
  if (ctx.hasCommand('start')) {
    return ctx.reply(ctx.match.toString())
  }
  return next()
})

В обычных ситуациях ctx.has пригодится нечасто, но главное его применение — в conversations. Из-за более императивного подхода в них недоступны привычные методы Composer'а, их и заменит ctx.has. Подробнее »

Ещё обновили сессии. Добавили мульти-сессии, позволяющие хранить разные части данных в разных хранилищах; добавили «улучшатель» хранилищ, добавляющий TTL для сессий и инструмент для миграций. Первые два кажутся мне не такими важными, а вот миграции — это правда полезно.

По мере развития бота формат данных в сессии может меняться. При этом у старых пользователей могут оставаться данные в старом формате, с которыми бот может работать неправильно. Раньше с этим приходилось бороться обходными путями: добавлять проверки на отсутствующие поля, мигрировать из одного формата в другой.

Новый плагин упрощает эти действия. Он позволяет создавать функции, которые мигрируют данные из одной версии формата в следующую. При этом плагин сам следит за версией данных у каждого пользователя и запускает миграции при необходимости. Подробнее »

Ну и напоследок — обновили плагин для создания клавиатур. Наконец-то добавили поддержку resize_keyboard, one_time_keyboard и других полей для обычных клавиатур, без них было очень неудобно (хотя я и не пользуюсь обычными клавиатурами). А самое главное, добавили фичу, за которую я топил больше двух месяцев — конструкторы для клавиатур.

Встроенный в grammY плагин для построения клавиатур написан в императивном стиле. Например:

const keyboard = new InlineKeyboard()
  .text('1', 'a').text('2', 'b').row()
  .text('3', 'c')

И это не всегда может быть удобно (например, если нужно создать клавиатуру из динамического массива)

Поэтому я предпочитаю декларативный подход на базе обычных двумерных массивов. Я сделал плагин grammy-markup, который предоставляет функции-помощники для создания кнопок Button и IButton. Но вот незадача: в Keyboard и InlineKeyboard нельзя передать сырые данные о клавиатуре в виде двумерного массива! Было нельзя, до этого обновления. Теперь клавиатуры можно строить так (с помощью плагина grammy-markup):

const keyboard = new InlineKeyboard([
  [IButton.text('1', 'a'), IButton.text('2', 'b')],
  [IButton.text('3', 'c'),
])

Плагин grammy-markup в связи с этим получает версию 1.0! Репо »

Это такой способ хостинга, при котором у разработчика нет контроля за серверами. Вместо этого программа загружается напрямую в serverless платформу, и уже она берет на себя всё остальное.

Получается что-то типа цифрового коммунизма: каждому по потребностям, с каждого по затратам. Программы на Serverless платформах автоматически масштабируются, при резком наплыве запроосов получая дополнительные мощности, а платить приходится только за непосредственно потраченные ресурсы. Кроме того, у провайдеров зачастую есть бесплатные тарифы, что делает их привлекательным вариантом для маленьких хобби-проектов.

Обычно serverless-провайдеры не разрешают держать код постоянно запущенным. Вместо этого взаимодействие с программой обычно строится на базе отдельных запросов. Чаще всего это обычные HTTP-запросы, но можно встретить возможность запуска кода по таймеру или по MQTT.

Как работает Serverless?

Serverless-платформы можно поделить на два типа:

Мой опыт

Я попробовал много разных serverless-платформ (табличку со сравнением которых мы с сообществом grammY пытаемся вести тут). Некоторые мне понравились, а некоторые — не очень. Рассматривал я их больше с точки зрения бесплатного хостинга для хобби-проектов, хотя для средненагруженных проектов должно быть тоже очень интересно.

Самая большая проблема — это долговременное хранение данных. У serverless инстансов нет традиционной файловой системы, поэтому даже хранение сессий в телеграм-ботах становится проблемой. У некоторых провайдеров есть свои решения (например, Deta Base), но не у всех. grammY предоставляет своё бесплатное хранилище (на базе S3), но оно подходит только для прототипов, потому что производительность у него очень слабая.

Зато если бот или веб-сервер не имеют собственного состояния, serverless показывает себя крайне хорошо. Например, я за несколько минут переписал @gmojibot на Deno (благо grammY его поддерживает) и захостил на Deno Deploy. Работает просто замечательно.

Что мне не понравилось

А не понравились мне решения от Scaleway: Serverless Functions и Serverless Containers. А я надеялся, что Serverless Containers будут вести себя как обычные VPS-ки, только скейлиться при необходимости и оплачиваться по использованным ресурсам. А оказались обычными "традиционными" serverless решениями с долгими холодными стартами, не очень понятными ценовыми политиками и без доступа к файловой системе. Монгу в таком не захостишь, а так хотелось.