diff --git a/apps/dh/api-dh/source/DataHub.WebApi.Tests/Snapshots/SchemaTests.ChangeTest.verified.graphql b/apps/dh/api-dh/source/DataHub.WebApi.Tests/Snapshots/SchemaTests.ChangeTest.verified.graphql index 9b99197e5e..166c6fc129 100644 --- a/apps/dh/api-dh/source/DataHub.WebApi.Tests/Snapshots/SchemaTests.ChangeTest.verified.graphql +++ b/apps/dh/api-dh/source/DataHub.WebApi.Tests/Snapshots/SchemaTests.ChangeTest.verified.graphql @@ -2839,7 +2839,7 @@ enum DocumentStatus { AWAITING_REPLY ACCEPTED REJECTED - SERVICE_BUS_ACCEPTED + BIZ_TALK_ACCEPTED MANUALLY_HANDLED } diff --git a/libs/dh/esett/feature-outgoing-messages/src/status.component.ts b/libs/dh/esett/feature-outgoing-messages/src/status.component.ts index d91710f34b..54b28a945f 100644 --- a/libs/dh/esett/feature-outgoing-messages/src/status.component.ts +++ b/libs/dh/esett/feature-outgoing-messages/src/status.component.ts @@ -33,7 +33,7 @@ import { DhEmDashFallbackPipe } from '@energinet-datahub/dh/shared/ui-util'; @switch (_status) { @case ('RECEIVED') @case ('AWAITING_DISPATCH') - @case ('SERVICE_BUS_ACCEPTED') + @case ('BIZ_TALK_ACCEPTED') @case ('AWAITING_REPLY') { {{ t(_status) }} @@ -74,7 +74,7 @@ export class DhOutgoingMessageStatusBadgeComponent { return secondsPassed > 30; // 30 seconds to convert. case 'AWAITING_DISPATCH': return secondsPassed > 60 * 30; // 30 minutes to dispatch. - case 'SERVICE_BUS_ACCEPTED': + case 'BIZ_TALK_ACCEPTED': return secondsPassed > 60 * 30; // 30 minutes to dispatch. case 'AWAITING_REPLY': return secondsPassed > 60 * 60; // 1 hour to reply. diff --git a/libs/dh/globalization/assets-localization/src/assets/i18n/da.json b/libs/dh/globalization/assets-localization/src/assets/i18n/da.json index be556506e5..8494188bc3 100644 --- a/libs/dh/globalization/assets-localization/src/assets/i18n/da.json +++ b/libs/dh/globalization/assets-localization/src/assets/i18n/da.json @@ -2270,7 +2270,7 @@ "RECEIVED": "Modtaget", "AWAITING_DISPATCH": "Afventer afsendelse", "AWAITING_REPLY": "Afventer svar fra eSett", - "SERVICE_BUS_ACCEPTED": "Afventer svar fra ECP", + "BIZ_TALK_ACCEPTED": "Afventer svar fra ECP", "ACCEPTED": "Accepteret", "REJECTED": "Afvist", "MANUALLY_HANDLED": "Manuelt løst" diff --git a/libs/dh/globalization/assets-localization/src/assets/i18n/en.json b/libs/dh/globalization/assets-localization/src/assets/i18n/en.json index 51aaccb2ad..7979d524a1 100644 --- a/libs/dh/globalization/assets-localization/src/assets/i18n/en.json +++ b/libs/dh/globalization/assets-localization/src/assets/i18n/en.json @@ -2270,7 +2270,7 @@ "RECEIVED": "Received", "AWAITING_DISPATCH": "Awaiting dispatch", "AWAITING_REPLY": "Awaiting reply from eSett", - "SERVICE_BUS_ACCEPTED": "Awaiting reply from ECP", + "BIZ_TALK_ACCEPTED": "Awaiting reply from ECP", "ACCEPTED": "Accepted", "REJECTED": "Rejected", "MANUALLY_HANDLED": "Solved manually" diff --git a/libs/dh/shared/util-apollo/src/data-source/ApolloDataSource.ts b/libs/dh/shared/util-apollo/src/data-source/ApolloDataSource.ts index b39967e19a..038006f776 100644 --- a/libs/dh/shared/util-apollo/src/data-source/ApolloDataSource.ts +++ b/libs/dh/shared/util-apollo/src/data-source/ApolloDataSource.ts @@ -57,12 +57,12 @@ export type Pageable = { }; export abstract class ApolloDataSource< - TResult, - TVariables extends TPagingVariables, - TNode, - TPageInfo, - TPagingVariables extends CommonVariables, - > + TResult, + TVariables extends TPagingVariables, + TNode, + TPageInfo, + TPagingVariables extends CommonVariables, +> extends DataSource implements IWattTableDataSource { diff --git a/libs/dh/shared/util-apollo/src/lazyQuery.ts b/libs/dh/shared/util-apollo/src/lazyQuery.ts index d3806a7744..84d0769367 100644 --- a/libs/dh/shared/util-apollo/src/lazyQuery.ts +++ b/libs/dh/shared/util-apollo/src/lazyQuery.ts @@ -21,14 +21,18 @@ import type { TypedDocumentNode } from '@graphql-typed-document-node/core'; import { QueryOptions, QueryResult, query } from './query'; // Lazy queries cannot be skipped as they are triggered imperatively -export interface LazyQueryOptions - extends Omit, 'skip'> { +export interface LazyQueryOptions extends Omit< + QueryOptions, + 'skip' +> { onCompleted?: (data: TResult) => void; onError?: (error: ApolloError) => void; } -export interface LazyQueryResult - extends QueryResult { +export interface LazyQueryResult< + TResult, + TVariables extends OperationVariables, +> extends QueryResult { query: ( options?: Partial> ) => Promise>; diff --git a/libs/dh/shared/util-apollo/src/mutation.ts b/libs/dh/shared/util-apollo/src/mutation.ts index b073681aa9..e480dbb7c5 100644 --- a/libs/dh/shared/util-apollo/src/mutation.ts +++ b/libs/dh/shared/util-apollo/src/mutation.ts @@ -49,8 +49,10 @@ export enum MutationStatus { } // Add the `onCompleted` and `onError` callbacks to align with `useMutation` -export interface MutationOptions - extends Omit, 'mutation'> { +export interface MutationOptions extends Omit< + ApolloMutationOptions, + 'mutation' +> { onCompleted?: (data: TResult, clientOptions?: MutationOptions) => void; onError?: (error: ApolloError, clientOptions?: MutationOptions) => void; } diff --git a/libs/dh/shared/util-apollo/src/query.ts b/libs/dh/shared/util-apollo/src/query.ts index f498e9a8ae..35eb24dd73 100644 --- a/libs/dh/shared/util-apollo/src/query.ts +++ b/libs/dh/shared/util-apollo/src/query.ts @@ -76,20 +76,24 @@ export enum QueryStatus { // Since the `query` function is a wrapper around Apollo's `watchQuery`, the options API is almost // exactly the same. This just makes some changes to better align with the `useQuery` hook. -interface BaseQueryOptions - extends Omit, 'query' | 'useInitialLoading' | 'variables'> { +interface BaseQueryOptions extends Omit< + WatchQueryOptions, + 'query' | 'useInitialLoading' | 'variables' +> { // The `nextFetchPolicy` typically also accepts a function. Omitted for simplicity. nextFetchPolicy?: WatchQueryOptions['fetchPolicy']; } -interface SkippedQueryOptions - extends BaseQueryOptions { +interface SkippedQueryOptions< + TVariables extends OperationVariables, +> extends BaseQueryOptions { skip: true; variables?: Partial; } -interface ImmediateQueryOptions - extends BaseQueryOptions { +interface ImmediateQueryOptions< + TVariables extends OperationVariables, +> extends BaseQueryOptions { skip?: boolean; variables?: TVariables; } diff --git a/libs/dh/shared/util-apollo/src/subscription.ts b/libs/dh/shared/util-apollo/src/subscription.ts index 3547a68738..942971c795 100644 --- a/libs/dh/shared/util-apollo/src/subscription.ts +++ b/libs/dh/shared/util-apollo/src/subscription.ts @@ -31,8 +31,10 @@ import { DhApollo } from '@energinet-datahub/dh/shared/data-access-graphql'; import { fixObservable } from './query'; // Add the `onCompleted` and `onError` callbacks to align with `useMutation` -export interface SubscriptionOptions - extends Omit, 'query'> { +export interface SubscriptionOptions< + TResult, + TVariables extends OperationVariables | undefined, +> extends Omit, 'query'> { onData?: (data: TResult) => void; onError?: (error: ApolloError) => void; onCompleted?: () => void; diff --git a/libs/gf/msw/test-util-msw-setup/src/assets/mockServiceWorker.js b/libs/gf/msw/test-util-msw-setup/src/assets/mockServiceWorker.js index 34057e898f..e5c0b165ec 100644 --- a/libs/gf/msw/test-util-msw-setup/src/assets/mockServiceWorker.js +++ b/libs/gf/msw/test-util-msw-setup/src/assets/mockServiceWorker.js @@ -8,42 +8,42 @@ * - Please do NOT serve this file on production. */ -const PACKAGE_VERSION = '2.7.3' -const INTEGRITY_CHECKSUM = '00729d72e3b82faf54ca8b9621dbb96f' -const IS_MOCKED_RESPONSE = Symbol('isMockedResponse') -const activeClientIds = new Set() +const PACKAGE_VERSION = '2.7.3'; +const INTEGRITY_CHECKSUM = '00729d72e3b82faf54ca8b9621dbb96f'; +const IS_MOCKED_RESPONSE = Symbol('isMockedResponse'); +const activeClientIds = new Set(); self.addEventListener('install', function () { - self.skipWaiting() -}) + self.skipWaiting(); +}); self.addEventListener('activate', function (event) { - event.waitUntil(self.clients.claim()) -}) + event.waitUntil(self.clients.claim()); +}); self.addEventListener('message', async function (event) { - const clientId = event.source.id + const clientId = event.source.id; if (!clientId || !self.clients) { - return + return; } - const client = await self.clients.get(clientId) + const client = await self.clients.get(clientId); if (!client) { - return + return; } const allClients = await self.clients.matchAll({ type: 'window', - }) + }); switch (event.data) { case 'KEEPALIVE_REQUEST': { sendToClient(client, { type: 'KEEPALIVE_RESPONSE', - }) - break + }); + break; } case 'INTEGRITY_CHECK_REQUEST': { @@ -53,12 +53,12 @@ self.addEventListener('message', async function (event) { packageVersion: PACKAGE_VERSION, checksum: INTEGRITY_CHECKSUM, }, - }) - break + }); + break; } case 'MOCK_ACTIVATE': { - activeClientIds.add(clientId) + activeClientIds.add(clientId); sendToClient(client, { type: 'MOCKING_ENABLED', @@ -68,68 +68,68 @@ self.addEventListener('message', async function (event) { frameType: client.frameType, }, }, - }) - break + }); + break; } case 'MOCK_DEACTIVATE': { - activeClientIds.delete(clientId) - break + activeClientIds.delete(clientId); + break; } case 'CLIENT_CLOSED': { - activeClientIds.delete(clientId) + activeClientIds.delete(clientId); const remainingClients = allClients.filter((client) => { - return client.id !== clientId - }) + return client.id !== clientId; + }); // Unregister itself when there are no more clients if (remainingClients.length === 0) { - self.registration.unregister() + self.registration.unregister(); } - break + break; } } -}) +}); self.addEventListener('fetch', function (event) { - const { request } = event + const { request } = event; // Bypass navigation requests. if (request.mode === 'navigate') { - return + return; } // Opening the DevTools triggers the "only-if-cached" request // that cannot be handled by the worker. Bypass such requests. if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') { - return + return; } // Bypass all requests when there are no active clients. // Prevents the self-unregistered worked from handling requests // after it's been deleted (still remains active until the next reload). if (activeClientIds.size === 0) { - return + return; } // Generate unique request ID. - const requestId = crypto.randomUUID() - event.respondWith(handleRequest(event, requestId)) -}) + const requestId = crypto.randomUUID(); + event.respondWith(handleRequest(event, requestId)); +}); async function handleRequest(event, requestId) { - const client = await resolveMainClient(event) - const response = await getResponse(event, client, requestId) + const client = await resolveMainClient(event); + const response = await getResponse(event, client, requestId); // Send back the response clone for the "response:*" life-cycle events. // Ensure MSW is active and ready to handle the message, otherwise // this message will pend indefinitely. if (client && activeClientIds.has(client.id)) { - ;(async function () { - const responseClone = response.clone() + (async function () { + const responseClone = response.clone(); sendToClient( client, @@ -145,12 +145,12 @@ async function handleRequest(event, requestId) { headers: Object.fromEntries(responseClone.headers.entries()), }, }, - [responseClone.body], - ) - })() + [responseClone.body] + ); + })(); } - return response + return response; } // Resolve the main client for the given event. @@ -158,67 +158,65 @@ async function handleRequest(event, requestId) { // that registered the worker. It's with the latter the worker should // communicate with during the response resolving phase. async function resolveMainClient(event) { - const client = await self.clients.get(event.clientId) + const client = await self.clients.get(event.clientId); if (activeClientIds.has(event.clientId)) { - return client + return client; } if (client?.frameType === 'top-level') { - return client + return client; } const allClients = await self.clients.matchAll({ type: 'window', - }) + }); return allClients .filter((client) => { // Get only those clients that are currently visible. - return client.visibilityState === 'visible' + return client.visibilityState === 'visible'; }) .find((client) => { // Find the client ID that's recorded in the // set of clients that have registered the worker. - return activeClientIds.has(client.id) - }) + return activeClientIds.has(client.id); + }); } async function getResponse(event, client, requestId) { - const { request } = event + const { request } = event; // Clone the request because it might've been already used // (i.e. its body has been read and sent to the client). - const requestClone = request.clone() + const requestClone = request.clone(); function passthrough() { // Cast the request headers to a new Headers instance // so the headers can be manipulated with. - const headers = new Headers(requestClone.headers) + const headers = new Headers(requestClone.headers); // Remove the "accept" header value that marked this request as passthrough. // This prevents request alteration and also keeps it compliant with the // user-defined CORS policies. - const acceptHeader = headers.get('accept') + const acceptHeader = headers.get('accept'); if (acceptHeader) { - const values = acceptHeader.split(',').map((value) => value.trim()) - const filteredValues = values.filter( - (value) => value !== 'msw/passthrough', - ) + const values = acceptHeader.split(',').map((value) => value.trim()); + const filteredValues = values.filter((value) => value !== 'msw/passthrough'); if (filteredValues.length > 0) { - headers.set('accept', filteredValues.join(', ')) + headers.set('accept', filteredValues.join(', ')); } else { - headers.delete('accept') + headers.delete('accept'); } } - return fetch(requestClone, { headers }) + return fetch(requestClone, { headers }); } // Bypass mocking when the client is not active. if (!client) { - return passthrough() + return passthrough(); } // Bypass initial page load requests (i.e. static assets). @@ -226,11 +224,11 @@ async function getResponse(event, client, requestId) { // means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet // and is not ready to handle requests. if (!activeClientIds.has(client.id)) { - return passthrough() + return passthrough(); } // Notify the client that a request has been intercepted. - const requestBuffer = await request.arrayBuffer() + const requestBuffer = await request.arrayBuffer(); const clientMessage = await sendToClient( client, { @@ -252,39 +250,36 @@ async function getResponse(event, client, requestId) { keepalive: request.keepalive, }, }, - [requestBuffer], - ) + [requestBuffer] + ); switch (clientMessage.type) { case 'MOCK_RESPONSE': { - return respondWithMock(clientMessage.data) + return respondWithMock(clientMessage.data); } case 'PASSTHROUGH': { - return passthrough() + return passthrough(); } } - return passthrough() + return passthrough(); } function sendToClient(client, message, transferrables = []) { return new Promise((resolve, reject) => { - const channel = new MessageChannel() + const channel = new MessageChannel(); channel.port1.onmessage = (event) => { if (event.data && event.data.error) { - return reject(event.data.error) + return reject(event.data.error); } - resolve(event.data) - } + resolve(event.data); + }; - client.postMessage( - message, - [channel.port2].concat(transferrables.filter(Boolean)), - ) - }) + client.postMessage(message, [channel.port2].concat(transferrables.filter(Boolean))); + }); } async function respondWithMock(response) { @@ -293,15 +288,15 @@ async function respondWithMock(response) { // instance will have status code set to 0. Since it's not possible to create // a Response instance with status code 0, handle that use-case separately. if (response.status === 0) { - return Response.error() + return Response.error(); } - const mockedResponse = new Response(response.body, response) + const mockedResponse = new Response(response.body, response); Reflect.defineProperty(mockedResponse, IS_MOCKED_RESPONSE, { value: true, enumerable: true, - }) + }); - return mockedResponse + return mockedResponse; }