@axinom/mosaic-id-link-be 0.13.4-rc.3 → 0.13.4-rc.31

package/src/long-lived-token/index.ts

@@ -1,9 +1,4 @@
 import { TokenResult } from '@axinom/mosaic-id-utils';
-import {
-  assertError,
-  Logger,
-  skipMaskTag,
-} from '@axinom/mosaic-service-common';
 import { getGqlClient } from '../common/gql-client';
 import {
   GenerateLongLivedTokenDocument,
@@ -26,60 +21,49 @@ export const generateLongLivedToken = async (
   userAccessToken: string,
   validityDurationInSeconds?: number,
 ): Promise<TokenResult> => {
-  const logger = new Logger({ context: generateLongLivedToken.name });
-  try {
-    const client = getGqlClient(
-      (await getWellKnownEndpoints(authEndpoint)).authGraphQlEndpoint,
-      serviceAccountToken,
-    );
+  const client = getGqlClient(
+    (await getWellKnownEndpoints(authEndpoint)).authGraphQlEndpoint,
+    serviceAccountToken,
+  );
 
-    const result = await client.mutate<
-      GenerateLongLivedTokenMutation,
-      GenerateLongLivedTokenMutationVariables
-    >({
-      mutation: GenerateLongLivedTokenDocument,
-      variables: {
-        input: {
-          userToken: userAccessToken,
-          validityDurationInSeconds,
-        },
+  const result = await client.mutate<
+    GenerateLongLivedTokenMutation,
+    GenerateLongLivedTokenMutationVariables
+  >({
+    mutation: GenerateLongLivedTokenDocument,
+    variables: {
+      input: {
+        userToken: userAccessToken,
+        validityDurationInSeconds,
       },
-      errorPolicy: 'all',
-      fetchPolicy: 'no-cache',
-    });
-
-    if (!result.errors) {
-      if (!result.data) {
-        throw new Error(
-          `Unexpected null or undefined value received for 'generateLongLivedToken' result.`,
-        );
-      }
-      const tokenResponse = result.data.generateLongLivedToken;
+    },
+    errorPolicy: 'all',
+    fetchPolicy: 'no-cache',
+  });
 
-      const longLivedToken = {
-        accessToken: tokenResponse.accessToken,
-        tokenType: tokenResponse.tokenType,
-        expiresInSeconds: tokenResponse.expiresInSeconds,
-      };
-
-      return longLivedToken;
-    } else {
-      const aggregatedErrorMessage = result.errors.reduce(
-        (aggregatedError, gqlError) => {
-          return (aggregatedError += gqlError.message);
-        },
-        '',
+  if (!result.errors) {
+    if (!result.data) {
+      throw new Error(
+        `Unexpected null or undefined value received for 'generateLongLivedToken' result.`,
       );
-
-      throw new Error(aggregatedErrorMessage);
     }
-  } catch (error) {
-    assertError(error);
-    logger.error(error, {
-      message: 'Error during call to generateLongLivedToken',
-      details: { skipMaskTag },
-    });
+    const tokenResponse = result.data.generateLongLivedToken;
+
+    const longLivedToken = {
+      accessToken: tokenResponse.accessToken,
+      tokenType: tokenResponse.tokenType,
+      expiresInSeconds: tokenResponse.expiresInSeconds,
+    };
+
+    return longLivedToken;
+  } else {
+    const aggregatedErrorMessage = result.errors.reduce(
+      (aggregatedError, gqlError) => {
+        return (aggregatedError += gqlError.message);
+      },
+      '',
+    );
 
-    throw error;
+    throw new Error(aggregatedErrorMessage);
   }
 };

package/src/service-account-token/index.ts

@@ -1,9 +1,4 @@
 import { TokenResult } from '@axinom/mosaic-id-utils';
-import {
-  assertError,
-  Logger,
-  skipMaskTag,
-} from '@axinom/mosaic-service-common';
 import { getGqlClient } from '../common/gql-client';
 import {
   GetManagedServiceTokenDocument,
@@ -17,9 +12,7 @@ import {
   GetServiceTokenMutationVariables,
 } from '../generated/graphql.types';
 
-const logger = new Logger({ context: 'get-service-account-token' });
-
-// TODO: Once we merge authenticateServiceAccount & authenticateManagedServiceAccount mutaitons,
+// TODO: Once we merge authenticateServiceAccount & authenticateManagedServiceAccount mutations,
 // these functions can also be merged into one.
 
 /**
@@ -34,57 +27,47 @@ export const getServiceAccountToken = async (
   clientId: string,
   clientSecret: string,
 ): Promise<TokenResult> => {
-  try {
-    const client = getGqlClient(new URL(`/graphql`, authEndpoint).href);
-
-    let serviceAccountAccessToken: TokenResult;
-
-    const result = await client.mutate<
-      GetServiceTokenMutation,
-      GetServiceTokenMutationVariables
-    >({
-      mutation: GetServiceTokenDocument,
-      variables: {
-        clientId: clientId,
-        clientSecret: clientSecret,
-      },
-      errorPolicy: 'all',
-      fetchPolicy: 'no-cache',
-    });
-
-    if (!result.errors) {
-      if (!result.data) {
-        throw new Error(
-          `Unexpected null or undefined value received for 'getServiceAccountToken' result.`,
-        );
-      }
-      const tokenResponse = result.data.authenticateServiceAccount;
-
-      serviceAccountAccessToken = {
-        accessToken: tokenResponse.accessToken,
-        tokenType: tokenResponse.tokenType,
-        expiresInSeconds: tokenResponse.expiresInSeconds,
-      };
-
-      return serviceAccountAccessToken;
-    } else {
-      const aggregatedErrorMessage = result.errors.reduce(
-        (aggregatedError, gqlError) => {
-          return (aggregatedError += gqlError.message);
-        },
-        '',
+  const client = getGqlClient(new URL(`/graphql`, authEndpoint).href);
+
+  let serviceAccountAccessToken: TokenResult;
+
+  const result = await client.mutate<
+    GetServiceTokenMutation,
+    GetServiceTokenMutationVariables
+  >({
+    mutation: GetServiceTokenDocument,
+    variables: {
+      clientId: clientId,
+      clientSecret: clientSecret,
+    },
+    errorPolicy: 'all',
+    fetchPolicy: 'no-cache',
+  });
+
+  if (!result.errors) {
+    if (!result.data) {
+      throw new Error(
+        `Unexpected null or undefined value received for 'getServiceAccountToken' result.`,
       );
-
-      throw new Error(aggregatedErrorMessage);
     }
-  } catch (error) {
-    assertError(error);
-    logger.error(error, {
-      message: 'Error during call to getServiceAccountToken',
-      details: { skipMaskTag },
-    });
-
-    throw error;
+    const tokenResponse = result.data.authenticateServiceAccount;
+
+    serviceAccountAccessToken = {
+      accessToken: tokenResponse.accessToken,
+      tokenType: tokenResponse.tokenType,
+      expiresInSeconds: tokenResponse.expiresInSeconds,
+    };
+
+    return serviceAccountAccessToken;
+  } else {
+    const aggregatedErrorMessage = result.errors.reduce(
+      (aggregatedError, gqlError) => {
+        return (aggregatedError += gqlError.message);
+      },
+      '',
+    );
+
+    throw new Error(aggregatedErrorMessage);
   }
 };
 
@@ -104,53 +87,48 @@ export const getManagedServiceAccountToken = async (
   targetTenantId?: string,
   targetEnvironmentId?: string,
 ): Promise<TokenResult> => {
-  try {
-    const client = getGqlClient(new URL(`/graphql`, authEndpoint).href);
-
-    let serviceAccountAccessToken: TokenResult;
-
-    const result = await client.mutate<
-      GetManagedServiceTokenMutation,
-      GetManagedServiceTokenMutationVariables
-    >({
-      mutation: GetManagedServiceTokenDocument,
-      variables: {
-        clientId: clientId,
-        clientSecret: clientSecret,
-        targetTenantId,
-        targetEnvironmentId: targetEnvironmentId,
-      },
-      errorPolicy: 'all',
-      fetchPolicy: 'no-cache',
-    });
-
-    if (!result.errors && result.data) {
-      const tokenResponse = result.data.authenticateManagedServiceAccount;
-
-      serviceAccountAccessToken = {
-        accessToken: tokenResponse.accessToken,
-        tokenType: tokenResponse.tokenType,
-        expiresInSeconds: tokenResponse.expiresInSeconds,
-      };
-
-      return serviceAccountAccessToken;
-    } else {
-      const aggregatedErrorMessage = result.errors?.reduce(
-        (aggregatedError, gqlError) => {
-          return (aggregatedError += gqlError.message);
-        },
-        '',
+  const client = getGqlClient(new URL(`/graphql`, authEndpoint).href);
+
+  let serviceAccountAccessToken: TokenResult;
+
+  const result = await client.mutate<
+    GetManagedServiceTokenMutation,
+    GetManagedServiceTokenMutationVariables
+  >({
+    mutation: GetManagedServiceTokenDocument,
+    variables: {
+      clientId: clientId,
+      clientSecret: clientSecret,
+      targetTenantId,
+      targetEnvironmentId: targetEnvironmentId,
+    },
+    errorPolicy: 'all',
+    fetchPolicy: 'no-cache',
+  });
+
+  if (!result.errors) {
+    if (!result.data) {
+      throw new Error(
+        `Unexpected null or undefined value received for 'getManagedServiceAccountToken' result.`,
       );
-      throw new Error(aggregatedErrorMessage);
     }
-  } catch (error) {
-    assertError(error);
-    logger.error(error, {
-      message: 'Error during call to getManagedServiceAccountToken',
-      details: { skipMaskTag },
-    });
-
-    throw error;
+    const tokenResponse = result.data.authenticateManagedServiceAccount;
+
+    serviceAccountAccessToken = {
+      accessToken: tokenResponse.accessToken,
+      tokenType: tokenResponse.tokenType,
+      expiresInSeconds: tokenResponse.expiresInSeconds,
+    };
+
+    return serviceAccountAccessToken;
+  } else {
+    const aggregatedErrorMessage = result.errors.reduce(
+      (aggregatedError, gqlError) => {
+        return (aggregatedError += gqlError.message);
+      },
+      '',
+    );
+    throw new Error(aggregatedErrorMessage);
   }
 };
 
@@ -171,52 +149,47 @@ export const getScopedManagedServiceAccountToken = async (
   clientSecret: string,
   managementJWT: string,
 ): Promise<TokenResult> => {
-  try {
-    const client = getGqlClient(new URL(`/graphql`, authEndpoint).href);
-
-    let serviceAccountAccessToken: TokenResult;
-
-    const result = await client.mutate<
-      GetManagedServiceTokenWithEnvironmentScopeMutation,
-      GetManagedServiceTokenWithEnvironmentScopeMutationVariables
-    >({
-      mutation: GetManagedServiceTokenWithEnvironmentScopeDocument,
-      variables: {
-        clientId: clientId,
-        clientSecret: clientSecret,
-        managementJWT,
-      },
-      errorPolicy: 'all',
-      fetchPolicy: 'no-cache',
-    });
-
-    if (!result.errors && result.data) {
-      const tokenResponse =
-        result.data.authenticateManagedServiceAccountWithEnvironmentScope;
-
-      serviceAccountAccessToken = {
-        accessToken: tokenResponse.accessToken,
-        tokenType: tokenResponse.tokenType,
-        expiresInSeconds: tokenResponse.expiresInSeconds,
-      };
-
-      return serviceAccountAccessToken;
-    } else {
-      const aggregatedErrorMessage = result.errors?.reduce(
-        (aggregatedError, gqlError) => {
-          return (aggregatedError += gqlError.message);
-        },
-        '',
+  const client = getGqlClient(new URL(`/graphql`, authEndpoint).href);
+
+  let serviceAccountAccessToken: TokenResult;
+
+  const result = await client.mutate<
+    GetManagedServiceTokenWithEnvironmentScopeMutation,
+    GetManagedServiceTokenWithEnvironmentScopeMutationVariables
+  >({
+    mutation: GetManagedServiceTokenWithEnvironmentScopeDocument,
+    variables: {
+      clientId: clientId,
+      clientSecret: clientSecret,
+      managementJWT,
+    },
+    errorPolicy: 'all',
+    fetchPolicy: 'no-cache',
+  });
+
+  if (!result.errors) {
+    if (!result.data) {
+      throw new Error(
+        `Unexpected null or undefined value received for 'getScopedManagedServiceAccountToken' result.`,
       );
-      throw new Error(aggregatedErrorMessage);
     }
-  } catch (error) {
-    assertError(error);
-    logger.error(error, {
-      message: 'Error during call to getScopedManagedServiceAccountToken',
-      details: { skipMaskTag },
-    });
-
-    throw error;
+    const tokenResponse =
+      result.data.authenticateManagedServiceAccountWithEnvironmentScope;
+
+    serviceAccountAccessToken = {
+      accessToken: tokenResponse.accessToken,
+      tokenType: tokenResponse.tokenType,
+      expiresInSeconds: tokenResponse.expiresInSeconds,
+    };
+
+    return serviceAccountAccessToken;
+  } else {
+    const aggregatedErrorMessage = result.errors.reduce(
+      (aggregatedError, gqlError) => {
+        return (aggregatedError += gqlError.message);
+      },
+      '',
+    );
+    throw new Error(aggregatedErrorMessage);
   }
 };

package/src/well-known-endpoints/index.ts

@@ -1,6 +1,4 @@
-import { Logger } from '@axinom/mosaic-service-common';
 import axios from 'axios';
-import { assertAxiosError } from '../common';
 import { WellKnownEndpoints } from '../common/types';
 
 /**
@@ -11,40 +9,10 @@ import { WellKnownEndpoints } from '../common/types';
 export async function getWellKnownEndpoints(
   authEndpoint: string,
 ): Promise<WellKnownEndpoints> {
-  const logger = new Logger({ context: getWellKnownEndpoints.name });
   const wellKnownEndpointUrl = new URL(`/.well-known`, `${authEndpoint}`).href;
 
-  try {
-    const result: WellKnownEndpoints = (await axios.get(wellKnownEndpointUrl))
-      .data;
-    return result;
-  } catch (error) {
-    const message = 'Error occurred while requesting /.well-known endpoint';
-    assertAxiosError(error);
-    if (error.response) {
-      // Received an error response (5xx, 4xx) from the server
-      logger.error({
-        message,
-        details: {
-          responseStatus: error.response.status,
-          responseData: error.response.data,
-          responseHeaders: error.response.headers,
-          stack: error.stack,
-        },
-      });
-    } else if (error.request) {
-      // Did not receive a response, or request never left
-      logger.error({
-        message: `${message}. Did not receive a response from the server.`,
-        details: { requestPath: error.request.path, stack: error.stack },
-      });
-    } else {
-      logger.error({
-        message,
-        details: { error: error.message, stack: error.stack },
-      });
-    }
+  const result: WellKnownEndpoints = (await axios.get(wellKnownEndpointUrl))
+    .data;
 
-    throw new Error(message);
-  }
+  return result;
 }