@platform-mesh/portal-server-lib 0.0.0 → 0.5.2

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

@@ -0,0 +1,157 @@
+import { RequestContext } from '../pm-request-context-provider.js';
+import { ContentConfigurationServiceProvidersService } from './content-configuration-service-providers.service.js';
+import { welcomeNodeConfig } from './models/welcome-node-config.js';
+import { GraphQLClient } from 'graphql-request';
+
+jest.mock('graphql-request', () => {
+  return {
+    GraphQLClient: jest.fn().mockImplementation(() => ({
+      request: jest.fn(),
+    })),
+    gql(query: TemplateStringsArray) {
+      return query[0];
+    },
+  };
+});
+
+describe('ContentConfigurationServiceProvidersService', () => {
+  let service: ContentConfigurationServiceProvidersService;
+  let mockClient: jest.Mocked<GraphQLClient>;
+  let context: RequestContext;
+
+  beforeEach(() => {
+    service = new ContentConfigurationServiceProvidersService();
+    mockClient = new GraphQLClient('') as any;
+    (GraphQLClient as jest.Mock).mockReturnValue(mockClient);
+    context = {
+      isSubDomain: true,
+      organization: 'org1',
+      crdGatewayApiUrl:
+        'http://example.com/kubernetes-graphql-gateway/root/graphql',
+      account: 'acc1',
+    } as RequestContext;
+  });
+
+  it('throws if token is missing', async () => {
+    await expect(
+      service.getServiceProviders('', ['entity'], context),
+    ).rejects.toThrow('Token is required');
+  });
+
+  it('throws if context organization is missing', async () => {
+    const badContext = { ...context, organization: undefined } as any;
+    await expect(
+      service.getServiceProviders('token', ['entity'], badContext),
+    ).rejects.toThrow('Context with organization is required');
+  });
+
+  it('returns welcome node config when on the base domain', async () => {
+    context.isSubDomain = false;
+    const result = await service.getServiceProviders(
+      'token',
+      ['entity'],
+      context,
+    );
+
+    expect(result).toEqual(welcomeNodeConfig);
+  });
+
+  it('throws if context organization is missing', async () => {
+    context.isSubDomain = false;
+    const result = await service.getServiceProviders(
+      'token',
+      ['entity'],
+      context,
+    );
+
+    expect(result).toEqual(welcomeNodeConfig);
+  });
+
+  it('returns parsed content configurations', async () => {
+    mockClient.request.mockResolvedValue({
+      ui_platform_mesh_io: {
+        ContentConfigurations: [
+          {
+            metadata: {
+              name: 'conf1',
+              labels: { 'ui.platform-mesh.io/entity': 'entity' },
+            },
+            spec: { remoteConfiguration: { url: 'http://remote' } },
+            status: {
+              configurationResult: JSON.stringify({ url: 'http://parsed' }),
+            },
+          },
+        ],
+      },
+    });
+    const result = await service.getServiceProviders(
+      'token',
+      ['entity'],
+      context,
+    );
+    expect(result.rawServiceProviders[0].contentConfiguration[0].url).toBe(
+      'http://parsed',
+    );
+  });
+
+  it('falls back to spec.remoteConfiguration.url if missing in parsed config', async () => {
+    mockClient.request.mockResolvedValue({
+      ui_platform_mesh_io: {
+        ContentConfigurations: [
+          {
+            metadata: {
+              name: 'conf1',
+              labels: { 'ui.platform-mesh.io/entity': 'entity' },
+            },
+            spec: { remoteConfiguration: { url: 'http://remote' } },
+            status: { configurationResult: JSON.stringify({}) },
+          },
+        ],
+      },
+    });
+    const result = await service.getServiceProviders(
+      'token',
+      ['entity'],
+      context,
+    );
+    expect(result.rawServiceProviders[0].contentConfiguration[0].url).toBe(
+      'http://remote',
+    );
+  });
+
+  it('throws on missing configurationResult', async () => {
+    mockClient.request.mockResolvedValue({
+      ui_platform_mesh_io: {
+        ContentConfigurations: [
+          {
+            metadata: {
+              name: 'conf1',
+              labels: { 'ui.platform-mesh.io/entity': 'entity' },
+            },
+            spec: { remoteConfiguration: { url: 'http://remote' } },
+            status: {},
+          },
+        ],
+      },
+    });
+    await expect(
+      service.getServiceProviders('token', ['entity'], context),
+    ).rejects.toThrow('Missing configurationResult');
+  });
+
+  it('throws if response structure is invalid', async () => {
+    mockClient.request.mockResolvedValue({});
+    await expect(
+      service.getServiceProviders('token', ['entity'], context),
+    ).rejects.toThrow(
+      'Invalid response structure: missing ContentConfigurations',
+    );
+  });
+
+  it('wraps unexpected errors', async () => {
+    mockClient.request.mockRejectedValue(new Error('network error'));
+    await expect(
+      service.getServiceProviders('token', ['entity'], context),
+    ).rejects.toThrow('Failed to fetch content configurations: network error');
+  });
+});

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

@@ -0,0 +1,130 @@
+import { RequestContext } from '../pm-request-context-provider.js';
+import { contentConfigurationsQuery } from './contentconfigurations-query.js';
+import { ContentConfigurationQueryResponse } from './models/contentconfigurations.js';
+import { welcomeNodeConfig } from './models/welcome-node-config.js';
+import { Injectable } from '@nestjs/common';
+import {
+  ContentConfiguration,
+  ServiceProviderResponse,
+  ServiceProviderService,
+} from '@openmfp/portal-server-lib';
+import { GraphQLClient } from 'graphql-request';
+
+@Injectable()
+export class ContentConfigurationServiceProvidersService
+  implements ServiceProviderService
+{
+  async getServiceProviders(
+    token: string,
+    entities: string[],
+    context: RequestContext,
+  ): Promise<ServiceProviderResponse> {
+    // Validate required parameters
+    if (!token) {
+      throw new Error('Token is required');
+    }
+
+    if (!context.isSubDomain) {
+      return welcomeNodeConfig;
+    }
+
+    if (!context?.organization) {
+      throw new Error('Context with organization is required');
+    }
+
+    let url = context.crdGatewayApiUrl.replace(
+      'kubernetes-graphql-gateway/root',
+      'kubernetes-graphql-gateway/virtual-workspace/contentconfigurations/root',
+    );
+
+    const platformMeshAccountId = context?.['core_platform-mesh_io_account'];
+    if (platformMeshAccountId) {
+      url = url.replace('/graphql', `:${platformMeshAccountId}/graphql`);
+    }
+
+    console.log(`Calculated crd gateway api url: ${url}`);
+    const client = new GraphQLClient(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+
+    try {
+      const response = await client.request<ContentConfigurationQueryResponse>(
+        contentConfigurationsQuery,
+        {},
+      );
+
+      // Validate response structure
+      if (!response?.ui_platform_mesh_io?.ContentConfigurations) {
+        throw new Error(
+          'Invalid response structure: missing ContentConfigurations',
+        );
+      }
+
+      const entity = !entities || !entities.length ? 'main' : entities[0];
+      const contentConfigurations =
+        response.ui_platform_mesh_io.ContentConfigurations.filter(
+          (item) =>
+            item.metadata.labels?.['ui.platform-mesh.io/entity'] === entity,
+        ).map((item) => {
+          try {
+            // Validate required fields
+            if (!item.status?.configurationResult) {
+              throw new Error(
+                `Missing configurationResult for item: ${item.metadata?.name || 'unknown'}`,
+              );
+            }
+
+            const contentConfiguration = JSON.parse(
+              item.status.configurationResult,
+            ) as ContentConfiguration;
+
+            if (!contentConfiguration.url) {
+              contentConfiguration.url = item.spec.remoteConfiguration?.url;
+            }
+            return contentConfiguration;
+          } catch (parseError) {
+            // Log the error but don't fail the entire operation
+            console.error(
+              `Failed to parse configuration for item ${item.metadata?.name || 'unknown'}:`,
+              parseError,
+            );
+
+            // Re-throw specific errors as-is, others as JSON parse errors
+            if (
+              parseError instanceof Error &&
+              parseError.message.includes('Missing configurationResult')
+            ) {
+              throw parseError;
+            }
+            throw new Error(
+              `Invalid JSON in configurationResult for item: ${item.metadata?.name || 'unknown'}`,
+            );
+          }
+        });
+
+      return {
+        rawServiceProviders: [
+          {
+            name: 'platform-mesh-system',
+            displayName: '',
+            creationTimestamp: '',
+            contentConfiguration: contentConfigurations,
+          },
+        ],
+      };
+    } catch (error) {
+      // Re-throw with more context if it's not already our custom error
+      if (
+        error instanceof Error &&
+        error.message.includes('configurationResult')
+      ) {
+        throw error;
+      }
+      throw new Error(
+        `Failed to fetch content configurations: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      );
+    }
+  }
+}

package/src/portal-options/service-providers/contentconfigurations-query.ts

@@ -0,0 +1,22 @@
+import { gql } from 'graphql-request';
+
+export const contentConfigurationsQuery = gql`
+  query {
+    ui_platform_mesh_io {
+      ContentConfigurations {
+        metadata {
+          name
+          labels
+        }
+        spec {
+          remoteConfiguration {
+            url
+          }
+        }
+        status {
+          configurationResult
+        }
+      }
+    }
+  }
+`;

package/src/portal-options/service-providers/kubernetes-service-providers.service.spec.ts

@@ -0,0 +1,197 @@
+import { KcpKubernetesService } from '../services/kcp-k8s.service.js';
+import { KubernetesServiceProvidersService } from './kubernetes-service-providers.service.js';
+import { welcomeNodeConfig } from './models/welcome-node-config.js';
+import { mock } from 'jest-mock-extended';
+
+const listClusterCustomObject = jest.fn();
+
+jest.mock('@kubernetes/client-node', () => {
+  class KubeConfig {
+    loadFromDefault = jest.fn();
+    loadFromFile = jest.fn();
+    getCurrentCluster = jest.fn().mockReturnValue({
+      server: 'https://k8s.example.com/base',
+      name: 'test-cluster',
+    });
+    makeApiClient = jest.fn().mockImplementation(() => ({
+      listClusterCustomObject,
+    }));
+    addUser = jest.fn();
+    addContext = jest.fn();
+    setCurrentContext = jest.fn();
+  }
+  class CustomObjectsApi {}
+  return { KubeConfig, CustomObjectsApi };
+});
+
+jest.mock('@kubernetes/client-node/dist/gen/middleware.js', () => ({
+  PromiseMiddlewareWrapper: class {
+    pre?: (ctx: any) => Promise<any> | any;
+    post?: (ctx: any) => Promise<any> | any;
+    constructor(opts: any) {
+      this.pre = opts.pre;
+      this.post = opts.post;
+    }
+  },
+}));
+
+describe('KubernetesServiceProvidersService', () => {
+  let kcpKubernetesServiceMock: jest.Mocked<KcpKubernetesService>;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    kcpKubernetesServiceMock = mock();
+    kcpKubernetesServiceMock.getKcpWorkspaceUrl.mockReturnValue(
+      new URL('https://k8s.example.com/clusters/root:orgs:test-org'),
+    );
+    kcpKubernetesServiceMock.getKcpK8sApiClient.mockReturnValue({
+      listClusterCustomObject,
+    } as any);
+  });
+
+  it('throws if token is missing', async () => {
+    const svc = new KubernetesServiceProvidersService(kcpKubernetesServiceMock);
+    await expect(
+      svc.getServiceProviders('', ['entity'], {
+        token: undefined,
+      }),
+    ).rejects.toThrow('Token is required');
+  });
+
+  it('throws if context organization is missing', async () => {
+    const svc = new KubernetesServiceProvidersService(kcpKubernetesServiceMock);
+    await expect(
+      svc.getServiceProviders('token', ['entity'], {
+        token: 'token',
+        organization: undefined,
+        isSubDomain: true,
+      }),
+    ).rejects.toThrow('Context with organization is required');
+  });
+
+  it('returns welcome node config when on the base domain', async () => {
+    const svc = new KubernetesServiceProvidersService(kcpKubernetesServiceMock);
+    const result = await svc.getServiceProviders('token', ['entity'], {
+      organization: undefined,
+      isSubDomain: false,
+    });
+
+    expect(result).toEqual(welcomeNodeConfig);
+  });
+
+  it('should return empty list when API returns no items', async () => {
+    listClusterCustomObject.mockImplementation(
+      async (_gvr: any, _opts: any) => {
+        return {};
+      },
+    );
+
+    const svc = new KubernetesServiceProvidersService(kcpKubernetesServiceMock);
+    const res = await svc.getServiceProviders('token', [], {
+      organization: 'org',
+      isSubDomain: true,
+    });
+    expect(res.rawServiceProviders).toEqual([]);
+  });
+
+  it('should map items to contentConfiguration and fill url from spec when missing', async () => {
+    let capturedUrl = '';
+    const ctx = {
+      _url: 'https://k8s.example.com/base',
+      getUrl() {
+        return this._url;
+      },
+      setUrl(u: string) {
+        this._url = u;
+      },
+      setHeaderParam: jest.fn(),
+    };
+    listClusterCustomObject.mockImplementation(async (_gvr: any, opts: any) => {
+      const mw = opts?.middleware?.[0];
+      if (mw?.pre) await mw.pre(ctx);
+      capturedUrl = ctx._url;
+      return {
+        items: [
+          {
+            status: { configurationResult: JSON.stringify({}) },
+            spec: {
+              remoteConfiguration: { url: 'http://fallback.example/app' },
+            },
+          },
+        ],
+      };
+    });
+    kcpKubernetesServiceMock.getKcpVirtualWorkspaceUrl.mockReturnValue(
+      new URL(
+        'https://k8s.example.com/services/contentconfigurations/clusters/root:orgs:acme:a1',
+      ),
+    );
+
+    const svc = new KubernetesServiceProvidersService(kcpKubernetesServiceMock);
+    const res = await svc.getServiceProviders('token', ['main'], {
+      organization: 'acme',
+      isSubDomain: true,
+      'core_platform-mesh_io_account': 'a1',
+    });
+
+    expect(res.rawServiceProviders[0].contentConfiguration).toHaveLength(1);
+    expect(res.rawServiceProviders[0].contentConfiguration[0].url).toBe(
+      'http://fallback.example/app',
+    );
+
+    expect(capturedUrl).toEqual(
+      'https://k8s.example.com/services/contentconfigurations/clusters/root:orgs:acme:a1/apis/ui.platform-mesh.io/v1alpha1/contentconfigurations',
+    );
+    expect(ctx.setHeaderParam).toHaveBeenCalledWith(
+      'Authorization',
+      `Bearer token`,
+    );
+  });
+
+  it('should retry once on HTTP 429 and log retry message', async () => {
+    jest.useFakeTimers();
+    const sequence: any[] = [
+      Object.assign(new Error('Too Many Requests'), { code: 429 }),
+      { items: [] },
+    ];
+    listClusterCustomObject.mockImplementation(async () => {
+      const next = sequence.shift();
+      if (next instanceof Error || next?.code === 429) {
+        throw next;
+      }
+      return next;
+    });
+
+    const logSpy = jest
+      .spyOn(console, 'log')
+      .mockImplementation(() => undefined as unknown as never);
+    const errSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined as unknown as never);
+
+    const svc = new KubernetesServiceProvidersService(kcpKubernetesServiceMock);
+    const promise = svc.getServiceProviders('token', [], {
+      organization: 'org',
+      isSubDomain: true,
+    });
+
+    await jest.advanceTimersByTimeAsync(1000);
+
+    const res = await promise;
+    expect(res.rawServiceProviders).toEqual([
+      {
+        name: 'platform-mesh-system',
+        displayName: '',
+        creationTimestamp: '',
+        contentConfiguration: [],
+      },
+    ]);
+    expect(logSpy).toHaveBeenCalledWith(
+      'Retry after 1 second reading kubernetes resources.',
+    );
+
+    logSpy.mockRestore();
+    errSpy.mockRestore();
+    jest.useRealTimers();
+  });
+});

package/src/portal-options/service-providers/kubernetes-service-providers.service.ts

@@ -0,0 +1,115 @@
+import { KcpKubernetesService } from '../services/kcp-k8s.service.js';
+import { welcomeNodeConfig } from './models/welcome-node-config.js';
+import { PromiseMiddlewareWrapper } from '@kubernetes/client-node/dist/gen/middleware.js';
+import { Injectable } from '@nestjs/common';
+import {
+  ContentConfiguration,
+  ServiceProviderResponse,
+  ServiceProviderService,
+} from '@openmfp/portal-server-lib';
+
+@Injectable()
+export class KubernetesServiceProvidersService
+  implements ServiceProviderService
+{
+  constructor(private kcpKubernetesService: KcpKubernetesService) {}
+
+  async getServiceProviders(
+    token: string,
+    entities: string[],
+    context: Record<string, any>,
+  ): Promise<ServiceProviderResponse> {
+    // Validate required parameters
+    if (!token) {
+      throw new Error('Token is required');
+    }
+
+    if (!context.isSubDomain) {
+      return welcomeNodeConfig;
+    }
+
+    if (!context?.organization) {
+      throw new Error('Context with organization is required');
+    }
+
+    const entity = !entities || !entities.length ? 'main' : entities[0];
+
+    let response;
+    try {
+      response = await this.getKubernetesResources(entity, context, token);
+    } catch (error) {
+      console.error(error);
+
+      if (error.code == 429 || error.statusCode == 429) {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        console.log('Retry after 1 second reading kubernetes resources.');
+        response = await this.getKubernetesResources(entity, context, token);
+      }
+    }
+
+    if (!response.items) {
+      return {
+        rawServiceProviders: [],
+      };
+    }
+
+    const responseItems = response.items as any[];
+
+    const contentConfigurations = responseItems
+      .filter((item) => !!item.status.configurationResult)
+      .map((item) => {
+        const contentConfiguration = JSON.parse(
+          item.status.configurationResult,
+        ) as ContentConfiguration;
+        if (!contentConfiguration.url) {
+          contentConfiguration.url = item.spec.remoteConfiguration?.url;
+        }
+        return contentConfiguration;
+      });
+
+    return {
+      rawServiceProviders: [
+        {
+          name: 'platform-mesh-system',
+          displayName: '',
+          creationTimestamp: '',
+          contentConfiguration: contentConfigurations,
+        },
+      ],
+    };
+  }
+
+  private async getKubernetesResources(
+    entity: string,
+    requestContext: Record<string, any>,
+    token: string,
+  ) {
+    const gvr = {
+      group: 'ui.platform-mesh.io',
+      version: 'v1alpha1',
+      plural: 'contentconfigurations',
+      labelSelector: `ui.platform-mesh.io/entity=${entity}`,
+    };
+
+    const k8sApi = this.kcpKubernetesService.getKcpK8sApiClient();
+    return await k8sApi.listClusterCustomObject(gvr, {
+      middleware: [
+        new PromiseMiddlewareWrapper({
+          pre: async (context) => {
+            const kcpUrl = this.kcpKubernetesService.getKcpVirtualWorkspaceUrl(
+              requestContext.organization,
+              requestContext?.['core_platform-mesh_io_account'],
+            );
+            const path = `${kcpUrl}/apis/${gvr.group}/${gvr.version}/${gvr.plural}`;
+            console.log('kcp url: ', path);
+
+            context.setUrl(path);
+            context.setHeaderParam('Authorization', `Bearer ${token}`);
+            return context;
+          },
+          post: async (context) => context,
+        }),
+      ],
+    });
+  }
+}

package/src/portal-options/service-providers/models/contentconfigurations.ts

@@ -0,0 +1,13 @@
+export interface ContentConfigurationQueryResponse {
+  ui_platform_mesh_io: ContentConfigurationsResponse;
+}
+
+export interface ContentConfigurationsResponse {
+    ContentConfigurations: ContentConfigurationResponse[];
+}
+
+export interface ContentConfigurationResponse {
+    metadata: { name: string; labels?: Record<string, string>; };
+    spec: { remoteConfiguration?: { url?: string; }; };
+    status: { configurationResult?: string; };
+}

package/src/portal-options/service-providers/models/welcome-node-config.ts

@@ -0,0 +1,36 @@
+import { ServiceProviderResponse } from '@openmfp/portal-server-lib';
+
+export const welcomeNodeConfig: ServiceProviderResponse = {
+  rawServiceProviders: [
+    {
+      name: 'platform-mesh-system',
+      displayName: '',
+      creationTimestamp: '',
+      contentConfiguration: [
+        {
+          name: 'platform-mesh-system',
+          creationTimestamp: '',
+          luigiConfigFragment: {
+            data: {
+              nodes: [
+                {
+                  entityType: 'global',
+                  pathSegment: 'welcome',
+                  hideFromNav: true,
+                  hideSideNav: true,
+                  showBreadcrumbs: false,
+                  order: 1,
+                  url: '/assets/platform-mesh-portal-ui-wc.js#welcome-view',
+                  webcomponent: {
+                    selfRegistered: true,
+                  },
+                  context: { kcpPath: 'root:orgs' },
+                },
+              ],
+            },
+          },
+        },
+      ],
+    },
+  ],
+};