@coopenomics/notifications 2025.11.8-3

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@coopenomics/notifications",
+  "version": "2025.11.8-3",
+  "description": "Typesafe notification workflows library for Novu",
+  "type": "module",
+  "private": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "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"
+    }
+  },
+  "gitHead": "0937d087709c65b1de50b5b549f46ecbf5b42ba3"
+}

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,
+  },
+});

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('✅ Все воркфлоу синхронизированы успешно');
+  }
+}