Merge pull request #6 from platform-mesh/feat/onboard-user-iam-log-action

Feat/onboard user iam log action

Author: makdeniss

jest.config.ts

@@ -17,5 +17,24 @@ module.exports = {
   },
   coveragePathIgnorePatterns: ['/node_modules/', '/integration-tests/'],
   coverageDirectory: '../test-run-reports/coverage/unit',
-  transformIgnorePatterns: ['node_modules/(?!@openmfp/portal-server-lib/)'],
+  transformIgnorePatterns: ['/node_modules/(?!(@openmfp/portal-server-lib|graphql-request)/)'],
+  transform: {
+    '^.+\\.(t|j)s$': [
+      'ts-jest',
+      {
+        tsconfig: 'tsconfig.test.json',
+        useESM: true,
+      },
+    ],
+  },
+  testEnvironment: 'node',
+  passWithNoTests: true,
+  roots: ['<rootDir>'],
+  moduleNameMapper: {
+    '^@openmfp/portal-lib(|/.*)$': '<rootDir>/libs/portal-lib/src/$1',
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  preset: 'ts-jest/presets/default-esm',
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleFileExtensions: ['js', 'json', 'ts'],
 };

src/portal-options/index.ts

@@ -2,3 +2,4 @@ export * from './entity-context-provider/account-entity-context-provider.service
 export * from './portal-context-provider/openmfp-portal-context.service.js';
 export * from './request-context-provider/openmfp-request-context-provider.js';
 export * from './service-providers/content-configuration-service-providers.service.js';
+export * from './service-providers/iam/auth-callback-provider.js';

src/portal-options/request-context-provider/openmfp-request-context-provider.spec.ts

@@ -0,0 +1,48 @@
+import { OpenmfpPortalContextService } from '../portal-context-provider/openmfp-portal-context.service';
+import { RequestContextProviderImpl } from './openmfp-request-context-provider';
+import { EnvService } from '@openmfp/portal-server-lib';
+import type { Request } from 'express';
+import { mock } from 'jest-mock-extended';
+
+describe('RequestContextProviderImpl', () => {
+  let provider: RequestContextProviderImpl;
+  const envService = mock<EnvService>();
+  const portalContext = mock<OpenmfpPortalContextService>();
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    (envService.getDomain as unknown as jest.Mock).mockReturnValue({
+      idpName: 'org1',
+      domain: 'org1.example.com',
+    });
+    (portalContext.getContextValues as unknown as jest.Mock).mockResolvedValue({
+      crdGatewayApiUrl: 'http://gateway/graphql',
+      other: 'x',
+    });
+
+    provider = new RequestContextProviderImpl(
+      envService as any,
+      portalContext as any,
+    );
+  });
+
+  it('should merge request query, portal context and organization from envService', async () => {
+    const req = {
+      query: { account: 'acc-123', extra: '1' },
+      hostname: 'org1.example.com',
+    } as unknown as Request;
+
+    const result = await provider.getContextValues(req);
+
+    expect(result).toMatchObject({
+      account: 'acc-123',
+      extra: '1',
+      crdGatewayApiUrl: 'http://gateway/graphql',
+      other: 'x',
+      organization: 'org1',
+    });
+
+    expect(envService.getDomain).toHaveBeenCalledWith(req);
+    expect(portalContext.getContextValues).toHaveBeenCalledWith(req);
+  });
+});

src/portal-options/service-providers/content-configuration-service-providers.service.spec.ts

@@ -7,7 +7,9 @@ jest.mock('graphql-request', () => {
     GraphQLClient: jest.fn().mockImplementation(() => ({
       request: jest.fn(),
     })),
-    gql(query: TemplateStringsArray) { return query[0]; },
+    gql(query: TemplateStringsArray) {
+      return query[0];
+    },
   };
 });
 

src/portal-options/service-providers/iam/auth-callback-provider.spec.ts

@@ -0,0 +1,68 @@
+import { AuthCallbackProvider } from './auth-callback-provider';
+import { IAMGraphQlService } from './iam-graphql.service';
+import { Test, TestingModule } from '@nestjs/testing';
+import type { AuthTokenData } from '@openmfp/portal-server-lib';
+import type { Request, Response } from 'express';
+import { mock } from 'jest-mock-extended';
+
+describe('AuthCallbackProvider', () => {
+  let callback: AuthCallbackProvider;
+  let iamServiceMock: IAMGraphQlService;
+
+  beforeEach(async () => {
+    iamServiceMock = mock<IAMGraphQlService>();
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        AuthCallbackProvider,
+        {
+          provide: IAMGraphQlService,
+          useValue: iamServiceMock,
+        },
+      ],
+    }).compile();
+
+    callback = module.get<AuthCallbackProvider>(AuthCallbackProvider);
+  });
+
+  it('should be defined', () => {
+    expect(callback).toBeDefined();
+  });
+
+  it('should create a user', async () => {
+    const req = mock<Request>();
+    const res = mock<Response>();
+
+    await callback.handleSuccess(req, res, {
+      id_token: 'idtoken',
+    } as AuthTokenData);
+
+    expect(iamServiceMock.addUser).toHaveBeenCalledTimes(1);
+    expect(iamServiceMock.addUser).toHaveBeenCalledWith('idtoken', req);
+  });
+
+  it('should log error if addUser throws', async () => {
+    const req = mock<Request>();
+    const res = mock<Response>();
+    const error = new Error('boom');
+    (iamServiceMock.addUser as jest.Mock).mockRejectedValueOnce(error);
+
+    const errorSpy = jest
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .spyOn((callback as any).logger, 'error')
+      .mockImplementation(() => undefined as unknown as never);
+
+    await callback.handleSuccess(req, res, {
+      id_token: 'bad',
+    } as AuthTokenData);
+
+    expect(iamServiceMock.addUser).toHaveBeenCalledTimes(1);
+    expect(errorSpy).toHaveBeenCalledWith(error);
+  });
+
+  it('should resolve handleFailure without action', async () => {
+    const req = mock<Request>();
+    const res = mock<Response>();
+
+    await expect(callback.handleFailure(req, res)).resolves.toBeUndefined();
+  });
+});

src/portal-options/service-providers/iam/auth-callback-provider.ts

@@ -0,0 +1,27 @@
+import { IAMGraphQlService } from './iam-graphql.service.js';
+import { Injectable, Logger } from '@nestjs/common';
+import { AuthCallback, AuthTokenData } from '@openmfp/portal-server-lib';
+import { Request, Response } from 'express';
+
+@Injectable()
+export class AuthCallbackProvider implements AuthCallback {
+  private logger: Logger = new Logger(AuthCallbackProvider.name);
+
+  constructor(private iamService: IAMGraphQlService) {}
+
+  async handleSuccess(
+    request: Request,
+    response: Response,
+    authTokenResponse: AuthTokenData,
+  ): Promise<void> {
+    try {
+      await this.iamService.addUser(authTokenResponse.id_token, request);
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+
+  async handleFailure(request: Request, response: Response): Promise<void> {
+    return Promise.resolve();
+  }
+}

src/portal-options/service-providers/iam/iam-graphql.service.spec.ts

@@ -0,0 +1,60 @@
+import { RequestContextProviderImpl } from '../../request-context-provider/openmfp-request-context-provider';
+import { IAMGraphQlService } from './iam-graphql.service';
+import { MUTATION_LOGIN } from './queries';
+import { GraphQLClient } from 'graphql-request';
+import { mock } from 'jest-mock-extended';
+
+describe('IAMGraphQlService', () => {
+  const mockIamServiceApiUrl = 'http://localhost:8080/query';
+  let service: IAMGraphQlService;
+  const gqlClient = {
+    request: jest.fn(),
+  } as unknown as GraphQLClient;
+
+  const requestContextProvider = mock<RequestContextProviderImpl>({
+    getContextValues: jest
+      .fn()
+      .mockResolvedValue({ iamServiceApiUrl: mockIamServiceApiUrl }),
+  });
+
+  let GraphQLClientMock: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+
+    // Re-apply RequestContextProvider mock after resetAllMocks
+    (
+      requestContextProvider.getContextValues as unknown as jest.Mock
+    ).mockResolvedValue({
+      iamServiceApiUrl: mockIamServiceApiUrl,
+    });
+
+    // Mock GraphQLClient constructor to return our mocked client
+    GraphQLClientMock = jest
+      .spyOn<any, any>(require('graphql-request'), 'GraphQLClient')
+      .mockImplementation(() => gqlClient);
+
+    service = new IAMGraphQlService(requestContextProvider as any);
+  });
+
+  it('should call mutation addUser', async () => {
+    (gqlClient.request as jest.Mock).mockResolvedValue('');
+
+    const response = await service.addUser('token', {} as any);
+
+    expect(GraphQLClientMock).toHaveBeenCalledWith(mockIamServiceApiUrl, {
+      headers: { Authorization: 'Bearer token' },
+    });
+    expect(gqlClient.request).toHaveBeenCalledWith(MUTATION_LOGIN);
+    expect(response).toBe(undefined);
+  });
+
+  it('should call mutation addUser and log error', async () => {
+    console.error = jest.fn();
+    (gqlClient.request as jest.Mock).mockRejectedValue('error');
+
+    const response = await service.addUser('token', {} as any);
+    expect(response).toBe(undefined);
+    expect(console.error).toHaveBeenCalledWith('error');
+  });
+});

src/portal-options/service-providers/iam/iam-graphql.service.ts

@@ -0,0 +1,27 @@
+import { RequestContextProviderImpl } from '../../request-context-provider/openmfp-request-context-provider';
+import { MUTATION_LOGIN } from './queries.js';
+import { Injectable } from '@nestjs/common';
+import type { Request } from 'express';
+import { GraphQLClient } from 'graphql-request';
+
+@Injectable()
+export class IAMGraphQlService {
+  constructor(private requestContextProvider: RequestContextProviderImpl) {}
+
+  async addUser(token: string, request: Request): Promise<void> {
+    const requestContext =
+      await this.requestContextProvider.getContextValues(request);
+    const iamUrl = requestContext.iamServiceApiUrl;
+    const client = new GraphQLClient(iamUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+
+    try {
+      const response = await client.request(MUTATION_LOGIN);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}

src/portal-options/service-providers/iam/queries.ts

@@ -0,0 +1,7 @@
+import { gql } from 'graphql-request';
+
+export const MUTATION_LOGIN = gql`
+  mutation {
+    login
+  }
+`;