Core.callModule – bezpośrednie wywołania

Core.callModule pozwala wywołać metodę zarejestrowaną w dowolnym innym module zainstalowanym na tej samej instancji Orbito. Wywołanie przechodzi przez serwer Orbito, który przekazuje je do odpowiedniego kontenera i zwraca wynik.

Składnia

const result = await Core.callModule(moduleId, methodName, params)

Parametr	Typ	Opis
`moduleId`	`string`	Identyfikator modułu docelowego (np. `'core/orders'`)
`methodName`	`string`	Nazwa metody zarejestrowanej przez `Core.registerMethod`
`params`	`object`	Argumenty przekazywane do metody

Porady

Metoda jest asynchroniczna i zawsze zwraca Promise. Używaj await.

Kontekst firmy

companyId nie jest przekazywane – platforma ustala je na podstawie tożsamości połączenia. Wywołanie zawsze trafia do modułu tej samej firmy. Szczegóły w Kontekst firmy.

Moduł zainstalowany kilka razy

Adresowanie po kodzie modułu jest jednoznaczne tylko wtedy, gdy firma ma jedną aktywną instalację modułu docelowego. Gdy ma ich więcej (np. trzy sklepy Prestashop), platforma odrzuca wywołanie błędem AMBIGUOUS_MODULE_TARGET – wtedy użyj Core.callInstanceMethod.

Core.callInstanceMethod

Wywołuje metodę konkretnej instalacji modułu, adresowanej po instanceId. To wariant callModule dla modułów instalowanych wielokrotnie.

const result = await Core.callInstanceMethod(targetInstanceId, methodName, params)

Parametr	Typ	Opis
`targetInstanceId`	`string`	Identyfikator instancji modułu docelowego
`methodName`	`string`	Nazwa metody zarejestrowanej przez `Core.registerMethod`
`params`	`object`	Argumenty przekazywane do metody

Platforma sprawdza, że instancja docelowa należy do tej samej firmy – identyfikator instancji z innej firmy zostanie odrzucony takim samym komunikatem jak identyfikator nieistniejący.

Skąd wziąć instanceId:

z this.caller.instanceId / ctx.caller.instanceId, gdy odpowiadasz instancji, która sama Cię wywołała lub odpaliła hook,
z własnej konfiguracji modułu (użytkownik wybiera sklep na ekranie ustawień),
z Core.getInstanceId() po stronie modułu, który chce się „przedstawić" innemu modułowi.

Przykład – fallback z kodu modułu na instancję:

const { Core } = require('@orbito/api-lib');

async function syncOrders(shopInstanceId) {
  try {
    return await Core.callModule('core/prestashop', 'syncOrders', {});
  } catch (err) {
    if (err.code !== 'AMBIGUOUS_MODULE_TARGET') throw err;

    // Firma ma kilka sklepów – trzeba wskazać konkretny
    return await Core.callInstanceMethod(shopInstanceId, 'syncOrders', {});
  }
}

Przykład – odpowiedź do instancji, która nas wywołała:

Core.registerMethod('stock.reserve', async (params, ctx) => {
  const reservation = await reserve(params);

  if (ctx.caller) {
    // Odsyłamy potwierdzenie dokładnie do tego sklepu, który prosił o rezerwację
    await Core.callInstanceMethod(ctx.caller.instanceId, 'stock.reserved', {
      reservationId: reservation._id
    });
  }

  return reservation;
});

Przykłady

Pobranie szczegółów zamówienia

const { Core, Log } = require('@orbito/api-lib');

Core.registerMethod('invoice.generate', async (params, ctx) => {
  // Pobranie danych zamówienia z modułu core/orders
  const order = await Core.callModule(
    'core/orders',
    'order.get',
    { orderId: params.orderId }
  );

  Log.info('Pobrano zamówienie do faktury', { orderId: order._id });

  // ... generowanie faktury na podstawie order ...

  return { invoiceId: generatedId };
});

Łańcuch wywołań

Moduły mogą wywoływać siebie nawzajem, budując bardziej złożone przepływy:

Core.registerMethod('shipment.create', async (params, ctx) => {
  // 1. Pobierz zamówienie
  const order = await Core.callModule('core/orders', 'order.get', {
    orderId: params.orderId
  });

  // 2. Pobierz dane klienta
  const customer = await Core.callModule('core/customers', 'customer.get', {
    customerId: order.customerId
  });

  // 3. Utwórz przesyłkę
  const shipment = await createShipment(order, customer);

  return shipment;
});

Obsługa błędów

Core.callModule rzuci wyjątek w następujących sytuacjach:

moduł docelowy nie jest zainstalowany dla danej firmy,
firma ma kilka aktywnych instalacji modułu docelowego – błąd ma wtedy err.code === 'AMBIGUOUS_MODULE_TARGET', a wywołanie trzeba powtórzyć przez Core.callInstanceMethod,
metoda o podanej nazwie nie istnieje (nie została zarejestrowana),
handler metody w module docelowym rzucił wyjątek.

Core.callInstanceMethod rzuci wyjątek również wtedy, gdy wskazana instancja nie istnieje, jest wyłączona albo należy do innej firmy (komunikat jest w tych przypadkach identyczny – platforma nie zdradza istnienia cudzych instancji).

Zawsze opakuj wywołanie w try/catch:

Core.registerMethod('process', async (params, ctx) => {
  let order;

  try {
    order = await Core.callModule('core/orders', 'order.get', {
      orderId: params.orderId
    });
  } catch (err) {
    Log.error('Nie udało się pobrać zamówienia', {
      orderId: params.orderId,
      error: err.message
    });
    // Zwróć czytelny błąd zamiast pozwolić wyjątkowi propagować
    return { success: false, error: 'Zamówienie niedostępne' };
  }

  // ... dalsza logika ...
});

Cykliczne wywołania

Unikaj sytuacji, w której moduł A wywołuje moduł B, a moduł B wywołuje moduł A. Orbito nie chroni przed cyklami – spowodują one błąd przekroczenia czasu lub przepełnienie stosu.