falkordb 6.3.0 → 6.4.0

package/README.md

@@ -48,7 +48,7 @@ await graph.query(`CREATE (:Rider {name:'Valentino Rossi'})-[:rides]->(:Team {na
         (:Rider {name:'Dani Pedrosa'})-[:rides]->(:Team {name:'Honda'}),
         (:Rider {name:'Andrea Dovizioso'})-[:rides]->(:Team {name:'Ducati'})`)
 
-result = await graph.query(`MATCH (r:Rider)-[:rides]->(t:Team) 
+const result = await graph.query(`MATCH (r:Rider)-[:rides]->(t:Team) 
                             WHERE t.name = $name RETURN r.name`, 
                             {params: {name: 'Yamaha'}})
                             

package/dist/src/clients/client.d.ts

@@ -3,6 +3,7 @@ import { QueryOptions } from "../commands";
 import { ConstraintType, EntityType } from "../graph";
 import FalkorDB from "../falkordb";
 import { SingleGraphConnection } from "./single";
+import { MemoryUsageOptions, MemoryUsageReply } from "../commands/MEMORY_USAGE";
 export interface Client {
     init(falkordb: FalkorDB): Promise<void>;
     list(): Promise<Array<string>>;
@@ -15,6 +16,7 @@ export interface Client {
     copy<T>(srcGraph: string, destGraph: string): Promise<any>;
     delete(graph: string): Promise<void>;
     explain(graph: string, query: string): Promise<any>;
+    memoryUsage(graph: string, options?: MemoryUsageOptions): Promise<MemoryUsageReply>;
     slowLog(graph: string): Promise<{
         timestamp: Date;
         command: string;

package/dist/src/clients/cluster.d.ts

@@ -5,6 +5,7 @@ import commands, { QueryOptions } from "../commands";
 import { RedisClusterType } from "@redis/client";
 import FalkorDB from "../falkordb";
 import { SingleGraphConnection } from "./single";
+import { MemoryUsageOptions, MemoryUsageReply } from "../commands/MEMORY_USAGE";
 export type ClusterGraphConnection = RedisClusterType<{
     falkordb: typeof commands;
 }, RedisFunctions, RedisScripts>;
@@ -49,6 +50,7 @@ export declare class Cluster implements Client {
         query: string;
         took: number;
     }[]>;
+    memoryUsage(graph: string, options?: MemoryUsageOptions): Promise<MemoryUsageReply>;
     constraintCreate(graph: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
     constraintDrop(graph: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
     profile<_T>(graph: string, query: string): Promise<string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | /*elided*/ any | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined>;

package/dist/src/clients/cluster.js

@@ -75,6 +75,9 @@ class Cluster {
     slowLog(graph) {
         return this.#client.falkordb.slowLog(graph);
     }
+    async memoryUsage(graph, options) {
+        return this.#client.falkordb.memoryUsage(graph, options);
+    }
     async constraintCreate(graph, constraintType, entityType, label, ...properties) {
         const reply = this.#client.falkordb.constraintCreate(graph, constraintType, entityType, label, ...properties);
         return reply.then(() => { });

package/dist/src/clients/nullClient.d.ts

@@ -4,6 +4,7 @@ import FalkorDB from "../falkordb";
 import { ConstraintType, EntityType } from "../graph";
 import { Client } from "./client";
 import { SingleGraphConnection } from "./single";
+import { MemoryUsageOptions, MemoryUsageReply } from "../commands/MEMORY_USAGE";
 /**
  * The `NullClient` class is a placeholder implementation of the `Client` interface.
  *
@@ -34,6 +35,7 @@ export declare class NullClient implements Client {
         query: string;
         took: number;
     }[]>;
+    memoryUsage(_graph: string, _options?: MemoryUsageOptions): Promise<MemoryUsageReply>;
     constraintCreate(_graph: string, _constraintType: ConstraintType, _entityType: EntityType, _label: string, ..._properties: string[]): Promise<void>;
     constraintDrop(_graph: string, _constraintType: ConstraintType, _entityType: EntityType, _label: string, ..._properties: string[]): Promise<void>;
     quit(): Promise<void>;

package/dist/src/clients/nullClient.js

@@ -52,6 +52,9 @@ class NullClient {
     slowLog(_graph) {
         throw new Error("Method not implemented.");
     }
+    memoryUsage(_graph, _options) {
+        throw new Error("Method not implemented.");
+    }
     constraintCreate(_graph, _constraintType, _entityType, _label, ..._properties) {
         throw new Error("Method not implemented.");
     }

package/dist/src/clients/single.d.ts

@@ -4,6 +4,7 @@ import { RedisCommandArgument, RedisFunctions, RedisScripts } from "@redis/clien
 import commands, { QueryOptions } from "../commands";
 import { RedisClientType } from "@redis/client";
 import FalkorDB from "../falkordb";
+import { MemoryUsageOptions, MemoryUsageReply } from "../commands/MEMORY_USAGE";
 export type SingleGraphConnection = RedisClientType<{
     falkordb: typeof commands;
 }, RedisFunctions, RedisScripts>;
@@ -43,6 +44,7 @@ export declare class Single implements Client {
         query: string;
         took: number;
     }[]>;
+    memoryUsage(graph: string, options?: MemoryUsageOptions): Promise<MemoryUsageReply>;
     constraintCreate(graph: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
     constraintDrop(graph: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
     copy<_T>(srcGraph: string, destGraph: string): Promise<"OK">;

package/dist/src/clients/single.js

@@ -74,6 +74,14 @@ class Single {
         }
         return this.client.falkordb.slowLog(graph);
     }
+    async memoryUsage(graph, options) {
+        if (this.#usePool) {
+            return this.client.executeIsolated(async (isolatedClient) => {
+                return isolatedClient.falkordb.memoryUsage(graph, options);
+            });
+        }
+        return this.client.falkordb.memoryUsage(graph, options);
+    }
     async constraintCreate(graph, constraintType, entityType, label, ...properties) {
         const reply = this.client.falkordb.constraintCreate(graph, constraintType, entityType, label, ...properties);
         return reply.then(() => { });

package/dist/src/commands/MEMORY_USAGE.d.ts

@@ -0,0 +1,6 @@
+export interface MemoryUsageOptions {
+    SAMPLES?: number;
+}
+export declare function transformArguments(key: string, options?: MemoryUsageOptions): Array<string>;
+export type MemoryUsageReply = Array<string | number | MemoryUsageReply>;
+export declare function transformReply(): MemoryUsageReply;

package/dist/src/commands/MEMORY_USAGE.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = transformArguments;
+function transformArguments(key, options) {
+    const args = ["GRAPH.MEMORY", "USAGE", key];
+    return options?.SAMPLES ? [...args, String(options.SAMPLES)] : [...args];
+}

package/dist/src/commands/index.d.ts

@@ -13,6 +13,7 @@ import * as CONSTRAINT_DROP from './CONSTRAINT_DROP';
 import * as COPY from './COPY';
 import * as SENTINEL_MASTER from './SENTINEL_MASTER';
 import * as SENTINEL_MASTERS from './SENTINEL_MASTERS';
+import * as MEMORY_USAGE from './MEMORY_USAGE';
 import { RedisCommandArgument, RedisCommandArguments } from '@redis/client/dist/lib/commands';
 declare const _default: {
     CONFIG_GET: typeof CONFIG_GET;
@@ -45,6 +46,8 @@ declare const _default: {
     sentinelMaster: typeof SENTINEL_MASTER;
     SENTINEL_MASTERS: typeof SENTINEL_MASTERS;
     sentinelMasters: typeof SENTINEL_MASTERS;
+    MEMORY_USAGE: typeof MEMORY_USAGE;
+    memoryUsage: typeof MEMORY_USAGE;
 };
 export default _default;
 type QueryParam = null | string | number | boolean | QueryParams | Array<QueryParam>;

package/dist/src/commands/index.js

@@ -16,6 +16,7 @@ const CONSTRAINT_DROP = require("./CONSTRAINT_DROP");
 const COPY = require("./COPY");
 const SENTINEL_MASTER = require("./SENTINEL_MASTER");
 const SENTINEL_MASTERS = require("./SENTINEL_MASTERS");
+const MEMORY_USAGE = require("./MEMORY_USAGE");
 exports.default = {
     CONFIG_GET,
     configGet: CONFIG_GET,
@@ -46,7 +47,9 @@ exports.default = {
     SENTINEL_MASTER,
     sentinelMaster: SENTINEL_MASTER,
     SENTINEL_MASTERS,
-    sentinelMasters: SENTINEL_MASTERS
+    sentinelMasters: SENTINEL_MASTERS,
+    MEMORY_USAGE,
+    memoryUsage: MEMORY_USAGE,
 };
 function pushQueryArguments(args, graph, query, options, compact) {
     args.push(graph);

package/dist/src/graph.d.ts

@@ -3,8 +3,9 @@ import { QueryOptions } from "./commands";
 import { QueryReply } from "./commands/QUERY";
 import { ConstraintType, EntityType } from "./commands/CONSTRAINT_CREATE";
 import { Client } from "./clients/client";
+import { MemoryUsageOptions } from "./commands/MEMORY_USAGE";
 export { ConstraintType, EntityType };
-export type GraphReply<T> = Omit<QueryReply, 'headers' | 'data'> & {
+export type GraphReply<T> = Omit<QueryReply, "headers" | "data"> & {
     data?: Array<T>;
 };
 export default class Graph {
@@ -15,6 +16,7 @@ export default class Graph {
     delete(): Promise<void>;
     explain(query: string): Promise<any>;
     profile(query: string): Promise<any>;
+    memoryUsage(options?: MemoryUsageOptions): Promise<import("./commands/MEMORY_USAGE").MemoryUsageReply>;
     slowLog(): Promise<{
         timestamp: Date;
         command: string;

package/dist/src/graph.js

@@ -4,6 +4,7 @@ exports.EntityType = exports.ConstraintType = void 0;
 const CONSTRAINT_CREATE_1 = require("./commands/CONSTRAINT_CREATE");
 Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: function () { return CONSTRAINT_CREATE_1.ConstraintType; } });
 Object.defineProperty(exports, "EntityType", { enumerable: true, get: function () { return CONSTRAINT_CREATE_1.EntityType; } });
+const polyfill_1 = require("@js-temporal/polyfill");
 // https://github.com/FalkorDB/FalkorDB/blob/master/src/resultset/formatters/resultset_formatter.h#L20
 var GraphValueTypes;
 (function (GraphValueTypes) {
@@ -20,6 +21,10 @@ var GraphValueTypes;
     GraphValueTypes[GraphValueTypes["MAP"] = 10] = "MAP";
     GraphValueTypes[GraphValueTypes["POINT"] = 11] = "POINT";
     GraphValueTypes[GraphValueTypes["VECTORF32"] = 12] = "VECTORF32";
+    GraphValueTypes[GraphValueTypes["DATETIME"] = 13] = "DATETIME";
+    GraphValueTypes[GraphValueTypes["DATE"] = 14] = "DATE";
+    GraphValueTypes[GraphValueTypes["TIME"] = 15] = "TIME";
+    GraphValueTypes[GraphValueTypes["DURATION"] = 16] = "DURATION";
 })(GraphValueTypes || (GraphValueTypes = {}));
 // export type GraphConnection = SingleGraphConnection | ClusterGraphConnection;
 class Graph {
@@ -47,6 +52,9 @@ class Graph {
     async profile(query) {
         return this.#client.profile(this.#name, query);
     }
+    async memoryUsage(options) {
+        return this.#client.memoryUsage(this.#name, options);
+    }
     async slowLog() {
         return this.#client.slowLog(this.#name);
     }
@@ -61,21 +69,20 @@ class Graph {
     }
     #setMetadataPromise;
     #updateMetadata() {
-        this.#setMetadataPromise ??= this.#setMetadata()
-            .finally(() => this.#setMetadataPromise = undefined);
+        this.#setMetadataPromise ??= this.#setMetadata().finally(() => (this.#setMetadataPromise = undefined));
         return this.#setMetadataPromise;
     }
     // DO NOT use directly, use #updateMetadata instead
     async #setMetadata() {
         const [labels, relationshipTypes, propertyKeys] = await Promise.all([
-            this.#client.roQuery(this.#name, 'CALL db.labels()', undefined, false),
-            this.#client.roQuery(this.#name, 'CALL db.relationshipTypes()', undefined, false),
-            this.#client.roQuery(this.#name, 'CALL db.propertyKeys()', undefined, false)
+            this.#client.roQuery(this.#name, "CALL db.labels()", undefined, false),
+            this.#client.roQuery(this.#name, "CALL db.relationshipTypes()", undefined, false),
+            this.#client.roQuery(this.#name, "CALL db.propertyKeys()", undefined, false),
         ]);
         this.#metadata = {
             labels: this.#cleanMetadataArray(labels.data),
             relationshipTypes: this.#cleanMetadataArray(relationshipTypes.data),
-            propertyKeys: this.#cleanMetadataArray(propertyKeys.data)
+            propertyKeys: this.#cleanMetadataArray(propertyKeys.data),
         };
         return this.#metadata;
     }
@@ -106,7 +113,7 @@ class Graph {
                     }
                 }
                 return data;
-            })
+            }),
         };
         if (promises.length)
             await Promise.all(promises);
@@ -120,11 +127,11 @@ class Graph {
             case GraphValueTypes.INTEGER:
                 return value;
             case GraphValueTypes.BOOLEAN:
-                return value === 'true';
+                return value === "true";
             case GraphValueTypes.DOUBLE:
                 return parseFloat(value);
             case GraphValueTypes.ARRAY:
-                return value.map(x => this.#parseValue(x, promises));
+                return value.map((x) => this.#parseValue(x, promises));
             case GraphValueTypes.EDGE:
                 return this.#parseEdge(value, promises);
             case GraphValueTypes.NODE:
@@ -132,7 +139,7 @@ class Graph {
             case GraphValueTypes.PATH:
                 return {
                     nodes: value[0][1].map(([, node]) => this.#parseNode(node, promises)),
-                    edges: value[1][1].map(([, edge]) => this.#parseEdge(edge, promises))
+                    edges: value[1][1].map(([, edge]) => this.#parseEdge(edge, promises)),
                 };
             case GraphValueTypes.MAP: {
                 const map = {};
@@ -144,24 +151,44 @@ class Graph {
             case GraphValueTypes.POINT:
                 return {
                     latitude: parseFloat(value[0]),
-                    longitude: parseFloat(value[1])
+                    longitude: parseFloat(value[1]),
                 };
             case GraphValueTypes.VECTORF32:
-                return value.map(x => Number(x));
+                return value.map((x) => Number(x));
+            case GraphValueTypes.DATETIME:
+                return polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000)
+                    .toZonedDateTimeISO("UTC")
+                    .toPlainDateTime();
+            case GraphValueTypes.DATE:
+                return polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000)
+                    .toZonedDateTimeISO("UTC")
+                    .toPlainDate();
+            case GraphValueTypes.TIME:
+                return polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000)
+                    .toZonedDateTimeISO("UTC")
+                    .toPlainTime();
+            case GraphValueTypes.DURATION:
+                const time = polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000);
+                const epoch = polyfill_1.Temporal.Instant.fromEpochMilliseconds(0);
+                return epoch
+                    .toZonedDateTimeISO("UTC")
+                    .until(time.toZonedDateTimeISO("UTC"), {
+                    largestUnit: "years",
+                });
             default:
                 throw new Error(`unknown scalar type: ${valueType}`);
         }
     }
-    #parseEdge([id, relationshipTypeId, sourceId, destinationId, properties], promises) {
+    #parseEdge([id, relationshipTypeId, sourceId, destinationId, properties,], promises) {
         const edge = {
             id,
             sourceId,
             destinationId,
-            properties: this.#parseProperties(properties, promises)
+            properties: this.#parseProperties(properties, promises),
         };
-        const relationshipType = this.#getMetadata('relationshipTypes', relationshipTypeId);
+        const relationshipType = this.#getMetadata("relationshipTypes", relationshipTypeId);
         if (relationshipType instanceof Promise) {
-            promises.push(relationshipType.then(value => edge.relationshipType = value));
+            promises.push(relationshipType.then((value) => (edge.relationshipType = value)));
         }
         else {
             edge.relationshipType = relationshipType;
@@ -171,9 +198,9 @@ class Graph {
     #parseNode([id, labelIds, properties], promises) {
         const labels = new Array(labelIds.length);
         for (let i = 0; i < labelIds.length; i++) {
-            const value = this.#getMetadata('labels', labelIds[i]);
+            const value = this.#getMetadata("labels", labelIds[i]);
             if (value instanceof Promise) {
-                promises.push(value.then(value => labels[i] = value));
+                promises.push(value.then((value) => (labels[i] = value)));
             }
             else {
                 labels[i] = value;
@@ -182,15 +209,15 @@ class Graph {
         return {
             id,
             labels,
-            properties: this.#parseProperties(properties, promises)
+            properties: this.#parseProperties(properties, promises),
         };
     }
     #parseProperties(raw, promises) {
         const parsed = {};
         for (const [id, type, value] of raw) {
-            const parsedValue = this.#parseValue([type, value], promises), key = this.#getMetadata('propertyKeys', id);
+            const parsedValue = this.#parseValue([type, value], promises), key = this.#getMetadata("propertyKeys", id);
             if (key instanceof Promise) {
-                promises.push(key.then(key => parsed[key] = parsedValue));
+                promises.push(key.then((key) => (parsed[key] = parsedValue)));
             }
             else {
                 parsed[key] = parsedValue;
@@ -204,7 +231,7 @@ class Graph {
             idxType = "";
         }
         let query = `CREATE ${idxType ? idxType + " " : ""}INDEX FOR ${pattern} ON (${properties
-            .map(prop => `e.${prop}`)
+            .map((prop) => `e.${prop}`)
             .join(", ")})`;
         if (options) {
             const optionsMap = Object.entries(options)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "falkordb",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "description": "A FalkorDB javascript library",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -32,8 +32,11 @@
   "keywords": [
     "falkordb"
   ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "devDependencies": {
-    "@tsconfig/node14": "^14.1.2",
+    "@tsconfig/node20": "^20.1.4",
     "@types/jest": "^29.5.14",
     "@types/lodash": "^4.17.13",
     "@types/node": "^24.0.3",
@@ -44,9 +47,10 @@
     "jest": "^29.7.0",
     "release-it": "^19.0.3",
     "ts-jest": "^29.2.5",
-    "typescript": "^5.7.2"
+    "typescript": "^5.9.3"
   },
   "dependencies": {
+    "@js-temporal/polyfill": "^0.5.1",
     "@redis/client": "^1.6.0",
     "cluster-key-slot": "1.1.2",
     "generic-pool": "^3.9.0",