Safer types for responses with potentially empty data objects.

.changeset/brave-geese-develop.md

@@ -0,0 +1,7 @@
+---
+'@dgac/nmb2b-client': minor
+---
+
+Improve type safety of B2B replies when objects are potentially empty.
+
+See https://github.com/DGAC/nmb2b-client-js/issues/149

src/Airspace/queryCompleteAIXMDatasets.ts

@@ -3,6 +3,8 @@ import { instrument } from '../utils/instrumentation';
 import { injectSendTime, responseStatusHandler } from '../utils/internals';
 import { prepareSerializer } from '../utils/transformers';
 import type { AirspaceClient } from './';
+import type { AiracIdentifier, AIXMFile } from './types';
+import type { CollapseEmptyObjectsToNull } from '../utils/types';
 
 import type {
   DateYearMonthDay,
@@ -14,11 +16,13 @@ export interface CompleteAIXMDatasetRequest {
   queryCriteria: CompleteDatasetQueryCriteria;
 }
 
-export type CompleteAIXMDatasetReply = Reply & {
-  data: {
-    datasetSummaries: CompleteDatasetSummary[];
-  };
-};
+export type CompleteAIXMDatasetReply = CollapseEmptyObjectsToNull<
+  Reply & {
+    data: {
+      datasetSummaries: CompleteDatasetSummary[];
+    };
+  }
+>;
 
 type Values = CompleteAIXMDatasetRequest;
 type Result = CompleteAIXMDatasetReply;
@@ -54,8 +58,6 @@ export default function prepareQueryCompleteAIXMDatasets(
   );
 }
 
-import type { AiracIdentifier, AIXMFile } from './types';
-
 interface CompleteDatasetSummary {
   updateId: string;
   publicationDate: DateYearMonthDay;

src/Airspace/retrieveAUP.ts

@@ -3,6 +3,9 @@ import { injectSendTime, responseStatusHandler } from '../utils/internals';
 import type { SoapOptions } from '../soap';
 import { prepareSerializer } from '../utils/transformers';
 import { instrument } from '../utils/instrumentation';
+import type { AUPId, AUP } from './types';
+import type { Reply } from '../Common/types';
+import type { CollapseEmptyObjectsToNull } from '../utils/types';
 
 type Values = AUPRetrievalRequest;
 type Result = AUPRetrievalReply;
@@ -36,16 +39,15 @@ export default function prepareRetrieveAUP(client: AirspaceClient): Resolver {
   );
 }
 
-import type { AUPId, AUP } from './types';
-import type { Reply } from '../Common/types';
-
 export interface AUPRetrievalRequest {
   aupId: AUPId;
   returnComputed?: boolean;
 }
 
-export interface AUPRetrievalReply extends Reply {
-  data: {
-    aup: AUP;
-  };
-}
+export type AUPRetrievalReply = CollapseEmptyObjectsToNull<
+  Reply & {
+    data: {
+      aup: AUP;
+    };
+  }
+>;

src/Airspace/retrieveAUPChain.ts

@@ -3,6 +3,14 @@ import { instrument } from '../utils/instrumentation';
 import { injectSendTime, responseStatusHandler } from '../utils/internals';
 import { prepareSerializer } from '../utils/transformers';
 import type { AirspaceClient } from './';
+import type {
+  AirNavigationUnitId,
+  DateYearMonthDay,
+  Reply,
+} from '../Common/types';
+
+import type { AUPChain } from './types';
+import type { CollapseEmptyObjectsToNull } from '../utils/types';
 
 type Values = AUPChainRetrievalRequest;
 type Result = AUPChainRetrievalReply;
@@ -38,21 +46,15 @@ export default function prepareRetrieveAUPChain(
   );
 }
 
-import type {
-  AirNavigationUnitId,
-  DateYearMonthDay,
-  Reply,
-} from '../Common/types';
-
-import type { AUPChain } from './types';
-
 export interface AUPChainRetrievalRequest {
   chainDate: DateYearMonthDay;
   amcIds?: AirNavigationUnitId[];
 }
 
-export type AUPChainRetrievalReply = Reply & {
-  data: {
-    chains: AUPChain[];
-  };
-};
+export type AUPChainRetrievalReply = CollapseEmptyObjectsToNull<
+  Reply & {
+    data: {
+      chains: AUPChain[];
+    };
+  }
+>;

src/Airspace/retrieveEAUPChain.ts

@@ -1,8 +1,12 @@
-import type { AirspaceClient } from './';
-import { injectSendTime, responseStatusHandler } from '../utils/internals';
 import type { SoapOptions } from '../soap';
-import { prepareSerializer } from '../utils/transformers';
 import { instrument } from '../utils/instrumentation';
+import { injectSendTime, responseStatusHandler } from '../utils/internals';
+import { prepareSerializer } from '../utils/transformers';
+import type { AirspaceClient } from './';
+import type { DateYearMonthDay, Reply } from '../Common/types';
+
+import type { CollapseEmptyObjectsToNull } from '../utils/types';
+import type { EAUPChain } from './types';
 
 type Values = EAUPChainRetrievalRequest;
 type Result = EAUPChainRetrievalReply;
@@ -38,16 +42,14 @@ export default function prepareRetrieveEAUPChain(
   );
 }
 
-import type { DateYearMonthDay, Reply } from '../Common/types';
-
-import type { EAUPChain } from './types';
-
 export interface EAUPChainRetrievalRequest {
   chainDate: DateYearMonthDay;
 }
 
-export type EAUPChainRetrievalReply = Reply & {
-  data: {
-    chain: EAUPChain;
-  };
-};
+export type EAUPChainRetrievalReply = CollapseEmptyObjectsToNull<
+  Reply & {
+    data: {
+      chain: EAUPChain;
+    };
+  }
+>;

src/Common/types.ts

@@ -128,7 +128,7 @@ export type ReplyStatus =
   | 'CONFLICTING_UPDATE'
   | 'INVALID_DATASET';
 
-export interface Reply {
+export type Reply = {
   requestReceptionTime?: DateTimeSecond;
   requestId?: string;
   sendTime?: DateTimeSecond;
@@ -140,11 +140,11 @@ export interface Reply {
   reason?: string;
 }
 
-export interface Request {
+export type Request = {
   endUserId?: string;
   onBehalfOfUnit?: AirNavigationUnitId;
   sendTime: DateTimeSecond;
-}
+};
 
 export type ServiceGroup =
   | 'AIRSPACE'

src/Flight/queryFlightPlans.test.ts

@@ -59,70 +59,94 @@ describe('queryFlightPlans', async () => {
     }
   });
 
-  test.runIf(shouldUseRealB2BConnection)('query known flight', async () => {
-    try {
-      if (!knownFlight || !('flight' in knownFlight)) {
-        return;
-      }
+  test.runIf(shouldUseRealB2BConnection)('query empty callsign', async () => {
+    const invalidCallsign = 'ABCDE';
+
+    const res = await Flight.queryFlightPlans({
+      aircraftId: invalidCallsign,
+      nonICAOAerodromeOfDeparture: false,
+      airFiled: false,
+      nonICAOAerodromeOfDestination: false,
+      estimatedOffBlockTime: {
+        wef: sub(new Date(), {
+          minutes: 30,
+        }),
+        unt: add(new Date(), {
+          minutes: 30,
+        }),
+      },
+    });
 
-      assert(knownFlight.flight.flightId.keys, 'Invalid flight');
-
-      const res = await Flight.queryFlightPlans({
-        aircraftId: knownFlight.flight.flightId.keys.aircraftId,
-        nonICAOAerodromeOfDeparture: false,
-        airFiled: false,
-        nonICAOAerodromeOfDestination: false,
-        estimatedOffBlockTime: {
-          wef: sub(knownFlight.flight.flightId.keys.estimatedOffBlockTime, {
-            minutes: 30,
-          }),
-          unt: add(knownFlight.flight.flightId.keys.estimatedOffBlockTime, {
-            minutes: 30,
-          }),
-        },
-      });
-
-      const { data } = res;
-
-      if (!data.summaries || data.summaries.length === 0) {
-        console.error(
-          'Query did not return any flight plan, this should never happen.',
-        );
-        return;
-      }
+    expect(res.data).toBe(null);
+  });
+
+  test.runIf(shouldUseRealB2BConnection && false)(
+    'query known flight',
+    async () => {
+      try {
+        if (!knownFlight || !('flight' in knownFlight)) {
+          return;
+        }
 
-      for (const f of data.summaries) {
-        if (!('lastValidFlightPlan' in f || 'currentInvalid' in f)) {
-          throw new Error(
-            'queryFlightPlans: either lastValidFlightPlan or currentInvalid should exist',
+        assert(knownFlight.flight.flightId.keys, 'Invalid flight');
+
+        const res = await Flight.queryFlightPlans({
+          aircraftId: knownFlight.flight.flightId.keys.aircraftId,
+          nonICAOAerodromeOfDeparture: false,
+          airFiled: false,
+          nonICAOAerodromeOfDestination: false,
+          estimatedOffBlockTime: {
+            wef: sub(knownFlight.flight.flightId.keys.estimatedOffBlockTime, {
+              minutes: 30,
+            }),
+            unt: add(knownFlight.flight.flightId.keys.estimatedOffBlockTime, {
+              minutes: 30,
+            }),
+          },
+        });
+
+        const { data } = res;
+
+        if (!data?.summaries || data.summaries.length === 0) {
+          console.error(
+            'Query did not return any flight plan, this should never happen.',
           );
+          return;
         }
 
-        if ('lastValidFlightPlan' in f) {
-          expect(f.lastValidFlightPlan).toMatchObject({
-            id: {
-              id: expect.any(String),
-              keys: {
-                aircraftId: expect.any(String),
-                aerodromeOfDeparture: expect.any(String),
-                aerodromeOfDestination: expect.any(String),
-                estimatedOffBlockTime: expect.any(Date),
+        for (const f of data.summaries) {
+          if (!('lastValidFlightPlan' in f || 'currentInvalid' in f)) {
+            throw new Error(
+              'queryFlightPlans: either lastValidFlightPlan or currentInvalid should exist',
+            );
+          }
+
+          if ('lastValidFlightPlan' in f) {
+            expect(f.lastValidFlightPlan).toMatchObject({
+              id: {
+                id: expect.any(String),
+                keys: {
+                  aircraftId: expect.any(String),
+                  aerodromeOfDeparture: expect.any(String),
+                  aerodromeOfDestination: expect.any(String),
+                  estimatedOffBlockTime: expect.any(Date),
+                },
               },
-            },
-            status: expect.any(String),
-          });
-        } else if ('currentInvalid' in f) {
-          console.warn(
-            'Query returned a flight with a currentInvalid property',
-          );
+              status: expect.any(String),
+            });
+          } else if ('currentInvalid' in f) {
+            console.warn(
+              'Query returned a flight with a currentInvalid property',
+            );
+          }
+        }
+      } catch (err) {
+        if (err instanceof NMB2BError) {
+          console.log(inspect(err, { depth: 4 }));
         }
-      }
-    } catch (err) {
-      if (err instanceof NMB2BError) {
-        console.log(inspect(err, { depth: 4 }));
-      }
 
-      throw err;
-    }
-  });
+        throw err;
+      }
+    },
+  );
 });

src/Flight/retrieveFlight.test.ts

@@ -87,7 +87,7 @@ describe('retrieveFlight', async () => {
           requestedFlightFields: ['ftfmPointProfile'],
         });
 
-        assert(res.data.flight?.ftfmPointProfile);
+        assert(res.data?.flight?.ftfmPointProfile);
 
         res.data.flight.ftfmPointProfile.forEach((item) => {
           expect(item).toEqual(
@@ -127,7 +127,7 @@ describe('retrieveFlight', async () => {
           requestedFlightFields: ['aircraftType', 'delay'],
         });
 
-        const flight = res.data.flight;
+        const flight = res.data?.flight;
         expect(flight).toBeDefined();
         expect(flight?.flightId.id).toEqual(
           expect.stringMatching(/^A(A|T)[0-9]{8}$/),