Вызовите сервис для каждой строки, возвращенной из другого сервиса, и объедините результаты

Question

Я пытаюсь вызвать одну службу, скажем, Service1, которая возвращает список, а затем вызвать другую службу, Service2, по одному разу для каждой строки. Затем я хочу объединить два результата.

Таким образом, первая служба возвращает список массивов, поля которых определены в интерфейсе. Скажи:

interface Service1 {
   primaryKey1 : string;
   primaryKey2 : string;
   value1      : string;
} 

Затем другой сервис с большим количеством значений должен быть извлечен из второго сервиса.

interface Service2 {
   value2 : string;
   value3: string;
}

Эта служба может возвращать несколько строк для каждой строки, возвращаемой из Service1. И их необходимо объединить, чтобы значения из Service1 были объединены в каждую строку, возвращаемую из Service2.

И мы получим список со следующими значениями:

interface result {
   primaryKey1 : string;
   primaryKey2: string;
   value1 : string;
   value2 : string;
   value3 : string;
}

В дополнение к этой сложности является тот факт, что все вызовы ко второй услуге должны вызываться последовательно, поскольку эта служба допускает только один вызов за один раз. Не одновременно, как хотелось бы.

Итак, мой вопрос. Как бы я хорошо структурировал это в TypeScript? Я действительно не знаю, с чего начать. В настоящее время я вызываю такие службы, как this.executeRequest(request_service1).then((response) => {});, а затем создаю стек с входными данными для следующей службы и выполняю все эти. Но у меня возникли проблемы с созданием начального списка и последующим объединением всех результатов в один и тот же список. Код заканчивается очень плохо структурированным.

Редактировать: По запросу, вот пример данных, которые могут быть возвращены:

Результат Service1:

var service1_result : Service1[] = [
   { primaryKey: "1", primaryKey2: "A", value1: "test"},
   { primaryKey: "1", primaryKey2: "B", value1: "test2"},
   { primaryKey: "2", primaryKey2: "A", value1: "test3"},
]

Результат Service2:

 var service2_result : Service2[] = [
       { value2: "abc", value3: "efg"},
       { value2: "abc2", value3: "efg2"},
       { value2: "abc3", value3: "efg3"},
    ]

Обратите внимание, что Service2 будет возвращать подобные массивы один раз для каждой строки в service1_result. И они должны быть связаны со строкой, к которой они были призваны.

Edit: Таким образом, поток будет выглядеть примерно так:

1. Позвонить в службу сервиса 1
2. Для каждой строки в Service1 используйте этот результат в качестве входных данных для Service2.
3. Объедините данные так, чтобы каждая строка, возвращенная из Service2, стала строкой со всеми значениями из обеих служб.

Если все первые две строки из Service1 вернули все строки из Service2, а третья строка вернула только первую строку из Service2, ответ будет выглядеть следующим образом:

[
   {"1", "A", "Test", "abc", "efg"},
   {"1", "A", "Test", "abc2", "efg2"},
   {"1", "A", "Test", "abc3", "efg3"},
   {"1", "B", "Test2", "abc", "efg"},
   {"1", "B", "Test2", "abc2", "efg2"},
   {"1", "B", "Test2", "abc3", "efg3"},
   {"2", "A", "Test3", "abc", "efg"},
]

Answer 1

при условии, что вы просто хотите объединить каждый элемент из обоих списков (т. Е. zip эти массивы), что-то вроде этого должно сработать

interface Service1Response {
  primaryKey1: string;
  primaryKey2: string;
  value1: string;
}

interface Service2Response {
  value2: string;
  value3: string;
}

interface MergedResult extends Service1Response, Service2Response {}

async function service1Mock(): Promise<Service1Response[]> {
  return [
    { primaryKey1: "1", primaryKey2: "A", value1: "test" },
    { primaryKey1: "1", primaryKey2: "B", value1: "test2" },
    { primaryKey1: "2", primaryKey2: "A", value1: "test3" }
  ];
}

async function service2Mock(): Promise<Service2Response[]> {
  return [
    { value2: "abc", value3: "efg" },
    { value2: "abc2", value3: "efg2" },
    { value2: "abc3", value3: "efg3" }
  ];
}

async function callServices(): Promise<MergedResult[]> {
  const response1 = await service1Mock();
  const response2 = await service2Mock();
  return response1.map((item1, index) => ({ ...item1, ...response2[index] }));
}

callServices()
  .then(response => {
    console.log(response);
  })
  .catch(error => {
    console.error(error);
  });

Answer 2

детская площадка Алгоритм может выглядеть примерно так.Результат находится в 2-х мерном массиве (service1xservice2).Сначала я вызываю службу 1, затем сопоставляю результаты с результатами, возвращенными из вызывающей службы 2. И, наконец, я повторяю все и отображаю его в объединенном объекте.Вы можете сделать его чище и разделить лямбды-маппинги на отдельные именованные функции, которые вам решать.Дайте мне знать, если это то, что вы искали, или я должен отредактировать ответ.