@jupiterone/integration-sdk-cli 8.3.1 → 8.4.2

package/src/neo4j/neo4jGraphStore.ts

@@ -7,8 +7,8 @@ export interface Neo4jGraphObjectStoreParams {
   uri: string;
   username: string;
   password: string;
-  integrationInstanceID: string,
-  session?: neo4j.Session
+  integrationInstanceID: string;
+  session?: neo4j.Session;
 }
 
 export class Neo4jGraphStore {
@@ -19,10 +19,9 @@ export class Neo4jGraphStore {
   private integrationInstanceID: string;
 
   constructor(params: Neo4jGraphObjectStoreParams) {
-    if(params.session) {
+    if (params.session) {
       this.persistedSession = params.session;
-    }
-    else {
+    } else {
       this.neo4jDriver = neo4j.driver(
         params.uri,
         neo4j.auth.basic(params.username, params.password),
@@ -31,12 +30,14 @@ export class Neo4jGraphStore {
     this.integrationInstanceID = params.integrationInstanceID;
   }
 
-  private async runCypherCommand(cypherCommand: string, cypherParameters?: any): Promise<neo4j.Result> {
-    if(this.persistedSession) {
+  private async runCypherCommand(
+    cypherCommand: string,
+    cypherParameters?: any,
+  ): Promise<neo4j.Result> {
+    if (this.persistedSession) {
       const result = await this.persistedSession.run(cypherCommand);
       return result;
-    }
-    else {
+    } else {
       const session = this.neo4jDriver.session({
         database: this.databaseName,
         defaultAccessMode: neo4j.session.WRITE,
@@ -65,9 +66,9 @@ export class Neo4jGraphStore {
         SET ${nodeAlias} += $propertyParameters
         SET ${nodeAlias}:${entity._type};`;
       await this.runCypherCommand(buildCommand, {
-        propertyParameters: propertyParameters, 
-        finalKeyValue: finalKeyValue, 
-        integrationInstanceID: this.integrationInstanceID
+        propertyParameters: propertyParameters,
+        finalKeyValue: finalKeyValue,
+        integrationInstanceID: this.integrationInstanceID,
       });
     }
   }
@@ -84,43 +85,56 @@ export class Neo4jGraphStore {
       if (relationship._fromEntityKey) {
         startEntityKey = sanitizeValue(relationship._fromEntityKey.toString());
       }
-      if(relationship._toEntityKey) {
+      if (relationship._toEntityKey) {
         endEntityKey = sanitizeValue(relationship._toEntityKey.toString());
       }
 
-      if(relationship._mapping) { //Mapped Relationship
-        if(relationship._mapping['skipTargetCreation'] === false) {
+      if (relationship._mapping) {
+        //Mapped Relationship
+        if (relationship._mapping['skipTargetCreation'] === false) {
           //Create target entity first
           const tempEntity: Entity = {
             _class: relationship._mapping['targetEntity']._class,
             //TODO, I think this key is wrong, but not sure what else to use
-            _key:  sanitizeValue(relationship._key.replace(relationship._mapping['sourceEntityKey'], '')),
+            _key: sanitizeValue(
+              relationship._key.replace(
+                relationship._mapping['sourceEntityKey'],
+                '',
+              ),
+            ),
             _type: relationship._mapping['targetEntity']._type,
-          }
+          };
           await this.addEntities([tempEntity]);
         }
-        startEntityKey = sanitizeValue(relationship._mapping['sourceEntityKey']);
+        startEntityKey = sanitizeValue(
+          relationship._mapping['sourceEntityKey'],
+        );
         // TODO, see above.  This key might also be an issue for the same reason
-        endEntityKey = sanitizeValue(relationship._key.replace(relationship._mapping['sourceEntityKey'], ''));
+        endEntityKey = sanitizeValue(
+          relationship._key.replace(
+            relationship._mapping['sourceEntityKey'],
+            '',
+          ),
+        );
       }
 
       const buildCommand = `
       MERGE (start {_key: $startEntityKey, _integrationInstanceID: $integrationInstanceID})
       MERGE (end {_key: $endEntityKey, _integrationInstanceID: $integrationInstanceID})
-      MERGE (start)-[${relationshipAlias}:${relationship._type}]->(end)
+      MERGE (start)-[${relationshipAlias}:${relationship._class}]->(end)
       SET ${relationshipAlias} += $propertyParameters;`;
       await this.runCypherCommand(buildCommand, {
-        propertyParameters: propertyParameters, 
-        startEntityKey: startEntityKey, 
+        propertyParameters: propertyParameters,
+        startEntityKey: startEntityKey,
         endEntityKey: endEntityKey,
-        integrationInstanceID: this.integrationInstanceID
+        integrationInstanceID: this.integrationInstanceID,
       });
     }
   }
 
   // TODO, if we get to very large databases we could reach a size where
-  // one or both both of the below wipe commands can't be easily executed 
-  // in memory.  At that time, we should consider requiring/using the APOC 
+  // one or both both of the below wipe commands can't be easily executed
+  // in memory.  At that time, we should consider requiring/using the APOC
   // library so we can use apoc.periodic.iterate.  Leaving out for now,
   // since that would further complicate the Neo4j database setup.
   async wipeInstanceIdData() {

package/src/neo4j/uploadToNeo4j.ts

@@ -1,5 +1,8 @@
 import { Neo4jGraphStore } from './neo4jGraphStore';
-import { iterateParsedGraphFiles, isDirectoryPresent } from '@jupiterone/integration-sdk-runtime';
+import {
+  iterateParsedGraphFiles,
+  isDirectoryPresent,
+} from '@jupiterone/integration-sdk-runtime';
 import { FlushedGraphObjectData } from '@jupiterone/integration-sdk-runtime/src/storage/types';
 
 type UploadToNeo4jParams = {
@@ -44,4 +47,4 @@ export async function uploadToNeo4j({
   } finally {
     await store.close();
   }
-}
+}

package/src/neo4j/wipeNeo4j.ts

@@ -5,15 +5,17 @@ type WipeNeo4jParams = {
   neo4jUri?: string;
   neo4jUser?: string;
   neo4jPassword?: string;
-}
+};
 export async function wipeNeo4jByID({
   integrationInstanceID,
   neo4jUri = process.env.NEO4J_URI,
-  neo4jUser = process.env. NEO4J_USER,
-  neo4jPassword = process.env. NEO4J_PASSWORD,
+  neo4jUser = process.env.NEO4J_USER,
+  neo4jPassword = process.env.NEO4J_PASSWORD,
 }: WipeNeo4jParams) {
-  if(!neo4jUri || !neo4jUser || !neo4jPassword) {
-    throw new Error('ERROR: must provide login information in function call or include NEO4J_URI, NEO4J_USER, and NEO4J_PASSWORD files in your .env file!');
+  if (!neo4jUri || !neo4jUser || !neo4jPassword) {
+    throw new Error(
+      'ERROR: must provide login information in function call or include NEO4J_URI, NEO4J_USER, and NEO4J_PASSWORD files in your .env file!',
+    );
   }
 
   const store = new Neo4jGraphStore({
@@ -33,15 +35,17 @@ type WipeAllNeo4jParams = {
   neo4jUri?: string;
   neo4jUser?: string;
   neo4jPassword?: string;
-}
+};
 
 export async function wipeAllNeo4j({
   neo4jUri = process.env.NEO4J_URI,
-  neo4jUser = process.env. NEO4J_USER,
-  neo4jPassword = process.env. NEO4J_PASSWORD,
+  neo4jUser = process.env.NEO4J_USER,
+  neo4jPassword = process.env.NEO4J_PASSWORD,
 }: WipeAllNeo4jParams) {
-  if(!neo4jUri || !neo4jUser || !neo4jPassword) {
-    throw new Error('ERROR: must provide login information in function call or include NEO4J_URI, NEO4J_USER, and NEO4J_PASSWORD files in your .env file!');
+  if (!neo4jUri || !neo4jUser || !neo4jPassword) {
+    throw new Error(
+      'ERROR: must provide login information in function call or include NEO4J_URI, NEO4J_USER, and NEO4J_PASSWORD files in your .env file!',
+    );
   }
 
   const store = new Neo4jGraphStore({
@@ -55,4 +59,4 @@ export async function wipeAllNeo4j({
   } finally {
     await store.close();
   }
-}
+}

package/src/visualization/__tests__/createMappedRelationshipNodesAndEdges.test.ts

@@ -42,13 +42,11 @@ describe('#createMappedRelationshipNodesAndEdges', () => {
       },
     ];
 
-    const {
-      mappedRelationshipEdges,
-      mappedRelationshipNodes,
-    } = createMappedRelationshipNodesAndEdges({
-      mappedRelationships,
-      explicitEntities,
-    });
+    const { mappedRelationshipEdges, mappedRelationshipNodes } =
+      createMappedRelationshipNodesAndEdges({
+        mappedRelationships,
+        explicitEntities,
+      });
 
     expect(mappedRelationshipEdges).toEqual([
       {
@@ -71,13 +69,11 @@ describe('#createMappedRelationshipNodesAndEdges', () => {
       },
     ];
 
-    const {
-      mappedRelationshipEdges,
-      mappedRelationshipNodes,
-    } = createMappedRelationshipNodesAndEdges({
-      mappedRelationships,
-      explicitEntities,
-    });
+    const { mappedRelationshipEdges, mappedRelationshipNodes } =
+      createMappedRelationshipNodesAndEdges({
+        mappedRelationships,
+        explicitEntities,
+      });
 
     expect(mappedRelationshipEdges).toEqual([
       {
@@ -110,13 +106,11 @@ describe('#createMappedRelationshipNodesAndEdges', () => {
       },
     ];
 
-    const {
-      mappedRelationshipEdges,
-      mappedRelationshipNodes,
-    } = createMappedRelationshipNodesAndEdges({
-      mappedRelationships,
-      explicitEntities,
-    });
+    const { mappedRelationshipEdges, mappedRelationshipNodes } =
+      createMappedRelationshipNodesAndEdges({
+        mappedRelationships,
+        explicitEntities,
+      });
 
     expect(mappedRelationshipEdges).toEqual([
       {
@@ -184,13 +178,11 @@ describe('#createMappedRelationshipNodesAndEdges', () => {
       },
     ];
 
-    const {
-      mappedRelationshipEdges,
-      mappedRelationshipNodes,
-    } = createMappedRelationshipNodesAndEdges({
-      mappedRelationships,
-      explicitEntities,
-    });
+    const { mappedRelationshipEdges, mappedRelationshipNodes } =
+      createMappedRelationshipNodesAndEdges({
+        mappedRelationships,
+        explicitEntities,
+      });
 
     expect(mappedRelationshipEdges).toEqual([
       {
@@ -264,13 +256,11 @@ describe('#createMappedRelationshipNodesAndEdges', () => {
       },
     ];
 
-    const {
-      mappedRelationshipEdges,
-      mappedRelationshipNodes,
-    } = createMappedRelationshipNodesAndEdges({
-      mappedRelationships,
-      explicitEntities,
-    });
+    const { mappedRelationshipEdges, mappedRelationshipNodes } =
+      createMappedRelationshipNodesAndEdges({
+        mappedRelationships,
+        explicitEntities,
+      });
 
     expect(mappedRelationshipEdges).toEqual([
       {
@@ -328,13 +318,11 @@ describe('#createMappedRelationshipNodesAndEdges', () => {
       },
     ];
 
-    const {
-      mappedRelationshipEdges,
-      mappedRelationshipNodes,
-    } = createMappedRelationshipNodesAndEdges({
-      mappedRelationships,
-      explicitEntities,
-    });
+    const { mappedRelationshipEdges, mappedRelationshipNodes } =
+      createMappedRelationshipNodesAndEdges({
+        mappedRelationships,
+        explicitEntities,
+      });
 
     expect(mappedRelationshipEdges).toEqual([
       {
@@ -389,13 +377,11 @@ describe('#createMappedRelationshipNodesAndEdges', () => {
       },
     ];
 
-    const {
-      mappedRelationshipEdges,
-      mappedRelationshipNodes,
-    } = createMappedRelationshipNodesAndEdges({
-      mappedRelationships,
-      explicitEntities,
-    });
+    const { mappedRelationshipEdges, mappedRelationshipNodes } =
+      createMappedRelationshipNodesAndEdges({
+        mappedRelationships,
+        explicitEntities,
+      });
 
     expect(mappedRelationshipEdges).toEqual([
       {

package/src/visualization/generateVisualization.ts

@@ -28,11 +28,8 @@ export async function generateVisualization(
     log.warn(`Unable to find any files under path: ${graphDataPath}`);
   }
 
-  const {
-    entities,
-    relationships,
-    mappedRelationships,
-  } = await retrieveIntegrationData(entitiesAndRelationshipPaths);
+  const { entities, relationships, mappedRelationships } =
+    await retrieveIntegrationData(entitiesAndRelationshipPaths);
 
   const nodeDataSets = entities.map((entity) => ({
     id: getNodeIdFromEntity(entity, []),
@@ -47,13 +44,11 @@ export async function generateVisualization(
     }),
   );
 
-  const {
-    mappedRelationshipEdges,
-    mappedRelationshipNodes,
-  } = createMappedRelationshipNodesAndEdges({
-    mappedRelationships,
-    explicitEntities: entities,
-  });
+  const { mappedRelationshipEdges, mappedRelationshipNodes } =
+    createMappedRelationshipNodesAndEdges({
+      mappedRelationships,
+      explicitEntities: entities,
+    });
 
   await writeFileToPath({
     path: visualizationOutputPath,

package/src/visualization/retrieveIntegrationData.ts

@@ -18,11 +18,9 @@ export async function retrieveIntegrationData(
   const mappedRelationships: MappedRelationship[] = [];
 
   const entitiesAndRelationships = await Promise.all(
-    entitiesAndRelationshipPaths.map(
-      async (path): Promise<any> => {
-        return await readJsonFromPath<any>(path);
-      },
-    ),
+    entitiesAndRelationshipPaths.map(async (path): Promise<any> => {
+      return await readJsonFromPath<any>(path);
+    }),
   );
 
   for (const item of entitiesAndRelationships) {

package/src/visualization/types/IntegrationData.ts

@@ -1,4 +1,8 @@
-import { Entity, ExplicitRelationship, MappedRelationship } from '@jupiterone/integration-sdk-core';
+import {
+  Entity,
+  ExplicitRelationship,
+  MappedRelationship,
+} from '@jupiterone/integration-sdk-core';
 
 export interface IntegrationData {
   entities: Entity[];

package/src/visualization/utils.ts

@@ -1,18 +1,21 @@
 import { v4 as uuid } from 'uuid';
-import { Entity } from "@jupiterone/integration-sdk-core";
+import { Entity } from '@jupiterone/integration-sdk-core';
 
 export type NodeEntity = Partial<Entity> & { nodeId: string };
 
 /**
  * The nodeId should map back to _key, which ought to be globally unique.
  * Entities set their node ID once, and return if available.
- * 
+ *
  * If nodeId is not set, first check that the _key isn't already a nodeId for another entity.
  * Duplicates will break vis.js, so we will set nodeId to a UUID (this makes isNodeDuplicate(nodeEntity) === true)
- * 
+ *
  * If node is not a duplicate, return either the entity _key, or, if unavailable, return a new UUID.
  */
-export function getNodeIdFromEntity(entity: Partial<NodeEntity>, existingEntities: NodeEntity[]): string {
+export function getNodeIdFromEntity(
+  entity: Partial<NodeEntity>,
+  existingEntities: NodeEntity[],
+): string {
   if (entity.nodeId !== undefined) {
     return entity.nodeId;
   }

package/tsconfig.dist.json

@@ -3,9 +3,7 @@
   "compilerOptions": {
     "sourceMap": true
   },
-  "include": [
-    "src"
-  ],
+  "include": ["src"],
   "exclude": [
     "**/dist/*",
     "**/*.test.ts",

package/tsconfig.json

@@ -3,9 +3,7 @@
   "compilerOptions": {
     "outDir": "dist"
   },
-  "exclude": [
-    "**/dist/*"
-  ],
+  "exclude": ["**/dist/*"],
   "references": [
     { "path": "../integration-sdk-core" },
     { "path": "../integration-sdk-runtime" },