umbot-ydb-adapter 1.0.0

package/dist/yql.js

@@ -0,0 +1,584 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_OPERATORS = exports.YqlBuildError = exports.YDB_COLUMN_TYPES = void 0;
+exports.tableInfoFromSchema = tableInfoFromSchema;
+exports.tableInfoFromDefinition = tableInfoFromDefinition;
+exports.quoteTable = quoteTable;
+exports.quoteColumn = quoteColumn;
+exports.chooseIndex = chooseIndex;
+exports.buildSelect = buildSelect;
+exports.buildUpsert = buildUpsert;
+exports.buildUpdate = buildUpdate;
+exports.buildDelete = buildDelete;
+exports.buildCreateTable = buildCreateTable;
+exports.buildSchemaCheck = buildSchemaCheck;
+exports.buildColumnCheck = buildColumnCheck;
+exports.buildAddColumn = buildAddColumn;
+exports.buildIndexCheck = buildIndexCheck;
+exports.buildAddIndex = buildAddIndex;
+exports.escapeYqlString = escapeYqlString;
+exports.normalizeRow = normalizeRow;
+const umbot_1 = require("umbot");
+const primitive_1 = require("@ydbjs/value/primitive");
+const list_1 = require("@ydbjs/value/list");
+/**
+ * Типы колонок YDB, которые понимает адаптер.
+ */
+exports.YDB_COLUMN_TYPES = ['Utf8', 'Int64', 'Double', 'Bool'];
+/**
+ * Ошибка сборки запроса: некорректное имя, условие или значение.
+ * Адаптер не отправляет такой запрос в базу, а возвращает ошибку вызывающему коду.
+ */
+class YqlBuildError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'YqlBuildError';
+    }
+}
+exports.YqlBuildError = YqlBuildError;
+// Сегмент пути таблицы: имя может содержать директории YDB (`bots/UsersData`)
+const TABLE_SEGMENT_REGEXP = /^[A-Za-z_][\w-]*$/;
+const COLUMN_NAME_REGEXP = /^[A-Za-z_]\w*$/;
+// Через эти ключи можно добраться до прототипа: в имени колонки их быть не может
+const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+const COMPARE_OPERATORS = {
+    $gt: '>',
+    $gte: '>=',
+    $lt: '<',
+    $lte: '<=',
+    $ne: '!=',
+    $like: 'LIKE',
+};
+/**
+ * Операторы условий, которые понимает адаптер.
+ */
+exports.SUPPORTED_OPERATORS = [
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte',
+    '$ne',
+    '$in',
+    '$nin',
+    '$like',
+    '$null',
+];
+/**
+ * Вторичные индексы таблицы. Индекс, совпадающий с началом первичного ключа, не создаётся:
+ * ключ уже даёт быстрый поиск по этим полям.
+ */
+function buildIndexes(primaryKey, indexes) {
+    const result = [];
+    for (const fields of indexes) {
+        const isKeyPrefix = fields.every((field, i) => primaryKey[i] === field);
+        if (!isKeyPrefix) {
+            result.push({ name: `idx_${fields.join('_')}`, fields: [...fields] });
+        }
+    }
+    return result;
+}
+/**
+ * Собирает описание таблицы из схемы umbot (`DB_TABLES_SCHEMA`).
+ * Все поля встроенных таблиц строковые, поэтому колонки получают тип `Utf8`.
+ * @param schema Описание таблицы
+ * @returns Описание таблицы для адаптера
+ */
+function tableInfoFromSchema(schema) {
+    const primaryKey = [schema.primaryKeyName, ...schema.uniqueKeys];
+    const columns = new Map();
+    for (const name of Object.keys(schema.fields)) {
+        columns.set(name, 'Utf8');
+    }
+    return {
+        tableName: schema.tableName,
+        primaryKey,
+        columns,
+        indexes: buildIndexes(primaryKey, schema.indexes),
+    };
+}
+/**
+ * Собирает описание своей таблицы из опции `tables` и проверяет его.
+ * @param definition Описание таблицы
+ * @returns Описание таблицы для адаптера
+ */
+function tableInfoFromDefinition(definition) {
+    const { tableName, primaryKey } = definition;
+    const columns = new Map(Object.entries(definition.columns));
+    quoteTable(tableName);
+    if (!primaryKey.length) {
+        throw new YqlBuildError(`У таблицы "${tableName}" не задан первичный ключ.`);
+    }
+    const indexes = definition.indexes ?? [];
+    for (const column of [...primaryKey, ...indexes.flat()]) {
+        if (!columns.has(column)) {
+            throw new YqlBuildError(`Колонка "${column}" таблицы "${tableName}" используется в ключе или индексе, но не описана в columns.`);
+        }
+    }
+    for (const [column, type] of columns) {
+        quoteColumn(column);
+        if (!exports.YDB_COLUMN_TYPES.includes(type)) {
+            throw new YqlBuildError(`Неизвестный тип "${type}" колонки "${column}" таблицы "${tableName}". Поддерживаются: ${exports.YDB_COLUMN_TYPES.join(', ')}.`);
+        }
+    }
+    return {
+        tableName,
+        primaryKey: [...primaryKey],
+        columns,
+        indexes: buildIndexes(primaryKey, indexes),
+    };
+}
+/**
+ * Проверяет имя таблицы и возвращает его в обратных кавычках.
+ * @param name Имя таблицы
+ * @returns Имя для подстановки в YQL
+ */
+function quoteTable(name) {
+    if (!name.split('/').every((segment) => TABLE_SEGMENT_REGEXP.test(segment))) {
+        throw new YqlBuildError(`Недопустимое имя таблицы: "${name}"`);
+    }
+    return `\`${name}\``;
+}
+/**
+ * Проверяет имя колонки (или индекса) и возвращает его в обратных кавычках.
+ * @param name Имя колонки
+ * @returns Имя для подстановки в YQL
+ */
+function quoteColumn(name) {
+    if (FORBIDDEN_KEYS.has(name) || !COLUMN_NAME_REGEXP.test(name)) {
+        throw new YqlBuildError(`Недопустимое имя колонки: "${name}"`);
+    }
+    return `\`${name}\``;
+}
+/**
+ * Набор параметров запроса: выдаёт имена `$p0`, `$p1`, ...
+ */
+class YqlParams {
+    params = {};
+    #index = 0;
+    add(value) {
+        const name = `$p${this.#index++}`;
+        this.params[name] = value;
+        return name;
+    }
+}
+/**
+ * Определяет тип колонки: из схемы таблицы, затем из правил модели.
+ * @returns Тип колонки или undefined, если он неизвестен (тогда тип выводится из значения)
+ */
+function getColumnType(column, ctx) {
+    const fromSchema = ctx.table?.columns.get(column);
+    if (fromSchema) {
+        return fromSchema;
+    }
+    const rule = ctx.rules?.find((item) => item.name.includes(column));
+    switch (rule?.type) {
+        case 'string':
+        case 'text':
+            return 'Utf8';
+        case 'int':
+        case 'integer':
+            return 'Int64';
+        case 'bool':
+            return 'Bool';
+        default:
+            return undefined;
+    }
+}
+/**
+ * Максимальная длина строки из правил модели (`max` у правил `string`/`text`).
+ */
+function getMaxLength(column, ctx) {
+    const rule = ctx.rules?.find((item) => (item.type === 'string' || item.type === 'text') && item.name.includes(column));
+    return rule?.max;
+}
+/**
+ * Выводит тип колонки из JS-значения, когда ни схема, ни правила его не задают.
+ */
+function inferType(column, value) {
+    switch (typeof value) {
+        case 'string':
+            return 'Utf8';
+        case 'boolean':
+            return 'Bool';
+        case 'bigint':
+            return 'Int64';
+        case 'number':
+            return Number.isInteger(value) ? 'Int64' : 'Double';
+        default:
+            throw new YqlBuildError(`Значение поля "${column}" имеет неподдерживаемый тип (${typeof value}). ` +
+                'Передайте строку, число или boolean, либо выполните запрос через query().');
+    }
+}
+/**
+ * Приводит значение к целому для колонки Int64.
+ */
+function toBigInt(column, value) {
+    if (typeof value === 'bigint') {
+        return value;
+    }
+    const num = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+    if (typeof num === 'number' && Number.isSafeInteger(num)) {
+        return BigInt(num);
+    }
+    throw new YqlBuildError(`Поле "${column}" ожидает целое число, получено: ${String(value)}`);
+}
+/**
+ * Приводит значение к строке для колонки Utf8 и обрезает его по `max` из правил модели.
+ */
+function toText(column, value, ctx) {
+    const text = typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value);
+    const max = getMaxLength(column, ctx);
+    return max === undefined ? text : umbot_1.Text.resize(text, max);
+}
+/**
+ * Превращает значение (не null и не undefined) в типизированное значение YDB.
+ * @param column Имя колонки
+ * @param value Значение
+ * @param type Тип колонки
+ * @param ctx Контекст запроса
+ * @returns Значение для параметра запроса
+ */
+function toYdbValue(column, value, type, ctx) {
+    switch (type) {
+        case 'Utf8':
+            return new primitive_1.Text(toText(column, value, ctx));
+        case 'Int64':
+            return new primitive_1.Int64(toBigInt(column, value));
+        case 'Double': {
+            const num = Number(value);
+            if (!Number.isFinite(num)) {
+                throw new YqlBuildError(`Поле "${column}" ожидает число, получено: ${String(value)}`);
+            }
+            return new primitive_1.Double(num);
+        }
+        case 'Bool':
+            return new primitive_1.Bool(value === true || value === 1 || value === '1' || value === 'true');
+    }
+}
+/**
+ * Добавляет значение колонки в параметры запроса.
+ * @returns Имя параметра (`$pN`)
+ */
+function bindValue(column, value, ctx, params) {
+    const type = getColumnType(column, ctx) ?? inferType(column, value);
+    return params.add(toYdbValue(column, value, type, ctx));
+}
+/**
+ * Собирает условие `IN` / `NOT IN` для списка значений.
+ */
+function buildInCondition(column, operator, value, ctx, params) {
+    if (!Array.isArray(value)) {
+        throw new YqlBuildError(`Оператор "${operator}" для поля "${column}" ожидает массив.`);
+    }
+    if (!value.length) {
+        // Пустой список: IN не совпадает ни с чем, NOT IN — со всем
+        return operator === '$in' ? 'FALSE' : 'TRUE';
+    }
+    if (value.some((item) => item === null || item === undefined)) {
+        throw new YqlBuildError(`Оператор "${operator}" для поля "${column}" не принимает null; используйте $null.`);
+    }
+    const type = getColumnType(column, ctx) ?? inferType(column, value[0]);
+    const items = value.map((item) => toYdbValue(column, item, type, ctx));
+    const name = params.add(new list_1.List(...items));
+    return `${quoteColumn(column)} ${operator === '$in' ? 'IN' : 'NOT IN'} ${name}`;
+}
+/**
+ * Собирает одно условие с оператором (`{ age: { $gt: 18 } }`).
+ */
+function buildOperatorCondition(column, operator, value, ctx, params) {
+    const quoted = quoteColumn(column);
+    switch (operator) {
+        case '$in':
+        case '$nin':
+            return buildInCondition(column, operator, value, ctx, params);
+        case '$null':
+            return `${quoted} ${value ? 'IS NULL' : 'IS NOT NULL'}`;
+        case '$ne':
+            if (value === null) {
+                return `${quoted} IS NOT NULL`;
+            }
+            break;
+    }
+    if (value === null || value === undefined) {
+        throw new YqlBuildError(`Оператор "${operator}" для поля "${column}" не принимает null.`);
+    }
+    return `${quoted} ${COMPARE_OPERATORS[operator]} ${bindValue(column, value, ctx, params)}`;
+}
+/**
+ * Собирает условие для одного поля `IQueryData`.
+ */
+function buildFieldCondition(column, value, ctx, params) {
+    if (value === undefined) {
+        // «Условие», которого нет, для UPDATE/DELETE опаснее ошибки
+        throw new YqlBuildError(`Условие для поля "${column}" не задано (undefined).`);
+    }
+    if (value === null) {
+        return [`${quoteColumn(column)} IS NULL`];
+    }
+    if (Array.isArray(value)) {
+        throw new YqlBuildError(`Условие для поля "${column}" — массив. Для списка значений используйте $in.`);
+    }
+    if (typeof value !== 'object') {
+        return [`${quoteColumn(column)} = ${bindValue(column, value, ctx, params)}`];
+    }
+    const conditions = value;
+    const keys = Object.keys(conditions);
+    if (!keys.length || !keys.every((key) => key.startsWith('$'))) {
+        throw new YqlBuildError(`Условие для поля "${column}" не содержит операторов. Поддерживаются: ${exports.SUPPORTED_OPERATORS.join(', ')}.`);
+    }
+    return keys.map((key) => {
+        if (!exports.SUPPORTED_OPERATORS.includes(key)) {
+            throw new YqlBuildError(`Неизвестный оператор "${key}" для поля "${column}". Поддерживаются: ${exports.SUPPORTED_OPERATORS.join(', ')}.`);
+        }
+        return buildOperatorCondition(column, key, conditions[key], ctx, params);
+    });
+}
+/**
+ * Переводит условия `IQueryData` в выражение WHERE.
+ * Скалярное значение — равенство, объект — набор операторов, null — `IS NULL`.
+ * @returns Выражение без слова WHERE; пустая строка, если условий нет
+ */
+function buildWhere(where, ctx, params) {
+    if (!where) {
+        return '';
+    }
+    const parts = [];
+    for (const column of Object.keys(where)) {
+        parts.push(...buildFieldCondition(column, where[column], ctx, params));
+    }
+    return parts.join(' AND ');
+}
+/**
+ * Поля, заданные в условии простым равенством с не-null значением.
+ */
+function getEqualityKeys(where) {
+    const keys = new Set();
+    if (where) {
+        for (const key of Object.keys(where)) {
+            const value = where[key];
+            if (value !== null && value !== undefined && typeof value !== 'object') {
+                keys.add(key);
+            }
+        }
+    }
+    return keys;
+}
+/**
+ * Выбирает вторичный индекс для SELECT. YDB не использует индекс без явного `VIEW`,
+ * поэтому поиск по (platform, path) в таблицах токенов без него шёл бы полным перебором.
+ * @returns Имя индекса или undefined, если поиск идёт по первичному ключу или индекса нет
+ */
+function chooseIndex(table, where) {
+    if (!table || !table.indexes.length) {
+        return undefined;
+    }
+    const keys = getEqualityKeys(where);
+    if (table.primaryKey.every((key) => keys.has(key))) {
+        return undefined;
+    }
+    return table.indexes.find((index) => index.fields.every((field) => keys.has(field)))?.name;
+}
+/**
+ * Собирает SELECT.
+ * @param tableName Имя таблицы
+ * @param where Условия выборки
+ * @param isOne Нужна только одна запись
+ * @param ctx Контекст запроса
+ * @returns Запрос
+ */
+function buildSelect(tableName, where, isOne, ctx) {
+    const params = new YqlParams();
+    const index = chooseIndex(ctx.table, where);
+    const view = index ? ` VIEW ${quoteColumn(index)}` : '';
+    const condition = buildWhere(where, ctx, params);
+    const text = `SELECT * FROM ${quoteTable(tableName)}${view}` +
+        (condition ? ` WHERE ${condition}` : '') +
+        (isOne ? ' LIMIT 1' : '');
+    return { text, params: params.params };
+}
+/**
+ * Собирает UPSERT одной записи. Поля со значением undefined пропускаются,
+ * null записывается как NULL.
+ * @param tableName Имя таблицы
+ * @param data Данные записи
+ * @param ctx Контекст запроса
+ * @returns Запрос
+ */
+function buildUpsert(tableName, data, ctx) {
+    const params = new YqlParams();
+    const columns = [];
+    const values = [];
+    for (const column of Object.keys(data)) {
+        const value = data[column];
+        if (value === undefined) {
+            continue;
+        }
+        columns.push(quoteColumn(column));
+        values.push(value === null ? 'NULL' : bindValue(column, value, ctx, params));
+    }
+    for (const key of ctx.table?.primaryKey ?? []) {
+        if (data[key] === undefined || data[key] === null) {
+            throw new YqlBuildError(`Не задано поле первичного ключа "${key}" таблицы "${tableName}".`);
+        }
+    }
+    if (!columns.length) {
+        throw new YqlBuildError(`Нет данных для записи в таблицу "${tableName}".`);
+    }
+    const text = `UPSERT INTO ${quoteTable(tableName)} (${columns.join(', ')}) VALUES (${values.join(', ')})`;
+    return { text, params: params.params };
+}
+/**
+ * Собирает UPDATE. Колонки первичного ключа из SET убираются: YDB не меняет ключ
+ * записи, а модель umbot передаёт `uniqueKeys` и в данных, и в условии.
+ * @param tableName Имя таблицы
+ * @param data Новые значения
+ * @param where Условия (обязательны)
+ * @param ctx Контекст запроса
+ * @returns Запрос или null, если менять нечего
+ */
+function buildUpdate(tableName, data, where, ctx) {
+    const params = new YqlParams();
+    const primaryKey = ctx.table?.primaryKey ?? [];
+    const assignments = [];
+    for (const column of Object.keys(data)) {
+        const value = data[column];
+        if (value === undefined || primaryKey.includes(column)) {
+            continue;
+        }
+        const bound = value === null ? 'NULL' : bindValue(column, value, ctx, params);
+        assignments.push(`${quoteColumn(column)} = ${bound}`);
+    }
+    const condition = buildWhere(where, ctx, params);
+    if (!condition) {
+        throw new YqlBuildError(`UPDATE таблицы "${tableName}" без условий запрещён.`);
+    }
+    if (!assignments.length) {
+        return null;
+    }
+    const text = `UPDATE ${quoteTable(tableName)} SET ${assignments.join(', ')} WHERE ${condition}`;
+    return { text, params: params.params };
+}
+/**
+ * Собирает DELETE.
+ * @param tableName Имя таблицы
+ * @param where Условия (обязательны: удаление всей таблицы этим методом запрещено)
+ * @param ctx Контекст запроса
+ * @returns Запрос
+ */
+function buildDelete(tableName, where, ctx) {
+    const params = new YqlParams();
+    const condition = buildWhere(where, ctx, params);
+    if (!condition) {
+        throw new YqlBuildError(`DELETE из таблицы "${tableName}" без условий запрещён.`);
+    }
+    return {
+        text: `DELETE FROM ${quoteTable(tableName)} WHERE ${condition}`,
+        params: params.params,
+    };
+}
+/**
+ * Описание вторичного индекса для CREATE TABLE / ALTER TABLE.
+ * Индекс синхронный: запись, только что сохранённая через UPSERT, сразу видна в поиске по индексу.
+ */
+function indexDefinition(index) {
+    return `INDEX ${quoteColumn(index.name)} GLOBAL SYNC ON (${index.fields.map(quoteColumn).join(', ')})`;
+}
+/**
+ * Собирает CREATE TABLE IF NOT EXISTS. Колонки ключа объявляются NOT NULL.
+ * @param table Описание таблицы
+ * @returns Текст запроса
+ */
+function buildCreateTable(table) {
+    const lines = [];
+    for (const [column, type] of table.columns) {
+        const notNull = table.primaryKey.includes(column) ? ' NOT NULL' : '';
+        lines.push(`${quoteColumn(column)} ${type}${notNull}`);
+    }
+    for (const index of table.indexes) {
+        lines.push(indexDefinition(index));
+    }
+    lines.push(`PRIMARY KEY (${table.primaryKey.map(quoteColumn).join(', ')})`);
+    return `CREATE TABLE IF NOT EXISTS ${quoteTable(table.tableName)} (\n    ${lines.join(',\n    ')}\n)`;
+}
+/**
+ * Собирает запрос-проверку: выполняется без ошибок, только если таблица, все её колонки
+ * и индексы уже есть. Данные не читаются (`LIMIT 0`).
+ * @param table Описание таблицы
+ * @returns Текст запроса (несколько SELECT через `;`)
+ */
+function buildSchemaCheck(table) {
+    const name = quoteTable(table.tableName);
+    const columns = [...table.columns.keys()].map(quoteColumn).join(', ');
+    const statements = [`SELECT ${columns} FROM ${name} LIMIT 0;`];
+    for (const index of table.indexes) {
+        const fields = index.fields.map(quoteColumn).join(', ');
+        statements.push(`SELECT ${fields} FROM ${name} VIEW ${quoteColumn(index.name)} LIMIT 0;`);
+    }
+    return statements.join('\n');
+}
+/**
+ * Собирает проверку наличия одной колонки.
+ */
+function buildColumnCheck(tableName, column) {
+    return `SELECT ${quoteColumn(column)} FROM ${quoteTable(tableName)} LIMIT 0`;
+}
+/**
+ * Собирает ALTER TABLE ... ADD COLUMN.
+ */
+function buildAddColumn(tableName, column, type) {
+    return `ALTER TABLE ${quoteTable(tableName)} ADD COLUMN ${quoteColumn(column)} ${type}`;
+}
+/**
+ * Собирает проверку наличия индекса.
+ */
+function buildIndexCheck(tableName, index) {
+    const fields = index.fields.map(quoteColumn).join(', ');
+    return `SELECT ${fields} FROM ${quoteTable(tableName)} VIEW ${quoteColumn(index.name)} LIMIT 0`;
+}
+/**
+ * Собирает ALTER TABLE ... ADD INDEX.
+ */
+function buildAddIndex(tableName, index) {
+    return `ALTER TABLE ${quoteTable(tableName)} ADD ${indexDefinition(index)}`;
+}
+/**
+ * Экранирует строку для подстановки внутрь строкового литерала YQL (`'...'` или `"..."`).
+ * Адаптер сам так не делает — все значения уходят параметрами; функция нужна тем,
+ * кто собирает свой запрос через `model.escapeString()`.
+ * @param value Значение
+ * @returns Строка с экранированными обратным слешем, кавычками и управляющими символами
+ */
+function escapeYqlString(value) {
+    return String(value).replace(/[\\'"\n\r\0]/g, (char) => {
+        switch (char) {
+            case '\n':
+                return '\\n';
+            case '\r':
+                return '\\r';
+            case '\0':
+                return '\\x00';
+            default:
+                return '\\' + char;
+        }
+    });
+}
+/**
+ * Приводит значение из ответа YDB к виду, который понимают модели umbot:
+ * Int64 приходит как bigint, а JSON.stringify и сравнения с числами на нём ломаются.
+ * @param row Строка результата
+ * @returns Строка с bigint, переведёнными в number (или в строку, если не помещаются)
+ */
+function normalizeRow(row) {
+    const result = {};
+    for (const key of Object.keys(row)) {
+        const value = row[key];
+        if (typeof value === 'bigint') {
+            const num = Number(value);
+            result[key] = Number.isSafeInteger(num) ? num : value.toString();
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,95 @@
+{
+    "name": "umbot-ydb-adapter",
+    "version": "1.0.0",
+    "description": "YDB (Yandex Database) adapter for the umbot framework: storage for Alice skills and chat bots in Yandex Cloud Functions without a separate database server.",
+    "keywords": [
+        "umbot",
+        "universal-bot",
+        "ydb",
+        "yandex-database",
+        "yandex-cloud",
+        "cloud-functions",
+        "serverless",
+        "alice",
+        "alisa",
+        "database",
+        "db-adapter",
+        "typescript",
+        "bot-framework"
+    ],
+    "author": {
+        "name": "Maxim-M",
+        "email": "maximco36895@yandex.ru",
+        "url": "https://github.com/max36895"
+    },
+    "license": "MIT",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "type": "commonjs",
+    "homepage": "https://github.com/max36895/umbot-ydb-adapter#readme",
+    "bugs": {
+        "url": "https://github.com/max36895/umbot-ydb-adapter/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/max36895/umbot-ydb-adapter.git"
+    },
+    "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "test:coverage": "jest --coverage",
+        "bt": "npm run build && npm run test",
+        "live": "npm run build && node scripts/live-check.js",
+        "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json",
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "prettier": "prettier --write .",
+        "prettier:check": "prettier --check .",
+        "check": "npm run prettier:check && npm run typecheck && npm run lint",
+        "prepublishOnly": "npm run build",
+        "deploy": "npm run build && npm publish"
+    },
+    "engines": {
+        "node": ">=20.19.0"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE.md"
+    ],
+    "peerDependencies": {
+        "umbot": "^3.1.4"
+    },
+    "dependencies": {
+        "@ydbjs/auth": "^6.3.1",
+        "@ydbjs/core": "^6.3.1",
+        "@ydbjs/query": "^6.3.0",
+        "@ydbjs/value": "^6.0.8"
+    },
+    "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "@types/jest": "^30.0.0",
+        "@types/node": "^20.19.30",
+        "eslint": "^10.2.0",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-security": "^4.0.0",
+        "globals": "^17.4.0",
+        "jest": "^30.3.0",
+        "prettier": "^3.8.1",
+        "ts-jest": "^29.4.9",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.60.0",
+        "umbot": "^3.1.4"
+    },
+    "funding": {
+        "type": "individual",
+        "url": "https://boosty.to/max36895/donate"
+    },
+    "maintainers": [
+        {
+            "name": "max36895",
+            "email": "maximco36895@yandex.ru",
+            "url": "https://github.com/max36895"
+        }
+    ]
+}