@coopenomics/notifications 2025.11.8

package/dist/sync/novu-sync.service.d.ts

@@ -0,0 +1,30 @@
+import { Types } from '../index';
+export interface NovuSyncConfig {
+    apiKey: string;
+    apiUrl: string;
+}
+export declare class NovuSyncService {
+    private readonly client;
+    private readonly config;
+    constructor(config: NovuSyncConfig);
+    /**
+     * Получить информацию о воркфлоу
+     */
+    getWorkflow(workflowId: string): Promise<any>;
+    /**
+     * Создать новый воркфлоу
+     */
+    createWorkflow(data: Types.NovuWorkflowData): Promise<any>;
+    /**
+     * Обновить существующий воркфлоу
+     */
+    updateWorkflow(workflowId: string, data: Types.NovuWorkflowData): Promise<any>;
+    /**
+     * Создать или обновить воркфлоу (upsert)
+     */
+    upsertWorkflow(workflow: Types.WorkflowDefinition): Promise<any>;
+    /**
+     * Создать или обновить все воркфлоу
+     */
+    upsertAllWorkflows(): Promise<void>;
+}

package/dist/sync/novu-sync.service.js

@@ -0,0 +1,128 @@
+import axios from 'axios';
+import { allWorkflows } from '../index';
+export class NovuSyncService {
+    constructor(config) {
+        this.config = config;
+        if (!this.config.apiKey) {
+            throw new Error('NOVU_API_KEY is required');
+        }
+        if (!this.config.apiUrl) {
+            throw new Error('NOVU_API_URL is required');
+        }
+        this.client = axios.create({
+            baseURL: this.config.apiUrl,
+            headers: {
+                'Authorization': `ApiKey ${this.config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    /**
+     * Получить информацию о воркфлоу
+     */
+    async getWorkflow(workflowId) {
+        try {
+            const response = await this.client.get(`/v2/workflows/${workflowId}`);
+            return response.data;
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Создать новый воркфлоу
+     */
+    async createWorkflow(data) {
+        try {
+            // Для создания НЕ передаем origin (как в testFramework2.ts)
+            const createData = { ...data };
+            delete createData.origin;
+            const response = await this.client.post('/v2/workflows', createData);
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Ошибка создания воркфлоу ${data.workflowId}:`, error.response?.data || error.message);
+            throw error;
+        }
+    }
+    /**
+     * Обновить существующий воркфлоу
+     */
+    async updateWorkflow(workflowId, data) {
+        try {
+            // Для обновления ВСЕГДА передаем origin: "external" (как в testFramework2.ts)
+            const updateData = { ...data, origin: 'novu-cloud' };
+            const response = await this.client.put(`/v2/workflows/${workflowId}`, updateData);
+            // console.log('response', response.data);
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Ошибка обновления воркфлоу ${workflowId}:`, error.response?.data || error.message);
+            throw error;
+        }
+    }
+    /**
+     * Создать или обновить воркфлоу (upsert)
+     */
+    async upsertWorkflow(workflow) {
+        try {
+            console.log(`Проверяем воркфлоу: ${workflow.workflowId}`);
+            const existingWorkflow = await this.getWorkflow(workflow.workflowId);
+            const novuData = {
+                name: workflow.name,
+                workflowId: workflow.workflowId,
+                description: workflow.description,
+                payloadSchema: workflow.payloadSchema,
+                steps: workflow.steps,
+                preferences: workflow.preferences,
+                tags: workflow.tags,
+            };
+            if (existingWorkflow) {
+                console.log(`Обновляем воркфлоу: ${workflow.workflowId}`);
+                return await this.updateWorkflow(workflow.workflowId, novuData);
+            }
+            else {
+                console.log(`Создаём воркфлоу: ${workflow.workflowId}`);
+                return await this.createWorkflow(novuData);
+            }
+        }
+        catch (error) {
+            console.error(`Ошибка upsert воркфлоу ${workflow.workflowId}:`, error.message);
+            throw error;
+        }
+    }
+    /**
+     * Создать или обновить все воркфлоу
+     */
+    async upsertAllWorkflows() {
+        console.log(`Начинаем upsert ${allWorkflows.length} воркфлоу...`);
+        const errors = [];
+        let successCount = 0;
+        for (const workflow of allWorkflows) {
+            try {
+                await this.upsertWorkflow(workflow);
+                console.log(`✓ Воркфлоу ${workflow.workflowId} успешно обработан`);
+                successCount++;
+            }
+            catch (error) {
+                const errorMessage = `Ошибка обработки воркфлоу ${workflow.workflowId}: ${error.message}`;
+                console.error(`✗ ${errorMessage}`);
+                errors.push(errorMessage);
+            }
+        }
+        console.log(`\nРезультат синхронизации:`);
+        console.log(`✅ Успешно: ${successCount}`);
+        console.log(`❌ Ошибки: ${errors.length}`);
+        if (errors.length > 0) {
+            console.log(`\nСписок ошибок:`);
+            errors.forEach((error, index) => {
+                console.log(`${index + 1}. ${error}`);
+            });
+            throw new Error(`Синхронизация завершилась с ошибками: ${errors.length} из ${allWorkflows.length} воркфлоу`);
+        }
+        console.log('✅ Все воркфлоу синхронизированы успешно');
+    }
+}

package/dist/sync/sync-runner.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { NovuSyncService } from './novu-sync.service';
+declare function runSync(): Promise<boolean>;
+export { runSync, NovuSyncService };

package/dist/sync/sync-runner.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import { NovuSyncService } from './novu-sync.service';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { watch } from 'chokidar';
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+dotenv.config();
+// Конфигурация из переменных окружения
+const config = {
+    apiKey: process.env.NOVU_API_KEY || '',
+    apiUrl: process.env.NOVU_API_URL || '',
+};
+async function runSync() {
+    console.log('🔄 Запуск синхронизации воркфлоу...');
+    try {
+        // Проверяем конфигурацию
+        if (!config.apiKey) {
+            throw new Error('❌ NOVU_API_KEY не установлен в переменных окружения');
+        }
+        if (!config.apiUrl) {
+            throw new Error('❌ NOVU_API_URL не установлен в переменных окружения');
+        }
+        const syncService = new NovuSyncService(config);
+        await syncService.upsertAllWorkflows();
+        console.log('✅ Синхронизация завершена успешно');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Ошибка синхронизации:', error.message);
+        return false;
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const isDev = args.includes('--dev') || process.env.NODE_ENV === 'development';
+    if (isDev) {
+        console.log('📡 Режим разработки: отслеживаем изменения...');
+        // Запускаем синхронизацию сразу
+        const initialSyncSuccess = await runSync();
+        if (!initialSyncSuccess) {
+            console.error('❌ Первоначальная синхронизация не удалась');
+            process.exit(1);
+        }
+        // Отслеживаем изменения в файлах воркфлоу и типов
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const workflowsPath = join(__dirname, '../workflows');
+        const typesPath = join(__dirname, '../types');
+        const watchPaths = [];
+        if (existsSync(workflowsPath)) {
+            watchPaths.push(workflowsPath);
+        }
+        if (existsSync(typesPath)) {
+            watchPaths.push(typesPath);
+        }
+        if (watchPaths.length > 0) {
+            console.log('👀 Отслеживаем изменения в:', watchPaths.join(', '));
+            let syncTimeout = null;
+            const watcher = watch(watchPaths, {
+                ignored: /node_modules/,
+                persistent: true,
+                ignoreInitial: true,
+            });
+            watcher.on('change', (path) => {
+                console.log(`📝 Изменен файл: ${path}`);
+                // Дебаунс для избежания множественных запусков
+                if (syncTimeout) {
+                    clearTimeout(syncTimeout);
+                }
+                syncTimeout = setTimeout(async () => {
+                    console.log('⏰ Запускаем синхронизацию...');
+                    const success = await runSync();
+                    if (!success) {
+                        console.error('⚠️  Синхронизация не удалась, но продолжаем отслеживание...');
+                    }
+                }, 1000);
+            });
+            watcher.on('add', (path) => {
+                console.log(`➕ Добавлен файл: ${path}`);
+                if (syncTimeout) {
+                    clearTimeout(syncTimeout);
+                }
+                syncTimeout = setTimeout(async () => {
+                    console.log('⏰ Запускаем синхронизацию...');
+                    const success = await runSync();
+                    if (!success) {
+                        console.error('⚠️  Синхронизация не удалась, но продолжаем отслеживание...');
+                    }
+                }, 1000);
+            });
+            watcher.on('unlink', (path) => {
+                console.log(`➖ Удален файл: ${path}`);
+                if (syncTimeout) {
+                    clearTimeout(syncTimeout);
+                }
+                syncTimeout = setTimeout(async () => {
+                    console.log('⏰ Запускаем синхронизацию...');
+                    const success = await runSync();
+                    if (!success) {
+                        console.error('⚠️  Синхронизация не удалась, но продолжаем отслеживание...');
+                    }
+                }, 1000);
+            });
+            console.log('💡 Нажмите Ctrl+C для выхода');
+            // Держим процесс живым
+            process.on('SIGINT', () => {
+                console.log('\n👋 Выход из режима разработки');
+                watcher.close();
+                process.exit(0);
+            });
+        }
+        else {
+            console.log('⚠️  Папки для отслеживания не найдены');
+            process.exit(1);
+        }
+    }
+    else {
+        // Production режим - запускаем один раз
+        const success = await runSync();
+        process.exit(success ? 0 : 1);
+    }
+}
+// Проверяем, запущен ли файл как основной модуль
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        console.error('❌ Критическая ошибка:', error);
+        process.exit(1);
+    });
+}
+export { runSync, NovuSyncService };

package/dist/utils/role-utils.d.ts

@@ -0,0 +1,8 @@
+import { UserRole } from '../workflows/role-based-workflows';
+export interface UserWithRole {
+    isChairman: boolean;
+    isMember: boolean;
+    isUser?: boolean;
+}
+export declare function getUserRole(user: UserWithRole): UserRole;
+export declare function isAuthenticatedUser(user: UserWithRole): boolean;

package/dist/utils/role-utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserRole = getUserRole;
+exports.isAuthenticatedUser = isAuthenticatedUser;
+// Функция для определения роли пользователя
+function getUserRole(user) {
+    if (user.isChairman) {
+        return 'chairman';
+    }
+    if (user.isMember) {
+        return 'member';
+    }
+    return 'user';
+}
+// Функция для проверки является ли пользователь авторизованным
+function isAuthenticatedUser(user) {
+    return user.isChairman || user.isMember || Boolean(user.isUser);
+}

package/dist/workflows/incoming-transfer/incoming-transfer-workflow.d.ts

@@ -0,0 +1,3 @@
+import { WorkflowDefinition } from '../../types';
+import { IncomingTransferWorkflowPayload } from './types';
+export declare const incomingTransferWorkflow: WorkflowDefinition<IncomingTransferWorkflowPayload>;

package/dist/workflows/incoming-transfer/incoming-transfer-workflow.js

@@ -0,0 +1,16 @@
+import { WorkflowBuilder } from '../../base/workflow-builder';
+import { createEmailStep, createInAppStep, createPushStep } from '../../base/defaults';
+import { incomingTransferPayloadSchema } from './types';
+export const incomingTransferWorkflow = WorkflowBuilder
+    .create()
+    .name('Входящий перевод')
+    .workflowId('vkhodyashchiy-perevod')
+    .description('Уведомление о получении входящего перевода')
+    .payloadSchema(incomingTransferPayloadSchema)
+    .tags(['user', 'chairman', 'member']) // Доступно для всех ролей
+    .addSteps([
+    createEmailStep('incoming-transfer-email', 'Получен входящий перевод на сумму {{payload.quantity}}', 'Уведомляем вас о получении входящего перевода.<br><br><strong>Сумма перевода: {{payload.quantity}}</strong><br><br>Перевод успешно зачислен на ваш счет.'),
+    createInAppStep('incoming-transfer-notification', 'Входящий перевод', 'Получен входящий перевод на сумму {{payload.quantity}}'),
+    createPushStep('incoming-transfer-push', 'Входящий перевод', 'Получен перевод на сумму {{payload.quantity}}'),
+])
+    .build();

package/dist/workflows/incoming-transfer/index.d.ts

@@ -0,0 +1,3 @@
+export { incomingTransferWorkflow } from './incoming-transfer-workflow';
+export { incomingTransferPayloadSchema } from './types';
+export type { IncomingTransferPayload, IncomingTransferWorkflowPayload } from './types';

package/dist/workflows/incoming-transfer/index.js

@@ -0,0 +1,2 @@
+export { incomingTransferWorkflow } from './incoming-transfer-workflow';
+export { incomingTransferPayloadSchema } from './types';

package/dist/workflows/incoming-transfer/types.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { BaseWorkflowPayload } from '../../types';
+export declare const incomingTransferPayloadSchema: z.ZodObject<{
+    quantity: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    quantity: string;
+}, {
+    quantity: string;
+}>;
+export type IncomingTransferPayload = z.infer<typeof incomingTransferPayloadSchema>;
+export interface IncomingTransferWorkflowPayload extends BaseWorkflowPayload, IncomingTransferPayload {
+}

package/dist/workflows/incoming-transfer/types.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+// Схема для incoming-transfer воркфлоу
+export const incomingTransferPayloadSchema = z.object({
+    quantity: z.string(),
+});

package/dist/workflows/new-agenda-item/index.d.ts

@@ -0,0 +1,3 @@
+export { newAgendaItemWorkflow } from './new-agenda-item-workflow';
+export { newAgendaItemPayloadSchema } from './types';
+export type { NewAgendaItemPayload, NewAgendaItemWorkflowPayload } from './types';

package/dist/workflows/new-agenda-item/index.js

@@ -0,0 +1,2 @@
+export { newAgendaItemWorkflow } from './new-agenda-item-workflow';
+export { newAgendaItemPayloadSchema } from './types';

package/dist/workflows/new-agenda-item/new-agenda-item-workflow.d.ts

@@ -0,0 +1,3 @@
+import { WorkflowDefinition } from '../../types';
+import { NewAgendaItemWorkflowPayload } from './types';
+export declare const newAgendaItemWorkflow: WorkflowDefinition<NewAgendaItemWorkflowPayload>;

package/dist/workflows/new-agenda-item/new-agenda-item-workflow.js

@@ -0,0 +1,16 @@
+import { WorkflowBuilder } from '../../base/workflow-builder';
+import { createEmailStep, createInAppStep, createPushStep } from '../../base/defaults';
+import { newAgendaItemPayloadSchema } from './types';
+export const newAgendaItemWorkflow = WorkflowBuilder
+    .create()
+    .name('Новый вопрос на повестке')
+    .workflowId('noviy-vopros-na-povestke')
+    .description('Уведомление о новом вопросе на повестке дня собрания совета для председателя и членов совета')
+    .payloadSchema(newAgendaItemPayloadSchema)
+    .tags(['chairman', 'member']) // Доступно только для председателя и членов
+    .addSteps([
+    createEmailStep('new-agenda-item-email', 'Новый вопрос на повестке: {{payload.itemTitle}}', 'Добавлен новый вопрос на повестку:<br><br><strong>{{payload.itemTitle}}</strong><br><br>{{payload.itemDescription}}<br><br>Автор: {{payload.authorName}} ({{payload.authorEmail}})<br><br>{{payload.meetingDate}}Дата заседания: {{payload.meetingDate}}<br>{{payload.meetingDate}}{{payload.meetingTitle}}Заседание: {{payload.meetingTitle}}{{payload.meetingTitle}}'),
+    createInAppStep('new-agenda-item-notification', 'Новый вопрос на повестке', 'Добавлен новый вопрос: {{payload.itemTitle}}<br>Автор: {{payload.authorName}}'),
+    createPushStep('new-agenda-item-push', 'Новый вопрос на повестке', 'Добавлен новый вопрос: {{payload.itemTitle}}'),
+])
+    .build();

package/dist/workflows/new-agenda-item/types.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { BaseWorkflowPayload } from '../../types';
+export declare const newAgendaItemPayloadSchema: z.ZodObject<{
+    itemTitle: z.ZodString;
+    itemDescription: z.ZodString;
+    authorName: z.ZodString;
+    authorEmail: z.ZodString;
+    meetingDate: z.ZodOptional<z.ZodString>;
+    meetingTitle: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    itemTitle: string;
+    itemDescription: string;
+    authorName: string;
+    authorEmail: string;
+    meetingDate?: string | undefined;
+    meetingTitle?: string | undefined;
+}, {
+    itemTitle: string;
+    itemDescription: string;
+    authorName: string;
+    authorEmail: string;
+    meetingDate?: string | undefined;
+    meetingTitle?: string | undefined;
+}>;
+export type NewAgendaItemPayload = z.infer<typeof newAgendaItemPayloadSchema>;
+export interface NewAgendaItemWorkflowPayload extends BaseWorkflowPayload, NewAgendaItemPayload {
+}

package/dist/workflows/new-agenda-item/types.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+// Схема для new-agenda-item воркфлоу
+export const newAgendaItemPayloadSchema = z.object({
+    itemTitle: z.string(),
+    itemDescription: z.string(),
+    authorName: z.string(),
+    authorEmail: z.string().email(),
+    meetingDate: z.string().optional(),
+    meetingTitle: z.string().optional(),
+});

package/dist/workflows/role-based-workflows.d.ts

@@ -0,0 +1,21 @@
+import { WorkflowDefinition } from '../types';
+export type UserRole = 'chairman' | 'member' | 'user';
+export interface RoleBasedWorkflow {
+    workflow: WorkflowDefinition;
+    roles: UserRole[];
+    displayName: string;
+    description: string;
+}
+export declare const roleBasedWorkflows: RoleBasedWorkflow[];
+export declare function getWorkflowsByRole(role: UserRole): RoleBasedWorkflow[];
+export declare function getWorkflowsWithRoleAccess(role: UserRole): Array<RoleBasedWorkflow & {
+    hasAccess: boolean;
+}>;
+export declare function hasWorkflowAccess(workflowId: string, role: UserRole): boolean;
+export declare function getAvailableRoles(userRole: UserRole): UserRole[];
+export declare function getRoleDisplayName(role: UserRole): string;
+export declare const workflowsByRole: {
+    readonly chairman: RoleBasedWorkflow[];
+    readonly member: RoleBasedWorkflow[];
+    readonly user: RoleBasedWorkflow[];
+};

package/dist/workflows/role-based-workflows.js

@@ -0,0 +1,65 @@
+import { welcomeWorkflow } from './welcome';
+import { newAgendaItemWorkflow } from './new-agenda-item';
+// Определение воркфлоу по ролям
+export const roleBasedWorkflows = [
+    {
+        workflow: welcomeWorkflow,
+        roles: ['chairman', 'member', 'user'], // Все роли
+        displayName: 'Приветственные уведомления',
+        description: 'Уведомления при регистрации в системе',
+    },
+    {
+        workflow: newAgendaItemWorkflow,
+        roles: ['chairman', 'member'], // Только председатель и члены совета
+        displayName: 'Новый вопрос на повестке',
+        description: 'Уведомления о новых вопросах на повестке заседания',
+    },
+];
+// Функция для получения воркфлоу по роли пользователя
+export function getWorkflowsByRole(role) {
+    return roleBasedWorkflows.filter(item => item.roles.includes(role));
+}
+// Функция для получения всех воркфлоу с указанием доступности для роли
+export function getWorkflowsWithRoleAccess(role) {
+    return roleBasedWorkflows.map(item => ({
+        ...item,
+        hasAccess: item.roles.includes(role),
+    }));
+}
+// Функция для проверки доступа к воркфлоу
+export function hasWorkflowAccess(workflowId, role) {
+    const workflowItem = roleBasedWorkflows.find(item => item.workflow.workflowId === workflowId);
+    return workflowItem ? workflowItem.roles.includes(role) : false;
+}
+// Функция для получения всех доступных ролей для пользователя
+export function getAvailableRoles(userRole) {
+    switch (userRole) {
+        case 'chairman':
+            return ['user', 'member', 'chairman']; // Председатель видит все роли
+        case 'member':
+            return ['user', 'member']; // Член совета видит user и member
+        case 'user':
+            return ['user']; // Обычный пользователь видит только user
+        default:
+            return ['user'];
+    }
+}
+// Функция для получения названия роли для отображения
+export function getRoleDisplayName(role) {
+    switch (role) {
+        case 'chairman':
+            return 'Председатель';
+        case 'member':
+            return 'Член совета';
+        case 'user':
+            return 'Пользователь';
+        default:
+            return 'Пользователь';
+    }
+}
+// Экспорт воркфлоу по ролям для удобного доступа
+export const workflowsByRole = {
+    chairman: getWorkflowsByRole('chairman'),
+    member: getWorkflowsByRole('member'),
+    user: getWorkflowsByRole('user'),
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@coopenomics/notifications",
+  "version": "2025.11.8",
+  "description": "Typesafe notification workflows library for Novu",
+  "type": "module",
+  "private": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --watch",
+    "clean": "rm -rf dist",
+    "sync": "tsx src/sync/sync-runner.ts",
+    "sync:dev": "tsx src/sync/sync-runner.ts --dev",
+    "sync:watch": "tsx src/sync/sync-runner.ts --dev"
+  },
+  "dependencies": {
+    "axios": "^1.7.7",
+    "dotenv": "^17.1.0",
+    "transliteration": "^2.3.5",
+    "zod": "^3.22.4",
+    "zod-to-json-schema": "^3.22.5"
+  },
+  "devDependencies": {
+    "@types/chokidar": "^2.1.3",
+    "@types/node": "^20.0.0",
+    "chokidar": "^3.6.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "unbuild": "^2.0.0"
+  },
+  "bin": {
+    "novu-sync": "./dist/sync/sync-runner.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  }
+}

package/src/base/defaults.ts

@@ -0,0 +1,66 @@
+import { PreferencesConfig, ChannelsConfig, ChannelConfig } from '../types';
+
+// Базовая конфигурация канала
+export const createChannelConfig = (enabled: boolean, readOnly = false): ChannelConfig => ({
+  enabled,
+  readOnly,
+});
+
+// Базовая конфигурация каналов
+export const createDefaultChannelsConfig = (): ChannelsConfig => ({
+  email: createChannelConfig(true),
+  sms: createChannelConfig(false),
+  in_app: createChannelConfig(true),
+  push: createChannelConfig(false),
+  chat: createChannelConfig(false),
+});
+
+// Базовые preferences для воркфлоу
+export const createDefaultPreferences = (): PreferencesConfig => ({
+  user: {
+    all: createChannelConfig(true),
+    channels: createDefaultChannelsConfig(),
+  },
+  workflow: {
+    all: createChannelConfig(true),
+    channels: createDefaultChannelsConfig(),
+  },
+});
+
+// Вспомогательные функции для создания шагов
+export const createEmailStep = (name: string, subject: string, body: string) => ({
+  name,
+  type: 'email' as const,
+  controlValues: {
+    subject,
+    body,
+    editorType: 'html' as const,
+  },
+});
+
+export const createInAppStep = (name: string, subject: string, body: string, avatar?: string) => ({
+  name,
+  type: 'in_app' as const,
+  controlValues: {
+    subject,
+    body,
+    avatar: avatar || 'https://novu.coopenomics.world/images/bell.svg',
+  },
+});
+
+export const createPushStep = (name: string, title: string, body: string) => ({
+  name,
+  type: 'push' as const,
+  controlValues: {
+    subject: title,
+    body,
+  },
+});
+
+export const createSmsStep = (name: string, body: string) => ({
+  name,
+  type: 'sms' as const,
+  controlValues: {
+    body,
+  },
+});