@jupiterone/cli 8.3.1 → 8.4.2

package/jest.config.js

@@ -1,3 +1,3 @@
 module.exports = {
-  ...require('../../jest.config.base')
+  ...require('../../jest.config.base'),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jupiterone/cli",
-  "version": "8.3.1",
+  "version": "8.4.2",
   "description": "The JupiterOne cli",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -24,8 +24,8 @@
     "test": "jest"
   },
   "dependencies": {
-    "@jupiterone/integration-sdk-core": "^8.3.1",
-    "@jupiterone/integration-sdk-runtime": "^8.3.1",
+    "@jupiterone/integration-sdk-core": "^8.4.2",
+    "@jupiterone/integration-sdk-runtime": "^8.4.2",
     "@lifeomic/attempt": "^3.0.0",
     "commander": "^5.0.0",
     "globby": "^11.0.1",
@@ -43,5 +43,5 @@
     "csvtojson": "^2.0.10",
     "memfs": "^3.2.0"
   },
-  "gitHead": "b730a382d3a7cd7b2b2c219af2b8bc13c059521f"
+  "gitHead": "1504c547765bd8636a8adcaf19098bc1b9f802e1"
 }

package/src/__tests__/cli-import.test.ts

@@ -61,15 +61,12 @@ beforeEach(async () => {
   mockedCreateApiClient.mockReturnValue(axios);
   vol.reset();
   vol.fromJSON({
-    [`${TEST_STORAGE_LOCATION}/csv/entities/entity_type_1/${uuid()}.csv`]: await parseToCsv(
-      type1Entities,
-    ),
-    [`${TEST_STORAGE_LOCATION}/csv/entities/entity_type_2/${uuid()}.csv`]: await parseToCsv(
-      type2Entities,
-    ),
-    [`${TEST_STORAGE_LOCATION}/csv/relationships/relationship_type_1/${uuid()}.csv`]: await parseToCsv(
-      type1Relationships,
-    ),
+    [`${TEST_STORAGE_LOCATION}/csv/entities/entity_type_1/${uuid()}.csv`]:
+      await parseToCsv(type1Entities),
+    [`${TEST_STORAGE_LOCATION}/csv/entities/entity_type_2/${uuid()}.csv`]:
+      await parseToCsv(type2Entities),
+    [`${TEST_STORAGE_LOCATION}/csv/relationships/relationship_type_1/${uuid()}.csv`]:
+      await parseToCsv(type1Relationships),
   });
   mockedGlobby.mockImplementation((path) => {
     let paths: string[] = [];

package/src/__tests__/utils/fetchAssetsContents.ts

@@ -1,8 +1,8 @@
-import { Volume } from "memfs/lib/volume";
+import { Volume } from 'memfs/lib/volume';
 
 export function fetchAssetsContents(vol: Volume) {
   const files = vol.toJSON();
   return Object.keys(files)
-    .filter(filename => filename.endsWith('.csv'))
-    .map(filename => files[filename]) as string[];
+    .filter((filename) => filename.endsWith('.csv'))
+    .map((filename) => files[filename]) as string[];
 }

package/src/__tests__/utils/index.ts

@@ -1,2 +1,2 @@
 export * from './constants';
-export * from './fetchAssetsContents';
+export * from './fetchAssetsContents';

package/src/export/__tests__/exportAssetsToJson.test.ts

@@ -1,11 +1,14 @@
-import { mocked } from "ts-jest/utils";
+import { mocked } from 'ts-jest/utils';
 import ora from 'ora';
 
-import { exportAssetsToJson, ExportAssetsToJsonParams } from "../exportAssetsToJson";
-import { DEFAULT_EXPORT_DIRECTORY } from "../../commands";
+import {
+  exportAssetsToJson,
+  ExportAssetsToJsonParams,
+} from '../exportAssetsToJson';
+import { DEFAULT_EXPORT_DIRECTORY } from '../../commands';
 import { bulkDownloadToJson } from '../bulkDownloadToJson';
 import * as log from '../../log';
-import { TEST_API_KEY } from "../../__tests__/utils";
+import { TEST_API_KEY } from '../../__tests__/utils';
 
 jest.mock('../bulkDownloadToJson');
 jest.mock('../../log');
@@ -19,69 +22,81 @@ const options: ExportAssetsToJsonParams = {
   includeDeleted: true,
   includeEntities: true,
   includeRelationships: true,
-  apiKey: TEST_API_KEY
-}
+  apiKey: TEST_API_KEY,
+};
 
 test('should download both entities and relationships when specified to include them', async () => {
   await exportAssetsToJson(options);
 
   expect(bulkDownloadToJson).toHaveBeenCalledTimes(2);
-  expect(bulkDownloadToJson).toHaveBeenCalledWith(expect.objectContaining({
-    storageDirectory: options.storageDirectory,
-    apiKey: options.apiKey,
-    includeDeleted: options.includeDeleted,
-    assetType: 'entities',
-    progress: expect.anything()
-  }));
-  expect(bulkDownloadToJson).toHaveBeenCalledWith(expect.objectContaining({
-    storageDirectory: options.storageDirectory,
-    apiKey: options.apiKey,
-    includeDeleted: options.includeDeleted,
-    assetType: 'relationships',
-    progress: expect.anything()
-  }));
-  expect(mockedSpinner.succeed).toHaveBeenCalledWith(expect.stringMatching(
-    /Export Successful, Downloaded \d+ entities and \d+ relationships!/g
-  ));
+  expect(bulkDownloadToJson).toHaveBeenCalledWith(
+    expect.objectContaining({
+      storageDirectory: options.storageDirectory,
+      apiKey: options.apiKey,
+      includeDeleted: options.includeDeleted,
+      assetType: 'entities',
+      progress: expect.anything(),
+    }),
+  );
+  expect(bulkDownloadToJson).toHaveBeenCalledWith(
+    expect.objectContaining({
+      storageDirectory: options.storageDirectory,
+      apiKey: options.apiKey,
+      includeDeleted: options.includeDeleted,
+      assetType: 'relationships',
+      progress: expect.anything(),
+    }),
+  );
+  expect(mockedSpinner.succeed).toHaveBeenCalledWith(
+    expect.stringMatching(
+      /Export Successful, Downloaded \d+ entities and \d+ relationships!/g,
+    ),
+  );
 });
 
 test('should exclude entities when includeEntities is false', async () => {
   await exportAssetsToJson({
     ...options,
-    includeEntities: false
+    includeEntities: false,
   });
 
   expect(bulkDownloadToJson).toHaveBeenCalledTimes(1);
-  expect(bulkDownloadToJson).toHaveBeenCalledWith(expect.objectContaining({
-    storageDirectory: options.storageDirectory,
-    apiKey: options.apiKey,
-    includeDeleted: options.includeDeleted,
-    assetType: 'relationships',
-    progress: expect.anything()
-  }));
+  expect(bulkDownloadToJson).toHaveBeenCalledWith(
+    expect.objectContaining({
+      storageDirectory: options.storageDirectory,
+      apiKey: options.apiKey,
+      includeDeleted: options.includeDeleted,
+      assetType: 'relationships',
+      progress: expect.anything(),
+    }),
+  );
 });
 
 test('should exclude relationships when includeRelationships is false', async () => {
   await exportAssetsToJson({
     ...options,
-    includeRelationships: false
+    includeRelationships: false,
   });
 
   expect(bulkDownloadToJson).toHaveBeenCalledTimes(1);
-  expect(bulkDownloadToJson).toHaveBeenCalledWith(expect.objectContaining({
-    storageDirectory: options.storageDirectory,
-    apiKey: options.apiKey,
-    includeDeleted: options.includeDeleted,
-    assetType: 'entities',
-    progress: expect.anything()
-  }));
+  expect(bulkDownloadToJson).toHaveBeenCalledWith(
+    expect.objectContaining({
+      storageDirectory: options.storageDirectory,
+      apiKey: options.apiKey,
+      includeDeleted: options.includeDeleted,
+      assetType: 'entities',
+      progress: expect.anything(),
+    }),
+  );
 });
 
 test('should log error when there is an issue bulk downloading', async () => {
   const error = new Error();
   mockedBulkDownload.mockRejectedValue(error);
 
-  await expect(exportAssetsToJson(options)).rejects.toThrow(error)
+  await expect(exportAssetsToJson(options)).rejects.toThrow(error);
   expect(log.error).toHaveBeenCalledWith('Failed to export assets to JSON');
-  expect(mockedSpinner.fail).toHaveBeenCalledWith('Failed to export assets to JSON');
+  expect(mockedSpinner.fail).toHaveBeenCalledWith(
+    'Failed to export assets to JSON',
+  );
 });

package/src/export/__tests__/exportJsonAssetsToCsv.test.ts

@@ -13,30 +13,40 @@ import { TEST_API_KEY } from '../../__tests__/utils';
 
 jest.mock('fs');
 jest.mock('../../log');
-jest.mock('ora')
+jest.mock('ora');
 
 const mockedSpinner = ora().start();
 const TEST_DIRECTORY = DEFAULT_EXPORT_DIRECTORY;
 const TEST_FILES = {
-  [`${TEST_DIRECTORY}/json/entities/entity_type_1/${uuid()}.json`]: JSON.stringify(
-    [createEntity({ id: '1', type: '1' })]
-  ),
-  [`${TEST_DIRECTORY}/json/entities/entity_type_1/${uuid()}.json`]: JSON.stringify(
-    [createEntity({ id: '2', type: '1' })]
-  ),
-  [`${TEST_DIRECTORY}/json/entities/entity_type_2/${uuid()}.json`]: JSON.stringify(
-    [createEntity({ id: '3', type: '2' })]
-  ),
-  [`${TEST_DIRECTORY}/json/entities/entity_type_2/${uuid()}.json`]: JSON.stringify(
-    [createEntity({ id: '4', type: '2' }), createEntity({ id: '5', type: '2' })]
-  ),
-  [`${TEST_DIRECTORY}/json/relationships/relationship_type_1/${uuid()}.json`]: JSON.stringify([
-    createRelationship({ from: createEntity({ id: '1', type: '1' }), to: createEntity({ id: '3', type: '2' }) }),
-    createRelationship({ from: createEntity({ id: '2', type: '1' }), to: createEntity({ id: '3', type: '2' }) })
-  ]),
-  [`${TEST_DIRECTORY}/json/relationships/relationship_type_2/${uuid()}.json`]: JSON.stringify([
-    createRelationship({ from: createEntity({ id: '4', type: '2' }), to: createEntity({ id: '2', type: '1' }) }),
-  ]),
+  [`${TEST_DIRECTORY}/json/entities/entity_type_1/${uuid()}.json`]:
+    JSON.stringify([createEntity({ id: '1', type: '1' })]),
+  [`${TEST_DIRECTORY}/json/entities/entity_type_1/${uuid()}.json`]:
+    JSON.stringify([createEntity({ id: '2', type: '1' })]),
+  [`${TEST_DIRECTORY}/json/entities/entity_type_2/${uuid()}.json`]:
+    JSON.stringify([createEntity({ id: '3', type: '2' })]),
+  [`${TEST_DIRECTORY}/json/entities/entity_type_2/${uuid()}.json`]:
+    JSON.stringify([
+      createEntity({ id: '4', type: '2' }),
+      createEntity({ id: '5', type: '2' }),
+    ]),
+  [`${TEST_DIRECTORY}/json/relationships/relationship_type_1/${uuid()}.json`]:
+    JSON.stringify([
+      createRelationship({
+        from: createEntity({ id: '1', type: '1' }),
+        to: createEntity({ id: '3', type: '2' }),
+      }),
+      createRelationship({
+        from: createEntity({ id: '2', type: '1' }),
+        to: createEntity({ id: '3', type: '2' }),
+      }),
+    ]),
+  [`${TEST_DIRECTORY}/json/relationships/relationship_type_2/${uuid()}.json`]:
+    JSON.stringify([
+      createRelationship({
+        from: createEntity({ id: '4', type: '2' }),
+        to: createEntity({ id: '2', type: '1' }),
+      }),
+    ]),
 };
 
 beforeEach(() => {
@@ -48,7 +58,7 @@ test('should not export anything if there are no json assets', async () => {
     includeEntities: true,
     includeRelationships: true,
     storageDirectory: TEST_DIRECTORY,
-    apiKey: TEST_API_KEY
+    apiKey: TEST_API_KEY,
   });
 
   expect(vol.toJSON()).toEqual({});
@@ -61,25 +71,40 @@ test('should export both entities and relationships when specified', async () =>
     includeEntities: true,
     includeRelationships: true,
     storageDirectory: TEST_DIRECTORY,
-    apiKey: TEST_API_KEY
+    apiKey: TEST_API_KEY,
   });
-  const assets = await Promise.all(fetchAssetsContents(vol).map(convertCsvToJson))
-
-  expect(assets)
-    .toEqual(
-      expect.arrayContaining([
-        [createEntity({ id: '1', type: '1' })],
-        [createEntity({ id: '2', type: '1' })],
-        [createEntity({ id: '3', type: '2' })],
-        [createEntity({ id: '4', type: '2' }), createEntity({ id: '5', type: '2' })],
-        [
-          createRelationship({ from: createEntity({ id: '1', type: '1' }), to: createEntity({ id: '3', type: '2' }) }),
-          createRelationship({ from: createEntity({ id: '2', type: '1' }), to: createEntity({ id: '3', type: '2' }) })
-        ],
-        [createRelationship({ from: createEntity({ id: '4', type: '2' }), to: createEntity({ id: '2', type: '1' }) })]
-      ])
-    );
-  expect(assets).toHaveLength(6)
+  const assets = await Promise.all(
+    fetchAssetsContents(vol).map(convertCsvToJson),
+  );
+
+  expect(assets).toEqual(
+    expect.arrayContaining([
+      [createEntity({ id: '1', type: '1' })],
+      [createEntity({ id: '2', type: '1' })],
+      [createEntity({ id: '3', type: '2' })],
+      [
+        createEntity({ id: '4', type: '2' }),
+        createEntity({ id: '5', type: '2' }),
+      ],
+      [
+        createRelationship({
+          from: createEntity({ id: '1', type: '1' }),
+          to: createEntity({ id: '3', type: '2' }),
+        }),
+        createRelationship({
+          from: createEntity({ id: '2', type: '1' }),
+          to: createEntity({ id: '3', type: '2' }),
+        }),
+      ],
+      [
+        createRelationship({
+          from: createEntity({ id: '4', type: '2' }),
+          to: createEntity({ id: '2', type: '1' }),
+        }),
+      ],
+    ]),
+  );
+  expect(assets).toHaveLength(6);
 });
 
 test('should export only entities when includeRelationships is false', async () => {
@@ -89,21 +114,25 @@ test('should export only entities when includeRelationships is false', async ()
     includeEntities: true,
     includeRelationships: false,
     storageDirectory: TEST_DIRECTORY,
-    apiKey: TEST_API_KEY
+    apiKey: TEST_API_KEY,
   });
 
-  const assets = await Promise.all(fetchAssetsContents(vol).map(convertCsvToJson))
-
-  expect(assets)
-    .toEqual(
-      expect.arrayContaining([
-        [createEntity({ id: '1', type: '1' })],
-        [createEntity({ id: '2', type: '1' })],
-        [createEntity({ id: '3', type: '2' })],
-        [createEntity({ id: '4', type: '2' }), createEntity({ id: '5', type: '2' })],
-      ])
-    );
-  expect(assets).toHaveLength(4)
+  const assets = await Promise.all(
+    fetchAssetsContents(vol).map(convertCsvToJson),
+  );
+
+  expect(assets).toEqual(
+    expect.arrayContaining([
+      [createEntity({ id: '1', type: '1' })],
+      [createEntity({ id: '2', type: '1' })],
+      [createEntity({ id: '3', type: '2' })],
+      [
+        createEntity({ id: '4', type: '2' }),
+        createEntity({ id: '5', type: '2' }),
+      ],
+    ]),
+  );
+  expect(assets).toHaveLength(4);
 });
 
 test('should export only relationships when includeEntities is false', async () => {
@@ -113,39 +142,56 @@ test('should export only relationships when includeEntities is false', async ()
     includeEntities: false,
     includeRelationships: true,
     storageDirectory: TEST_DIRECTORY,
-    apiKey: TEST_API_KEY
+    apiKey: TEST_API_KEY,
   });
 
-  const assets = await Promise.all(fetchAssetsContents(vol).map(convertCsvToJson))
+  const assets = await Promise.all(
+    fetchAssetsContents(vol).map(convertCsvToJson),
+  );
 
-  expect(assets)
-    .toEqual(expect.arrayContaining([
+  expect(assets).toEqual(
+    expect.arrayContaining([
+      [
+        createRelationship({
+          from: createEntity({ id: '1', type: '1' }),
+          to: createEntity({ id: '3', type: '2' }),
+        }),
+        createRelationship({
+          from: createEntity({ id: '2', type: '1' }),
+          to: createEntity({ id: '3', type: '2' }),
+        }),
+      ],
       [
-        createRelationship({ from: createEntity({ id: '1', type: '1' }), to: createEntity({ id: '3', type: '2' }) }),
-        createRelationship({ from: createEntity({ id: '2', type: '1' }), to: createEntity({ id: '3', type: '2' }) })
+        createRelationship({
+          from: createEntity({ id: '4', type: '2' }),
+          to: createEntity({ id: '2', type: '1' }),
+        }),
       ],
-      [createRelationship({ from: createEntity({ id: '4', type: '2' }), to: createEntity({ id: '2', type: '1' }) })]
-    ]));
+    ]),
+  );
 
   expect(assets).toHaveLength(2);
-
 });
 
 test('should log error when export fails', async () => {
   vol.fromJSON({
-    [`${TEST_DIRECTORY}/json/entities/entity_type_1/${uuid()}.json`]: '{;}'
-  })
+    [`${TEST_DIRECTORY}/json/entities/entity_type_1/${uuid()}.json`]: '{;}',
+  });
 
-  await expect(exportJsonAssetsToCsv({
-    includeEntities: true,
-    includeRelationships: true,
-    storageDirectory: TEST_DIRECTORY,
-    apiKey: TEST_API_KEY
-  })).rejects.toThrow(/Unexpected token/g);
+  await expect(
+    exportJsonAssetsToCsv({
+      includeEntities: true,
+      includeRelationships: true,
+      storageDirectory: TEST_DIRECTORY,
+      apiKey: TEST_API_KEY,
+    }),
+  ).rejects.toThrow(/Unexpected token/g);
   expect(log.error).toHaveBeenCalledWith('Failed to export JSON assets to CSV');
-  expect(mockedSpinner.fail).toHaveBeenCalledWith('Failed to export JSON assets to CSV');
+  expect(mockedSpinner.fail).toHaveBeenCalledWith(
+    'Failed to export JSON assets to CSV',
+  );
 });
 
 function convertCsvToJson(content: string) {
   return csvToJson({ checkType: true }).fromString(content);
-}
+}

package/src/export/__tests__/groupJsonAssetsByType.test.ts

@@ -13,9 +13,9 @@ beforeEach(() => {
 });
 
 test('should return nothing if there are no files found', async () => {
-  await expect(groupJsonAssetsByType({ assetDirectory: TEST_DIRECTORY }))
-    .resolves
-    .toEqual({})
+  await expect(
+    groupJsonAssetsByType({ assetDirectory: TEST_DIRECTORY }),
+  ).resolves.toEqual({});
 });
 
 test('should group assets by type', async () => {
@@ -34,7 +34,9 @@ test('should group assets by type', async () => {
     [`${TEST_DIRECTORY}/json/entities/entity_type_2/${uuid()}.json`]: '{}',
   });
 
-  const batchedAssetFiles = await groupJsonAssetsByType({ assetDirectory: TEST_DIRECTORY });
+  const batchedAssetFiles = await groupJsonAssetsByType({
+    assetDirectory: TEST_DIRECTORY,
+  });
 
   expect(batchedAssetFiles.entity_type_1).toHaveLength(5);
   expect(batchedAssetFiles.entity_type_2).toHaveLength(6);

package/src/export/__tests__/utils/createEntity.ts

@@ -1,6 +1,14 @@
-import { Entity } from "@jupiterone/integration-sdk-core";
+import { Entity } from '@jupiterone/integration-sdk-core';
 
-export function createEntity({ type, id, optionalProps }: { type: string, id: string, optionalProps?: object }) {
+export function createEntity({
+  type,
+  id,
+  optionalProps,
+}: {
+  type: string;
+  id: string;
+  optionalProps?: object;
+}) {
   return {
     id: `entity-${id}`,
     name: `Entity ${id}`,
@@ -9,6 +17,6 @@ export function createEntity({ type, id, optionalProps }: { type: string, id: st
     _class: 'Entity',
     _type: `entity_type_${type}`,
     _key: `entity-${id}`,
-    ...optionalProps
-  } as Entity
-}
+    ...optionalProps,
+  } as Entity;
+}

package/src/export/__tests__/utils/createRelationship.ts

@@ -1,6 +1,6 @@
 import {
   Entity,
-  createDirectRelationship
+  createDirectRelationship,
 } from '@jupiterone/integration-sdk-core';
 import { RelationshipClass } from '@jupiterone/data-model';
 

package/src/export/__tests__/utils/parseCsvToJson.ts

@@ -4,5 +4,5 @@ export function parseCsvToJson(json: string) {
   return csvToJson({
     checkType: true,
     flatKeys: true,
-  }).fromString(json)
-}
+  }).fromString(json);
+}

package/src/export/__tests__/utils/parseToCsv.ts

@@ -1,6 +1,5 @@
 import jsonexport from 'jsonexport';
 
-
 export function parseToCsv(content: object[]): Promise<string> {
-  return jsonexport(content)
-}
+  return jsonexport(content);
+}

package/src/export/__tests__/writeAssetsToCsv.test.ts

@@ -11,18 +11,16 @@ jest.mock('fs');
 
 test('should write assets to csv files by given types', async () => {
   vol.fromJSON({
-    [`${TEST_STORAGE_LOCATION}/json/entities/entity_type_1/${uuid()}.json`]: JSON.stringify(
-      [
+    [`${TEST_STORAGE_LOCATION}/json/entities/entity_type_1/${uuid()}.json`]:
+      JSON.stringify([
         createEntity({ id: '1', type: '1' }),
         createEntity({ id: '2', type: '1' }),
-      ],
-    ),
-    [`${TEST_STORAGE_LOCATION}/json/entities/entity_type_2/${uuid()}.json`]: JSON.stringify(
-      [
+      ]),
+    [`${TEST_STORAGE_LOCATION}/json/entities/entity_type_2/${uuid()}.json`]:
+      JSON.stringify([
         createEntity({ id: '3', type: '2' }),
         createEntity({ id: '4', type: '2' }),
-      ],
-    ),
+      ]),
   });
 
   await writeAssetsToCsv({

package/src/export/exportAssets.ts

@@ -4,10 +4,14 @@ import { deleteDirectory } from '../fileSystem';
 import { exportAssetsToJson } from './exportAssetsToJson';
 import { exportJsonAssetsToCsv } from './exportJsonAssetsToCsv';
 
-export type ExportAssetsParams = Omit<ExportOptions, 'dataDir'> & { storageDirectory: string };
+export type ExportAssetsParams = Omit<ExportOptions, 'dataDir'> & {
+  storageDirectory: string;
+};
 
 export default async function exportAssets(options: ExportAssetsParams) {
-  log.info(`Starting account export to the [${options.storageDirectory}] directory`);
+  log.info(
+    `Starting account export to the [${options.storageDirectory}] directory`,
+  );
   log.info(`Exporting Entities: ${options.includeEntities}`);
   log.info(`Exporting Relationships: ${options.includeRelationships}`);
   log.info(`Include Deleted Assets: ${options.includeDeleted}`);

package/src/export/groupJsonAssetsByType.ts

@@ -4,19 +4,22 @@ import path from 'path';
 import _ from 'lodash';
 
 interface BatchAssetParams {
-  assetDirectory: string
+  assetDirectory: string;
 }
 
-export async function groupJsonAssetsByType({ assetDirectory }: BatchAssetParams) {
+export async function groupJsonAssetsByType({
+  assetDirectory,
+}: BatchAssetParams) {
   const assetJsonFiles = await globby([
-    upath.toUnix(`${assetDirectory}/**/*.json`)
+    upath.toUnix(`${assetDirectory}/**/*.json`),
   ]);
 
-  const assetJsonFilesByType = _.groupBy(assetJsonFiles, p => path.basename(path.dirname(p)))
+  const assetJsonFilesByType = _.groupBy(assetJsonFiles, (p) =>
+    path.basename(path.dirname(p)),
+  );
 
-  return Object.keys(assetJsonFilesByType)
-    .reduce((acc, key) => {
-      acc[key] = assetJsonFilesByType[key]
-      return acc;
-    }, {} as { [key: string]: string[] })
+  return Object.keys(assetJsonFilesByType).reduce((acc, key) => {
+    acc[key] = assetJsonFilesByType[key];
+    return acc;
+  }, {} as { [key: string]: string[] });
 }

package/src/export/util.ts

@@ -1,3 +1,3 @@
 export function sanitizeContent(content: string) {
-  return content.replace(/\\n/g, '\\\\n').replace(/\\r/g, '\\\\r')
-}
+  return content.replace(/\\n/g, '\\\\n').replace(/\\r/g, '\\\\r');
+}