fix: collect errors while bundling (#57)

* fix: collect errors while bundling

* fix: linting

* chore: add test for invalid pointer

Author: lottamus

src/__tests__/bundle.spec.ts

@@ -125,6 +125,196 @@ describe('bundleTargetPath()', () => {
     });
   });
 
+  it('should throw if invalid pointer for bundle target', () => {
+    const document = {
+      definitions: {
+        user: {
+          id: 'foo',
+          address: {
+            $ref: '#/definitions/address',
+          },
+        },
+        address: {
+          street: 'foo',
+          user: {
+            $ref: '#/definitions/user',
+          },
+        },
+        card: {
+          zip: '20815',
+        },
+      },
+      __target__: {
+        entity: {
+          $ref: '#/definitions/user',
+        },
+      },
+    };
+
+    const clone = cloneDeep(document);
+
+    expect(() =>
+      bundleTarget({
+        document: clone,
+        path: 'invalid_pointer',
+      }),
+    ).toThrow('Invalid JSON Pointer syntax; URI fragment identifiers must begin with a hash.');
+  });
+
+  it('should handle invalid pointers for internal $refs', () => {
+    const document = {
+      definitions: {
+        user: {
+          id: 'foo',
+          address: {
+            $ref: '#/definitions/address',
+          },
+        },
+        address: {
+          street: 'foo',
+          invalidPointer: {
+            $ref: '#./definitions/card',
+          },
+        },
+        card: {
+          zip: '20815',
+        },
+      },
+      __target__: {
+        entity: {
+          $ref: '#/definitions/user',
+        },
+      },
+    };
+
+    const clone = cloneDeep(document);
+
+    const result = bundleTarget({
+      document: clone,
+      path: '#/__target__',
+    });
+
+    // Do not mutate document
+    expect(clone).toEqual(document);
+
+    expect(result).toEqual({
+      entity: {
+        $ref: '#/__bundled__/definitions/user',
+      },
+      __bundled__: {
+        definitions: {
+          user: {
+            id: 'foo',
+            address: {
+              $ref: '#/__bundled__/definitions/address',
+            },
+          },
+          address: {
+            street: 'foo',
+            invalidPointer: {
+              $ref: '#./definitions/card',
+            },
+          },
+        },
+      },
+      __errors__: {
+        '#./definitions/card': 'Invalid JSON Pointer syntax.',
+      },
+    });
+  });
+
+  it('should ignore invalid pointers', () => {
+    const document = {
+      practice: {
+        title: 'Account',
+        allOf: [
+          {
+            $ref: '#./UuidModel',
+          },
+          {
+            type: 'object',
+            properties: {
+              address: {
+                $ref: '#./Address',
+              },
+              email: {
+                type: 'string',
+                format: 'email',
+              },
+              name: {
+                type: 'string',
+              },
+              phone: {
+                type: 'string',
+              },
+              website: {
+                type: 'string',
+                format: 'uri',
+              },
+              owner: {
+                $ref: '#./Account',
+              },
+            },
+            required: ['name'],
+          },
+        ],
+      },
+      __target__: {
+        $ref: '#/practice',
+      },
+    };
+
+    const clone = cloneDeep(document);
+
+    const result = bundleTarget({
+      document: clone,
+      path: '#/practice',
+    });
+
+    // Do not mutate document
+    expect(clone).toEqual(document);
+
+    expect(result).toEqual({
+      title: 'Account',
+      allOf: [
+        {
+          $ref: '#./UuidModel',
+        },
+        {
+          type: 'object',
+          properties: {
+            address: {
+              $ref: '#./Address',
+            },
+            email: {
+              type: 'string',
+              format: 'email',
+            },
+            name: {
+              type: 'string',
+            },
+            phone: {
+              type: 'string',
+            },
+            website: {
+              type: 'string',
+              format: 'uri',
+            },
+            owner: {
+              $ref: '#./Account',
+            },
+          },
+          required: ['name'],
+        },
+      ],
+      __errors__: {
+        '#./UuidModel': 'Invalid JSON Pointer syntax.',
+        '#./Address': 'Invalid JSON Pointer syntax.',
+        '#./Account': 'Invalid JSON Pointer syntax.',
+      },
+    });
+  });
+
   it('should mirror original source decision re arrays or objects', () => {
     const document = {
       parameters: [

src/bundle.ts

@@ -7,6 +7,7 @@ import { pointerToPath } from './pointerToPath';
 import { traverse } from './traverse';
 
 export const BUNDLE_ROOT = '__bundled__';
+export const ERRORS_ROOT = '__errors__';
 
 export const bundleTarget = <T = unknown>({ document, path }: { document: T; path: string }, cur?: unknown) =>
   _bundle(cloneDeep(document), path, cur);
@@ -17,21 +18,35 @@ const _bundle = (
   cur?: unknown,
   bundledRefInventory: any = {},
   bundledObj: any = {},
+  errorsObj: any = {},
 ) => {
   const objectToBundle = get(document, pointerToPath(path));
 
   traverse(cur ? cur : objectToBundle, ({ parent }) => {
     if (hasRef(parent) && isLocalRef(parent.$ref)) {
+      if (errorsObj[parent.$ref]) return;
+
       if (bundledRefInventory[parent.$ref]) {
         parent.$ref = bundledRefInventory[parent.$ref];
 
         // no need to continue, this $ref has already been bundled
         return;
       }
 
-      const _path = pointerToPath(parent.$ref);
-      const inventoryPath = [BUNDLE_ROOT, ..._path];
-      const inventoryRef = pathToPointer(inventoryPath);
+      let _path;
+      let inventoryPath;
+      let inventoryRef;
+
+      try {
+        _path = pointerToPath(parent.$ref);
+        inventoryPath = [BUNDLE_ROOT, ..._path];
+        inventoryRef = pathToPointer(inventoryPath);
+      } catch (error) {
+        errorsObj[parent.$ref] = error.message;
+      }
+
+      // Ignore invalid $refs and carry on
+      if (!_path || !inventoryPath || !inventoryRef) return;
 
       const bundled$Ref = get(document, _path);
       if (bundled$Ref) {
@@ -56,12 +71,16 @@ const _bundle = (
         }
 
         set(bundledObj, inventoryPath, bundled$Ref);
-        _bundle(document, path, bundled$Ref, bundledRefInventory, bundledObj);
+        _bundle(document, path, bundled$Ref, bundledRefInventory, bundledObj, errorsObj);
       }
     }
   });
 
   set(objectToBundle, BUNDLE_ROOT, bundledObj[BUNDLE_ROOT]);
 
+  if (Object.keys(errorsObj).length) {
+    set(objectToBundle, ERRORS_ROOT, errorsObj);
+  }
+
   return objectToBundle;
 };