hyperspace-sdk-ts 2.0.0 → 2.2.0

package/dist/client.d.ts

@@ -18,6 +18,14 @@ export interface SearchResult {
         [key: string]: string;
     };
 }
+export interface GraphNode {
+    id: number;
+    layer: number;
+    neighbors: number[];
+    metadata: {
+        [key: string]: string;
+    };
+}
 export declare class HyperspaceClient {
     private client;
     private metadata;
@@ -46,5 +54,15 @@ export declare class HyperspaceClient {
         stateHash: number;
         count: number;
     }>;
+    getNode(id: number, layer?: number, collection?: string): Promise<GraphNode>;
+    getNeighbors(id: number, layer?: number, limit?: number, offset?: number, collection?: string): Promise<GraphNode[]>;
+    getConceptParents(id: number, layer?: number, limit?: number, collection?: string): Promise<GraphNode[]>;
+    traverse(startId: number, layer?: number, maxDepth?: number, maxNodes?: number, collection?: string, options?: {
+        filter?: {
+            [key: string]: string;
+        };
+        filters?: Filter[];
+    }): Promise<GraphNode[]>;
+    findSemanticClusters(layer?: number, minClusterSize?: number, maxClusters?: number, maxNodes?: number, collection?: string): Promise<number[][]>;
     close(): void;
 }

package/dist/client.js

@@ -234,6 +234,163 @@ class HyperspaceClient {
             });
         });
     }
+    getNode(id, layer = 0, collection = '') {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb_1.GetNodeRequest();
+            req.setCollection(collection);
+            req.setId(id);
+            req.setLayer(layer);
+            this.client.getNode(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                const metaMap = resp.getMetadataMap();
+                const metadata = {};
+                if (metaMap.getLength() > 0) {
+                    metaMap.forEach((entry, key) => {
+                        metadata[key] = entry;
+                    });
+                }
+                resolve({
+                    id: resp.getId(),
+                    layer: resp.getLayer(),
+                    neighbors: resp.getNeighborsList(),
+                    metadata
+                });
+            });
+        });
+    }
+    getNeighbors(id, layer = 0, limit = 64, offset = 0, collection = '') {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb_1.GetNeighborsRequest();
+            req.setCollection(collection);
+            req.setId(id);
+            req.setLayer(layer);
+            req.setLimit(limit);
+            req.setOffset(offset);
+            this.client.getNeighbors(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                const nodes = resp.getNeighborsList().map((n) => {
+                    const metaMap = n.getMetadataMap();
+                    const metadata = {};
+                    if (metaMap.getLength() > 0) {
+                        metaMap.forEach((entry, key) => {
+                            metadata[key] = entry;
+                        });
+                    }
+                    return {
+                        id: n.getId(),
+                        layer: n.getLayer(),
+                        neighbors: n.getNeighborsList(),
+                        metadata
+                    };
+                });
+                resolve(nodes);
+            });
+        });
+    }
+    getConceptParents(id, layer = 0, limit = 32, collection = '') {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb_1.GetConceptParentsRequest();
+            req.setCollection(collection);
+            req.setId(id);
+            req.setLayer(layer);
+            req.setLimit(limit);
+            this.client.getConceptParents(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                const nodes = resp.getParentsList().map((n) => {
+                    const metaMap = n.getMetadataMap();
+                    const metadata = {};
+                    if (metaMap.getLength() > 0) {
+                        metaMap.forEach((entry, key) => {
+                            metadata[key] = entry;
+                        });
+                    }
+                    return {
+                        id: n.getId(),
+                        layer: n.getLayer(),
+                        neighbors: n.getNeighborsList(),
+                        metadata
+                    };
+                });
+                resolve(nodes);
+            });
+        });
+    }
+    traverse(startId, layer = 0, maxDepth = 2, maxNodes = 256, collection = '', options) {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb_1.TraverseRequest();
+            req.setCollection(collection);
+            req.setStartId(startId);
+            req.setLayer(layer);
+            req.setMaxDepth(maxDepth);
+            req.setMaxNodes(maxNodes);
+            if (options === null || options === void 0 ? void 0 : options.filter) {
+                const map = req.getFilterMap();
+                for (const k in options.filter) {
+                    map.set(k, options.filter[k]);
+                }
+            }
+            if (options === null || options === void 0 ? void 0 : options.filters) {
+                const protoFilters = options.filters.map(f => {
+                    const pf = new hyperspace_pb.Filter();
+                    if (f.match) {
+                        const m = new hyperspace_pb.Match();
+                        m.setKey(f.match.key);
+                        m.setValue(f.match.value);
+                        pf.setMatch(m);
+                    }
+                    else if (f.range) {
+                        const r = new hyperspace_pb.Range();
+                        r.setKey(f.range.key);
+                        if (f.range.gte !== undefined)
+                            r.setGte(f.range.gte);
+                        if (f.range.lte !== undefined)
+                            r.setLte(f.range.lte);
+                        pf.setRange(r);
+                    }
+                    return pf;
+                });
+                req.setFiltersList(protoFilters);
+            }
+            this.client.traverse(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                const nodes = resp.getNodesList().map((n) => {
+                    const metaMap = n.getMetadataMap();
+                    const metadata = {};
+                    if (metaMap.getLength() > 0) {
+                        metaMap.forEach((entry, key) => {
+                            metadata[key] = entry;
+                        });
+                    }
+                    return {
+                        id: n.getId(),
+                        layer: n.getLayer(),
+                        neighbors: n.getNeighborsList(),
+                        metadata
+                    };
+                });
+                resolve(nodes);
+            });
+        });
+    }
+    findSemanticClusters(layer = 0, minClusterSize = 3, maxClusters = 32, maxNodes = 10000, collection = '') {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb_1.FindSemanticClustersRequest();
+            req.setCollection(collection);
+            req.setLayer(layer);
+            req.setMinClusterSize(minClusterSize);
+            req.setMaxClusters(maxClusters);
+            req.setMaxNodes(maxNodes);
+            this.client.findSemanticClusters(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp.getClustersList().map((c) => c.getNodeIdsList()));
+            });
+        });
+    }
     close() {
         this.client.close();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyperspace-sdk-ts",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Official TypeScript SDK for HyperspaceDB gRPC API",
   "main": "dist/client.js",
   "types": "dist/client.d.ts",