Programare asincronă și Promise în TypeScript

// Creăm un Promise tipizat care se rezolvă cu un șir de caractere
const fetchGreeting = (): Promise<string> => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const success = Math.random() > 0.5;
      if (success) {
        resolve("Salut, TypeScript!");
      } else {
        reject(new Error("Preluarea salutului a eșuat"));
      }
    }, 1000);
  });
};

// Folosim Promise-ul cu inferență corectă a tipurilor
fetchGreeting()
  .then((greeting) => {
    // TypeScript știe că „greeting” este un șir de caractere
    console.log(greeting.toUpperCase());
  })
  .catch((error: Error) => {
    console.error("Eroare:", error.message);
  });

// Definim tipurile pentru răspunsul API-ului nostru
interface User {
  id: number;
  name: string;
  email: string;
  role: 'admin' | 'user' | 'guest';
}

// Funcție care întoarce un Promise cu un tablou de User
async function fetchUsers(): Promise<User[]> {
  console.log('Se preiau utilizatorii...');
  // Simulăm un apel de API
  await new Promise(resolve => setTimeout(resolve, 1000));
  return [
    { id: 1, name: 'Alice', email: '[email protected]', role: 'admin' },
    { id: 2, name: 'Bob', email: '[email protected]', role: 'user' }
  ];
}

// Funcție asincronă pentru procesarea utilizatorilor
async function processUsers() {
  try {
    // TypeScript știe că users este User[]
    const users = await fetchUsers();
    console.log(`S-au preluat ${users.length} utilizatori`);

    // Acces la proprietăți verificat de tipuri
    const adminEmails = users
      .filter(user => user.role === 'admin')
      .map(user => user.email);

    console.log('Emailurile administratorilor:', adminEmails);
    return users;
  } catch (error) {
    if (error instanceof Error) {
      console.error('Procesarea utilizatorilor a eșuat:', error.message);
    } else {
      console.error('A apărut o eroare necunoscută');
    }
    throw error; // Rearuncăm eroarea pentru ca apelantul să o trateze
  }
}

// Executăm funcția asincronă
processUsers()
  .then(users => console.log('Procesare finalizată'))
  .catch(err => console.error('Procesarea a eșuat:', err));

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

async function fetchProduct(id: number): Promise<Product> {
  console.log(`Se preia produsul ${id}...`);
  await new Promise(resolve => setTimeout(resolve, Math.random() * 1000));
  return { id, name: `Produsul ${id}`, price: Math.floor(Math.random() * 100) };
}

async function fetchMultipleProducts() {
  try {
    // Pornim toate preluările în paralel
    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(`Preț total: $${total.toFixed(2)}`);
  } catch (error) {
    console.error('Eroare la preluarea produselor:', error);
  }
}

fetchMultipleProducts();

// Definim un tip pentru callback
type FetchCallback = (error: Error | null, data?: string) => void;

// Funcție care primește un callback tipizat
function fetchDataWithCallback(url: string, callback: FetchCallback): void {
  // Simulăm o operațiune asincronă
  setTimeout(() => {
    try {
      // Simulăm un răspuns reușit
      callback(null, "Date de răspuns");
    } catch (error) {
      callback(error instanceof Error ? error : new Error('Eroare necunoscută'));
    }
  }, 1000);
}

// Folosirea funcției cu callback
fetchDataWithCallback('https://api.example.com', (error, data) => {
  if (error) {
    console.error('Eroare:', error.message);
    return;
  }

  // TypeScript știe că data este un șir de caractere (sau undefined)
  if (data) {
    console.log(data.toUpperCase());
  }
});

// Tipuri diferite de promise-uri
const fetchUser = (id: number): Promise<{ id: number; name: string }> =>
  Promise.resolve({ id, name: `Utilizatorul ${id}` });

const fetchPosts = (userId: number): Promise<Array<{ id: number; title: string }>> =>
  Promise.resolve([
    { id: 1, title: 'Postarea 1' },
    { id: 2, title: 'Postarea 2' }
  ]);

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

// Rulăm toate în paralel
async function loadUserDashboard(userId: number) {
  try {
    const [user, posts, stats] = await Promise.all([
      fetchUser(userId),
      fetchPosts(userId),
      fetchStats(userId)
    ]);

    // TypeScript știe tipurile pentru user, posts și stats
    console.log(`Utilizator: ${user.name}`);
    console.log(`Postări: ${posts.length}`);
    console.log(`Aprecieri: ${stats.likes}`);

    return { user, posts, stats };
  } catch (error) {
    console.error('Încărcarea tabloului de bord a eșuat:', error);
    throw error;
  }
}

// Executăm cu un ID de utilizator
loadUserDashboard(1);

// Funcție ajutătoare pentru expirare
const timeout = (ms: number): Promise<never> =>
  new Promise((_, reject) =>
    setTimeout(() => reject(new Error(`Expirare după ${ms}ms`)), ms)
  );

// Simulăm un apel de API cu expirare
async function fetchWithTimeout<T>(
  promise: Promise<T>,
  timeoutMs: number = 5000
): Promise<T> {
  return Promise.race([
    promise,
    timeout(timeoutMs).then(() => {
      throw new Error(`Cererea a expirat după ${timeoutMs}ms`);
    }),
  ]);
}

// Exemplu de utilizare
async function fetchUserData() {
  try {
    const response = await fetchWithTimeout(
      fetch('https://api.example.com/user/1'),
      3000 // expirare după 3 secunde
    );
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Eroare:', (error as Error).message);
    throw error;
  }
}

// Simulăm mai multe apeluri de API cu rezultate diferite
const fetchData = async (id: number) => {
  // Facem ca unele cereri să eșueze aleatoriu
  if (Math.random() > 0.7) {
    throw new Error(`Preluarea datelor pentru ID-ul ${id} a eșuat`);
  }
  return { id, data: `Date pentru ${id}` };
};

// Procesăm mai multe elemente, tratând individual erorile
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 }))
  );

  // Așteptăm ca toate să se încheie
  const results = await Promise.allSettled(promises);

  // Procesăm rezultatele
  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(`Procesate cu succes: ${successful.length}`);
  console.log(`Eșuate: ${failed.length}`);

  return { successful, failed };
}

// Procesăm un lot de ID-uri
processBatch([1, 2, 3, 4, 5]);

// Clasa de eroare de bază pentru aplicația noastră
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);
  }
}

// Tipuri de eroare specifice
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} cu ID-ul ${id} nu a fost găsit`,
      'NOT_FOUND',
      { resource, id }
    );
  }
}

// Înlocuitor local pentru fetch, ca exemplul să nu atingă niciodată rețeaua
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' })
  });

// Exemplu de utilizare
async function fetchUserData(userId: string): Promise<{ id: string; name: string }> {
  try {
    // Simulăm un apel de API
    const response = await mockFetch(`/api/users/${userId}`);

    if (!response.ok) {
      if (response.status === 404) {
        throw new NotFoundError('Utilizatorul', userId);
      } else if (response.status >= 500) {
        throw new NetworkError('Eroare de server', { status: response.status });
      } else {
        throw new Error(`Eroare HTTP! status: ${response.status}`);
      }
    }

    const data = await response.json();

    // Validăm datele din răspuns
    if (!data.name) {
      throw new ValidationError('name', 'Numele este obligatoriu');
    }

    return data;
  } catch (error) {
    if (error instanceof AppError) {
      // Este deja una dintre erorile noastre personalizate
      throw error;
    }
    // Învelim erorile neașteptate
    throw new AppError(
      'Preluarea datelor utilizatorului a eșuat',
      'UNEXPECTED_ERROR',
      { cause: error }
    );
  }
}

// Tratarea erorilor în aplicație
async function displayUserProfile(userId: string) {
  try {
    const user = await fetchUserData(userId);
    console.log('Profilul utilizatorului:', user);
  } catch (error) {
    if (error instanceof NetworkError) {
      console.error('Problemă de rețea:', error.message);
      // Afișăm interfața de reîncercare
    } else if (error instanceof ValidationError) {
      console.error('Validarea a eșuat:', error.message);
      // Evidențiem câmpul invalid
    } else if (error instanceof NotFoundError) {
      console.error('Nu a fost găsit:', error.message);
      // Afișăm pagina 404
    } else {
      console.error('Eroare neașteptată:', error);
      // Afișăm un mesaj de eroare generic
    }
  }
}

// Executăm cu date de exemplu
displayUserProfile('123');

// Funcție generator asincronă
async function* generateNumbers(): AsyncGenerator<number, void, unknown> {
  let i = 0;
  while (i < 5) {
    // Simulăm o operațiune asincronă
    await new Promise(resolve => setTimeout(resolve, 1000));
    yield i++;
  }
}

// Folosirea generatorului asincron
async function consumeNumbers() {
  for await (const num of generateNumbers()) {
    // TypeScript știe că num este un număr
    console.log(num * 2);
  }
}