@coopenomics/notifications 2025.11.8

package/src/base/workflow-builder.ts

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { 
+  WorkflowDefinition, 
+  BaseWorkflowPayload, 
+  WorkflowStep, 
+  PayloadSchema,
+  NovuWorkflowData,
+  NovuOrigin 
+} from '../types';
+import { createDefaultPreferences } from './defaults';
+
+export class WorkflowBuilder<T extends BaseWorkflowPayload> {
+  private _name: string = '';
+  private _workflowId: string = '';
+  private _description?: string;
+  private _steps: WorkflowStep[] = [];
+  private _payloadZodSchema?: z.ZodSchema<T>;
+  private _origin?: NovuOrigin;
+  private _tags?: string[];
+
+  static create<T extends BaseWorkflowPayload>(): WorkflowBuilder<T> {
+    return new WorkflowBuilder<T>();
+  }
+
+  name(name: string): this {
+    this._name = name;
+    return this;
+  }
+
+  workflowId(id: string): this {
+    this._workflowId = id;
+    return this;
+  }
+
+  description(description: string): this {
+    this._description = description;
+    return this;
+  }
+
+  origin(origin: NovuOrigin): this {
+    this._origin = origin;
+    return this;
+  }
+
+  tags(tags: string[]): this {
+    this._tags = tags;
+    return this;
+  }
+
+  addStep(step: WorkflowStep): this {
+    this._steps.push(step);
+    return this;
+  }
+
+  addSteps(steps: WorkflowStep[]): this {
+    this._steps.push(...steps);
+    return this;
+  }
+
+  payloadSchema(schema: z.ZodSchema<T>): this {
+    this._payloadZodSchema = schema;
+    return this;
+  }
+
+  build(): WorkflowDefinition<T> {
+    if (!this._name) throw new Error('Workflow name is required');
+    if (!this._workflowId) throw new Error('Workflow ID is required');
+    if (!this._payloadZodSchema) throw new Error('Payload schema is required');
+
+    // Преобразуем Zod схему в JSON Schema для Novu
+    const jsonSchema = zodToJsonSchema(this._payloadZodSchema);
+    
+    // Правильная типизация: zodToJsonSchema может вернуть разные типы схем
+    const payloadSchema: PayloadSchema = {
+      type: (jsonSchema as any).type || 'object',
+      properties: (jsonSchema as any).properties || {},
+      required: Array.isArray((jsonSchema as any).required) ? (jsonSchema as any).required : [],
+    };
+
+    const workflow: WorkflowDefinition<T> = {
+      name: this._name,
+      workflowId: this._workflowId,
+      description: this._description,
+      payloadSchema,
+      steps: this._steps,
+      preferences: createDefaultPreferences(),
+      payloadZodSchema: this._payloadZodSchema,
+    };
+
+    // Добавляем origin только если он указан
+    if (this._origin) {
+      workflow.origin = this._origin;
+    }
+
+    // Добавляем tags только если они указаны
+    if (this._tags) {
+      workflow.tags = this._tags;
+    }
+
+    return workflow;
+  }
+
+  // Конвертация в формат для Novu API
+  toNovuData(): NovuWorkflowData {
+    const workflow = this.build();
+    const novuData: NovuWorkflowData = {
+      name: workflow.name,
+      workflowId: workflow.workflowId,
+      description: workflow.description,
+      payloadSchema: workflow.payloadSchema,
+      steps: workflow.steps,
+      preferences: workflow.preferences,
+    };
+
+    // Добавляем origin только если он указан
+    if (workflow.origin) {
+      novuData.origin = workflow.origin;
+    }
+
+    // Добавляем tags только если они указаны
+    if (workflow.tags) {
+      novuData.tags = workflow.tags;
+    }
+
+    return novuData;
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+// Экспортируем типы
+export * as Types from './types';
+
+// Экспортируем базовые утилиты
+export * from './base/defaults';
+export { WorkflowBuilder } from './base/workflow-builder';
+
+// Экспортируем все воркфлоу
+export * as Workflows from './workflows';

package/src/sync/README.md

@@ -0,0 +1,54 @@
+# Синхронизация Novu Workflows
+
+Эта папка содержит серверную логику для синхронизации воркфлоу с Novu API.
+
+## Файлы
+
+- `novu-sync.service.ts` - Сервис для работы с Novu API
+- `sync-runner.ts` - Скрипт для запуска синхронизации
+- `README.md` - Этот файл
+
+## Использование
+
+### Production режим (один раз)
+```bash
+pnpm run sync
+```
+
+### Development режим (watch)
+```bash
+pnpm run sync:dev
+# или
+pnpm run sync:watch
+```
+
+## Переменные окружения
+
+Требуются следующие переменные:
+- `NOVU_API_KEY` - API ключ для Novu
+- `NOVU_API_URL` - URL Novu API (по умолчанию: https://api.novu.co)
+
+## Режимы работы
+
+### Production
+- Запускается один раз
+- Синхронизирует все воркфлоу
+- Завершается после выполнения
+
+### Development
+- Запускается и остается активным
+- Отслеживает изменения в папках `workflows/` и `types/`
+- Автоматически перезапускает синхронизацию при изменениях
+- Дебаунс 1 секунда для избежания множественных запусков
+
+## Как работает
+
+1. Загружает все воркфлоу из `../workflows/index.ts`
+2. Для каждого воркфлоу:
+   - Проверяет существование в Novu API
+   - Создает новый или обновляет существующий
+3. Логирует результаты операций
+
+## Важно
+
+⚠️ Этот модуль предназначен только для серверного использования и не должен импортироваться на фронтенде! 

package/src/sync/novu-sync.service.ts

@@ -0,0 +1,246 @@
+import axios, { AxiosInstance } from 'axios';
+import { 
+  Types,
+  Workflows 
+} from '../index';
+
+export interface NovuSyncConfig {
+  apiKey: string;
+  apiUrl: string;
+}
+
+export class NovuSyncService {
+  private readonly client: AxiosInstance;
+  private readonly config: NovuSyncConfig;
+
+  constructor(config: NovuSyncConfig) {
+    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: string): Promise<any> {
+    try {
+      const response = await this.client.get(`/v2/workflows/${workflowId}`);
+      return response.data;
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Получить список всех воркфлоу
+   */
+  async getAllWorkflows(): Promise<any[]> {
+    try {
+      const response = await this.client.get('/v2/workflows', {
+        params: {
+          limit: 10000
+        }
+      });
+      
+      return response.data.data.workflows || [];
+    } catch (error: any) {
+      console.error('Ошибка получения списка воркфлоу:', console.dir(error.response?.data || error.message, {depth: null}));
+      throw error;
+    }
+  }
+
+  /**
+   * Создать новый воркфлоу
+   */
+  async createWorkflow(data: Types.NovuWorkflowData): Promise<any> {
+    try {
+      // Для создания НЕ передаем origin (как в testFramework2.ts)
+      const createData = { ...data };
+      
+      delete createData.origin;
+      
+      const response = await this.client.post('/v2/workflows', createData);
+      return response.data;
+    } catch (error: any) {
+      console.error(`Ошибка создания воркфлоу ${data.workflowId}:`, error.response?.data || error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Обновить существующий воркфлоу
+   */
+  async updateWorkflow(workflowId: string, data: Types.NovuWorkflowData): Promise<any> {
+    try {
+      // Для обновления ВСЕГДА передаем origin: "external" (как в testFramework2.ts)
+      const updateData = { ...data, origin: 'novu-cloud' as const };
+      const response = await this.client.put(`/v2/workflows/${workflowId}`, updateData);
+      // console.log('response', response.data);
+      return response.data;
+    } catch (error: any) {
+      console.error(`Ошибка обновления воркфлоу ${workflowId}:`, error.response?.data || error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Удалить воркфлоу по ID
+   */
+  async deleteWorkflow(workflowId: string): Promise<void> {
+    try {
+      await this.client.delete(`/v2/workflows/${workflowId}`);
+      console.log(`Удален воркфлоу: ${workflowId}`);
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        console.log(`Воркфлоу ${workflowId} не найден (уже удален)`);
+        return;
+      }
+      console.error(`Ошибка удаления воркфлоу ${workflowId}:`, error.response?.data || error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Создать или обновить воркфлоу (upsert)
+   */
+  async upsertWorkflow(workflow: Types.WorkflowDefinition): Promise<any> {
+    try {
+      console.log(`Проверяем воркфлоу: ${workflow.workflowId}`);
+      
+      const existingWorkflow = await this.getWorkflow(workflow.workflowId);
+      
+      const novuData: Types.NovuWorkflowData = {
+        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: any) {
+      console.error(`Ошибка upsert воркфлоу ${workflow.workflowId}:`, error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Удалить все существующие воркфлоу
+   */
+  async deleteAllWorkflows(): Promise<void> {
+    console.log('Получаем список всех воркфлоу для удаления...');
+
+    try {
+      const workflows = await this.getAllWorkflows();
+      console.log(`Найдено ${workflows.length} воркфлоу для удаления`);
+
+      if (workflows.length === 0) {
+        console.log('Нет воркфлоу для удаления');
+        return;
+      }
+
+      const errors: string[] = [];
+      let deletedCount = 0;
+
+      for (const workflow of workflows) {
+        try {
+          await this.deleteWorkflow(workflow.workflowId || workflow._id);
+          deletedCount++;
+        } catch (error: any) {
+          const errorMessage = `Ошибка удаления воркфлоу ${workflow.workflowId || workflow._id}: ${error.message}`;
+          console.error(`✗ ${errorMessage}`);
+          errors.push(errorMessage);
+        }
+      }
+
+      console.log(`\nРезультат удаления:`);
+      console.log(`✅ Удалено: ${deletedCount}`);
+      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} из ${workflows.length} воркфлоу`);
+      }
+
+      console.log('✅ Все существующие воркфлоу удалены успешно');
+    } catch (error: any) {
+      console.error('❌ Критическая ошибка при удалении воркфлоу:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Создать или обновить все воркфлоу (с предварительным удалением существующих)
+   */
+  async upsertAllWorkflows(): Promise<void> {
+    console.log('🚀 Начинаем полную синхронизацию воркфлоу...');
+
+    // Шаг 1: Удаляем все существующие воркфлоу
+    // try {
+    //   await this.deleteAllWorkflows();
+    // } catch (error: any) {
+    //   console.error('❌ Ошибка при удалении существующих воркфлоу:', error.message);
+    //   throw error;
+    // }
+
+    // Шаг 2: Создаем новые воркфлоу
+    console.log(`\n📝 Начинаем создание ${Workflows.allWorkflows.length} новых воркфлоу...`);
+
+    const errors: string[] = [];
+    let successCount = 0;
+
+    for (const workflow of Workflows.allWorkflows) {
+      try {
+        await this.upsertWorkflow(workflow);
+        console.log(`✓ Воркфлоу ${workflow.workflowId} успешно создан`);
+        successCount++;
+      } catch (error: any) {
+        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} из ${Workflows.allWorkflows.length} воркфлоу`);
+    }
+
+    console.log('✅ Все воркфлоу синхронизированы успешно');
+  }
+} 

package/src/sync/sync-runner.ts

@@ -0,0 +1,154 @@
+#!/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: any) {
+    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: NodeJS.Timeout | null = null;
+      
+      const watcher = watch(watchPaths, {
+        ignored: /node_modules/,
+        persistent: true,
+        ignoreInitial: true,
+      });
+      
+      watcher.on('change', (path: string) => {
+        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: string) => {
+        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: string) => {
+        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/src/types/index.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+
+// Базовые типы для каналов уведомлений
+export interface ChannelConfig {
+  enabled: boolean;
+  readOnly?: boolean;
+}
+
+export interface ChannelsConfig {
+  email: ChannelConfig;
+  sms: ChannelConfig;
+  in_app: ChannelConfig;
+  push: ChannelConfig;
+  chat: ChannelConfig;
+}
+
+export interface PreferencesConfig {
+  user: {
+    all: ChannelConfig;
+    channels: ChannelsConfig;
+  };
+  workflow: {
+    all: ChannelConfig;
+    channels: ChannelsConfig;
+  };
+}
+
+// Базовые типы для шагов воркфлоу
+export interface StepControlValues {
+  subject?: string;
+  body?: string;
+  title?: string;
+  content?: string;
+  avatar?: string;
+  editorType?: 'html' | 'text';
+  [key: string]: any;
+}
+
+export interface WorkflowStep {
+  name: string;
+  type: 'email' | 'sms' | 'in_app' | 'push' | 'chat' | 'delay' | 'digest';
+  controlValues: StepControlValues;
+}
+
+// Базовый интерфейс для payload воркфлоу
+export interface BaseWorkflowPayload {
+  [key: string]: any;
+}
+
+// Интерфейс для схемы payload (JSON Schema)
+export interface PayloadSchema {
+  type: string;
+  properties: Record<string, any>;
+  required: string[];
+}
+
+// Допустимые значения для origin в Novu
+export type NovuOrigin = 'novu-cloud' | 'novu-cloud-v1' | 'external';
+
+// Главный интерфейс для воркфлоу
+export interface WorkflowDefinition<T extends BaseWorkflowPayload = BaseWorkflowPayload> {
+  name: string;
+  workflowId: string;
+  description?: string;
+  payloadSchema: PayloadSchema;
+  steps: WorkflowStep[];
+  preferences: PreferencesConfig;
+  origin?: NovuOrigin; // Делаем optional
+  tags?: string[]; // Теги для группировки воркфлоу
+  // Типизированная схема для валидации payload
+  payloadZodSchema: z.ZodSchema<T>;
+}
+
+// Интерфейс для создания воркфлоу в Novu (без origin для создания)
+export interface NovuWorkflowData {
+  name: string;
+  workflowId: string;
+  description?: string;
+  payloadSchema: PayloadSchema;
+  steps: WorkflowStep[];
+  preferences: PreferencesConfig;
+  origin?: NovuOrigin; // Optional - только для обновлений
+  tags?: string[]; // Теги для группировки воркфлоу
+}
+
+// Интерфейс для триггера воркфлоу
+export interface WorkflowTriggerData<T extends BaseWorkflowPayload> {
+  workflowId: string;
+  subscriberId: string;
+  payload: T;
+  actor?: {
+    subscriberId: string;
+    email?: string;
+  };
+}
+
+// Утилитарные типы
+export type WorkflowStepType = WorkflowStep['type'];
+export type ChannelType = keyof ChannelsConfig;

package/src/utils/index.ts

@@ -0,0 +1 @@
+export { slugify } from './slugify/slugify';