Асинхронность и Promise в TypeScript

// Создаём типизированный Promise, который разрешается строкой
const fetchGreeting = (): Promise<string> => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const success = Math.random() > 0.5;
      if (success) {
        resolve("Привет, TypeScript!");
      } else {
        reject(new Error("Не удалось получить приветствие"));
      }
    }, 1000);
  });
};

// Используем Promise с правильным выводом типов
fetchGreeting()
  .then((greeting) => {
    // TypeScript знает, что 'greeting' — это строка
    console.log(greeting.toUpperCase());
  })
  .catch((error: Error) => {
    console.error("Ошибка:", error.message);
  });

// Определяем типы для ответа нашего API
interface User {
  id: number;
  name: string;
  email: string;
  role: 'admin' | 'user' | 'guest';
}

// Функция, которая возвращает Promise с массивом User
async function fetchUsers(): Promise<User[]> {
  console.log('Загрузка пользователей...');
  // Имитируем вызов API
  await new Promise(resolve => setTimeout(resolve, 1000));
  return [
    { id: 1, name: 'Alice', email: 'alice@example.com', role: 'admin' },
    { id: 2, name: 'Bob', email: 'bob@example.com', role: 'user' }
  ];
}

// Асинхронная функция для обработки пользователей
async function processUsers() {
  try {
    // TypeScript знает, что users имеет тип User[]
    const users = await fetchUsers();
    console.log(`Получено пользователей: ${users.length}`);

    // Типобезопасный доступ к свойствам
    const adminEmails = users
      .filter(user => user.role === 'admin')
      .map(user => user.email);

    console.log('Email администраторов:', adminEmails);
    return users;
  } catch (error) {
    if (error instanceof Error) {
      console.error('Не удалось обработать пользователей:', error.message);
    } else {
      console.error('Произошла неизвестная ошибка');
    }
    throw error; // Пробрасываем дальше, чтобы вызывающий код мог обработать
  }
}

// Запускаем асинхронную функцию
processUsers()
  .then(users => console.log('Обработка завершена'))
  .catch(err => console.error('Обработка не удалась:', err));

interface Product {
  id: number;
  name: string;
  price: number;
}

async function fetchProduct(id: number): Promise<Product> {
  console.log(`Загрузка товара ${id}...`);
  await new Promise(resolve => setTimeout(resolve, Math.random() * 1000));
  return { id, name: `Товар ${id}`, price: Math.floor(Math.random() * 100) };
}

async function fetchMultipleProducts() {
  try {
    // Запускаем все загрузки параллельно
    const [product1, product2, product3] = await Promise.all([
      fetchProduct(1),
      fetchProduct(2),
      fetchProduct(3)
    ]);

    const total = [product1, product2, product3]
      .reduce((sum, product) => sum + product.price, 0);
    console.log(`Итоговая цена: $${total.toFixed(2)}`);
  } catch (error) {
    console.error('Ошибка при загрузке товаров:', error);
  }
}

fetchMultipleProducts();

// Определяем тип для колбэка
type FetchCallback = (error: Error | null, data?: string) => void;

// Функция, принимающая типизированный колбэк
function fetchDataWithCallback(url: string, callback: FetchCallback): void {
  // Имитируем асинхронную операцию
  setTimeout(() => {
    try {
      // Имитируем успешный ответ
      callback(null, "Данные ответа");
    } catch (error) {
      callback(error instanceof Error ? error : new Error('Неизвестная ошибка'));
    }
  }, 1000);
}

// Использование функции с колбэком
fetchDataWithCallback('https://api.example.com', (error, data) => {
  if (error) {
    console.error('Ошибка:', error.message);
    return;
  }

  // TypeScript знает, что data — это строка (или undefined)
  if (data) {
    console.log(data.toUpperCase());
  }
});

// Промисы разных типов
const fetchUser = (id: number): Promise<{ id: number; name: string }> =>
  Promise.resolve({ id, name: `Пользователь ${id}` });

const fetchPosts = (userId: number): Promise<Array<{ id: number; title: string }>> =>
  Promise.resolve([
    { id: 1, title: 'Запись 1' },
    { id: 2, title: 'Запись 2' }
  ]);

const fetchStats = (userId: number): Promise<{ views: number; likes: number }> =>
  Promise.resolve({ views: 100, likes: 25 });

// Запускаем всё параллельно
async function loadUserDashboard(userId: number) {
  try {
    const [user, posts, stats] = await Promise.all([
      fetchUser(userId),
      fetchPosts(userId),
      fetchStats(userId)
    ]);

    // TypeScript знает типы user, posts и stats
    console.log(`Пользователь: ${user.name}`);
    console.log(`Записей: ${posts.length}`);
    console.log(`Лайков: ${stats.likes}`);

    return { user, posts, stats };
  } catch (error) {
    console.error('Не удалось загрузить панель:', error);
    throw error;
  }
}

// Запускаем с идентификатором пользователя
loadUserDashboard(1);

// Вспомогательная функция для тайм-аута
const timeout = (ms: number): Promise<never> =>
  new Promise((_, reject) =>
    setTimeout(() => reject(new Error(`Тайм-аут через ${ms} мс`)), ms)
  );

// Имитируем вызов API с тайм-аутом
async function fetchWithTimeout<T>(
  promise: Promise<T>,
  timeoutMs: number = 5000
): Promise<T> {
  return Promise.race([
    promise,
    timeout(timeoutMs).then(() => {
      throw new Error(`Время ожидания запроса истекло через ${timeoutMs} мс`);
    }),
  ]);
}

// Пример использования
async function fetchUserData() {
  try {
    const response = await fetchWithTimeout(
      fetch('https://api.example.com/user/1'),
      3000 // тайм-аут 3 секунды
    );
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Ошибка:', (error as Error).message);
    throw error;
  }
}

// Имитируем несколько вызовов API с разными результатами
const fetchData = async (id: number) => {
  // Случайным образом «роняем» часть запросов
  if (Math.random() > 0.7) {
    throw new Error(`Не удалось получить данные для ID ${id}`);
  }
  return { id, data: `Данные для ${id}` };
};

// Обрабатываем несколько элементов с индивидуальной обработкой ошибок
async function processBatch(ids: number[]) {
  const promises = ids.map(id =>
    fetchData(id)
      .then(value => ({ status: 'fulfilled' as const, value }))
      .catch(reason => ({ status: 'rejected' as const, reason }))
  );

  // Ждём завершения всех
  const results = await Promise.allSettled(promises);

  // Обрабатываем результаты
  const successful = results
    .filter((result): result is PromiseFulfilledResult<{ status: 'fulfilled', value: any }> =>
      result.status === 'fulfilled' &&
      result.value.status === 'fulfilled'
    )
    .map(r => r.value.value);

  const failed = results
    .filter((result): result is PromiseRejectedResult |
      PromiseFulfilledResult<{ status: 'rejected', reason: any }> => {
      if (result.status === 'rejected') return true;
      return result.value.status === 'rejected';
    });

  console.log(`Успешно обработано: ${successful.length}`);
  console.log(`Не удалось: ${failed.length}`);

  return { successful, failed };
}

// Обрабатываем пакет идентификаторов
processBatch([1, 2, 3, 4, 5]);

// Базовый класс ошибки для нашего приложения
class AppError extends Error {
  constructor(
    message: string,
    public readonly code: string,
    public readonly details?: unknown
  ) {
    super(message);
    this.name = this.constructor.name;
    (Error as any).captureStackTrace?.(this, this.constructor);
  }
}

// Конкретные типы ошибок
class NetworkError extends AppError {
  constructor(message: string, details?: unknown) {
    super(message, 'NETWORK_ERROR', details);
  }
}

class ValidationError extends AppError {
  constructor(
    public readonly field: string,
    message: string
  ) {
    super(message, 'VALIDATION_ERROR', { field });
  }
}

class NotFoundError extends AppError {
  constructor(resource: string, id: string | number) {
    super(
      `${resource} с ID ${id} не найден`,
      'NOT_FOUND',
      { resource, id }
    );
  }
}

// Локальная замена fetch, чтобы пример никогда не обращался к сети
const mockFetch = (url: string): Promise<{ ok: boolean; status: number; json: () => Promise<any> }> =>
  Promise.resolve({
    ok: true,
    status: 200,
    json: async () => ({ id: url.split('/').pop(), name: 'Alice' })
  });

// Пример использования
async function fetchUserData(userId: string): Promise<{ id: string; name: string }> {
  try {
    // Имитируем вызов API
    const response = await mockFetch(`/api/users/${userId}`);

    if (!response.ok) {
      if (response.status === 404) {
        throw new NotFoundError('Пользователь', userId);
      } else if (response.status >= 500) {
        throw new NetworkError('Ошибка сервера', { status: response.status });
      } else {
        throw new Error(`Ошибка HTTP! статус: ${response.status}`);
      }
    }

    const data = await response.json();

    // Проверяем данные ответа
    if (!data.name) {
      throw new ValidationError('name', 'Поле name обязательно');
    }

    return data;
  } catch (error) {
    if (error instanceof AppError) {
      // Это уже одна из наших пользовательских ошибок
      throw error;
    }
    // Оборачиваем непредвиденные ошибки
    throw new AppError(
      'Не удалось получить данные пользователя',
      'UNEXPECTED_ERROR',
      { cause: error }
    );
  }
}

// Обработка ошибок в приложении
async function displayUserProfile(userId: string) {
  try {
    const user = await fetchUserData(userId);
    console.log('Профиль пользователя:', user);
  } catch (error) {
    if (error instanceof NetworkError) {
      console.error('Проблема с сетью:', error.message);
      // Показать интерфейс повторной попытки
    } else if (error instanceof ValidationError) {
      console.error('Проверка не пройдена:', error.message);
      // Подсветить некорректное поле
    } else if (error instanceof NotFoundError) {
      console.error('Не найдено:', error.message);
      // Показать страницу 404
    } else {
      console.error('Непредвиденная ошибка:', error);
      // Показать общее сообщение об ошибке
    }
  }
}

// Запускаем с примерными данными
displayUserProfile('123');

// Асинхронная функция-генератор
async function* generateNumbers(): AsyncGenerator<number, void, unknown> {
  let i = 0;
  while (i < 5) {
    // Имитируем асинхронную операцию
    await new Promise(resolve => setTimeout(resolve, 1000));
    yield i++;
  }
}

// Использование асинхронного генератора
async function consumeNumbers() {
  for await (const num of generateNumbers()) {
    // TypeScript знает, что num — это число
    console.log(num * 2);
  }
}