knowledgeGraphService

const knowledgeGraphModule = await $arcgis.import("@arcgis/core/rest/knowledgeGraphService.js");

// use fetchKnowledgeGraph() to retrieve the knowledge graph
// define the new entity type
const newEntityType = {
  type: "entity",
  name: "Person",
  properties: [
    {
      name: "nameProp",
      alias: "Name",
      fieldType: "esriFieldTypeString",
      role: "esriGraphPropertyRegular",
    },
  ],
};

// define a new relationship type
const newRelationshipType = {
  type: "relationship",
  name: "knows",
  properties: [
    {
      name: "dateMet",
      fieldType: "esriFieldTypeTimestampOffset",
      role: "esriGraphPropertyRegular",
    },
  ],
  endPoints: [
    {
      originEntityType: "Person",
      destinationEntityType: "Person",
    },
  ],
};

// add the new types, update the data model and get the updated graph.
knowledgeGraphModule.executeAddNamedTypes(graph,
  {
    newEntityTypes: [newEntityType],
    newRelationshipTypes: [newRelationshipType]
  }).then((response) => {
        graph = response.updatedKnowledgeGraph;
  })

// sample executeApplyEdits() to add a new entity to the `Supplier` entity type
const newEntity = new Entity({
  typeName: "Supplier",
  properties: {
    Name: "Supplier 5",
    EmployeeCount: 681
  }
});
KnowledgeGraphModule.executeApplyEdits(
  graph, {
      entityAdds: [newEntity]
    })
    .then((editResult) => {
      console.log("Graph Add Result", editResult);
    });
});

// Basic example results of adding one entity to the `Supplier` entity type
{
  editResults:[{
    adds:[
    {
      id: "{A1W5F4A8S-41F1-49A4-8412-ANIWN9906E88}",
      error: false
    }],
    deletes:[],
    typeName: "Supplier",
    updates:[]
  }],
  hasError: false,
  error: undefined
}

//update existing records
const updateEntity = new Entity({
  typeName: "Supplier",
  // update the EmployeeCount from 681 to 685
  properties: {
    Name: "Supplier 5",
    EmployeeCount: 685
  },
  id:"{A1W5F4A8S-41F1-49A4-8412-ANIWN9906E88}" //id of entity already in knowledge graph
});
const updateRelationship = new Relationship({
  typeName: "buys_part",
  properties: {
    quantity: 5000
  },
  // origin and destination entities must already exist in the graph
  originId: "{AN4E4G85-41F1-49A4-8412-CACCC9906E88}",
  destinationId: "{9D2D6AFD-41F1-49A4-8412-1DGR8E5D6S1G4}"
});
KnowledgeGraphModule.executeApplyEdits(
  graph, {
      entityUpdates: [updateEntity],
      relationshipUpdates: [updateRelationship]
    })
    .then((editResult) => {
      console.log("Graph Update Result", editResult);
    });
});

//delete existing records
KnowledgeGraphModule.executeApplyEdits(
  graph, {
      entityDeletes: [{
        typeName: "Supplier",
        ids: ["{AMGIE541G-41F1-49A4-8412-CACCC9906E88}", "{HNWIGHE15-WH52-2GE6-1A5W-A1F8W4FS3A1S5}"]
      },{
        typeName: "Part",
        ids: ["{FNIW4GF1-ANFW-49A4-ANW7-GNWIGHAF4S51FS}"]
      }],
      relationshipDeletes: [{
        typeName: "Buys_part",
        ids: ["{MH4E54G8E-MF4W-1842-2S44-15AF5W8F4S2W8}"]
      }],
      //delete all relationships connected to the deleted entities.
      options:{
        cascadeDelete: true
      }
    })
    .then((editResult) => {
      console.log("Graph Delete Result", editResult);
    });
});

const knowledgeGraphModule = await $arcgis.import("@arcgis/core/rest/knowledgeGraphService.js");

// use fetchKnowledgeGraph() to retrieve the knowledge graph
// Delete the type, update the data model and get the updated graph.
knowledgeGraphModule
  .executeDeleteNamedTypes(graph,"knows")
      .then((response) => {
         graph = response.updatedKnowledgeGraph;
      })

knowledgeGraphService.executeFindPaths({
    inKnowledgeGraphUrl: "https://sampleserver7.arcgisonline.com/server/rest/services/Hosted/BumbleBees/KnowledgeGraphServer",
    config: {
   type: "CIMFilteredFindPathsConfiguration",
   name: "exampleFFPconfiguration",
   originEntities: [
       {
      type: "CIMFilteredFindPathsEntity",
      iD: devPathStart,
      entityTypeName: "User"
       }
   ],
   destinationEntities: [
       {
      type: "CIMFilteredFindPathsEntity",
      iD: devPathEnd,
      entityTypeName: "Species"
       }
   ],
   pathFilters: [
       {
      type: "CIMFilteredFindPathsPathFilter",
      iD: null,
      itemTypeName: "Observation",
      itemType: "Entity",
      filterType: "Include"
       }
   ],
   defaultTraversalDirectionType: "Any",
   entityUsage: "EachPair",
   pathMode: "All",
   minPathLength: 1,
   maxPathLength: 8,
   maxCountPaths: 100000
   }
  });

// typical use case
KnowledgeGraphModule.executeQuery(
 knowledgeGraph, //graph
 { // queryArguments
   openCypherQuery: "MATCH (n) RETURN n LIMIT 100", //query
  }).then((queryResult) => {
    // do something with the result
});

// sample streaming query using bind parameters
// to search for entities with a the `name` property that matches a specific string
// or have their geometry within a bounding box.
// get all parts bought by each supplier.
// query returns both the supplier and the part it buys.
const query = `MATCH (s:Supplier)-[:buys_part]-(p:Part)
               WHERE s.name=$name OR esri.graph.ST_Intersects($geom, s.geometry)
               RETURN s,p`;

KnowledgeGraphModule.executeQueryStreaming(
  knowledgeGraph,
  {
    openCypherQuery: query,
    bindParameters: {
      name: "Supplier 5",
      //bounding box around the area of Washington DC, USA
      geom: new Polygon({
        rings: [
          [
            [38,-78],
            [39, -78],
            [39, -76],
            [-38, -76],
            [-38, -78],
          ],
       ],
    }),
  }
}).then((streamingQueryResult)=>{
  // streaming query returns a readableStream which must be read to access the returned graph data
  readStream(streamingQueryResult)
});

// a function to read the readable stream returned from the above query
const readStream = async (streamingQueryResult) => {
  let time = Date.now();
  let reader = streamingQueryResult.resultRowsStream.getReader();
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        console.log(`Completed database requests: ${(Date.now() - time) / 1000} seconds`);
        break;
      }
      console.log(`Chunk returned in: ${(Date.now() - time) / 1000} seconds`);
      // use the results
      // list the parts bought by each supplier
      let supplierParts = {};
      // each element of the result array will contain one supplier and one part it buys
      for (var v in value){
        let supplier = value[v][0].properties.Name
        let part = value [v][1].properties.Name
        if(!(supplier in supplierParts)){
          supplierParts[supplier] = [];
        }
        // collect parts by supplier that buys them
        supplierParts[supplier].push(part);
        console.log(supplierParts);
        // result printed to the console: {Supplier 1:[Part1], Supplier 3:[Part2, Part3]}
    }
  } catch (err) {
    if (err.name === "AbortError") {
      console.log("Request aborted as expected");
    } else {
      throw err;
    }
  }
};

// result stream from above query after it has been read
"Streaming chunk returned in: 0.082 seconds"
[
  [{
    "declaredClass": "esri.rest.knowledgeGraph.Entity",
    "properties": {
      "Name": "Supplier 1",
      "City": "Washington DC",
      "EmployeeCount": 31
    },
    "typeName": "Supplier",
    "id": "{57FDF2F3-34C8-48EF-9A3B-76ED9314C4D2}"
  },{
    "declaredClass": "esri.rest.knowledgeGraph.Entity",
    "properties": {
      "Part_ID": 695401,
      "Name": "Part1",
      "Minimum_quantity": 360
    },
    "typeName": "Part",
    "id": "{IWN51W4-1AW8-A2W6-1AW5F-1AW8F9F4W51AS}",
  }],
  [{
    "declaredClass": "esri.rest.knowledgeGraph.Entity",
    "properties": {
      "Name": "Supplier 2",
      "City": "Baltimore",
      "EmployeeCount": 53
    },
    "typeName": "Supplier",
    "id": "{1A4W8F5W-1WA8-5W6A-A1W8-A1W5F8W3S482A}"
  },{
    "declaredClass": "esri.rest.knowledgeGraph.Entity",
    "properties": {
      "Part_ID": 695401,
      "Name": "Part2",
      "Minimum_quantity": 2500
    },
    "typeName": "Part",
    "id": "{A1W5F8W4F-A1W8-1894-16A5-A86WF4A8SFWD}",
  }],
  [{
    "declaredClass": "esri.rest.knowledgeGraph.Entity",
    "properties": {
      "Name": "Supplier 2",
      "City": "Baltimore",
      "EmployeeCount": 53
    },
    "typeName": "Supplier",
    "id": "{1A4W8F5W-1WA8-5W6A-A1W8-L5H4G8RT1PK3}"
  },{
    "declaredClass": "esri.rest.knowledgeGraph.Entity",
    "properties": {
      "Part_ID": 695401,
      "Name": "Part3",
      "Minimum_quantity": 5000
    },
    "typeName": "Part",
    "id": "{PTJ51FT-KY4H-1GY5-G1Y8-G1Y5K49G8Y4GHJ}",
  }]
]

// aborting the query
// create instance of native browser abort controller
const controller = new AbortController();

// create query
KnowledgeGraphModule.executeQueryStreaming(
    knowledgeGraph,
    {
      openCypherQuery: "MATCH (n) RETURN n LIMIT 100",
    },
    {
      signal: controller.signal,
    }
  )
  .then((streamingQueryResult) => {
    readStream(streamingQueryResult);
  })
  // indicate that the stream was aborted
  .catch((err) => {
    if (err.name === "AbortError") {
      console.log("Request aborted as expected");
    }

// abort the query after half a second
setTimeout(() => {
  console.log("Sending abort signal");
  controller.abort();
}, 500);

// typical use case
KnowledgeGraphModule.executeSearch(
 knowledgeGraph, //graph
 { // searchArguments
   searchQuery: "Sun", //search term
   typeCategoryFilter: "both" //search entities, relationships or both.
  }).then((searchResult) => {
    // do something with the result
   console.log(searchResult)
});

// sample search result
{
  "declaredClass": "esri.rest.knowledgeGraph.GraphQueryResult",
  "resultRows": [
    [
      {
        "declaredClass": "esri.rest.knowledgeGraph.Entity",
        "properties": {
          "shape": {
            "declaredClass": "esri.geometry.Point",
            "cache": {},
            "hasM": false,
            "hasZ": false,
            "latitude": 53.589000000000006,
            "longitude": -0.9633,
            "type": "point",
            "extent": null,
            "spatialReference": {
              "wkid": 4326
            },
            "x": -0.9633,
            "y": 53.589000000000006
          },
          "Name": "Suncommon",
          "Employee_Count": 400
        },
        "typeName": "Company",
        "id": "{WIPJ483T-U8UI-LLK9-YUI8-Y5YK8YGD88E9}",
      }
    ],
    [
       {
        "declaredClass": "esri.rest.Relationship.Relationship",
        "originID": "{44027400-4B48-4FF2-B526-E27FC17EC246}",
        "destinationID": "{CB0CF580-3899-491E-8F10-0AD1DA4EE49B}",
        "properties": {
          "orderDay": "Sunday",
          "quantity": 15000
        },
        "typeName": "buys_part",
        "id": "{ABCDEFG-0000-1111-2222-0AD1DA4EE49B}"
      }
    ]
  }

// example search for "solar"with additional parameters
KnowledgeGraphModule.executeSearchStreaming(
  knowledgeGraph,
  {
    searchQuery: "solar",
    typeCategoryFilter: "both",
    returnSearchContext: false,
    start: 1,
    num: 200, //return 200 records.
    namedTypesFilter: ["Company", "Supplier", "Part"],
    idsFilter: ["{G4E8G2S8D-2GS5-98S4-3S5D-S1DE7G45DS48}",
                     "{FNWI1G5W-1A5W-3A5W-8412-A1W5F4W8F7AS}",
                     "{9D2D6AFD-41F1-49A4-8412-CACCC9906E88}"]
  }
).then((streamingSearchResult)=>{
  // the result of a streaming search is a readableStream which requires decoding.
  readStream(streamingSearchResult)
})

// a function to read the readable stream returned from the above query
const readStream = async (streamingQueryResult) => {
  let time = Date.now();
  let reader = streamingQueryResult.resultRowsStream.getReader();
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        console.log(`Completed database requests: ${(Date.now() - time) / 1000} seconds`, value);
        break;
      }
      console.log(`Chunk returned in: ${(Date.now() - time) / 1000} seconds`, value)
    }
  } catch (err) {
    if (err.name === "AbortError") {
      console.log("Request aborted as expected");
    } else {
      throw err;
    }
  }
};

// sample result of streaming search result chunk read and printed to the console

"Streaming chunk returned in: 0.082 seconds"
[
  [{
    "declaredClass": "esri.rest.knowledgeGraph.Entity",
    "properties": {
      "Name": "Suncommon",
      "Employee_Count": 400,
      "energyType": "solar"
    },
    "typeName": "Company",
    "id": "{G4E8G2S8D-2GS5-98S4-3S5D-S1DE7G45DS48}"
  }],
  [{
    "declaredClass": "esri.rest.knowledgeGraph.Entity",
    "properties": {
      "Name": "Quality Solar Supply",
      "Supplier_code": "158B",
      "City": "New Orleans",
    },
    "typeName": "Supplier",
    "id": "{FNWI1G5W-1A5W-3A5W-8412-A1W5F4W8F7AS}"
  }],
  [{
    "declaredClass": "esri.rest.knowledgeGraph.Entity",
    "properties": {
      "Name": "Solar panel",
      "panel_type": "Polycrystalline",
      "price_per_unit": 400
    },
    "typeName": "Part",
    "id": "{9D2D6AFD-41F1-49A4-8412-CACCC9906E88}"
  }]
]

// typical use case
const url = "https://myHostName.domain.com/server/rest/services/Hosted/myServiceName/KnowledgeGraphServer";

const knowledgeGraph = await knowledgeGraphService.fetchKnowledgeGraph(url)

KnowledgeGraphModule.fetchAllClientDataKeys(knowledgeGraph)
.then((clientDataKeys) => {
    // do something with result
});

// typical use case
const url = "https://myHostName.domain.com/server/rest/services/Hosted/myServiceName/KnowledgeGraphServer";

const knowledgeGraph = await knowledgeGraphService.fetchKnowledgeGraph(url)

KnowledgeGraphModule.fetchClientDataAtKeys(knowledgeGraph, ["Person/LinkChart/LinkChartSubLayer"])
.then((clientDataResultMap) => {
    // do something with result
});

// typical use case
const url = "https://myHostName.domain.com/server/rest/services/Hosted/myServiceName/KnowledgeGraphServer";

KnowledgeGraphModule.fetchKnowledgeGraph(url)
.then((kg) => {
    // do something with result
});

// typical use case
KnowledgeGraphModule.refreshDataModel(urlToKnowledgeGraph).then((newKG) => {
    // do something with result
});